TP_MNIS_Keras_dense.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    v1.1 2018/10/23 JLC Ajout image architecture réseau + correction fautes de frappe\n",
    "    v1.2 2019/06/13 BA  MAJ par Benjamin AILLOUD (stage L2 informatique)\n",
    "    v2.0 2019/06/16 JLC Reformulation version 2.\n",
    "    V2.1 2019/10/29 JLC Consolidation des versions keras 2.2.4 / tensorflow 1.13.1 / numpy 16.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-weight:bold;color:blue;font-family:arial;font-size:xx-large;\">\n",
    "    Machine learning avec les modules Python Keras & tensorflow \n",
    "</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"font-weight:bold;color:blue;font-family:arial;font-size:x-large;\">\n",
    "    Conception / entraînement / évaluation d'un réseau de neurones dédié à la reconnaissance de chiffres manuscrits.</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "<b>Info:</b> Document initialement inspiré du travail de Jason Brownlee : *Handwritten Digit Recognition using Convolutional Neural Networks in Python with Keras* publié en juin 2016 à l'adresse https://machinelearningmastery.com/handwritten-digit-recognition-using-convolutional-neural-networks-python-keras/\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A/ Quelques concepts fondamentaux autour des réseaux de neurones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Le neurone artificiel\n",
    "C'est une unité de traitement informatique programmée pour calculer la valeur de sa **fonction d'activation** en un point défini par la **combinaison linéaire de ses entrées** $\\Sigma_i w_i x_i - b$ :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center; font-style:italic; font-size=xx-small\">\n",
    "    <img src=\"./figures/nn_1.png\" width=\"600\" >\n",
    "    (crédit image : JLC)\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'entrée *Bias* reçoit le stimuli `-1` affecté du poids $b$ pour donner une **translation** (décalage) dans la fonction d'activation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fonction d'activation\n",
    "Les principaux rôles des fonctions d'activation des neurones artificiels sont :\n",
    "- donner au neurone artificiel un comportement **non linéaire** (avec par exemple des mécanismes de seuil, de saturation...)\n",
    "- fixer la plage de sortie de la valeur calculée par le neurone (par exemple sortie dans l'intervalle $[-1 ; 1]$, ou $[0 ; +\\infty[$\n",
    "\n",
    "Exemples de fonction d'activation couramment utilisées :<br />\n",
    "<p style=\"text-align:center; font-style:italic; font-size=xx-small\">\n",
    "    <img src=\"./figures/activationFunctions.png\"> \n",
    "    (crédit image : JLC)\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Banque d'images MNIST\n",
    "\n",
    "Dans ce travail, nous utiliserons les images de la banque MNIST disponible sur Internet (http://yann.lecun.com/exdb/mnist/).\n",
    "\n",
    "La banque MNIST propose des images en ton de gris de 28 $\\times$ 28 pixels, correspondant à des matrice de 28 $\\times$ 28 d'entiers compris entre 0 et 255 :\n",
    "<p style=\"text-align:center; font-style:italic; font-size=xx-small\">\n",
    "    <img src=\"./figures/MnistExamples.png\" width=\"500\" >\n",
    "    (crédit image : Josef Steppan — Travail personnel, CC BY-SA 4.0, commons.wikimedia.org/w/index.php?curid=64810040)\n",
    "</p>\n",
    "\n",
    "L'ensemble des images du jeu de données MNIST contient **60000 images d'apprentissage** et **10000 images de test**, soit en tout **70000 images** de 28 x 28 pixels."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Structure du réseau à construire \n",
    "Dans un premier temps nous allons construire un simple *réseau dense*, avec :\n",
    "- une **couche d'entrée** de 784 valeurs comprises entre 0 et 1 (les pixels de l'image 28 $\\times$ 28 mis sous forme d'un vecteur de 784 valeurs),\n",
    "- une **couche cachée** de 784 neurones utilisant la fonction d'activation `relu`,\n",
    "- une **couche de sortie** à 10 neurones, pour la classification des images en 10 classes associées aux chiffres {0,1,2...9}, utilisant la fonction d'activation `softmax` adaptée aux traitements de classification."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center; font-style:italic; font-size=xx-small\">\n",
    "    <img src=\"./figures/archiReseau.png\" width=\"900\">\n",
    "    (crédit image : JLC)\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La fonction d'activation `softmax` utilisée pour les 10 neurones de la couche de sortie permet de \"faire ressortir\" la sortie $y_i$ de valeur la plus grande : `softmax` donne une valeur très proche de 1 pour le neurone fournissant la plus grande valeur $y_i$, alors que pour tous les autres neurones, la valeur calculée par `softmax` sera proche de zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center; font-style:italic; font-size=xx-small\">\n",
    "    <img src=\"./figures/softmax.png\" width=\"400\">\n",
    "    (crédit image : JLC)\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarques : \n",
    "- Chaque neurone de la première couche cachée reçoit 785 entrées : les 784 valeurs des pixels de l'image plus l'entrée -1. \n",
    "- Il y a dons 785 inconnues pour chaque neurone : les 784 poids $w_i$ affectés à chaque entrée $x_i$, plus le  poids $b$ affecté à l'entrée -1 (le biais).\n",
    "- on compte donc 785 $\\times$ 784 inconnues pour la couche cachée et 785 $\\times$ 10 inconnues pour la couche de sortie : soit un total de 623290 inconnues dont la valeur doit être optimisée par l'algorithme d'apprentissage du réseau.\n",
    "\n",
    "C'est un algorithme de **retropropagation de l'erreur** entre valeur attendue et valeur prédite par le réseau qui permet de modifier les valeurs des poids des différentes couches pour minimiser l'erreur. Au fur et à mesure des apprentissages successifs, cette modification des poids du réseau de neurones tend vers un état qui constitue le réseau entraîné."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  B/ Environnement Python de travail"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-danger\">\n",
    "<span style=\"color:brown;font-family:arial;font-size:large\"> \n",
    "    Les développement en Python doivent se faire dans un <span style=\"font-weight:bold;\">environnement Python 3.6 dédié</span> : voir le document <span style=\"font-style:italic\">EnvironnementPython.pdf</span> si vous n'avez pas encore créé d'environnement Python dédié pour le travail avec les modules Keras et tensorflow.\n",
    "</span>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Environnement Python dédié\n",
    "Vérification :\n",
    "- de la version de Python : doit être 3.6.8 ou 3.6.9\n",
    "- de la version de keras : doit être 2.2.4\n",
    "- de la version de tensorflow : doit être 1.13.1\n",
    "- de la version de OpenCV : doit être 3.4.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys, keras, cv2\n",
    "import tensorflow as tf\n",
    "print(f\"Version de Python    : {sys.version.split()[0]}\")\n",
    "print(f\"Version, de Keras    : {keras.__version__}\")\n",
    "print(f\"Version de tensorflow: {tf.__version__}\")\n",
    "print(f\"Version, de OpenCV   : {cv2.__version__}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La documentation du module Python Keras (en anglais) est disponible sur https://keras.io."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incrustation des tracés matplotlib dans le cahier IPython et import de modules utiles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Faire affiche tous les *echos interactifs* d'une même cellule :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.core.interactiveshell import InteractiveShell  \n",
    "InteractiveShell.ast_node_interactivity = \"all\"          # affiche tous les echos interactifs d'une cellule\n",
    "# InteractiveShell.ast_node_interactivity = \"last_expr\"  # default behaviour"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# C/ Travail à faire"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1 -- Récupération du jeu de données MNIST :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://fr.wikipedia.org/wiki/Base_de_données_MNIST : La base de données MNIST (*Mixed National Institute of Standards and Technology*), est une base de données de chiffres écrits à la main. C'est un jeu de données très utilisé en apprentissage automatique.<br /><br />\n",
    "L'ensemble des images du jeu de données MNIST contient **60000 images d'apprentissage** et **10000 images de test**, soit en tout **70000 images** de 28 x 28 pixels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load data from https://www.openml.org/d/554\n",
    "from keras.datasets import mnist\n",
    "(image_train, etiq_train), (image_test, etiq_test) = mnist.load_data() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Faire afficher le type des objets `image_train`, `etiq_train`, `image_test` et `etiq_test` :</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Faire afficher les attributs `shape` et `dtype` des tableaux `image_train`, `etiq_train`, `image_test` et `etiq_test` -> interpréter les réponses :</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 -- Vérification des étiquettes des données : "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Faire afficher les 10 premières valeurs de `etiq_train` et `etiq_test` ; interpréter les réponses. </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 -- Visualisation des images MNIST  :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial;\">Avec la fonction `imshow` du module `matplotlib.pyplot` faire afficher la 601-ème image du tableau `image_train`. Indications :<br />\n",
    "\n",
    "- utiliser `plt.figure(figsize=(4,4))`;<br />\n",
    "- passer l'argument `cmap='binary'` à la fonction `imshow`;<br/>\n",
    "- enlever les graduations en X et Y avec l'instruction  `plt.xticks([]); plt.yticks([])`.</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Vérifier que l'étiquette associée à `image_train[600]` est bien `9` :</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Écrire une fonction `plot_image` qui prend les arguments 'qui vont bien' pour afficher les images MNIST commençant au rang `r` sur `L` lignes et `C` colonnes (utiliser `plt.subplot` pour faire un quadrillage d'images). La figure affichée doit avoir pour dimensions 10 x 10 pouces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Fait afficher 100 images à partir de la 600 ème dans une grille de 10x10 : </span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2 -- Pré-traitement des données"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Le pré-traitement des données constitue une des étapes fondamentales de l'apprentissage des réseaux de neurones.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour adapter les données au réseau de neurones, on doit transformer les matrice d'entiers `uint8` représentant les images 28 x 28 pixels en vecteurs **normalisés** $(V_i)_{i=0..783}$ de 784 valeurs réelles $V_i$  avec $ 0 \\leqslant V_i \\leqslant 1.$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 -- Transformation des matrices d'entrée en vecteurs normalisés :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_image_train, nb_image_test = image_train.shape[0], image_test.shape[0]\n",
    "nb_pixels = image_train.shape[1] * image_train.shape[2]   # 28 x 28 = 784 pixels\n",
    "\n",
    "# mise 'à plat' des matrices sous forme de vecteurs de floats \n",
    "# Indications: utiliser les méthodes 'reshape(new_shape)' et astype('float32') de ndarray).\n",
    "x_train = image_train.reshape((nb_image_train, nb_pixels)).astype('float32')\n",
    "x_test  = image_test.reshape((nb_image_test, nb_pixels)).astype('float32')\n",
    "\n",
    "# normalisation des tableaux X_train et X_test :\n",
    "x_train = x_train/255\n",
    "x_test  = x_test/255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Vérifier la tailles des tableaux `x_train` et `x_test`  :</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Vérifier les valeurs min et max des tableaux `x_train` et `x_test`  :</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 -- *Hot coding* des étiquettes :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les étiquettes des images sont des valeurs entières comprises entre 0 et 9. Pour traiter efficacement le problème de classification, on utilise la technique de `hot coding` qui remplace les valeurs des différentes classes par un vecteur comportant autant d'éléments que de classes à choisir.<br />\n",
    "Par exemple :\n",
    "- l'étiquette `0` sera transformée en le vecteur `[1 0 0 0 0 0 0 0 0 0]`.\n",
    "- l'étiquette `3` sera transformée en le vecteur `[0 0 0 1 0 0 0 0 0 0]`.\n",
    "- l'étiquette `9` sera transformée en le vecteur `[0 0 0 0 0 0 0 0 0 9]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pour réaliser le codage des étiquettes, on utilise la fonction `to_categorical` du module `keras.utils.np_utils` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.utils.np_utils import to_categorical\n",
    "# 'hot encoding' des sorties :\n",
    "y_train = to_categorical(etiq_train)\n",
    "y_test  = to_categorical(etiq_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Faire afficher les 10 premières valeurs de `etiq_train` et les 10 premières valeurs `hot encoded` de `y_train` :</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 -- Construction du réseau de neurones :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va maintenant construire un réseau de neurone **séquentiel** (cf https://keras.io/models/sequential ) en **4 lignes** Python à l'aide du module **keras** qui permet une manipulation de haut niveau des outils proposés par le module **tensorflow**.<br />\n",
    "\n",
    "Les spécifications du réseau de neurones à construire sont :\n",
    "- les entrées sont constituées des 784 pixels, mis sous forme d'un vecteur normalisé ;\n",
    "- le réseau de neurones comporte une première couche de 784 neurones utilisant la fonction d'activation `relu` (*retified linear unit*, voir https://keras.io/activations) ;\n",
    "- la couche de sortie comporte 10 neurones utilisant la fonction d'activation `softmax` pour convertir les sorties en valeur de probalibilités permettant de choisir une des 10 classes ;\n",
    "- la fonction d'erreur (différence entre étiquette et valeur prédite par le réseau) est `Logarithmic loss` (dans Keras elle coorepnd à la *loss function* `categorical_crossentropy`) ;\n",
    "- l'algorithme de descente de gradient ADAM est utilisé pour l'optimisation des poids des neurones par rétro-progation de l'erreur. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La **fonction d'erreur** (*loss function*) utilisée pour quantifier l'erreur entre l'étiquette associée aux données d'entrée est disponible dans keras sous le nom `categorical_crossentropy`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center; font-style:italic; font-size=xx-small\">\n",
    "    <img src=\"./figures/CrossEntropy.png\" width=650>\n",
    "    (crédit image : vidéo \"Deep Learning TensorFlow\" de Martin Gorner)\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Rendre les tirages aléatoires reproductibles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les poids d'un réseau de neurones sont initialisés par tirage aléatoire. Lorsqu'on invoque plusieurs fois de suite des générateurs aléatoires comme `numpy.random.rand` par exemple, on cconstate qu'à chaque invocation, on obtient une suite de valeurs aléatoires différentes :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.random.rand(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(np.random.rand(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ceci présente un gros inconvénient car les poids d'un réseau de neurones sont initialisés à la construction du réseau par tirage aléatoire : ceci veut dire qu'à chaque fois qu'on relance le cahier IPYthon par exemple on obtiendra un état initial du réseau différent conduisant à un résultat de réseau entraîné différent !\n",
    "\n",
    "Pour corriger ce comportement, on fixe la **graine** (*seed*) du générateur `numpy.random` de façon à générer des suites de nombres aléatoires reproductibles :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 43"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(seed)\n",
    "np.random.rand(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(seed)\n",
    "np.random.rand(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Construction du réseau de neurones dense en 4 lignes avec le module Keras :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense \n",
    "\n",
    "tf.logging.set_verbosity(tf.logging.ERROR)  # n'afficher que les ERREURS tf, pas les warnings....\n",
    "nb_classes = len(y_train[0])\n",
    "np.random.seed(43)\n",
    "\n",
    "# les 4 lignes pour construire le réseau de neurones:\n",
    "model = Sequential()\n",
    "model.add(Dense(nb_pixels, input_dim=nb_pixels, kernel_initializer='normal', activation='relu'))\n",
    "model.add(Dense(nb_classes, kernel_initializer='normal', activation='softmax'))\n",
    "model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Avec la méthode `summary` de l'objet `model`, faire afficher la description du modèle : expliquer les valeurs des paramètres ?</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Peux-tu retrouver le nombre total de paramètres avec une formule simple ?</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4 -- Entraînement du réseau :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le modèle est entraîné sur les $60\\,000$ images,\n",
    "- 10 fois de suite (paramètre `epochs`), \n",
    "- avec mises à jour des poids toutes les 200 images (paramètre `batch_size`),\n",
    "- en utilisant :\n",
    "    - les données d'entrée `x_train` (images)\n",
    "    - les données de sortie `y_train` (étiquettes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "history = model.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=10, batch_size=200, verbose=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tracé des courbes `accuracy` et `loss` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot(history):\n",
    "    # Plot training & validation accuracy values\n",
    "    plt.figure(figsize=(15,5))\n",
    "    ax1 = plt.subplot(1,2,1)\n",
    "    ax1.plot(history.history['acc'], 'o-',label='Train')\n",
    "    ax1.plot(history.history['val_acc'], 'o-', label='Test')\n",
    "    ax1.set_title('Model accuracy')\n",
    "    ax1.set_ylabel('Accuracy')\n",
    "    ax1.set_xlabel('Epoch') \n",
    "    ax1.grid()\n",
    "    ax1.legend(loc='best')\n",
    "    # Plot training & validation loss values\n",
    "    ax2 = plt.subplot(1,2,2)\n",
    "    ax2.plot(history.history['loss'], 'o-', label='Train')\n",
    "    ax2.plot(history.history['val_loss'], 'o-',  label='Test')\n",
    "    ax2.set_title('Model loss')\n",
    "    ax2.set_ylabel('Loss')\n",
    "    ax2.set_xlabel('Epoch')\n",
    "    ax2.legend(loc='best')\n",
    "    ax2.grid()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entrainer le réseau plus longtemps (par augmentation du paramètre `epochs` peut permettre d'aumengenter les performances du réseau... mais les courbes de précision du test (*test accuracy*) restent asymptotiquement voisinnes des 98 %.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5/ Vérication de l'apprentissage avec le jeu de test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode `predict`permet de demander au modèle sa prédiction pour une ou plusieurs entrées.<BR />\n",
    "Exemple de prédition pour une image test numéro i dans le jeu d'images de test (0 <= i <= 10000) :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1000\n",
    "rep = model.predict(x_test[i:i+1])\n",
    "\n",
    "np.set_printoptions(formatter={'float':'{:0.4f}'.format})\n",
    "print(\"valeur trouvée par le réseau de neurones :\", rep[0])\n",
    "\n",
    "np.set_printoptions(formatter={'float':'{:0.1f}'.format})\n",
    "print(\"valeur trouvée arrondie  : {}\".format(rep[0]))\n",
    "print(\"rep[0].argmax() donne    : {}\".format(rep[0].argmax()))\n",
    "\n",
    "plt.figure(figsize=(1,1))\n",
    "digit = image_test[i]\n",
    "plt.xticks([]); plt.yticks([])\n",
    "plt.imshow(digit, cmap='binary');\n",
    "print(f\"\\nLa bonne réponse est {etiq_test[i]}, soit en 'hot coded' : {y_test[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Écrire les instructions Python pour calculer avec les données de test le pourcentage d'erreur du réseau entrainé.... <br/> \n",
    "Conseil: la variable rep contient pour chaque image une liste de 10 probabilités, il pourra être utile d'utiliser la fonction argmax de la librairie numpy pour obtenir le chiffre de plus haute probabilité.</span>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6/ Évolution du réseau : augmentation du nombre de couches cahées "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut essayer de construire un réseau avec plus de couches. Par exemple :\n",
    "- couche d'entrée avec les 784 pixels\n",
    "- couche cachée 1 : 784 neurones, fonction d'activation `relu`\n",
    "- couche cachée 2 : 300 neurones, fonction d'activation `relu`\n",
    "- couche cachée 3 : 100 neurones, fonction d'activation `relu`    \n",
    "- couche de sortie : 10 neurone, fonction d'activation `softmax`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Peux-tu construire le réseau `model2` correspondant avec Keras ?</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_classes = len(y_train[0])\n",
    "np.random.seed(43)\n",
    "model2 = Sequential()\n",
    "model2.add(Dense(...)\n",
    "model2.add(Dense(...)\n",
    "model2.add(Dense(...)\n",
    "model2.add(Dense(...)\n",
    "model2.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\">Avec la méthode `summary` de l'objet `model2`, faire afficher la description du modèle : expliquer les valeurs des paramètres ?</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entraîner le réseau `model2` avec les mêmes données que `model`, et faire tracer les courbes de précission et d'erreur :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "history2 = model2.fit(x_train, y_train, validation_data=(x_test, y_test), epochs=10, batch_size=200, verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plot(history2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color:blue;font-family:arial\"> Augmenter le nombre de couches a t'il un impact sur les performances du réseau ?<br />\n",
    "Que peut on conclure sur l'utilité de complexifier ce type de réseau ? </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Double-clic ici pour inscrire ta réponse :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7/ Utiliser le réseau avec ses propres images"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On va utiliser le réseau entrainé pour voir comment il réagit avec des chiffres \"écrits à la main\" différents des chiffres de la banque MNIST...<br />\n",
    "Pour cela on utilise les images du dossier `chiffres` :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "images = ['chiffres/'+f for f in os.listdir('chiffres') if f.endswith(\".png\") or f.endswith(\".jpg\")]\n",
    "images.sort()\n",
    "print(f\"Images du dossier 'chiffres' : {images}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lecture des fichiers image avec openCV"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "# lecture des images -> matrices ndarray 28x28 \n",
    "input_data = [255-cv2.cvtColor(cv2.imread(image),cv2.COLOR_BGR2GRAY) for image in images]\n",
    "input_data = np.array(input_data)\n",
    "input_data.shape, input_data.dtype  # on doit avoir 4 matrices de 28 x 28 valeurs "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visualistion des images :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(15,5))\n",
    "for i,M in enumerate(input_data):  \n",
    "    plt.subplot(1,12,i+1)\n",
    "    plt.imshow(input_data[i], cmap='binary', interpolation='none');\n",
    "    plt.xticks([]); plt.yticks([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "transformation des matrices 28x28 en vecteurs de float normalisés :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nb_images = input_data.shape[0]\n",
    "# mise 'à plat' des matrices sous forme de vecteurs de floats :\n",
    "x_photo = input_data.reshape(nb_images, 28*28).astype('float32')\n",
    "# normalisation des données :\n",
    "x_photo /= 255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "prédiction du réseau entrainé, avec les images perso :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.set_printoptions(formatter={'float': '{:0.3f}'.format})  # demander à numpy d'afficher 3 décimales\n",
    "\n",
    "rep = model.predict(x_photo)\n",
    "print(rep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[r.argmax() for r in rep]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for r in rep:\n",
    "    print(f\"{r.argmax()} avec la probablilité {r.max():.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le 7 et le 9 ont été vus respectivement comme un 2 et 3 ...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Avec le deuxième réseau dense :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rep = model2.predict(x_photo)\n",
    "print(rep)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[r.argmax() for r in rep]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for r in rep:\n",
    "    print(f\"{r.argmax()} avec la probablilité {r.max():.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pas beaucoup mieux ...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les résultats montrent :\n",
    "- que le réseau à 1 seule couche cachée et à 2 couches cachées donnent quasiment les mêmes performances pour les images MNIST,\n",
    "- que l'apprentissage d'un réseau dense reste assez sensible à la nature du jeu de données : les images de chiffres hors banque MNIST ne ressemblent pas tout à fait à celles de la banque MNIST, d'où des erreurs de classification avec un simple réseau dense."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Suite....\n",
    "\n",
    "Pour aller au-delà des 98% de reconnaissance des chiffres, il faut passer à une autre architecture de réseau plus adaptée au traitement des images : les réseaux **convolutionnels**, traités dans le prochain cahier IPython `TP_MNIS_Keras_convo.ipynb`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Autres ressources intéressantes... des vidéos :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://www.youtube.com/embed/trWrEWfhTVg\" width=\"800\" height=\"450\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<iframe src=\"https://www.youtube.com/embed/trWrEWfhTVg\" width=\"800\" height=\"450\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://www.youtube.com/embed/aircAruvnKk\" width=\"800\" height=\"450\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<iframe src=\"https://www.youtube.com/embed/aircAruvnKk\" width=\"800\" height=\"450\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://www.youtube.com/embed/IHZwWFHWa-w\" width=\"800\" height=\"450\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<iframe src=\"https://www.youtube.com/embed/IHZwWFHWa-w\" width=\"800\" height=\"450\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe src=\"https://www.youtube.com/embed/Ilg3gGewQ5U\" width=\"800\" height=\"450\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<iframe src=\"https://www.youtube.com/embed/Ilg3gGewQ5U\" width=\"800\" height=\"450\" frameborder=\"0\" allow=\"accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}