From db85923e94c4919b6c29597ae7c32aa31506cd4c Mon Sep 17 00:00:00 2001 From: Arthur DANJOU Date: Wed, 29 Oct 2025 19:03:42 +0100 Subject: [PATCH] Implement feature X to enhance user experience and fix bug Y in module Z --- M2/Deep Learning/TP1 - Starter.ipynb | 657 +++++++++++++++++++++++++++ 1 file changed, 657 insertions(+) create mode 100644 M2/Deep Learning/TP1 - Starter.ipynb diff --git a/M2/Deep Learning/TP1 - Starter.ipynb b/M2/Deep Learning/TP1 - Starter.ipynb new file mode 100644 index 0000000..7352b7c --- /dev/null +++ b/M2/Deep Learning/TP1 - Starter.ipynb @@ -0,0 +1,657 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Séance 1 - Réseau de neurones dense\n", + "\n", + "On se propose de classifier les chiffres manuscrit du dataset [MNIST](https://yann.lecun.com/exdb/mnist/) en définissant ses propres réseaux de neurones denses. L'objectif est de découvrir la manière d'entraîner ces algorithmes et observer en pratique les bases théoriques discutées en cours.\n", + "\n", + "## Exploration des données\n", + "\n", + "Commençons par importer les données." + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "sns.set(style='whitegrid')\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "\n", + "(X_train_full, y_train_full), (X_test, y_test) = (keras.datasets.mnist.load_data())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Consigne** : À l'aide de la fonction [`train_test_split`](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html), séparer le jeu d'entraînement complet en un dataset d'entraînement et un dataset de validation. Afficher les tailles des datasets respectifs." + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(48000, 28, 28) (48000,)\n", + "(12000, 28, 28) (12000,)\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "X_train, X_valid, y_train, y_valid = train_test_split(X_train_full, y_train_full, test_size=0.2, random_state=42)\n", + "print(X_train.shape, y_train.shape)\n", + "print(X_valid.shape, y_valid.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Consigne** : Afficher plusieurs images du dataset d'entraînement aléatoirement. On pourra utiliser la fonction [`imshow`](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.imshow.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,10))\n", + "for i in range(25):\n", + " plt.subplot(5,5,i+1)\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.grid(False)\n", + " plt.imshow(X_train[i], cmap=plt.cm.binary)\n", + " plt.xlabel(y_train[i])\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Les images sont en niveau de gris, donc de valeurs entre 0 et 255. Pour entraîner correctement un réseau de neurones, il est préférable que les inputs soit standardisés.\n", + "\n", + "**Consigne** : Standardiser les données en utilisant la classe [`StandardScaler`](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html). On commencera par applatir les images en utilisant la méthode [`reshape`](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html), puis on applique le pré-processing et on termine par reformer la matrice." + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.preprocessing import StandardScaler\n", + "\n", + "scaler = StandardScaler()\n", + "X_train_flat = X_train.reshape(X_train.shape[0], -1).astype(np.float32)\n", + "X_valid_flat = X_valid.reshape(X_valid.shape[0], -1).astype(np.float32)\n", + "X_test_flat = X_test.reshape(X_test.shape[0], -1).astype(np.float32)\n", + "\n", + "scaler.fit(X_train_flat)\n", + "\n", + "X_train = scaler.transform(X_train_flat).reshape(X_train.shape)\n", + "X_valid = scaler.transform(X_valid_flat).reshape(X_valid.shape)\n", + "X_test = scaler.transform(X_test_flat).reshape(X_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Modélisation du réseau de neurones\n", + "\n", + "Pour le moment, nous travaillons avec des images de tailles $28\\times28$, mais nous ne savons pas définir (pour le moment) de réseau de neurones capable de travailler directement avec une image. Nous allons utiliser une couche nommée [`Flatten`](https://keras.io/api/layers/reshaping_layers/flatten/) dont le but est *d'applatir* une matrice de dimension *(height, width, channel)* en un vecteur de taille *height $\\times$ width $\\times$ channel*. Dans le cadre des données MNIST, *channel*=1 puisque nous sommes en niveau de gris, et *height=width=28*. On aura un vecteur de 784 dimensions.\n", + "\n", + "Une fois que nous aurons décrit l'ensemble du réseau, nous devrons terminer le réseau par une couche avec dix neurones : un pour chaque classe. Pour s'assurer que l'on aura une estimation de probabilité d'appartenance à la classe, on utilisera la fonction softmax. Pour un vecteur $x = (x_0, x_1, \\ldots, x_n)$ on a:\n", + "\n", + "$$\\text{softmax}(x)_j = \\frac{e^{x_j}}{\\displaystyle \\sum_{i=0}^n e^{x_i}}$$\n", + "\n", + "On veut définir le réseau suivant:\n", + "* **Couche cachée 1** : 256 neurones avec fonction d'activation ReLU\n", + "* **Couche cachée 2** : 128 neurones avec fonction d'activation ReLU\n", + "\n", + "On peut définir de plusieurs manières un réseau de neurones. La première est de la même manière qu'une liste à laquelle on ajoute des couches en utilisation le template de modèle *Sequential* :" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "model = keras.models.Sequential()\n", + "model.add(keras.layers.Input(shape=[28, 28]))\n", + "model.add(keras.layers.Flatten())\n", + "model.add(keras.layers.Dense(256, activation=\"relu\"))\n", + "model.add(keras.layers.Dense(128, activation=\"relu\"))\n", + "model.add(keras.layers.Dense(10, activation=\"softmax\"))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "En début de réseau de neurones on doit définir la dimension de l'input: ici (28, 28). Le reste des dimensions pour l'ensemble des couches qui lui succède sont calculées automatiquement.\n", + "\n", + "La deuxième manière est directement sous le format d'une liste:" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [], + "source": [ + "model = keras.models.Sequential([\n", + " keras.layers.Input(shape=[28, 28]),\n", + " keras.layers.Flatten(),\n", + " keras.layers.Dense(256, activation=\"relu\"),\n", + " keras.layers.Dense(128, activation=\"relu\"),\n", + " keras.layers.Dense(10, activation=\"softmax\")\n", + "])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Consigne** : Calculer à la main le nombre de neurones du modèle, couche par couche. Puis utiliser la méthode [`summary`](https://keras.io/api/models/model/#summary-method) pour vérifier les calculs." + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "784\n", + "256\n", + "128\n", + "10\n", + "256901120\n" + ] + }, + { + "data": { + "text/html": [ + "
Model: \"sequential_7\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential_7\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ flatten_7 (Flatten)             │ (None, 784)            │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_21 (Dense)                │ (None, 256)            │       200,960 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_22 (Dense)                │ (None, 128)            │        32,896 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ dense_23 (Dense)                │ (None, 10)             │         1,290 │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ flatten_7 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m784\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_21 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m200,960\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_22 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m32,896\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ dense_23 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m10\u001b[0m) │ \u001b[38;5;34m1,290\u001b[0m │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 235,146 (918.54 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m235,146\u001b[0m (918.54 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 235,146 (918.54 KB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m235,146\u001b[0m (918.54 KB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(28*28)\n", + "print(256)\n", + "print(128)\n", + "print(10)\n", + "print(784*256*128*10)\n", + "\n", + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nous avons décrit l'architecture du réseau de neurones. Il faut maintenant définir comment il va s'entraîner. Nous devons spécifier:\n", + "\n", + "* **Loss** : Quelle fonction de perte est à minimiser ?\n", + "* **Optimizer** Quel schéma de descente de gradient est à utiliser ?\n", + "* **Metrics** : Quelles métrique de performance souhaite-on observer pendant l'entraînement ?\n", + "\n", + "Puisque nous travaillons sur un problème de classification avec plusieurs classes, la fonction de perte [`sparse_categorical_crossentropy`](https://keras.io/api/losses/probabilistic_losses/#sparsecategoricalcrossentropy-class) est celle qu'il nous faut.\n", + "\n", + "Concernant l'*optimizer* il y a plusieurs possibilités que nous verrons dans une prochaine séance. Pour le moment nous travaillerons avec une descente de gradient stochastique par mini-batch [`SGD`](https://keras.io/api/optimizers/sgd/). Pour la définir, nous devons statuer sur:\n", + "* **Learning rate** : pas de descente, on décide de choisir la valeur 0.001\n", + "* **Batch size** : nombre d'observations à considérer pour chacune des passes. On décide de prendre 32 images par batch. Cette valeur sera à renseigner un peu plus tard.\n", + "\n", + "Pour les métriques, nous suivrons l'accuracy parce que la distribution des catégories à prédire n'est pas déséquilibrées." + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [], + "source": [ + "model.compile(loss=\"sparse_categorical_crossentropy\", optimizer=keras.optimizers.SGD(learning_rate=1e-3), metrics=[\"accuracy\"])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Entraînement\n", + "\n", + "Le modèle est maintenant prêt à être entraîné, il nous reste à lui indiquer:\n", + "* **Données** : jeu d'entraînement et jeu de validation\n", + "* **Époques** : le nombre de passes à réaliser sur l'ensemble du dataset\n", + "* **Batch size** : le nombre d'observations pour chaque batch, nous avions décidé juste avant que ce serait 32" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/5\n", + "\u001b[1m1500/1500\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 906us/step - accuracy: 0.6261 - loss: 1.3248 - val_accuracy: 0.8060 - val_loss: 0.7861\n", + "Epoch 2/5\n", + "\u001b[1m1500/1500\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 851us/step - accuracy: 0.8458 - loss: 0.6035 - val_accuracy: 0.8659 - val_loss: 0.5094\n", + "Epoch 3/5\n", + "\u001b[1m1500/1500\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 849us/step - accuracy: 0.8823 - loss: 0.4368 - val_accuracy: 0.8881 - val_loss: 0.4086\n", + "Epoch 4/5\n", + "\u001b[1m1500/1500\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 909us/step - accuracy: 0.8992 - loss: 0.3635 - val_accuracy: 0.9027 - val_loss: 0.3573\n", + "Epoch 5/5\n", + "\u001b[1m1500/1500\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 973us/step - accuracy: 0.9104 - loss: 0.3201 - val_accuracy: 0.9105 - val_loss: 0.3240\n" + ] + } + ], + "source": [ + "epochs = 5\n", + "batch_size = 32\n", + "\n", + "history = model.fit(X_train, y_train, epochs=epochs, batch_size=batch_size, validation_data=(X_valid, y_valid))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nous avons des informations disponible dans l'objet *history*, plus précisement dans *history.history*\n", + "\n", + "**Consigne** : Créer un [`DataFrame`](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html) à partir de *history.history* puis inspecter-le." + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " accuracy loss val_accuracy val_loss\n", + "0 0.626104 1.324757 0.806000 0.786121\n", + "1 0.845771 0.603548 0.865917 0.509403\n", + "2 0.882333 0.436788 0.888083 0.408570\n", + "3 0.899188 0.363508 0.902667 0.357323\n", + "4 0.910375 0.320065 0.910500 0.323977\n" + ] + } + ], + "source": [ + "history_df = pd.DataFrame(history.history)\n", + "\n", + "print(history_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Consigne**: Définir une fonction `plot_learning_curves` qui prend en paramètre l'objet *history* et qui renvoie un graphique. Le graphique correspondra à deux graphiques côte à côte :\n", + "1. Le premier montre l'évolution de la fonction de perte en fonction des époques\n", + "2. Le second montre l'évolution de l'accuracy en fonction des époques\n", + "Dans les deux cas, les valeurs de performance sur le dataset de validation doivent être en pointillé. " + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_learning_curves(history_df: pd.DataFrame):\n", + " plt.figure(figsize=(12, 4))\n", + "\n", + " plt.subplot(1, 2, 1)\n", + " plt.plot(history_df['loss'], label='Training Loss')\n", + " plt.plot(history_df[\"val_loss\"], label=\"Validation Loss\")\n", + " plt.xlabel(\"Epochs\")\n", + " plt.ylabel(\"Loss\")\n", + " plt.legend()\n", + "\n", + " plt.subplot(1, 2, 2)\n", + " plt.plot(history_df['accuracy'], label='Accuracy')\n", + " plt.plot(history_df[\"val_accuracy\"], label=\"Validation Accuracy\")\n", + " plt.xlabel('Epochs')\n", + " plt.ylabel('Accuracy')\n", + " plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Consigne** : Exploiter la fonction précédente pour observer les courbes d'apprentissage du l'entraînement précédent." + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_learning_curves(history_df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exploitation des prédictions\n", + "\n", + "On souhaite à présent utiliser le modèle pour prédire le chiffre présent dans une image.\n", + "\n", + "**Consigne** : Prédire sur le jeu de test à l'aide de la méthode [`predict`](https://keras.io/api/models/model_training_apis/#predict-method), puis observer le résultat sur la première image." + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m313/313\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 584us/step\n", + "[9.74647264e-06 1.09735396e-04 9.97379541e-01 1.93832698e-03\n", + " 1.09570681e-06 1.38037314e-04 3.21713072e-04 2.27138594e-06\n", + " 9.92569549e-05 2.42889826e-07]\n", + "2\n", + "2\n" + ] + } + ], + "source": [ + "predictions = model.predict(X_test)\n", + "\n", + "print(predictions[1])\n", + "print(np.argmax(predictions[1]))\n", + "print(y_test[1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Consigne** : Après avoir vérifier que si l'on somme les chiffres affichés pour la première image vaut bien 1, identifier la classe prédite par le modèle. Vérifier visuellement." + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1. 1. 1. ... 0.9999999 0.99999994 0.9999998 ]\n" + ] + } + ], + "source": [ + "print(np.sum(predictions, axis=1))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quel est l'impact du learning rate ?\n", + "\n", + "On s'intéresse à présent à l'importance du choix du learning rate. On se propose de tester plusieurs valeurs pour obtenir les meilleurs performances.\n", + "\n", + "**Consigne** : Définir une fonction `get_model` qui prend en paramètre un `float` qui correspond à un learning rate. La fonction renvoie un modèle compilé avec les mêmes paramètres que précédemment, sauf la valeur du learning rate qui est renseignée par l'utilisateur." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Avant de lancer sur plusieurs époques, commençons par écrire une ébauche de la boucle de comparaison avec 5 époques." + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Learning rate: 0.100000 - époques: 5\n" + ] + }, + { + "ename": "NameError", + "evalue": "name 'get_model' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mNameError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[87]\u001b[39m\u001b[32m, line 8\u001b[39m\n\u001b[32m 6\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m learning_rate \u001b[38;5;129;01min\u001b[39;00m learning_rates:\n\u001b[32m 7\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33m\"\u001b[39m\u001b[33mLearning rate: \u001b[39m\u001b[38;5;132;01m%f\u001b[39;00m\u001b[33m - époques: \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[33m\"\u001b[39m % (learning_rate, n_epochs))\n\u001b[32m----> \u001b[39m\u001b[32m8\u001b[39m model = \u001b[43mget_model\u001b[49m(learning_rate=learning_rate)\n\u001b[32m 9\u001b[39m history = model.fit(X_train, y_train, epochs=n_epochs, batch_size=batch_size, validation_data=(X_valid, y_valid))\n\u001b[32m 10\u001b[39m result = {\u001b[33m\"\u001b[39m\u001b[33mlearning_rate\u001b[39m\u001b[33m\"\u001b[39m: learning_rate, \u001b[33m\"\u001b[39m\u001b[33mn_epochs\u001b[39m\u001b[33m\"\u001b[39m: n_epochs, \u001b[33m\"\u001b[39m\u001b[33mhistory\u001b[39m\u001b[33m\"\u001b[39m: pd.DataFrame(history.history)}\n", + "\u001b[31mNameError\u001b[39m: name 'get_model' is not defined" + ] + } + ], + "source": [ + "n_epochs = 5\n", + "batch_size = 32\n", + "learning_rates = [10**(-power) for power in range(1, 4)]\n", + "\n", + "results = []\n", + "for learning_rate in learning_rates:\n", + " print(\"Learning rate: %f - époques: %d\" % (learning_rate, n_epochs))\n", + " model = get_model(learning_rate=learning_rate)\n", + " history = model.fit(X_train, y_train, epochs=n_epochs, batch_size=batch_size, validation_data=(X_valid, y_valid))\n", + " result = {\"learning_rate\": learning_rate, \"n_epochs\": n_epochs, \"history\": pd.DataFrame(history.history)}\n", + " results.append(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Consigne** : Définir une fonction `show_results` qui prend en paramètre l'objet *results* construit précédemment et qui renvoie un graphique similaire à celui renvoyé par `plot_learning_curves`. Cependant, les différentes itérations doivent être présente sur chaque graphique, ici les courbes d'entraînement pour chaque learning rate, avec la bonne légende pour chaque graphique." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Consigne**: Lancer l'entraînement pour plus d'époques afin de comparer avec la fonction `show_results` les différences d'entraînement. Commenter.\n", + "\n", + "Pour gagner du temps, on pourra augmenter le batch_size à 256 voire 528. Pour éviter de surcharger l'affichage, on peut utiliser le paramètre *verbose* de la méthode `fit` : s'il vaut 0 alors il n'y a aucun affichage." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Pour continuer\n", + "\n", + "Choisir une ou plusieurs pistes de recherche parmi les suivantes. Il est possible de choisir une autre direction, mais elle doit être validé auparavant.\n", + "\n", + "1. L'initialisation des réseaux de neurones étant aléatoire, et la mise à jour des poids étant réalisées avec SGD, on ne peut pas considérer un exemple comme une généralité. Reproduire l'étude précédente en lançant plusieurs fois le même modèle pour être capable de générer un graphique avec des intervalles de confiance.\n", + "2. Nous avons vu en cours que l'initialisation des poids peut avoir un impact fort sur la suite de l'entraînement. En exploitant le paramètre `kernel_initializer` présent dans la définition de la couche [`Dense`](https://keras.io/api/layers/core_layers/dense/), proposer et réaliser une étude pour vérifier ou infirmer cela.\n", + "3. Les réseaux de neurones peuvent sur-apprendre. Il est important de pouvoir les régulariser. En exploitant le paramètre `kernel_regularizer` présent dans la définition de la couche [`Dense`](https://keras.io/api/layers/core_layers/dense/), proposer une étude pour visualiser son impact sur l'apprentissage." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "studies", + "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.13.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}