From 9be76ed450ca00d30a9ce946dd58f6f7a399b15a Mon Sep 17 00:00:00 2001 From: HuanJY <huanjie.yen@outlook.fr> Date: Sun, 2 Mar 2025 15:00:59 +0100 Subject: [PATCH] modification partie1 --- Model1.ipynb | 2047 ------------------------------------------- Partie1.ipynb | 2313 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 2313 insertions(+), 2047 deletions(-) delete mode 100644 Model1.ipynb create mode 100644 Partie1.ipynb diff --git a/Model1.ipynb b/Model1.ipynb deleted file mode 100644 index 9cfc3e1..0000000 --- a/Model1.ipynb +++ /dev/null @@ -1,2047 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "dJOfdXd0rLkq", - "outputId": "fc57f090-98f6-42cd-90e9-2cdda6b7ab6b", - "collapsed": true - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mounted at /content/drive\n" - ] - } - ], - "source": [ - "from google.colab import drive\n", - "drive.mount('/content/drive')" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "collapsed": true, - "id": "wvVRgsvbrOGi" - }, - "outputs": [], - "source": [ - "!unzip -qq \"/content/drive/MyDrive/UTKFace.zip\" -d \"/content/UTKFace\"" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "id": "vCDg6rcirX27" - }, - "outputs": [], - "source": [ - "import os\n", - "import cv2\n", - "import numpy as np\n", - "import tensorflow as tf\n", - "from tensorflow import keras\n", - "from tensorflow.keras import layers\n", - "from sklearn.model_selection import train_test_split\n", - "from sklearn.metrics import classification_report\n", - "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n", - "from sklearn.metrics import mean_absolute_error, accuracy_score\n", - "import random\n", - "import matplotlib.pyplot as plt\n", - "from tensorflow.keras.models import Sequential\n", - "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization, Input, RandomFlip, RandomRotation, RandomZoom\n", - "from tensorflow.keras.optimizers import Adam\n", - "from sklearn.metrics import classification_report" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "id": "y0TdC-l4tmTV" - }, - "outputs": [], - "source": [ - "DATA_DIR = \"/content/UTKFace/UTKFace\"\n", - "\n", - "#Redimensionnement\n", - "IMG_HEIGHT = 64\n", - "IMG_WIDTH = 64" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Visualisation de la répartition Homme - Femme" - ], - "metadata": { - "id": "uZOOhUwt6CiH" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "NXS9xwO2qlRq", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 472 - }, - "outputId": "c5e31ef9-17bb-442c-b830-4a2db8b94471" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "<Figure size 640x480 with 1 Axes>" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "file_names = os.listdir(DATA_DIR)\n", - "sex_labels = []\n", - "for file in file_names:\n", - " # Le format est \"age_sexe_ethnie_dateNaiss.jpg\"\n", - " parts = file.split('_')\n", - " if len(parts) > 1: # Vérifie que le format est correct\n", - " sex_labels.append(int(parts[1])) # Le deuxième élément est le sexe (0 = Homme, 1 = Femme)\n", - "\n", - "# Compter les occurrences pour chaque sexe\n", - "labels, counts = np.unique(sex_labels, return_counts=True)\n", - "\n", - "# Convertir les occurrences en pourcentages\n", - "percentages = (counts / counts.sum()) * 100\n", - "\n", - "# Noms des classes\n", - "class_names = [\"Homme\", \"Femme\"]\n", - "\n", - "# Visualisation en graphique à barres\n", - "plt.bar(class_names, percentages, color=['blue', 'pink'])\n", - "plt.title(\"Répartition des genres dans le dataset UTKFace\")\n", - "plt.ylabel(\"Pourcentage (%)\")\n", - "plt.xlabel(\"Genre\")\n", - "plt.ylim(0, 100) # Limiter l'axe des ordonnées de 0 à 100\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "8-j7q5m8rIm2" - }, - "source": [ - "Il y a presque autant d'homme que de femme : le dataset n'aura pas besoin de manipulations spéciales pour gérer un déséquilibre de classes." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "7gLHomJpItWM" - }, - "source": [ - "# Traitement des images d'UTKFace" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Od7n-661tvEH", - "outputId": "223d5d74-7463-440f-ed53-10dd800791ff" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Nombre d'images chargées : 23708\n", - "Dimension de X : (23708, 64, 64, 3)\n", - "Dimension de y : (23708,)\n" - ] - } - ], - "source": [ - "#TRAITEMENT DE L'IMAGE\n", - "\n", - "def load_data(data_dir=DATA_DIR):\n", - " X = [] #liste d'img après traitement convertit en NumPY\n", - " y = [] #liste contenant les genres\n", - "\n", - " # Récup tts les img dans UTKFace\n", - " file_names = os.listdir(data_dir)\n", - "\n", - " for file in file_names:\n", - " # nom de fichier type \"age_sexe_ethnie_dateNaiss.jpg\"\n", - " # On récupère le deuxième champ pour le genre\n", - " # 0 => Homme, 1 => Femme\n", - " parts = file.split(\"_\")\n", - " gender_str = parts[1]\n", - " try:\n", - " gender = int(gender_str)\n", - " except:\n", - " continue\n", - "\n", - " # lecture\n", - " img_path = os.path.join(data_dir, file)\n", - " img = cv2.imread(img_path)\n", - " if img is None:\n", - " continue\n", - "\n", - " # conversion en RGB (cv2 lit en BGR par défaut)\n", - " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", - "\n", - " # redimension\n", - " img = cv2.resize(img, (IMG_WIDTH, IMG_HEIGHT))\n", - "\n", - " # Normalisation\n", - " img = img.astype(\"float32\") / 255.0\n", - "\n", - " X.append(img)\n", - " y.append(gender)\n", - "\n", - " return np.array(X), np.array(y)\n", - "\n", - "# Chargement des données\n", - "X, y = load_data(DATA_DIR)\n", - "\n", - "print(\"Nombre d'images chargées :\", len(X))\n", - "print(\"Dimension de X :\", X.shape)\n", - "print(\"Dimension de y :\", y.shape)" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Division du jeu de données" - ], - "metadata": { - "id": "yzTOCG_P54Cr" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "7Wnkfp6KxIZP", - "outputId": "38f45d82-715a-4cf5-fba1-5183473c2269" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Taille du jeu d'entraînement : (15172, 64, 64, 3) 15172\n", - "Taille du jeu de test : (4742, 64, 64, 3) 4742\n" - ] - } - ], - "source": [ - "#DIVISER LE JEU DE DONN2ES :\n", - "\n", - "# 1. Jeu d'entraînement (X_train, y_train) : utilisé pour entraîner le modèle.\n", - " #Jeu de test (X_test, y_test) : utilisé pour évaluer les performances du modèle sur des données qu'il n'a jamais vues.\n", - "X_train, X_test, y_train, y_test = train_test_split(\n", - " X, y,\n", - " test_size=0.2, # 20% pour le jeu de test\n", - " stratify=y # Proportions de classes respectées\n", - ")\n", - "\n", - "# 2. Séparer l'entraînement en sous-ensemble d'entraînement et de validation\n", - "X_train, X_val, y_train, y_val = train_test_split(\n", - " X_train, y_train,\n", - " test_size=0.2, # 10% de l'entraînement pour la validation\n", - " stratify=y_train\n", - ")\n", - "\n", - "print(\"Taille du jeu d'entraînement :\", X_train.shape, len(y_train))\n", - "print(\"Taille du jeu de test :\", X_test.shape, len(y_test))" - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Modèle V1" - ], - "metadata": { - "id": "x4TnxLl960zS" - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 289 - }, - "id": "yHtoQAKp3U32", - "outputId": "0444574d-43ab-4506-87a9-4245c1e1caf4", - "collapsed": true - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1mModel: \"sequential\"\u001b[0m\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "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", - "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m62\u001b[0m, \u001b[38;5;34m62\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m448\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m31\u001b[0m, \u001b[38;5;34m31\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m15376\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m246,032\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m17\u001b[0m │\n", - "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┓\n", - "┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n", - "┡â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┩\n", - "│ conv2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">62</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">62</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">448</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">31</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">31</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">15376</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">246,032</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">17</span> │\n", - "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m246,497\u001b[0m (962.88 KB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">246,497</span> (962.88 KB)\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m246,497\u001b[0m (962.88 KB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">246,497</span> (962.88 KB)\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n", - "</pre>\n" - ] - }, - "metadata": {} - } - ], - "source": [ - "# PREMIER ESSAI : OBSERVATION\n", - "\n", - "def build_model_v1(input_shape=(64, 64, 3)):\n", - " model = Sequential([\n", - " Input(shape=input_shape), # Entrée du réseau (images 64 x 64 en RGB)\n", - "\n", - " Conv2D(16, (3, 3), activation='relu'), # Convolution: 16 filtres, kernel 3x3, activation ReLU\n", - " MaxPooling2D((2, 2)), # MaxPooling: réduit la dimension spatiale de moitié (64→32)\n", - "\n", - " Flatten(), # Aplatissement pour passer de la partie \"convolutive\" à la partie \"dense\"\n", - "\n", - " Dense(16, activation='relu'), # Couche fully-connected (dense) avec 16 neurones\n", - " Dense(1, activation='sigmoid') # Couche de sortie: 1 neurone pour la classification binaire (Homme/Femme)\n", - " ])\n", - "\n", - " model.compile(\n", - " optimizer=Adam(learning_rate=0.001), # Optimiseur Adam, taux d'apprentissage de 0.001\n", - " loss='binary_crossentropy', # Fonction de perte adaptée à un problème de classification binaire\n", - " metrics=['accuracy'] # Métrique principale: accuracy\n", - " )\n", - " return model\n", - "\n", - "\n", - "model_v1 = build_model_v1((64, 64, 3))\n", - "model_v1.summary()\n" - ] - }, - { - "cell_type": "markdown", - "source": [ - "Dans cette première expérimentation (V1), nous avons conçu un réseau de neurones convolutionnel (CNN) simple afin d’effectuer une classification binaire (Homme vs Femme) sur le dataset UTKFace. L’objectif principal est d’observer les performances de cette architecture de base avant d’envisager un modèle final et plus complexe.\n", - "\n", - "Les images sont redimensionnées en 64×64 pixels et converties en RGB (3 canaux). Une taille plus grande nécessiterait plus de ressources mémoire et de puissance de calcul, tandis qu’une taille plus petite pourrait entraîner une perte d’information.\n", - "\n", - "L’architecture du réseau final est construite en suivant une approche progressive. La première couche est une convolution ```Conv2D(16, (3,3), activation='relu')``` qui applique 16 filtres de taille 3×3 pour extraire des caractéristiques locales comme les bords de visage et les textures. L’activation ReLU est utilisée pour introduire de la non-linéarité et améliorer la convergence. Le nombre de filtres est volontairement limité pour cette observation.\n", - "\n", - "La couche de pooling ```MaxPooling2D((2,2))``` permet de réduire la dimension spatiale des images en divisant leur taille par deux. Cette réduction diminue le nombre de paramètres du modèle, limite le risque de surapprentissage et résume l’information en conservant les caractéristiques les plus importantes.\n", - "\n", - "La couche ```Flatten()``` transforme ensuite la sortie des couches convolutionnelles en un vecteur unidimensionnel, pour le passage aux couches fully connected.\n", - "\n", - "La couche dense ```Dense(16, activation='relu')``` est ajoutée pour combiner les caractéristiques extraites précédemment.\n", - "\n", - "Enfin, la couche de sortie ```Dense(1, activation='sigmoid')``` contient un seul neurone activé par une fonction sigmoïde, adaptée à une classification binaire. Puisqu’il s’agit d’une classification binaire (Homme vs Femme), on a un seul neurone en sortie.\n", - "La sortie prend une valeur entre 0 et 1, qu’on interprétera comme la probabilité que l’image soit classée dans la classe « Femme ».\n", - "\n", - "\n", - "Le modèle est compilé avec l’optimiseur Adam et un taux d’apprentissage de 0.001, ce qui permet une convergence sans nécessiter un réglage manuel du taux d’apprentissage. La fonction de perte choisie est la binary crossentropy, standard pour les tâches de classification binaire. L’accuracy est utilisée comme métrique pour suivre les performances du modèle lors de l’entraînement.\n", - "\n", - "Ce modèle constitue une première approche permettant d’observer comment un CNN, même simple, parvient à traiter la classification des visages dans UTKFace. Son architecture volontairement minimaliste permet d’analyser ses performances initiales avant d’explorer des améliorations telles que l’augmentation du nombre de couches convolutionnelles, l’augmentation de la taille des images d’entrée ou l’intégration de techniques de régularisation comme le Dropout et la Batch Normalization.\n" - ], - "metadata": { - "id": "CJCl-OLT74Bl" - } - }, - { - "cell_type": "code", - "source": [ - "history_v1 = model_v1.fit(\n", - " X_train, y_train,\n", - " validation_data=(X_val, y_val),\n", - " epochs=10,\n", - " batch_size=32,\n", - " verbose=1\n", - ")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "LvGPGcXg6xUD", - "outputId": "34b2ddc2-5ab3-481b-bf60-cf8ac91dfc3e" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Epoch 1/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m45s\u001b[0m 94ms/step - accuracy: 0.7638 - loss: 0.5507 - val_accuracy: 0.8442 - val_loss: 0.4396\n", - "Epoch 2/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m72s\u001b[0m 73ms/step - accuracy: 0.8412 - loss: 0.4308 - val_accuracy: 0.8611 - val_loss: 0.3800\n", - "Epoch 3/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m37s\u001b[0m 65ms/step - accuracy: 0.8565 - loss: 0.3812 - val_accuracy: 0.8743 - val_loss: 0.3433\n", - "Epoch 4/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.8659 - loss: 0.3487 - val_accuracy: 0.8648 - val_loss: 0.3372\n", - "Epoch 5/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.8771 - loss: 0.3266 - val_accuracy: 0.8326 - val_loss: 0.3912\n", - "Epoch 6/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.8784 - loss: 0.3148 - val_accuracy: 0.8724 - val_loss: 0.3130\n", - "Epoch 7/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m33s\u001b[0m 69ms/step - accuracy: 0.8937 - loss: 0.2837 - val_accuracy: 0.8740 - val_loss: 0.3077\n", - "Epoch 8/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 83ms/step - accuracy: 0.8960 - loss: 0.2737 - val_accuracy: 0.8788 - val_loss: 0.2977\n", - "Epoch 9/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 75ms/step - accuracy: 0.8994 - loss: 0.2660 - val_accuracy: 0.8811 - val_loss: 0.2926\n", - "Epoch 10/10\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m43s\u001b[0m 80ms/step - accuracy: 0.9005 - loss: 0.2620 - val_accuracy: 0.8727 - val_loss: 0.3035\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "test_loss_v1, test_acc_v1 = model_v1.evaluate(X_test, y_test, verbose=0)\n", - "print(f\"[V1] Test accuracy: {test_acc_v1:.4f}\")\n", - "\n", - "y_pred_prob_v1 = model_v1.predict(X_test)\n", - "y_pred_v1 = (y_pred_prob_v1 > 0.5).astype(\"int32\")\n", - "print(classification_report(y_test, y_pred_v1, target_names=[\"Homme\", \"Femme\"]))" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "BuL1PPSt7xNp", - "outputId": "ec1d2abc-aec0-4fb9-9213-7a232f4f0104" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[V1] Test accuracy: 0.8762\n", - "\u001b[1m149/149\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 48ms/step\n", - " precision recall f1-score support\n", - "\n", - " Homme 0.86 0.91 0.88 2478\n", - " Femme 0.89 0.84 0.87 2264\n", - "\n", - " accuracy 0.88 4742\n", - " macro avg 0.88 0.87 0.88 4742\n", - "weighted avg 0.88 0.88 0.88 4742\n", - "\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Le modèle atteint une bonne accuracy (87.62 %), ce qui est très correct pour une première version.\n", - "\n", - "Le modèle semble mieux détecter les hommes (rappel plus élevé 0.91).\n", - "À l’inverse, il a une précision légèrement meilleure sur les femmes (0.89), mais un rappel plus bas (0.84), ce qui signifie qu’il classifie plus souvent un visage féminin comme masculin que l’inverse." - ], - "metadata": { - "id": "8FAmUXY6Aoa_" - } - }, - { - "cell_type": "code", - "source": [ - "plt.figure(figsize=(10,4))\n", - "\n", - "# Courbe de la fonction de perte (Loss)\n", - "plt.subplot(1,2,1)\n", - "plt.plot(history_v1.history['loss'], label='Train Loss')\n", - "plt.plot(history_v1.history['val_loss'], label='Val Loss')\n", - "plt.xlabel('Époques')\n", - "plt.ylabel('Perte (Loss)')\n", - "plt.legend()\n", - "plt.title('[V1] Training & Validation Loss')\n", - "\n", - "# Courbe de l’Accuracy\n", - "plt.subplot(1,2,2)\n", - "plt.plot(history_v1.history['accuracy'], label='Train Accuracy')\n", - "plt.plot(history_v1.history['val_accuracy'], label='Val Accuracy')\n", - "plt.xlabel('Époques')\n", - "plt.ylabel('Exactitude (Accuracy)')\n", - "plt.legend()\n", - "plt.title('[V1] Training & Validation Accuracy')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 407 - }, - "id": "vay2vOkpAbOo", - "outputId": "502ef8be-570d-413f-f35b-1a5df4c615b8" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "<Figure size 1000x400 with 2 Axes>" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "La loss d'entraînement diminue progressivement au fil des époques, ce qui indique que le modèle apprend bien sur les données d'entraînement.\n", - "La loss de validation suit la même tendance globale, mais avec des fluctuations, notamment une hausse autour de l’époque 5, ce qui peut indiquer un début de surapprentissage.\n", - "Vers la fin, la loss de validation cesse de diminuer et commence à remonter légèrement, ce qui renforce l’hypothèse d’un léger surapprentissage après plusieurs époques.\n", - "\n", - "La précision sur l'entraînement (train accuracy) augmente continuellement, atteignant 90 %.\n", - "La précision de validation (val accuracy) augmente également mais présente une diminution temporaire autour de l’époque 5, avant de remonter.\n", - "Une différence commence à apparaître entre les courbes d’entraînement et de validation, surtout vers la fin.\n", - "\n", - "La décroissance temporaire de l’accuracy de validation est un signe que le modèle commence à mémoriser les données d'entraînement plutôt que de généraliser.\n", - "Vers la fin de l’entraînement, l’écart entre accuracy d’entraînement et de validation s'agrandit, ce qui confirme le début du surapprentissage.\n", - "\n", - "Ainsi, pour améliorer le modèle, on peut :\n", - "\n", - "- Ajouter plus de bloc pour capturer plus de caractéristiques.\n", - "- Augmenter le nombre de filtres.\n", - "- Ajouter une couche de Dropout pour éviter que le réseau ne mémorise trop les données d’entraînement.\n", - "- Ajouter un EarlyStopping pour arrêter l'entraînement s'il n'y a pas d'amélioration. " - ], - "metadata": { - "id": "i4l9cu18BLzz" - } - }, - { - "cell_type": "markdown", - "source": [ - "# Modèle V2" - ], - "metadata": { - "id": "pXkTZMgNQyPp" - } - }, - { - "cell_type": "code", - "source": [ - "def build_model_v2(input_shape=(64, 64, 3)):\n", - " model = Sequential([\n", - " Input(shape=input_shape),\n", - "\n", - " # Bloc 1\n", - " Conv2D(16, (3, 3), activation='relu'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " # Bloc 2\n", - " Conv2D(32, (3, 3), activation='relu'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " # Bloc 3\n", - " Conv2D(64, (3, 3), activation='relu'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " Flatten(),\n", - "\n", - " # Couche Dense agrandie\n", - " Dense(128, activation='relu'),\n", - " Dropout(0.3), # plus le dropout est grand, plus y'a de la régularisation\n", - "\n", - " # Sortie binaire (sigmoid pour Homme/Femme)\n", - " Dense(1, activation='sigmoid')\n", - " ])\n", - "\n", - " # Compilation\n", - " model.compile(\n", - " optimizer=Adam(learning_rate=0.001),\n", - " loss='binary_crossentropy',\n", - " metrics=['accuracy']\n", - " )\n", - " return model\n", - "\n", - "model_v2 = build_model_v2((64, 64, 3))\n", - "model_v2.summary()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 593 - }, - "id": "gZZprTDXH3Ku", - "outputId": "707ca328-d8a9-4e22-b117-8a8a8d3933cd" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1mModel: \"sequential_3\"\u001b[0m\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_3\"</span>\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "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", - "│ conv2d_7 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m62\u001b[0m, \u001b[38;5;34m62\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m448\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_6 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m62\u001b[0m, \u001b[38;5;34m62\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_7 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m31\u001b[0m, \u001b[38;5;34m31\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_8 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m29\u001b[0m, \u001b[38;5;34m29\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m4,640\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_7 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m29\u001b[0m, \u001b[38;5;34m29\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_8 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m14\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_9 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_8 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_9 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m6\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ flatten_3 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2304\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_6 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m295,040\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dropout_2 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_7 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m129\u001b[0m │\n", - "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┓\n", - "┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n", - "┡â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┩\n", - "│ conv2d_7 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">62</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">62</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">448</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_6 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">62</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">62</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_7 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">31</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">31</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_8 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">29</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">29</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">4,640</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_7 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">29</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">29</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_8 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">14</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_9 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_8 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_9 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">6</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">6</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ flatten_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">2304</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">295,040</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dropout_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_7 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">129</span> │\n", - "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m319,201\u001b[0m (1.22 MB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">319,201</span> (1.22 MB)\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m318,977\u001b[0m (1.22 MB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">318,977</span> (1.22 MB)\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m224\u001b[0m (896.00 B)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">224</span> (896.00 B)\n", - "</pre>\n" - ] - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "early_stopping = EarlyStopping(\n", - " monitor='val_loss', # Surveille la val_loss\n", - " patience=5, # Arrête si pas d'amélioration après 5 époques consécutives\n", - " restore_best_weights=True # Récupère les poids de la meilleure époque\n", - ")\n", - "\n", - "\n", - "history_v2 = model_v2.fit(\n", - " X_train, y_train,\n", - " validation_data=(X_val, y_val),\n", - " epochs=50, # Nombre max d'époques\n", - " batch_size=32,\n", - " verbose=1,\n", - " callbacks=[early_stopping]\n", - ")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "UOYt4LZwPmts", - "outputId": "aa162b31-a07a-4ad1-fc13-ef2e744679d4" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Epoch 1/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m84s\u001b[0m 168ms/step - accuracy: 0.7781 - loss: 0.5551 - val_accuracy: 0.8643 - val_loss: 0.2971\n", - "Epoch 2/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 168ms/step - accuracy: 0.8786 - loss: 0.2795 - val_accuracy: 0.8669 - val_loss: 0.2953\n", - "Epoch 3/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m79s\u001b[0m 167ms/step - accuracy: 0.8963 - loss: 0.2417 - val_accuracy: 0.8759 - val_loss: 0.2674\n", - "Epoch 4/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 168ms/step - accuracy: 0.9093 - loss: 0.2170 - val_accuracy: 0.8851 - val_loss: 0.2482\n", - "Epoch 5/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 165ms/step - accuracy: 0.9248 - loss: 0.1822 - val_accuracy: 0.8872 - val_loss: 0.2433\n", - "Epoch 6/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 164ms/step - accuracy: 0.9301 - loss: 0.1724 - val_accuracy: 0.8790 - val_loss: 0.2863\n", - "Epoch 7/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 166ms/step - accuracy: 0.9386 - loss: 0.1511 - val_accuracy: 0.8853 - val_loss: 0.2711\n", - "Epoch 8/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 167ms/step - accuracy: 0.9497 - loss: 0.1293 - val_accuracy: 0.8766 - val_loss: 0.3293\n", - "Epoch 9/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 167ms/step - accuracy: 0.9499 - loss: 0.1225 - val_accuracy: 0.8893 - val_loss: 0.2870\n", - "Epoch 10/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m79s\u001b[0m 166ms/step - accuracy: 0.9582 - loss: 0.1077 - val_accuracy: 0.8946 - val_loss: 0.2837\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "test_loss_v2, test_acc_v2 = model_v2.evaluate(X_test, y_test, verbose=0)\n", - "print(f\"[V2] Test Accuracy : {test_acc_v2:.4f}\")\n", - "\n", - "# Prédictions et rapport de classification\n", - "y_pred_prob_v2 = model_v2.predict(X_test)\n", - "y_pred_v2 = (y_pred_prob_v2 > 0.5).astype(\"int32\")\n", - "\n", - "print(classification_report(y_test, y_pred_v2, target_names=[\"Homme\", \"Femme\"]))" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Ycz_Uo0wP4qa", - "outputId": "0cc91fb3-c3f5-4253-bbc9-2657586c0312" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[V2] Test Accuracy : 0.8893\n", - "\u001b[1m149/149\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 49ms/step\n", - " precision recall f1-score support\n", - "\n", - " Homme 0.89 0.90 0.89 2478\n", - " Femme 0.89 0.87 0.88 2264\n", - "\n", - " accuracy 0.89 4742\n", - " macro avg 0.89 0.89 0.89 4742\n", - "weighted avg 0.89 0.89 0.89 4742\n", - "\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Le modèle atteint une bonne accuracy sur le test (88.93 %), ce qui reste stable par rapport à la version précédente. Les métriques de classification montrent une précision équilibrée pour les deux classes (0.89 pour les hommes et les femmes), bien qu'on observe une légère baisse du rappel pour la classe \"Femme\" (0.87), ce qui indique que le modèle a tendance à classer certaines images féminines comme masculines." - ], - "metadata": { - "id": "yfFO54hwfcBi" - } - }, - { - "cell_type": "code", - "source": [ - "plt.figure(figsize=(10,4))\n", - "\n", - "# Courbe du loss\n", - "plt.subplot(1,2,1)\n", - "plt.plot(history_v2.history['loss'], label='Train Loss')\n", - "plt.plot(history_v2.history['val_loss'], label='Val Loss')\n", - "plt.xlabel('Époques')\n", - "plt.ylabel('Perte (Loss)')\n", - "plt.legend()\n", - "plt.title('[V2] Training & Validation Loss')\n", - "\n", - "# Courbe de l'accuracy\n", - "plt.subplot(1,2,2)\n", - "plt.plot(history_v2.history['accuracy'], label='Train Accuracy')\n", - "plt.plot(history_v2.history['val_accuracy'], label='Val Accuracy')\n", - "plt.xlabel('Époques')\n", - "plt.ylabel('Exactitude (Accuracy)')\n", - "plt.legend()\n", - "plt.title('[V2] Training & Validation Accuracy')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 407 - }, - "id": "YDhNAzlQPuQR", - "outputId": "af0ec3f3-39e1-4ed5-95b0-178c11cbe435" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "<Figure size 1000x400 with 2 Axes>" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "La loss d'entraînement diminue progressivement au fil des époques, ce qui indique que le modèle apprend bien sur les données d’entraînement. Cependant, la loss de validation suit une tendance plus fluctuante et commence à remonter légèrement après quelques époques, signe d’un début de surapprentissage. Cette hausse de la perte de validation suggère que le modèle commence à mémoriser les données d'entraînement plutôt qu'à généraliser correctement.\n", - "\n", - "L'accuracy d'entraînement augmente continuellement jusqu’à atteindre environ 96 %, tandis que l'accuracy de validation évolue plus lentement, avec des fluctuations et une progression plus modérée autour de 88-89 %. Une différence commence à apparaître entre ces deux courbes, indiquant que le modèle devient trop spécifique aux données d’entraînement.\n", - "\n", - "La différence entre la loss et l’accuracy d’entraînement et de validation montre que le modèle souffre d’un léger surapprentissage, qui pourrait s’accentuer si l’entraînement se poursuivait.\n", - "\n", - "Ainsi, pour améliorer le modèle, on peut : \n", - "- Ajouter des couches\n", - "- Augmenter le Dropout\n", - "- Ajouter une autre régularisation (L2)\n", - "- Ajuster l'Early stopping\n", - "- Augmenter les données pour rendre le modèle plus robuste aux variations" - ], - "metadata": { - "id": "-SLm_Chjfh-j" - } - }, - { - "cell_type": "markdown", - "source": [ - "# Modèle V3" - ], - "metadata": { - "id": "UK29iAuIhoqO" - } - }, - { - "cell_type": "code", - "source": [ - "def build_model_v3(input_shape=(64, 64, 3)):\n", - " model = Sequential([\n", - " # Data Augmentation\n", - " Input(shape=input_shape),\n", - " RandomFlip(\"horizontal\"),\n", - " RandomRotation(0.1),\n", - " RandomZoom(0.1),\n", - "\n", - " # Bloc 1\n", - " Conv2D(16, (3, 3), activation='relu', padding='same'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " # Bloc 2\n", - " Conv2D(32, (3, 3), activation='relu', padding='same'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " # Bloc 3\n", - " Conv2D(64, (3, 3), activation='relu', padding='same'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " # Bloc 4\n", - " Conv2D(128, (3, 3), activation='relu', padding='same'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " Flatten(),\n", - "\n", - " # Couche Dense + Dropout\n", - " Dense(128, activation='relu'),\n", - " BatchNormalization(),\n", - " Dropout(0.4),\n", - "\n", - " # Sortie binaire (Homme/Femme)\n", - " Dense(1, activation='sigmoid')\n", - " ])\n", - "\n", - " # Compilation\n", - " model.compile(\n", - " optimizer=Adam(learning_rate=0.001), # LR initial\n", - " loss='binary_crossentropy',\n", - " metrics=['accuracy']\n", - " )\n", - " return model\n", - "\n", - "\n", - "model_v3 = build_model_v3((64, 64, 3))\n", - "model_v3.summary()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 849 - }, - "id": "dhGgwldShrY3", - "outputId": "7f0cb8b3-eb24-41d5-bab1-16ec28610ed4" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1mModel: \"sequential_4\"\u001b[0m\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_4\"</span>\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "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", - "│ random_flip (\u001b[38;5;33mRandomFlip\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ random_rotation (\u001b[38;5;33mRandomRotation\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ random_zoom (\u001b[38;5;33mRandomZoom\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_10 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m448\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_9 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_10 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_11 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m4,640\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_10 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_11 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_12 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_11 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_12 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_13 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_12 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_13 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ flatten_4 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2048\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_8 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m262,272\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_13 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dropout_3 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_9 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m129\u001b[0m │\n", - "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┓\n", - "┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n", - "┡â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┩\n", - "│ random_flip (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomFlip</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ random_rotation (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomRotation</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ random_zoom (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomZoom</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_10 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">448</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_9 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_10 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_11 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">4,640</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_10 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_11 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_12 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_11 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_12 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_13 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">73,856</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_12 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_13 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ flatten_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">2048</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_8 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">262,272</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_13 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dropout_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_9 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">129</span> │\n", - "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m361,313\u001b[0m (1.38 MB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">361,313</span> (1.38 MB)\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m360,577\u001b[0m (1.38 MB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">360,577</span> (1.38 MB)\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m736\u001b[0m (2.88 KB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">736</span> (2.88 KB)\n", - "</pre>\n" - ] - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# 3. Callbacks: EarlyStopping + ReduceLROnPlateau\n", - "\n", - "early_stopping = EarlyStopping(\n", - " monitor='val_loss',\n", - " patience=10,\n", - " restore_best_weights=True\n", - ")\n", - "\n", - "reduce_lr = ReduceLROnPlateau(\n", - " monitor='val_loss', # Surveille la val_loss\n", - " factor=0.5, # Divise le LR par 2\n", - " patience=3, # Après 3 époques sans amélioration\n", - " min_lr=1e-5 # LR plancher\n", - ")\n", - "\n", - "\n", - "history_v3 = model_v3.fit(\n", - " X_train, y_train,\n", - " validation_data=(X_val, y_val),\n", - " epochs=50, # Nombre max d'époques\n", - " batch_size=32,\n", - " verbose=1,\n", - " callbacks=[early_stopping, reduce_lr]\n", - ")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "collapsed": true, - "id": "pLl1oiE_iK6E", - "outputId": "482c0b95-2929-42f2-a1a3-ba69d0682a06" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Epoch 1/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m124s\u001b[0m 249ms/step - accuracy: 0.7008 - loss: 0.6607 - val_accuracy: 0.7934 - val_loss: 0.4416 - learning_rate: 0.0010\n", - "Epoch 2/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m121s\u001b[0m 254ms/step - accuracy: 0.8140 - loss: 0.4086 - val_accuracy: 0.7826 - val_loss: 0.4805 - learning_rate: 0.0010\n", - "Epoch 3/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m118s\u001b[0m 249ms/step - accuracy: 0.8377 - loss: 0.3721 - val_accuracy: 0.8458 - val_loss: 0.3414 - learning_rate: 0.0010\n", - "Epoch 4/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 250ms/step - accuracy: 0.8470 - loss: 0.3441 - val_accuracy: 0.8458 - val_loss: 0.3348 - learning_rate: 0.0010\n", - "Epoch 5/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m144s\u001b[0m 254ms/step - accuracy: 0.8498 - loss: 0.3375 - val_accuracy: 0.8376 - val_loss: 0.3677 - learning_rate: 0.0010\n", - "Epoch 6/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 253ms/step - accuracy: 0.8673 - loss: 0.3061 - val_accuracy: 0.8595 - val_loss: 0.3123 - learning_rate: 0.0010\n", - "Epoch 7/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m124s\u001b[0m 260ms/step - accuracy: 0.8675 - loss: 0.3060 - val_accuracy: 0.8693 - val_loss: 0.2866 - learning_rate: 0.0010\n", - "Epoch 8/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m139s\u001b[0m 253ms/step - accuracy: 0.8741 - loss: 0.2949 - val_accuracy: 0.8677 - val_loss: 0.2922 - learning_rate: 0.0010\n", - "Epoch 9/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 253ms/step - accuracy: 0.8726 - loss: 0.2831 - val_accuracy: 0.8904 - val_loss: 0.2553 - learning_rate: 0.0010\n", - "Epoch 10/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m118s\u001b[0m 248ms/step - accuracy: 0.8771 - loss: 0.2803 - val_accuracy: 0.8753 - val_loss: 0.2698 - learning_rate: 0.0010\n", - "Epoch 11/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m147s\u001b[0m 258ms/step - accuracy: 0.8885 - loss: 0.2610 - val_accuracy: 0.8830 - val_loss: 0.2575 - learning_rate: 0.0010\n", - "Epoch 12/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m139s\u001b[0m 253ms/step - accuracy: 0.8795 - loss: 0.2725 - val_accuracy: 0.8853 - val_loss: 0.2651 - learning_rate: 0.0010\n", - "Epoch 13/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m119s\u001b[0m 250ms/step - accuracy: 0.8940 - loss: 0.2518 - val_accuracy: 0.8935 - val_loss: 0.2386 - learning_rate: 5.0000e-04\n", - "Epoch 14/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m120s\u001b[0m 252ms/step - accuracy: 0.8956 - loss: 0.2429 - val_accuracy: 0.8962 - val_loss: 0.2448 - learning_rate: 5.0000e-04\n", - "Epoch 15/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m146s\u001b[0m 260ms/step - accuracy: 0.8985 - loss: 0.2367 - val_accuracy: 0.8896 - val_loss: 0.2534 - learning_rate: 5.0000e-04\n", - "Epoch 16/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m141s\u001b[0m 258ms/step - accuracy: 0.8990 - loss: 0.2350 - val_accuracy: 0.8911 - val_loss: 0.2422 - learning_rate: 5.0000e-04\n", - "Epoch 17/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m143s\u001b[0m 259ms/step - accuracy: 0.9039 - loss: 0.2296 - val_accuracy: 0.9043 - val_loss: 0.2261 - learning_rate: 2.5000e-04\n", - "Epoch 18/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 259ms/step - accuracy: 0.9059 - loss: 0.2282 - val_accuracy: 0.8980 - val_loss: 0.2286 - learning_rate: 2.5000e-04\n", - "Epoch 19/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m139s\u001b[0m 253ms/step - accuracy: 0.9105 - loss: 0.2152 - val_accuracy: 0.9027 - val_loss: 0.2275 - learning_rate: 2.5000e-04\n", - "Epoch 20/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m140s\u001b[0m 249ms/step - accuracy: 0.9091 - loss: 0.2123 - val_accuracy: 0.9030 - val_loss: 0.2330 - learning_rate: 2.5000e-04\n", - "Epoch 21/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m123s\u001b[0m 259ms/step - accuracy: 0.9159 - loss: 0.2069 - val_accuracy: 0.9064 - val_loss: 0.2227 - learning_rate: 1.2500e-04\n", - "Epoch 22/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m141s\u001b[0m 258ms/step - accuracy: 0.9179 - loss: 0.1945 - val_accuracy: 0.9064 - val_loss: 0.2213 - learning_rate: 1.2500e-04\n", - "Epoch 23/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 258ms/step - accuracy: 0.9160 - loss: 0.2059 - val_accuracy: 0.9072 - val_loss: 0.2212 - learning_rate: 1.2500e-04\n", - "Epoch 24/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m137s\u001b[0m 248ms/step - accuracy: 0.9147 - loss: 0.2068 - val_accuracy: 0.9067 - val_loss: 0.2187 - learning_rate: 1.2500e-04\n", - "Epoch 25/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m146s\u001b[0m 258ms/step - accuracy: 0.9132 - loss: 0.2077 - val_accuracy: 0.9080 - val_loss: 0.2228 - learning_rate: 1.2500e-04\n", - "Epoch 26/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m139s\u001b[0m 251ms/step - accuracy: 0.9213 - loss: 0.1917 - val_accuracy: 0.9059 - val_loss: 0.2207 - learning_rate: 1.2500e-04\n", - "Epoch 27/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 251ms/step - accuracy: 0.9207 - loss: 0.1923 - val_accuracy: 0.9070 - val_loss: 0.2193 - learning_rate: 1.2500e-04\n", - "Epoch 28/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m141s\u001b[0m 249ms/step - accuracy: 0.9211 - loss: 0.1944 - val_accuracy: 0.9075 - val_loss: 0.2216 - learning_rate: 6.2500e-05\n", - "Epoch 29/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 250ms/step - accuracy: 0.9224 - loss: 0.1901 - val_accuracy: 0.9072 - val_loss: 0.2174 - learning_rate: 6.2500e-05\n", - "Epoch 30/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m143s\u001b[0m 252ms/step - accuracy: 0.9226 - loss: 0.1900 - val_accuracy: 0.9072 - val_loss: 0.2185 - learning_rate: 6.2500e-05\n", - "Epoch 31/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m144s\u001b[0m 257ms/step - accuracy: 0.9222 - loss: 0.1883 - val_accuracy: 0.9064 - val_loss: 0.2203 - learning_rate: 6.2500e-05\n", - "Epoch 32/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m123s\u001b[0m 259ms/step - accuracy: 0.9199 - loss: 0.1990 - val_accuracy: 0.9070 - val_loss: 0.2195 - learning_rate: 6.2500e-05\n", - "Epoch 33/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m123s\u001b[0m 259ms/step - accuracy: 0.9252 - loss: 0.1855 - val_accuracy: 0.9077 - val_loss: 0.2165 - learning_rate: 3.1250e-05\n", - "Epoch 34/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 259ms/step - accuracy: 0.9285 - loss: 0.1811 - val_accuracy: 0.9067 - val_loss: 0.2185 - learning_rate: 3.1250e-05\n", - "Epoch 35/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m119s\u001b[0m 251ms/step - accuracy: 0.9200 - loss: 0.1889 - val_accuracy: 0.9072 - val_loss: 0.2175 - learning_rate: 3.1250e-05\n", - "Epoch 36/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m146s\u001b[0m 260ms/step - accuracy: 0.9229 - loss: 0.1899 - val_accuracy: 0.9088 - val_loss: 0.2166 - learning_rate: 3.1250e-05\n", - "Epoch 37/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m141s\u001b[0m 259ms/step - accuracy: 0.9216 - loss: 0.1882 - val_accuracy: 0.9085 - val_loss: 0.2168 - learning_rate: 1.5625e-05\n", - "Epoch 38/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m118s\u001b[0m 249ms/step - accuracy: 0.9264 - loss: 0.1811 - val_accuracy: 0.9099 - val_loss: 0.2165 - learning_rate: 1.5625e-05\n", - "Epoch 39/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m124s\u001b[0m 260ms/step - accuracy: 0.9235 - loss: 0.1876 - val_accuracy: 0.9085 - val_loss: 0.2157 - learning_rate: 1.5625e-05\n", - "Epoch 40/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m141s\u001b[0m 258ms/step - accuracy: 0.9209 - loss: 0.1911 - val_accuracy: 0.9088 - val_loss: 0.2163 - learning_rate: 1.5625e-05\n", - "Epoch 41/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m120s\u001b[0m 253ms/step - accuracy: 0.9240 - loss: 0.1861 - val_accuracy: 0.9075 - val_loss: 0.2164 - learning_rate: 1.5625e-05\n", - "Epoch 42/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m145s\u001b[0m 259ms/step - accuracy: 0.9255 - loss: 0.1825 - val_accuracy: 0.9077 - val_loss: 0.2164 - learning_rate: 1.5625e-05\n", - "Epoch 43/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m142s\u001b[0m 260ms/step - accuracy: 0.9243 - loss: 0.1792 - val_accuracy: 0.9072 - val_loss: 0.2162 - learning_rate: 1.0000e-05\n", - "Epoch 44/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m137s\u001b[0m 250ms/step - accuracy: 0.9196 - loss: 0.1988 - val_accuracy: 0.9080 - val_loss: 0.2168 - learning_rate: 1.0000e-05\n", - "Epoch 45/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m144s\u001b[0m 254ms/step - accuracy: 0.9294 - loss: 0.1797 - val_accuracy: 0.9096 - val_loss: 0.2170 - learning_rate: 1.0000e-05\n", - "Epoch 46/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m119s\u001b[0m 251ms/step - accuracy: 0.9174 - loss: 0.1915 - val_accuracy: 0.9104 - val_loss: 0.2163 - learning_rate: 1.0000e-05\n", - "Epoch 47/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m147s\u001b[0m 261ms/step - accuracy: 0.9255 - loss: 0.1844 - val_accuracy: 0.9091 - val_loss: 0.2170 - learning_rate: 1.0000e-05\n", - "Epoch 48/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m118s\u001b[0m 249ms/step - accuracy: 0.9228 - loss: 0.1818 - val_accuracy: 0.9091 - val_loss: 0.2166 - learning_rate: 1.0000e-05\n", - "Epoch 49/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m144s\u001b[0m 253ms/step - accuracy: 0.9256 - loss: 0.1840 - val_accuracy: 0.9106 - val_loss: 0.2173 - learning_rate: 1.0000e-05\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "test_loss_v3, test_acc_v3 = model_v3.evaluate(X_test, y_test, verbose=0)\n", - "print(f\"[V3] Test Loss : {test_loss_v3:.4f}\")\n", - "print(f\"[V3] Test Accuracy : {test_acc_v3:.4f}\")\n", - "\n", - "# Prédictions & rapport de classification\n", - "y_pred_prob_v3 = model_v3.predict(X_test)\n", - "y_pred_v3 = (y_pred_prob_v3 > 0.5).astype(\"int32\")\n", - "\n", - "print(classification_report(y_test, y_pred_v3, target_names=[\"Homme\", \"Femme\"]))" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "F3lzVZbmiyXP", - "outputId": "153f19e4-9f23-4e59-b1a4-cf2b228b06ab" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[V3] Test Loss : 0.2246\n", - "[V3] Test Accuracy : 0.9123\n", - "\u001b[1m149/149\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m9s\u001b[0m 62ms/step\n", - " precision recall f1-score support\n", - "\n", - " Homme 0.92 0.91 0.92 2478\n", - " Femme 0.90 0.91 0.91 2264\n", - "\n", - " accuracy 0.91 4742\n", - " macro avg 0.91 0.91 0.91 4742\n", - "weighted avg 0.91 0.91 0.91 4742\n", - "\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "Le modèle V3 obtient une accuracy de 91.23 % sur l’ensemble de test, ce qui représente une amélioration notable par rapport aux versions précédentes. Les métriques de classification indiquent une bonne équilibre entre précision et rappel :\n", - "\n", - "Précision : 92 % pour la classe \"Homme\" et 90 % pour la classe \"Femme\".\n", - "\n", - "Rappel : 91 % pour les deux classes.\n", - "\n", - "F1-score : 92 % pour \"Homme\" et 91 % pour \"Femme\".\n", - "\n", - "Ces résultats montrent que le modèle a amélioré sa capacité à bien classifier les deux classes, avec une balance plus stable entre précision et rappel.\n", - "\n" - ], - "metadata": { - "id": "O755eEPGFrFG" - } - }, - { - "cell_type": "code", - "source": [ - "plt.figure(figsize=(10,4))\n", - "\n", - "# Courbe de la fonction de perte\n", - "plt.subplot(1,2,1)\n", - "plt.plot(history_v3.history['loss'], label='Train Loss')\n", - "plt.plot(history_v3.history['val_loss'], label='Val Loss')\n", - "plt.xlabel('Époques')\n", - "plt.ylabel('Perte (Loss)')\n", - "plt.legend()\n", - "plt.title('[V3] Training & Validation Loss')\n", - "\n", - "# Courbe d’accuracy\n", - "plt.subplot(1,2,2)\n", - "plt.plot(history_v3.history['accuracy'], label='Train Accuracy')\n", - "plt.plot(history_v3.history['val_accuracy'], label='Val Accuracy')\n", - "plt.xlabel('Époques')\n", - "plt.ylabel('Exactitude (Accuracy)')\n", - "plt.legend()\n", - "plt.title('[V3] Training & Validation Accuracy')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 407 - }, - "id": "QMQwcblEiQsc", - "outputId": "9bcd2270-806c-48e7-9187-4813045c0a64" - }, - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "<Figure size 1000x400 with 2 Axes>" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "La perte d’entraînement diminue régulièrement au fil des époques, ce qui montre que le modèle apprend efficacement.\n", - "La perte de validation suit une tendance similaire, avec quelques fluctuations en début d’entraînement, mais elle reste stable après environ 20 époques.\n", - "Contrairement aux versions précédentes, la perte de validation ne remonte pas, ce qui indique que le modèle généralise mieux et présente moins de surapprentissage.\n", - "\n", - "L’accuracy d’entraînement et de validation augmente progressivement, avec une stabilisation autour de 91-92 %.\n", - "La courbe de validation reste proche de celle d’entraînement, ce qui montre que le modèle n’a pas trop sur-appris sur les données d'entraînement.\n", - "Comparé aux versions précédentes, l’écart entre les deux courbes est réduit, ce qui confirme une meilleure généralisation.\n", - "\n", - "Voyons s'il existe des changements notables en augmentant la taille des images en 200 x 200 dans une V4." - ], - "metadata": { - "id": "Gp_62U96GBIP" - } - }, - { - "cell_type": "markdown", - "source": [ - "# Modèle V4" - ], - "metadata": { - "id": "zzor8VEsdZ7f" - } - }, - { - "cell_type": "code", - "source": [ - "IMG_HEIGHT = 200\n", - "IMG_WIDTH = 200\n", - "BATCH_SIZE = 32\n", - "TEST_SIZE = 0.2\n", - "VAL_SIZE = 0.2" - ], - "metadata": { - "id": "AIu1cth8dZlI" - }, - "execution_count": 10, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# --- PRÉTRAITEMENT D'UNE IMAGE ---\n", - "def preprocess_image(image_path, label):\n", - " \"\"\"\n", - " Charge une image, la redimensionne en 200x200, et la normalise.\n", - " \"\"\"\n", - " image = tf.io.read_file(image_path)\n", - " image = tf.image.decode_jpeg(image, channels=3)\n", - " image = tf.image.resize(image, (IMG_HEIGHT, IMG_WIDTH)) # Resize en 200x200\n", - " image = image / 255.0 # Normalisation entre [0,1]\n", - " return image, label\n", - "\n", - "# --- CHARGEMENT DES FICHIERS ---\n", - "file_paths = []\n", - "labels = []\n", - "\n", - "for file in os.listdir(DATA_DIR):\n", - " parts = file.split(\"_\")\n", - " if len(parts) < 2:\n", - " continue # Évite les fichiers mal nommés\n", - "\n", - " try:\n", - " gender = int(parts[1]) # Récupère le genre (0 = Homme, 1 = Femme)\n", - " except:\n", - " continue # Ignore les erreurs\n", - "\n", - " file_paths.append(os.path.join(DATA_DIR, file))\n", - " labels.append(gender)\n", - "\n", - "file_paths = np.array(file_paths)\n", - "labels = np.array(labels)\n", - "\n", - "print(f\"Nombre total d'images : {len(file_paths)}\")\n", - "\n", - "# --- SPLIT TRAIN / TEST / VALIDATION ---\n", - "X_train, X_test, y_train, y_test = train_test_split(\n", - " file_paths, labels,\n", - " test_size=TEST_SIZE,\n", - " stratify=labels,\n", - " random_state=42\n", - ")\n", - "\n", - "X_train, X_val, y_train, y_val = train_test_split(\n", - " X_train, y_train,\n", - " test_size=VAL_SIZE,\n", - " stratify=y_train,\n", - " random_state=42\n", - ")\n", - "\n", - "print(f\"Taille du jeu d'entraînement : {len(X_train)}\")\n", - "print(f\"Taille du jeu de validation : {len(X_val)}\")\n", - "print(f\"Taille du jeu de test : {len(X_test)}\")\n", - "\n", - "# --- CRÉATION DES DATASETS TF ---\n", - "def create_tf_dataset(X, y, batch_size=BATCH_SIZE):\n", - " dataset = tf.data.Dataset.from_tensor_slices((X, y))\n", - " dataset = dataset.map(preprocess_image, num_parallel_calls=tf.data.AUTOTUNE)\n", - " dataset = dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n", - " return dataset\n", - "\n", - "train_dataset = create_tf_dataset(X_train, y_train)\n", - "val_dataset = create_tf_dataset(X_val, y_val)\n", - "test_dataset = create_tf_dataset(X_test, y_test)\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "wVC5-zfWeHlr", - "outputId": "f93ee4ab-4806-4a49-e02f-8f87b467cc91" - }, - "execution_count": 11, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Nombre total d'images : 23708\n", - "Taille du jeu d'entraînement : 15172\n", - "Taille du jeu de validation : 3794\n", - "Taille du jeu de test : 4742\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "def build_model_v4(input_shape=(200, 200, 3)): # images 200x200\n", - " model = Sequential([\n", - " # Data Augmentation\n", - " Input(shape=input_shape),\n", - " RandomFlip(\"horizontal\"),\n", - " RandomRotation(0.1),\n", - " RandomZoom(0.1),\n", - "\n", - " # Bloc 1\n", - " Conv2D(16, (3, 3), activation='relu', padding='same'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " # Bloc 2\n", - " Conv2D(32, (3, 3), activation='relu', padding='same'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " # Bloc 3\n", - " Conv2D(64, (3, 3), activation='relu', padding='same'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " # Bloc 4\n", - " Conv2D(128, (3, 3), activation='relu', padding='same'),\n", - " BatchNormalization(),\n", - " MaxPooling2D((2, 2)),\n", - "\n", - " Flatten(),\n", - "\n", - " # Couche Dense + Dropout\n", - " Dense(128, activation='relu'),\n", - " BatchNormalization(),\n", - " Dropout(0.4),\n", - "\n", - " # Sortie binaire (Homme/Femme)\n", - " Dense(1, activation='sigmoid')\n", - " ])\n", - "\n", - " # Compilation\n", - " model.compile(\n", - " optimizer=Adam(learning_rate=0.001), # LR initial\n", - " loss='binary_crossentropy',\n", - " metrics=['accuracy']\n", - " )\n", - " return model\n", - "\n", - "# Création du modèle avec images 200x200\n", - "model_v4 = build_model_v4((200, 200, 3))\n", - "model_v4.summary()\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 849 - }, - "id": "iFbhk8keeWyF", - "outputId": "fce2d98b-8e43-4305-edba-0e9b5b2748f6" - }, - "execution_count": 12, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1mModel: \"sequential\"\u001b[0m\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "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", - "│ random_flip (\u001b[38;5;33mRandomFlip\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ random_rotation (\u001b[38;5;33mRandomRotation\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ random_zoom (\u001b[38;5;33mRandomZoom\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m448\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m200\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_1 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m4,640\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_1 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m100\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_1 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_2 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_2 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m50\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_2 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m25\u001b[0m, \u001b[38;5;34m25\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_3 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m25\u001b[0m, \u001b[38;5;34m25\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_3 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m25\u001b[0m, \u001b[38;5;34m25\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_3 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m12\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m18432\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m2,359,424\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n", - "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dropout (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m129\u001b[0m │\n", - "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┓\n", - "┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n", - "┡â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┩\n", - "│ random_flip (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomFlip</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ random_rotation (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomRotation</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ random_zoom (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomZoom</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">448</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">200</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">4,640</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_1 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">100</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_2 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">50</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_2 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ conv2d_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">73,856</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_3 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">25</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ max_pooling2d_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">12</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">18432</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">2,359,424</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ batch_normalization_4 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n", - "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dropout (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", - "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", - "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">129</span> │\n", - "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m2,458,465\u001b[0m (9.38 MB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2,458,465</span> (9.38 MB)\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m2,457,729\u001b[0m (9.38 MB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">2,457,729</span> (9.38 MB)\n", - "</pre>\n" - ] - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m736\u001b[0m (2.88 KB)\n" - ], - "text/html": [ - "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">736</span> (2.88 KB)\n", - "</pre>\n" - ] - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "# --- CALLBACKS ---\n", - "early_stopping = EarlyStopping(\n", - " monitor='val_loss',\n", - " patience=10,\n", - " restore_best_weights=True\n", - ")\n", - "\n", - "reduce_lr = ReduceLROnPlateau(\n", - " monitor='val_loss',\n", - " factor=0.5,\n", - " patience=3,\n", - " min_lr=1e-5\n", - ")\n", - "\n", - "# --- ENTRAÃŽNEMENT ---\n", - "history_v4 = model_v4.fit(\n", - " train_dataset, # On utilise tf.data.Dataset\n", - " validation_data=val_dataset, # Dataset de validation\n", - " epochs=50,\n", - " verbose=1,\n", - " callbacks=[early_stopping, reduce_lr]\n", - ")\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "GHVl_r_Seh87", - "outputId": "ac2a4baa-1087-4d4e-99ad-a9c68b0e825a" - }, - "execution_count": 13, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Epoch 1/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m55s\u001b[0m 77ms/step - accuracy: 0.7097 - loss: 0.6660 - val_accuracy: 0.7406 - val_loss: 0.4979 - learning_rate: 0.0010\n", - "Epoch 2/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m70s\u001b[0m 64ms/step - accuracy: 0.7972 - loss: 0.4429 - val_accuracy: 0.8276 - val_loss: 0.3784 - learning_rate: 0.0010\n", - "Epoch 3/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 64ms/step - accuracy: 0.8140 - loss: 0.4023 - val_accuracy: 0.8506 - val_loss: 0.3337 - learning_rate: 0.0010\n", - "Epoch 4/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 65ms/step - accuracy: 0.8299 - loss: 0.3719 - val_accuracy: 0.8263 - val_loss: 0.4084 - learning_rate: 0.0010\n", - "Epoch 5/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.8458 - loss: 0.3499 - val_accuracy: 0.8656 - val_loss: 0.3027 - learning_rate: 0.0010\n", - "Epoch 6/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 67ms/step - accuracy: 0.8550 - loss: 0.3289 - val_accuracy: 0.8735 - val_loss: 0.2854 - learning_rate: 0.0010\n", - "Epoch 7/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 64ms/step - accuracy: 0.8593 - loss: 0.3158 - val_accuracy: 0.8342 - val_loss: 0.3737 - learning_rate: 0.0010\n", - "Epoch 8/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 64ms/step - accuracy: 0.8626 - loss: 0.3073 - val_accuracy: 0.8598 - val_loss: 0.3253 - learning_rate: 0.0010\n", - "Epoch 9/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m32s\u001b[0m 66ms/step - accuracy: 0.8764 - loss: 0.2829 - val_accuracy: 0.8682 - val_loss: 0.2945 - learning_rate: 0.0010\n", - "Epoch 10/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 65ms/step - accuracy: 0.8847 - loss: 0.2756 - val_accuracy: 0.9001 - val_loss: 0.2336 - learning_rate: 5.0000e-04\n", - "Epoch 11/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.8910 - loss: 0.2552 - val_accuracy: 0.8983 - val_loss: 0.2448 - learning_rate: 5.0000e-04\n", - "Epoch 12/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 66ms/step - accuracy: 0.8998 - loss: 0.2410 - val_accuracy: 0.8935 - val_loss: 0.2493 - learning_rate: 5.0000e-04\n", - "Epoch 13/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 64ms/step - accuracy: 0.8959 - loss: 0.2402 - val_accuracy: 0.8959 - val_loss: 0.2518 - learning_rate: 5.0000e-04\n", - "Epoch 14/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.9089 - loss: 0.2293 - val_accuracy: 0.9114 - val_loss: 0.2217 - learning_rate: 2.5000e-04\n", - "Epoch 15/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 66ms/step - accuracy: 0.9117 - loss: 0.2206 - val_accuracy: 0.9101 - val_loss: 0.2197 - learning_rate: 2.5000e-04\n", - "Epoch 16/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 64ms/step - accuracy: 0.9102 - loss: 0.2147 - val_accuracy: 0.9149 - val_loss: 0.2108 - learning_rate: 2.5000e-04\n", - "Epoch 17/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m30s\u001b[0m 64ms/step - accuracy: 0.9151 - loss: 0.2086 - val_accuracy: 0.9101 - val_loss: 0.2245 - learning_rate: 2.5000e-04\n", - "Epoch 18/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 66ms/step - accuracy: 0.9193 - loss: 0.2044 - val_accuracy: 0.9091 - val_loss: 0.2198 - learning_rate: 2.5000e-04\n", - "Epoch 19/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 66ms/step - accuracy: 0.9181 - loss: 0.2038 - val_accuracy: 0.9077 - val_loss: 0.2224 - learning_rate: 2.5000e-04\n", - "Epoch 20/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.9207 - loss: 0.1964 - val_accuracy: 0.9122 - val_loss: 0.2096 - learning_rate: 1.2500e-04\n", - "Epoch 21/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 64ms/step - accuracy: 0.9241 - loss: 0.1872 - val_accuracy: 0.9106 - val_loss: 0.2184 - learning_rate: 1.2500e-04\n", - "Epoch 22/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 64ms/step - accuracy: 0.9256 - loss: 0.1873 - val_accuracy: 0.9159 - val_loss: 0.2095 - learning_rate: 1.2500e-04\n", - "Epoch 23/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 64ms/step - accuracy: 0.9239 - loss: 0.1861 - val_accuracy: 0.9154 - val_loss: 0.2066 - learning_rate: 1.2500e-04\n", - "Epoch 24/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 63ms/step - accuracy: 0.9296 - loss: 0.1800 - val_accuracy: 0.9183 - val_loss: 0.2081 - learning_rate: 1.2500e-04\n", - "Epoch 25/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 64ms/step - accuracy: 0.9279 - loss: 0.1808 - val_accuracy: 0.9109 - val_loss: 0.2185 - learning_rate: 1.2500e-04\n", - "Epoch 26/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m42s\u001b[0m 65ms/step - accuracy: 0.9304 - loss: 0.1807 - val_accuracy: 0.9178 - val_loss: 0.2100 - learning_rate: 1.2500e-04\n", - "Epoch 27/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 66ms/step - accuracy: 0.9311 - loss: 0.1713 - val_accuracy: 0.9196 - val_loss: 0.2076 - learning_rate: 6.2500e-05\n", - "Epoch 28/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m40s\u001b[0m 64ms/step - accuracy: 0.9313 - loss: 0.1776 - val_accuracy: 0.9172 - val_loss: 0.2110 - learning_rate: 6.2500e-05\n", - "Epoch 29/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 64ms/step - accuracy: 0.9351 - loss: 0.1703 - val_accuracy: 0.9167 - val_loss: 0.2144 - learning_rate: 6.2500e-05\n", - "Epoch 30/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 64ms/step - accuracy: 0.9332 - loss: 0.1696 - val_accuracy: 0.9199 - val_loss: 0.2079 - learning_rate: 3.1250e-05\n", - "Epoch 31/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m31s\u001b[0m 65ms/step - accuracy: 0.9321 - loss: 0.1679 - val_accuracy: 0.9204 - val_loss: 0.2091 - learning_rate: 3.1250e-05\n", - "Epoch 32/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.9345 - loss: 0.1653 - val_accuracy: 0.9191 - val_loss: 0.2099 - learning_rate: 3.1250e-05\n", - "Epoch 33/50\n", - "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m41s\u001b[0m 65ms/step - accuracy: 0.9350 - loss: 0.1658 - val_accuracy: 0.9183 - val_loss: 0.2103 - learning_rate: 1.5625e-05\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Évaluation du modèle\n", - "test_loss_v4, test_acc_v4 = model_v4.evaluate(test_dataset, verbose=0)\n", - "print(f\"[V4] Test Loss : {test_loss_v4:.4f}\")\n", - "print(f\"[V4] Test Accuracy : {test_acc_v4:.4f}\")\n", - "\n", - "# Génération des prédictions\n", - "y_pred_prob_v4 = model_v4.predict(test_dataset) # Déjà bien formaté\n", - "\n", - "# Convertir les probabilités en classes (0 ou 1)\n", - "y_pred_v4 = (y_pred_prob_v4 > 0.5).astype(\"int32\")\n", - "\n", - "# Comme y_test est un array numpy, récupérons les vraies étiquettes du dataset\n", - "y_true_v4 = np.concatenate([y for _, y in test_dataset], axis=0)\n", - "\n", - "# Affichage du rapport de classification\n", - "print(classification_report(y_true_v4, y_pred_v4, target_names=[\"Homme\", \"Femme\"]))\n", - "\n", - "plt.figure(figsize=(10,4))\n", - "\n", - "# Courbe de la fonction de perte\n", - "plt.subplot(1,2,1)\n", - "plt.plot(history_v4.history['loss'], label='Train Loss')\n", - "plt.plot(history_v4.history['val_loss'], label='Val Loss')\n", - "plt.xlabel('Époques')\n", - "plt.ylabel('Perte (Loss)')\n", - "plt.legend()\n", - "plt.title('[V4] Training & Validation Loss')\n", - "\n", - "# Courbe d’accuracy\n", - "plt.subplot(1,2,2)\n", - "plt.plot(history_v4.history['accuracy'], label='Train Accuracy')\n", - "plt.plot(history_v4.history['val_accuracy'], label='Val Accuracy')\n", - "plt.xlabel('Époques')\n", - "plt.ylabel('Exactitude (Accuracy)')\n", - "plt.legend()\n", - "plt.title('[V4] Training & Validation Accuracy')\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 615 - }, - "id": "3mqS6oMFfVBV", - "outputId": "f0c01e28-940b-4fe7-8780-60fd8e1271ae" - }, - "execution_count": 14, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[V4] Test Loss : 0.2019\n", - "[V4] Test Accuracy : 0.9203\n", - "\u001b[1m149/149\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m3s\u001b[0m 16ms/step\n", - " precision recall f1-score support\n", - "\n", - " Homme 0.93 0.92 0.92 2478\n", - " Femme 0.91 0.92 0.92 2264\n", - "\n", - " accuracy 0.92 4742\n", - " macro avg 0.92 0.92 0.92 4742\n", - "weighted avg 0.92 0.92 0.92 4742\n", - "\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "<Figure size 1000x400 with 2 Axes>" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - " En 200x200, le modèle apprend plus vite (convergence en 30 epochs), mais consomme plus de ressources GPU.\n", - "\n", - " Les performances obtenues en 64x64 et 200x200 sont très proches, avec une accuracy test de 91.2% vs 92.3% et un F1-score quasi identique. Bien que la version 200x200 montre une légère amélioration, l'écart est minime et ne justifie pas forcément l'augmentation du coût de calcul.\n", - "\n", - " En effet, ici, le modèle 64x64 est plus rapide et consomme moins de ressources tout en atteignant un niveau de précision très similaire.\n", - "\n", - " Cela s'explique car les images sont de mauvaise qualité. Augmenter la résolution à 200x200 ne va pas \"inventer\" des détails supplémentaires. Le CNN va simplement apprendre sur une version plus grande de la même mauvaise qualité." - ], - "metadata": { - "id": "DTqz5i7eomJu" - } - } - ], - "metadata": { - "colab": { - "provenance": [], - "toc_visible": true, - "gpuType": "T4" - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - }, - "accelerator": "GPU" - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/Partie1.ipynb b/Partie1.ipynb new file mode 100644 index 0000000..da1f4e9 --- /dev/null +++ b/Partie1.ipynb @@ -0,0 +1,2313 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "\n", + "# Classification de Genre avec CNN" + ], + "metadata": { + "id": "aZsTXyU2kzh_" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dJOfdXd0rLkq", + "outputId": "13ab30ca-baf0-4cce-dbde-315b63871de9", + "collapsed": true + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Mounted at /content/drive\n" + ] + } + ], + "source": [ + "from google.colab import drive\n", + "drive.mount('/content/drive')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true, + "id": "wvVRgsvbrOGi" + }, + "outputs": [], + "source": [ + "!unzip -qq \"/content/drive/MyDrive/UTKFace.zip\" -d \"/content/UTKFace\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "vCDg6rcirX27" + }, + "outputs": [], + "source": [ + "#Importation des bibliothèques\n", + "#Bibliothèques standards\n", + "import os\n", + "import random\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import cv2\n", + "\n", + "#TensorFlow & Keras\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras.models import Sequential\n", + "from tensorflow.keras.layers import (\n", + " Conv2D, MaxPooling2D, Flatten, Dense, Dropout, BatchNormalization,\n", + " Input, RandomFlip, RandomRotation, RandomZoom\n", + ")\n", + "from tensorflow.keras.optimizers import Adam\n", + "from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, ReduceLROnPlateau\n", + "\n", + "# Scikit-learn\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import (\n", + " classification_report, accuracy_score, mean_absolute_error\n", + ")\n" + ] + }, + { + "cell_type": "code", + "source": [ + "DATA_DIR = \"/content/UTKFace/UTKFace\"" + ], + "metadata": { + "id": "a6Y6ISogUs21" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "y0TdC-l4tmTV" + }, + "outputs": [], + "source": [ + "#Redimensionnement\n", + "IMG_HEIGHT = 64\n", + "IMG_WIDTH = 64" + ] + }, + { + "cell_type": "markdown", + "source": [ + "##Visualisation de la répartition des sexes" + ], + "metadata": { + "id": "uZOOhUwt6CiH" + } + }, + { + "cell_type": "markdown", + "source": [ + "Avant de construire un modèle de classification basé sur un réseau de neurones convolutifs (CNN), nous analysons la répartition des données.\n", + "\n", + "Cette étape permet de vérifier si le dataset est équilibré entre les classes, ici les genres \"Homme\" et \"Femme\".\n", + "\n", + "Un déséquilibre dans les données pourrait entraîner un biais dans l’apprentissage du modèle, qui risquerait alors de mieux reconnaître la classe majoritaire au détriment de l’autre.\n", + "\n", + "Une visualisation sous forme d’histogramme permet donc d’identifier d’éventuelles disparités et d’envisager solutions comme l’augmentation des données ou la pondération des classes dans la fonction de perte." + ], + "metadata": { + "id": "wG0g8LU_oBc4" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NXS9xwO2qlRq", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 478 + }, + "outputId": "8a8b5cfb-5273-49dd-ca6f-07f9dd6154f7" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# Le format des images est nommé de la manière suivante : \"age_sexe_ethnie_dateNaiss.jpg\"\n", + "\n", + "file_names = os.listdir(DATA_DIR)\n", + "sex_labels = []\n", + "for file in file_names:\n", + " parts = file.split('_')\n", + " if len(parts) > 1: # Vérifie que le format est correct\n", + " sex_labels.append(int(parts[1])) # Le deuxième élément est le sexe (0 = Homme, 1 = Femme)\n", + "\n", + "# Compter les occurrences pour chaque sexe\n", + "labels, counts = np.unique(sex_labels, return_counts=True)\n", + "\n", + "# Convertir les occurrences en pourcentages\n", + "percentages = (counts / counts.sum()) * 100\n", + "\n", + "# Noms des classes\n", + "class_names = [\"Homme\", \"Femme\"]\n", + "\n", + "# Visualisation en graphique à barres\n", + "plt.bar(class_names, percentages, color=['#AEC6CF', '#FFB6C1'], alpha=0.7)\n", + "plt.title(\"Répartition des genres dans le dataset UTKFace\", fontsize=14)\n", + "plt.ylabel(\"Pourcentage (%)\", fontsize=12)\n", + "plt.xlabel(\"Genre\", fontsize=12)\n", + "plt.ylim(0, 100)\n", + "plt.grid(axis='y', linestyle='--', alpha=0.6)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8-j7q5m8rIm2" + }, + "source": [ + "L’histogramme montre que le dataset UTKFace contient une légère dominance des images associées à la classe \"Homme\" par rapport à la classe \"Femme\" (environ 55% contre 45%).\n", + "\n", + "Bien que cet écart ne soit pas extrêmement marqué, il peut influencer la performance du modèle si celui-ci tend à privilégier la classe majoritaire.\n", + "\n", + "Une attention particulière sera donc portée à l’évaluation des métriques de performance (précision, rappel, F1-score) afin de s’assurer que le modèle ne favorise pas une classe au détriment de l’autre." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7gLHomJpItWM" + }, + "source": [ + "## Traitement des images d'UTKFace" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Avant d'entraîner notre modèle CNN, nous prétraitons les images.\n", + "\n", + "Le code ci-dessus effectue plusieurs étapes pour charger, nettoyer et préparer les images du dataset UTKFace:" + ], + "metadata": { + "id": "yzjcIjIoqLxH" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Od7n-661tvEH" + }, + "outputs": [], + "source": [ + "#TRAITEMENT DE L'IMAGE\n", + "\n", + "def load_data(data_dir=DATA_DIR):\n", + " X = [] #liste d'img après traitement convertit en NumPY\n", + " y = [] #liste contenant les genres\n", + "\n", + " # Récup tts les img dans UTKFace\n", + " file_names = os.listdir(data_dir)\n", + "\n", + " for file in file_names:\n", + " # nom de fichier type \"age_sexe_ethnie_dateNaiss.jpg\"\n", + " # On récupère le deuxième champ pour le genre\n", + " # 0 => Homme, 1 => Femme\n", + " parts = file.split(\"_\")\n", + " gender_str = parts[1]\n", + " try:\n", + " gender = int(gender_str)\n", + " except:\n", + " continue\n", + "\n", + " # lecture\n", + " img_path = os.path.join(data_dir, file)\n", + " img = cv2.imread(img_path)\n", + " if img is None:\n", + " continue\n", + "\n", + " # conversion en RGB (cv2 lit en BGR par défaut)\n", + " img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n", + "\n", + " # redimension\n", + " img = cv2.resize(img, (IMG_WIDTH, IMG_HEIGHT))\n", + "\n", + " # Normalisation\n", + " img = img.astype(\"float32\") / 255.0\n", + "\n", + " X.append(img)\n", + " y.append(gender)\n", + "\n", + " return np.array(X), np.array(y)\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Tout d'abord, nous récupérons la liste des fichiers images présents dans le dossier contenant le dataset.\n", + "\n", + "Chaque fichier suit un format de nommage standard : \"age_sexe_ethnie_dateNaiss.jpg\", où la deuxième valeur représente le genre (0 pour homme, 1 pour femme).\n", + "\n", + "Nous extrayons cette valeur pour créer notre vecteur ```y```, qui servira de labels pour la classification.\n", + "\n", + "Ensuite, chaque image est chargée:\n", + " ```(cv2.imread())```.\n", + "\n", + "Par défaut, OpenCV charge les images en format BGR, nous les convertissons donc en RGB : ```(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))```.\n", + "\n", + "Une fois convertie, l’image est redimensionnée ```(cv2.resize(img, (IMG_WIDTH, IMG_HEIGHT)))``` à une taille définie (64x64 pixels dans notre cas).\n", + "\n", + "Enfin, nous normalisons les valeurs des pixels en les divisant par 255 : ```(img.astype(\"float32\") / 255.0)```, ce qui permet d'avoir des valeurs comprises entre 0 et 1.\n", + "\n", + "Les images traitées sont stockées dans un tableau ```X```, et les labels correspondants dans ```y```." + ], + "metadata": { + "id": "UNea5GFHqn41" + } + }, + { + "cell_type": "code", + "source": [ + "# Chargement des données\n", + "X, y = load_data(DATA_DIR)\n", + "\n", + "print(\"Nombre d'images chargées :\", len(X))\n", + "print(\"Dimension de X :\", X.shape)\n", + "print(\"Dimension de y :\", y.shape)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3idVADgIqnkc", + "outputId": "f67d0997-62ab-4c5a-8006-1256249beeeb" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Nombre d'images chargées : 23708\n", + "Dimension de X : (23708, 64, 64, 3)\n", + "Dimension de y : (23708,)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Le chargement et le prétraitement ont permis d’obtenir 23 708 images, toutes converties au format RGB, redimensionnées et normalisées.\n", + "\n", + "Les dimensions finales des tableaux de données sont :\n", + "\n", + "```X.shape``` : (23708, 64, 64, 3), indiquant que nous avons 23 708 images de taille 64x64 avec 3 canaux de couleurs (RGB).\n", + "\n", + "```y.shape``` : (23708,), représentant le vecteur des labels associés à chaque image." + ], + "metadata": { + "id": "Yum7GH7crXKW" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Division du jeu de données" + ], + "metadata": { + "id": "yzTOCG_P54Cr" + } + }, + { + "cell_type": "markdown", + "source": [ + "Pour évaluer correctement la capacité de généralisation d’un modèle, nous séparons les données en plusieurs sous-ensembles :\n", + "\n", + "- **Jeu d’entraînement (train) 64%** : Est la partie la plus importante car c'est là où le modèle apprend. Plus il y a de données, mieux il pourra généraliser.\n", + "\n", + " On pourrait vouloir 80-90% pour l'entraînement, mais cela signifie moins de données pour la validation.\n", + "\n", + " Or, sans validation, on ne pourrait pas mesurer correctement si le modèle est en train de sur-apprendre (overfitting).\n", + "\n", + "\n", + "- **Jeu de validation (val) 20%** : Permet d’affiner les hyperparamètres (nombre d’époques, taux d’apprentissage, etc.) et de détecter le surapprentissage (overfitting). \n", + "Si on met trop peu (ex. 5-10%), les ajustements risquent d’être moins précis.\n", + "\n", + " Si on met trop (ex. 30-40%), il reste trop peu de données pour entraîner le modèle.\n", + "\n", + "\n", + "- **Jeu de test (test) 20%** : Utilisé uniquement pour évaluer les performances finales du modèle sur des données qu’il n’a jamais vues. Il sert à estimer comment le modèle se comportera sur des nouvelles images dans un contexte réel/\n", + "\n", + " Si on prend trop peu de données en test (<10%), la mesure de performance sera peu fiable.\n", + "\n", + " Si on prend trop de données en test (>30%), on réduit trop l’ensemble d'entraînement et le modèle risque d’apprendre moins bien." + ], + "metadata": { + "id": "LPIizvr8th4b" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7Wnkfp6KxIZP", + "outputId": "e42c98dc-aead-4c8a-971c-dc8b76ba6c9b" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Taille du jeu d'entraînement : (15172, 64, 64, 3) 15172\n", + "Taille du jeu de test : (4742, 64, 64, 3) 4742\n" + ] + } + ], + "source": [ + "#DIVISER LE JEU DE DONN2ES :\n", + "\n", + "# 1. Jeu d'entraînement (X_train, y_train) : utilisé pour entraîner le modèle.\n", + " #Jeu de test (X_test, y_test) : utilisé pour évaluer les performances du modèle sur des données qu'il n'a jamais vues.\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " X, y,\n", + " test_size=0.2, # 20% pour le jeu de test\n", + " stratify=y # Proportions de classes respectées\n", + ")\n", + "\n", + "# 2. Séparer l'entraînement en sous-ensemble d'entraînement et de validation\n", + "X_train, X_val, y_train, y_val = train_test_split(\n", + " X_train, y_train,\n", + " test_size=0.2, # 10% de l'entraînement pour la validation\n", + " stratify=y_train\n", + ")\n", + "\n", + "print(\"Taille du jeu d'entraînement :\", X_train.shape, len(y_train))\n", + "print(\"Taille du jeu de test :\", X_test.shape, len(y_test))" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## I. Première Observation : Implémentation d'un Modèle Simple" + ], + "metadata": { + "id": "x4TnxLl960zS" + } + }, + { + "cell_type": "markdown", + "source": [ + "Avant d'élaborer un grand modèle, nous commencerons par une première expérimentation avec une architecture simple.\n", + "\n", + "L'objectif ici est d'obtenir une première estimation de la performance d'un CNN minimaliste sur la classification de genre avec le dataset UTKFace.\n", + "\n", + "Cette approche permet d'identifier les améliorations pour les prochaines versions du modèle." + ], + "metadata": { + "id": "bmEatwHB17Kd" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Implémentation 1" + ], + "metadata": { + "id": "I2bOiv6-2hGz" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 289 + }, + "id": "yHtoQAKp3U32", + "outputId": "5a7fc2a7-7335-484f-e5dd-e9fb81ed5eed", + "collapsed": true + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1mModel: \"sequential\"\u001b[0m\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential\"</span>\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "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", + "│ conv2d (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m62\u001b[0m, \u001b[38;5;34m62\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m448\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m31\u001b[0m, \u001b[38;5;34m31\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ flatten (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m15376\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m246,032\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_1 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m17\u001b[0m │\n", + "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┓\n", + "┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n", + "┡â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┩\n", + "│ conv2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">62</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">62</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">448</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">31</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">31</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ flatten (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">15376</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">246,032</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_1 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">17</span> │\n", + "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m246,497\u001b[0m (962.88 KB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">246,497</span> (962.88 KB)\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m246,497\u001b[0m (962.88 KB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">246,497</span> (962.88 KB)\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> (0.00 B)\n", + "</pre>\n" + ] + }, + "metadata": {} + } + ], + "source": [ + "# PREMIER ESSAI : OBSERVATION\n", + "\n", + "def build_model_v1(input_shape=(64, 64, 3)):\n", + " model = Sequential([\n", + " Input(shape=input_shape), # Entrée du réseau (images 64 x 64 en RGB)\n", + "\n", + " Conv2D(16, (3, 3), activation='relu'), # Convolution: 16 filtres, kernel 3x3, activation ReLU\n", + " MaxPooling2D((2, 2)), # MaxPooling: réduit la dimension spatiale de moitié (64→32)\n", + "\n", + " Flatten(), # Aplatissement pour passer de la partie \"convolutive\" à la partie \"dense\"\n", + "\n", + " Dense(16, activation='relu'), # Couche fully-connected (dense) avec 16 neurones\n", + " Dense(1, activation='sigmoid') # Couche de sortie: 1 neurone pour la classification binaire (Homme/Femme)\n", + " ])\n", + "\n", + " model.compile(\n", + " optimizer=Adam(learning_rate=0.001), # Optimiseur Adam, taux d'apprentissage de 0.001\n", + " loss='binary_crossentropy', # Fonction de perte adaptée à un problème de classification binaire\n", + " metrics=['accuracy'] # Métrique principale: accuracy\n", + " )\n", + " return model\n", + "\n", + "\n", + "model_v1 = build_model_v1((64, 64, 3))\n", + "model_v1.summary()\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Le modèle V1 a été conçu avec une architecture volontairement simple, utilisant peu de paramètres, afin de tester si une structure minimale permet déjà d’extraire suffisamment d’informations pour réaliser la classification.\n", + "\n", + "1. Choix de la taille des images (64x64x3) :\n", + " - Les images ont été réduites à 64x64 pixels avec 3 canaux (RGB).\n", + " Une taille plus grande (~128x128 ou 256x256) aurait offert plus de détails, mais l’objectif étant de détecter des caractéristiques globales du visage (formes, structures), une résolution modérée suffit pour un premier test.\n", + "\n", + "2. Couche Flatten() :\n", + " - Le Flatten est essentiel pour transformer les sorties 2D de la convolution en un vecteur 1D, qui pourra être utilisé par les couches denses suivantes.\n", + "\n", + "3. Couche de sortie Dense(1, activation='sigmoid') :\n", + " - Un seul neurone en sortie, car il s’agit d’une classification binaire (homme ou femme).\n", + " - L’activation sigmoïde est choisie car elle permet de produire une probabilité entre 0 et 1, ce qui est adapté aux problèmes de classification binaire.\n" + ], + "metadata": { + "id": "CJCl-OLT74Bl" + } + }, + { + "cell_type": "code", + "source": [ + "history_v1 = model_v1.fit(\n", + " X_train, y_train,\n", + " validation_data=(X_val, y_val),\n", + " epochs=10,\n", + " batch_size=32,\n", + " verbose=1\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "LvGPGcXg6xUD", + "outputId": "fb6cab87-25b7-4993-ebd7-49191f9d61fb" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 41ms/step - accuracy: 0.7249 - loss: 0.5249 - val_accuracy: 0.8653 - val_loss: 0.3415\n", + "Epoch 2/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 42ms/step - accuracy: 0.8599 - loss: 0.3291 - val_accuracy: 0.8846 - val_loss: 0.2966\n", + "Epoch 3/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m19s\u001b[0m 39ms/step - accuracy: 0.8799 - loss: 0.2867 - val_accuracy: 0.8851 - val_loss: 0.2721\n", + "Epoch 4/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 39ms/step - accuracy: 0.8858 - loss: 0.2689 - val_accuracy: 0.8856 - val_loss: 0.2709\n", + "Epoch 5/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m21s\u001b[0m 41ms/step - accuracy: 0.8937 - loss: 0.2509 - val_accuracy: 0.8880 - val_loss: 0.2716\n", + "Epoch 6/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m20s\u001b[0m 39ms/step - accuracy: 0.9046 - loss: 0.2336 - val_accuracy: 0.8888 - val_loss: 0.2780\n", + "Epoch 7/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 36ms/step - accuracy: 0.9060 - loss: 0.2246 - val_accuracy: 0.8914 - val_loss: 0.2656\n", + "Epoch 8/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m23s\u001b[0m 41ms/step - accuracy: 0.9135 - loss: 0.2146 - val_accuracy: 0.8524 - val_loss: 0.3565\n", + "Epoch 9/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m24s\u001b[0m 50ms/step - accuracy: 0.9163 - loss: 0.2107 - val_accuracy: 0.8880 - val_loss: 0.2729\n", + "Epoch 10/10\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m36s\u001b[0m 41ms/step - accuracy: 0.9272 - loss: 0.1821 - val_accuracy: 0.8896 - val_loss: 0.2761\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Analyse des métriques" + ], + "metadata": { + "id": "in-jmVJD6O7E" + } + }, + { + "cell_type": "code", + "source": [ + "# Évaluation sur le jeu de test\n", + "\n", + "test_loss_v1, test_acc_v1 = model_v1.evaluate(X_test, y_test, verbose=0)\n", + "print(f\"[V1] Test accuracy: {test_acc_v1:.4f}\")\n", + "\n", + "# Prédictions sur le jeu de test\n", + "y_pred_prob_v1 = model_v1.predict(X_test)\n", + "y_pred_v1 = (y_pred_prob_v1 > 0.5).astype(\"int32\")\n", + "\n", + "# Rapport de classification pour le jeu de test\n", + "print(classification_report(y_test, y_pred_v1, target_names=[\"Homme\", \"Femme\"]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BuL1PPSt7xNp", + "outputId": "4e818b04-a698-4d77-ebe9-aa242ec54340" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[V1] Test accuracy: 0.8764\n", + "\u001b[1m149/149\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m2s\u001b[0m 16ms/step\n", + " precision recall f1-score support\n", + "\n", + " Homme 0.86 0.92 0.89 2478\n", + " Femme 0.90 0.83 0.87 2264\n", + "\n", + " accuracy 0.88 4742\n", + " macro avg 0.88 0.87 0.88 4742\n", + "weighted avg 0.88 0.88 0.88 4742\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + " **Métriques sur le jeu de test :**\n", + "\n", + "\n", + "L’accuracy globale de 87.64 % indique que le modèle fait des prédictions correctes dans la majorité des cas.\n", + "\n", + "Le modèle détecte mieux les hommes que les femmes (rappel 0.92 vs 0.83).\n", + "\n", + "Cela signifie qu’il a tendance à classer certaines femmes à tort comme des hommes.\n", + "\n", + "La précision est légèrement meilleure pour la classe \"Femme\" (0.90 contre 0.86 pour \"Homme\"), ce qui signifie que lorsqu'il prédit \"Femme\", il a généralement raison.\n", + "\n", + "\n", + "L’écart entre le rappel des deux classes montre que le modèle a un biais, possiblement dû à un déséquilibre dans les données ou à une difficulté du modèle à extraire des caractéristiques discriminantes pour la classe \"Femme\"." + ], + "metadata": { + "id": "ryCXTsIS_ji8" + } + }, + { + "cell_type": "code", + "source": [ + "# Évaluation sur le jeu de validation\n", + "test_loss_val, test_acc_val = model_v1.evaluate(X_val, y_val, verbose=0)\n", + "print(f\"[V1] Validation accuracy: {test_acc_val:.4f}\")\n", + "\n", + "# Prédictions sur le jeu de validation\n", + "y_pred_prob_val = model_v1.predict(X_val)\n", + "y_pred_val = (y_pred_prob_val > 0.5).astype(\"int32\")\n", + "\n", + "# Rapport de classification pour le jeu de validation\n", + "print(classification_report(y_val, y_pred_val, target_names=[\"Homme\", \"Femme\"]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qO3KMv8i-4nU", + "outputId": "c3a74911-92ec-44d4-a20f-a00912b74204" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Validation accuracy: 0.8896\n", + "\u001b[1m119/119\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 12ms/step\n", + " precision recall f1-score support\n", + "\n", + " Homme 0.87 0.93 0.90 1983\n", + " Femme 0.91 0.85 0.88 1811\n", + "\n", + " accuracy 0.89 3794\n", + " macro avg 0.89 0.89 0.89 3794\n", + "weighted avg 0.89 0.89 0.89 3794\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + " **Métriques sur le jeu de validation :**\n", + "\n", + "\n", + "L’accuracy sur la validation (88.96%) est légèrement supérieure à celle du test (87.64%), ce qui peut indiquer que le modèle s’adapte légèrement trop aux données de validation et perd en généralisation.\n", + "\n", + "On retrouve le même déséquilibre dans le rappel des classes : le modèle détecte mieux les hommes que les femmes.\n", + "\n", + "Le score F1 est équilibré, ce qui indique que les erreurs restent raisonnablement réparties malgré le léger biais observé." + ], + "metadata": { + "id": "8FAmUXY6Aoa_" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Visualisations de la courbe de la fonction de perte et de l'accuracy" + ], + "metadata": { + "id": "im4cEBHd8ao4" + } + }, + { + "cell_type": "markdown", + "source": [ + "Les courbes obtenues après l’entraînement du modèle V1 permettent d’évaluer la progression de l’apprentissage et d’identifier d’éventuels problèmes liés à la convergence du modèle ou à sa capacité de généralisation." + ], + "metadata": { + "id": "6GayFRyRA0w5" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10,4))\n", + "\n", + "# Courbe de la fonction de perte (Loss)\n", + "plt.subplot(1,2,1)\n", + "plt.plot(history_v1.history['loss'], label='Train Loss')\n", + "plt.plot(history_v1.history['val_loss'], label='Val Loss')\n", + "plt.xlabel('Époques')\n", + "plt.ylabel('Perte (Loss)')\n", + "plt.legend()\n", + "plt.title('[V1] Training & Validation Loss')\n", + "\n", + "# Courbe de l’Accuracy\n", + "plt.subplot(1,2,2)\n", + "plt.plot(history_v1.history['accuracy'], label='Train Accuracy')\n", + "plt.plot(history_v1.history['val_accuracy'], label='Val Accuracy')\n", + "plt.xlabel('Époques')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.title('[V1] Training & Validation Accuracy')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 407 + }, + "id": "vay2vOkpAbOo", + "outputId": "4c679858-cd7f-4ccb-e2c4-3a51319f6157" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1000x400 with 2 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "- Analyse de la fonction de perte (Loss) :\n", + "La loss d’entraînement diminue de manière régulière, ce qui montre que le modèle apprend bien sur ses données d’entraînement.\n", + "La loss de validation suit une tendance générale de diminution mais présente des fluctuations visibles, notamment une remontée après l’époque 5.\n", + "\n", + "Cette remontée indique que le modèle commence à sur-apprendre, c'est-à -dire qu'il s’adapte trop aux données d’entraînement et ne généralise plus aussi bien sur des données nouvelles.\n", + "Vers la fin de l'entraînement, la validation loss ne diminue plus et reste instable, confirmant un début de surapprentissage.\n", + "\n", + "- Analyse de la précision (Accuracy) :\n", + "L’accuracy en entraînement augmente continuellement, atteignant plus de 92 % en fin d'entraînement.\n", + "L’accuracy en validation suit également une progression, mais elle stagne autour de 88-89 % après plusieurs époques.\n", + "\n", + "Un écart se creuse entre les deux courbes, ce qui est un indicateur que le modèle généralise moins bien sur les données de validation.\n", + "Les fluctuations de la validation accuracy montrent que le modèle ne s'améliore plus après un certain point, renforçant l’hypothèse du surapprentissage.\n", + "\n", + "Le modèle est performant sur l'entraînement, mais perd en généralisation après quelques époques.\n", + "L’instabilité de la validation loss et de la validation accuracy suggère que le modèle pourrait bénéficier de régularisation pour éviter qu’il ne s’adapte trop aux données d’entraînement.\n", + "La validation accuracy n’évolue plus après un certain point, ce qui signifie qu’un arrêt anticipé (early stopping) pourrait être pertinent pour éviter d’entraîner inutilement le modèle sur des époques supplémentaires.\n" + ], + "metadata": { + "id": "i4l9cu18BLzz" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Améliorations possibles dans la version suivante " + ], + "metadata": { + "id": "7h8SA78gCqQe" + } + }, + { + "cell_type": "markdown", + "source": [ + "De ce fait, nous pourrions améliorer notre modèle en :\n", + "\n", + "- Ajoutant plus de couches convolutionnelles pour détecter plujs de motifs.\n", + "Augmenter le nombre de filtres dans chaque couche pour capturer plus d’informations.\n", + "\n", + "- Ajoutant un Dropout dans les couches denses pour éviter que le réseau ne mémorise trop les données d’entraînement.\n", + "\n", + "- Utilisant la Batch Normalization, qui stabilise l'apprentissage et limite les fluctuations de la validation loss.\n", + "\n", + "- Ajoutant un Early Stopping pour stopper l'entraînement si la validation loss ne s'améliore plus après plusieurs époques.\n", + "\n", + "- Réduire le learning rate si nécessaire pour permettre un apprentissage plus progressif et éviter les oscillations de la validation loss.\n", + "\n", + "- Appliquant du data augmentation pour générer plus de diversité dans les images et éviter que le modèle ne s’adapte trop fortement aux données d'entraînement." + ], + "metadata": { + "id": "hcAYFABWCwZT" + } + }, + { + "cell_type": "markdown", + "source": [ + "## II. Second essai : Amélioration du premier modèle" + ], + "metadata": { + "id": "UK29iAuIhoqO" + } + }, + { + "cell_type": "markdown", + "source": [ + "L'implémentation du modèle V2 repose sur l’analyse des résultats obtenus avec V1." + ], + "metadata": { + "id": "YntGoOUJZdZh" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Implémentation 2" + ], + "metadata": { + "id": "XddqjED2Foru" + } + }, + { + "cell_type": "code", + "source": [ + "# Définition du modèle\n", + "def build_model_v2(input_shape=(64, 64, 3)):\n", + " model = Sequential([\n", + " # Data Augmentation\n", + " Input(shape=input_shape),\n", + " RandomFlip(\"horizontal\"),\n", + " RandomRotation(0.1),\n", + " RandomZoom(0.1),\n", + "\n", + " # Bloc 1\n", + " Conv2D(16, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " # Bloc 2\n", + " Conv2D(32, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " # Bloc 3\n", + " Conv2D(64, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " # Bloc 4\n", + " Conv2D(128, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " Flatten(),\n", + "\n", + " # Couche Dense + Dropout\n", + " Dense(128, activation='relu'),\n", + " BatchNormalization(),\n", + " Dropout(0.4),\n", + "\n", + " # Sortie binaire (Homme/Femme)\n", + " Dense(1, activation='sigmoid')\n", + " ])\n", + "\n", + " # Compilation\n", + " model.compile(\n", + " optimizer=Adam(learning_rate=0.001), # LR initial\n", + " loss='binary_crossentropy',\n", + " metrics=['accuracy']\n", + " )\n", + " return model\n", + "\n", + "\n", + "model_v2 = build_model_v2((64, 64, 3))\n", + "model_v2.summary()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 849 + }, + "id": "dhGgwldShrY3", + "outputId": "18f4129f-72f9-4086-e06d-f2b9fef2481e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1mModel: \"sequential_4\"\u001b[0m\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_4\"</span>\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "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", + "│ random_flip_3 (\u001b[38;5;33mRandomFlip\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ random_rotation_3 (\u001b[38;5;33mRandomRotation\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ random_zoom_3 (\u001b[38;5;33mRandomZoom\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_13 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m448\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_15 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_13 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_14 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m4,640\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_16 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_14 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_15 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_17 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_15 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_16 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_18 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_16 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ flatten_4 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2048\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_8 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m262,272\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_19 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dropout_3 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_9 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m129\u001b[0m │\n", + "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┓\n", + "┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n", + "┡â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┩\n", + "│ random_flip_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomFlip</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ random_rotation_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomRotation</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ random_zoom_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomZoom</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_13 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">448</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_15 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_13 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_14 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">4,640</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_16 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_14 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_15 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_17 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_15 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_16 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">73,856</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_18 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_16 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ flatten_4 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">2048</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_8 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">262,272</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_19 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dropout_3 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_9 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">129</span> │\n", + "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m361,313\u001b[0m (1.38 MB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">361,313</span> (1.38 MB)\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m360,577\u001b[0m (1.38 MB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">360,577</span> (1.38 MB)\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m736\u001b[0m (2.88 KB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">736</span> (2.88 KB)\n", + "</pre>\n" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "- Contrairement à V1, V2 introduit une phase de prétraitement des images directement dans le modèle avec des transformations aléatoires :\n", + " - RandomFlip(\"horizontal\") : Simule des variations en retournant aléatoirement les images.\n", + " - RandomRotation(0.1) : Permet de simuler des légères rotations des visages.\n", + " - RandomZoom(0.1) : Introduit des zooms aléatoires.\n", + "\n", + "- Le modèle V2 introduit plus de couches convolutives et plus de filtres que le modèle V1 :\n", + " - V1 utilisait une seule couche de convolution avec 16 filtres.\n", + " - V2 applique quatre blocs convolutifs successifs, avec un nombre croissant de filtres (16 → 32 → 64 → 128).\n", + "\n", + "- Chaque bloc convolutionnel est maintenant suivi d’une normalisation de batch, ce qui :\n", + " - Stabilise l’apprentissage\n", + " - Accélère la convergence et permet d’utiliser un taux d’apprentissage plus élevé sans risque d’explosions de gradient.\n", + "\n", + "- Renforcement de la régularisation avec Dropout (Dropout(0.4)) :\n", + " - Contrairement à V1, V2 inclut une couche de Dropout après la couche dense pour éviter que le modèle ne mémorise trop les données d'entraînement.\n", + " \n", + " 0.4 signifie que 40 % des neurones sont désactivés aléatoirement à chaque passage, renforçant ainsi la généralisation du modèle.\n", + "\n", + "- Augmentation du nombre de neurones dans la couche dense (128)" + ], + "metadata": { + "id": "6m3ooAkbZpcm" + } + }, + { + "cell_type": "code", + "source": [ + "# Callbacks: EarlyStopping + ReduceLROnPlateau\n", + "\n", + "early_stopping = EarlyStopping(\n", + " monitor='val_loss',\n", + " patience=8,\n", + " restore_best_weights=True\n", + ")\n", + "\n", + "reduce_lr = ReduceLROnPlateau(\n", + " monitor='val_loss', # Surveille la val_loss\n", + " factor=0.5, # Divise le LR par 2\n", + " patience=3, # Après 3 époques sans amélioration\n", + " min_lr=1e-5 # LR plancher\n", + ")\n", + "\n", + "\n", + "history_v2 = model_v2.fit(\n", + " X_train, y_train,\n", + " validation_data=(X_val, y_val),\n", + " epochs=50, # Nombre max d'époques\n", + " batch_size=32,\n", + " verbose=1,\n", + " callbacks=[early_stopping, reduce_lr]\n", + ")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "collapsed": true, + "id": "thgT4OxPFBsc", + "outputId": "82519a74-89e7-4292-c91a-1c5a64febfae" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m74s\u001b[0m 148ms/step - accuracy: 0.6921 - loss: 0.6470 - val_accuracy: 0.6447 - val_loss: 0.6273 - learning_rate: 0.0010\n", + "Epoch 2/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 146ms/step - accuracy: 0.8066 - loss: 0.4223 - val_accuracy: 0.8179 - val_loss: 0.4219 - learning_rate: 0.0010\n", + "Epoch 3/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 145ms/step - accuracy: 0.8320 - loss: 0.3718 - val_accuracy: 0.8759 - val_loss: 0.2910 - learning_rate: 0.0010\n", + "Epoch 4/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m79s\u001b[0m 140ms/step - accuracy: 0.8534 - loss: 0.3297 - val_accuracy: 0.8300 - val_loss: 0.3705 - learning_rate: 0.0010\n", + "Epoch 5/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 143ms/step - accuracy: 0.8611 - loss: 0.3148 - val_accuracy: 0.8824 - val_loss: 0.2767 - learning_rate: 0.0010\n", + "Epoch 6/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 144ms/step - accuracy: 0.8540 - loss: 0.3196 - val_accuracy: 0.8875 - val_loss: 0.2668 - learning_rate: 0.0010\n", + "Epoch 7/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 143ms/step - accuracy: 0.8707 - loss: 0.3001 - val_accuracy: 0.8471 - val_loss: 0.3299 - learning_rate: 0.0010\n", + "Epoch 8/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 142ms/step - accuracy: 0.8665 - loss: 0.3007 - val_accuracy: 0.8975 - val_loss: 0.2492 - learning_rate: 0.0010\n", + "Epoch 9/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 143ms/step - accuracy: 0.8776 - loss: 0.2777 - val_accuracy: 0.8835 - val_loss: 0.2882 - learning_rate: 0.0010\n", + "Epoch 10/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 145ms/step - accuracy: 0.8741 - loss: 0.2837 - val_accuracy: 0.8777 - val_loss: 0.2787 - learning_rate: 0.0010\n", + "Epoch 11/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 141ms/step - accuracy: 0.8856 - loss: 0.2726 - val_accuracy: 0.8880 - val_loss: 0.2588 - learning_rate: 0.0010\n", + "Epoch 12/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 141ms/step - accuracy: 0.8903 - loss: 0.2586 - val_accuracy: 0.9014 - val_loss: 0.2224 - learning_rate: 5.0000e-04\n", + "Epoch 13/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 140ms/step - accuracy: 0.8950 - loss: 0.2468 - val_accuracy: 0.9012 - val_loss: 0.2277 - learning_rate: 5.0000e-04\n", + "Epoch 14/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 145ms/step - accuracy: 0.8985 - loss: 0.2384 - val_accuracy: 0.8991 - val_loss: 0.2317 - learning_rate: 5.0000e-04\n", + "Epoch 15/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 143ms/step - accuracy: 0.9019 - loss: 0.2324 - val_accuracy: 0.9041 - val_loss: 0.2263 - learning_rate: 5.0000e-04\n", + "Epoch 16/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 145ms/step - accuracy: 0.9023 - loss: 0.2272 - val_accuracy: 0.9117 - val_loss: 0.2209 - learning_rate: 2.5000e-04\n", + "Epoch 17/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 145ms/step - accuracy: 0.9068 - loss: 0.2169 - val_accuracy: 0.9083 - val_loss: 0.2256 - learning_rate: 2.5000e-04\n", + "Epoch 18/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 141ms/step - accuracy: 0.9094 - loss: 0.2155 - val_accuracy: 0.9096 - val_loss: 0.2169 - learning_rate: 2.5000e-04\n", + "Epoch 19/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m85s\u001b[0m 147ms/step - accuracy: 0.9053 - loss: 0.2270 - val_accuracy: 0.9075 - val_loss: 0.2197 - learning_rate: 2.5000e-04\n", + "Epoch 20/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 146ms/step - accuracy: 0.9051 - loss: 0.2283 - val_accuracy: 0.9128 - val_loss: 0.2144 - learning_rate: 2.5000e-04\n", + "Epoch 21/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 146ms/step - accuracy: 0.9083 - loss: 0.2179 - val_accuracy: 0.9112 - val_loss: 0.2165 - learning_rate: 2.5000e-04\n", + "Epoch 22/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 145ms/step - accuracy: 0.9134 - loss: 0.2113 - val_accuracy: 0.9101 - val_loss: 0.2164 - learning_rate: 2.5000e-04\n", + "Epoch 23/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 145ms/step - accuracy: 0.9164 - loss: 0.2102 - val_accuracy: 0.9125 - val_loss: 0.2192 - learning_rate: 2.5000e-04\n", + "Epoch 24/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 145ms/step - accuracy: 0.9115 - loss: 0.2139 - val_accuracy: 0.9122 - val_loss: 0.2134 - learning_rate: 1.2500e-04\n", + "Epoch 25/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 141ms/step - accuracy: 0.9202 - loss: 0.1949 - val_accuracy: 0.9104 - val_loss: 0.2139 - learning_rate: 1.2500e-04\n", + "Epoch 26/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 142ms/step - accuracy: 0.9165 - loss: 0.2004 - val_accuracy: 0.9114 - val_loss: 0.2139 - learning_rate: 1.2500e-04\n", + "Epoch 27/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 140ms/step - accuracy: 0.9159 - loss: 0.1992 - val_accuracy: 0.9046 - val_loss: 0.2250 - learning_rate: 1.2500e-04\n", + "Epoch 28/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m84s\u001b[0m 145ms/step - accuracy: 0.9220 - loss: 0.1946 - val_accuracy: 0.9114 - val_loss: 0.2116 - learning_rate: 6.2500e-05\n", + "Epoch 29/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 141ms/step - accuracy: 0.9207 - loss: 0.1943 - val_accuracy: 0.9083 - val_loss: 0.2126 - learning_rate: 6.2500e-05\n", + "Epoch 30/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m68s\u001b[0m 144ms/step - accuracy: 0.9232 - loss: 0.1879 - val_accuracy: 0.9117 - val_loss: 0.2126 - learning_rate: 6.2500e-05\n", + "Epoch 31/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 144ms/step - accuracy: 0.9202 - loss: 0.1917 - val_accuracy: 0.9125 - val_loss: 0.2109 - learning_rate: 6.2500e-05\n", + "Epoch 32/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m67s\u001b[0m 142ms/step - accuracy: 0.9208 - loss: 0.1869 - val_accuracy: 0.9154 - val_loss: 0.2114 - learning_rate: 6.2500e-05\n", + "Epoch 33/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 144ms/step - accuracy: 0.9230 - loss: 0.1905 - val_accuracy: 0.9128 - val_loss: 0.2124 - learning_rate: 6.2500e-05\n", + "Epoch 34/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 145ms/step - accuracy: 0.9273 - loss: 0.1800 - val_accuracy: 0.9104 - val_loss: 0.2135 - learning_rate: 6.2500e-05\n", + "Epoch 35/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m82s\u001b[0m 145ms/step - accuracy: 0.9223 - loss: 0.1930 - val_accuracy: 0.9141 - val_loss: 0.2118 - learning_rate: 3.1250e-05\n", + "Epoch 36/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m81s\u001b[0m 145ms/step - accuracy: 0.9241 - loss: 0.1843 - val_accuracy: 0.9130 - val_loss: 0.2121 - learning_rate: 3.1250e-05\n", + "Epoch 37/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m69s\u001b[0m 146ms/step - accuracy: 0.9208 - loss: 0.1946 - val_accuracy: 0.9104 - val_loss: 0.2152 - learning_rate: 3.1250e-05\n", + "Epoch 38/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m83s\u001b[0m 148ms/step - accuracy: 0.9259 - loss: 0.1824 - val_accuracy: 0.9117 - val_loss: 0.2132 - learning_rate: 1.5625e-05\n", + "Epoch 39/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m80s\u001b[0m 143ms/step - accuracy: 0.9248 - loss: 0.1798 - val_accuracy: 0.9101 - val_loss: 0.2131 - learning_rate: 1.5625e-05\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Analyse des métriques" + ], + "metadata": { + "id": "nJD1YwCJFs08" + } + }, + { + "cell_type": "code", + "source": [ + "# Évaluation sur le jeu de test\n", + "test_loss_v2, test_acc_v2 = model_v2.evaluate(X_test, y_test, verbose=0)\n", + "print(f\"[V2] Test accuracy: {test_acc_v2:.4f}\")\n", + "\n", + "# Prédictions sur le jeu de test\n", + "y_pred_prob_v2 = model_v2.predict(X_test)\n", + "y_pred_v2 = (y_pred_prob_v2 > 0.5).astype(\"int32\")\n", + "\n", + "# Rapport de classification pour le jeu de test\n", + "print(classification_report(y_test, y_pred_v2, target_names=[\"Homme\", \"Femme\"]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HV0pLdYdGSpR", + "outputId": "0b87b847-8321-439a-bcf6-0b52d313b1fa" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[V2] Test accuracy: 0.9142\n", + "\u001b[1m149/149\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m5s\u001b[0m 33ms/step\n", + " precision recall f1-score support\n", + "\n", + " Homme 0.92 0.92 0.92 2478\n", + " Femme 0.91 0.91 0.91 2264\n", + "\n", + " accuracy 0.91 4742\n", + " macro avg 0.91 0.91 0.91 4742\n", + "weighted avg 0.91 0.91 0.91 4742\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "L’accuracy du test est passée de 87.64 % (V1) à 91.42 % (V2), soit une amélioration de près de 4 %. L’accuracy en validation suit également cette progression, montrant que le modèle V2 généralise mieux que V1.\n", + "\n", + "L’augmentation du nombre de couches et l’utilisation de Batch Normalization semblent avoir stabilisé l’apprentissage, tandis que l’ajout de Dropout et de l’Early Stopping a permis de limiter le surapprentissage." + ], + "metadata": { + "id": "Dlvx4_mQe-G1" + } + }, + { + "cell_type": "code", + "source": [ + "# Évaluation sur le jeu de validation\n", + "test_loss_val, test_acc_val = model_v2.evaluate(X_val, y_val, verbose=0)\n", + "print(f\"[V2] Validation accuracy: {test_acc_val:.4f}\")\n", + "\n", + "# Prédictions sur le jeu de validation\n", + "y_pred_prob_val = model_v2.predict(X_val)\n", + "y_pred_val = (y_pred_prob_val > 0.5).astype(\"int32\")\n", + "\n", + "# Rapport de classification pour le jeu de validation\n", + "print(classification_report(y_val, y_pred_val, target_names=[\"Homme\", \"Femme\"]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "R1GDy7YYGGf-", + "outputId": "f421bfeb-5728-4ae8-edcd-0dcdeddffea8" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[V2] Validation accuracy: 0.9125\n", + "\u001b[1m119/119\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m4s\u001b[0m 37ms/step\n", + " precision recall f1-score support\n", + "\n", + " Homme 0.92 0.91 0.92 1983\n", + " Femme 0.91 0.91 0.91 1811\n", + "\n", + " accuracy 0.91 3794\n", + " macro avg 0.91 0.91 0.91 3794\n", + "weighted avg 0.91 0.91 0.91 3794\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Contrairement à V1, où l’équilibre entre les classes était légèrement biaisé en faveur des hommes, V2 montre des scores parfaitement équilibrés entre les classes \"Homme\" et \"Femme\".\n", + "\n", + "Le rappel de la classe \"Femme\" est passé de 0.84 (V1) à 0.91 (V2), réduisant ainsi les erreurs de classification.\n", + "\n", + "La précision des deux classes est maintenant symétrique (0.91-0.92), ce qui signifie que le modèle fait aussi bien pour identifier un homme qu’une femme.\n", + "\n" + ], + "metadata": { + "id": "6UHsDSo9fLJi" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Visualisations de la courbe de la fonction de perte et de l'accuracy" + ], + "metadata": { + "id": "tv-7opVcF3W0" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10,4))\n", + "\n", + "# Courbe de la fonction de perte\n", + "plt.subplot(1,2,1)\n", + "plt.plot(history_v2.history['loss'], label='Train Loss')\n", + "plt.plot(history_v2.history['val_loss'], label='Val Loss')\n", + "plt.xlabel('Époques')\n", + "plt.ylabel('Perte (Loss)')\n", + "plt.legend()\n", + "plt.title('[V2] Training & Validation Loss')\n", + "\n", + "# Courbe d’accuracy\n", + "plt.subplot(1,2,2)\n", + "plt.plot(history_v2.history['accuracy'], label='Train Accuracy')\n", + "plt.plot(history_v2.history['val_accuracy'], label='Val Accuracy')\n", + "plt.xlabel('Époques')\n", + "plt.ylabel('Accuracy')\n", + "plt.legend()\n", + "plt.title('[V2] Training & Validation Accuracy')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 407 + }, + "id": "b6r6JdXFFc-s", + "outputId": "7b488e89-6a4c-4def-c1d4-51438ad08181" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1000x400 with 2 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "La loss d’entraînement diminue progressivement, sans oscillations excessives.\n", + "\n", + "La loss de validation suit une tendance similaire et ne montre pas de remontée brutale, ce qui signifie que le modèle ne semble pas souffrir de surajustement.\n", + "\n", + "Dans V1, la validation loss commençait à osciller après quelques époques, ce qui était un signe de surapprentissage.\n", + "\n", + "Ici, V2 reste plus stable, ce qui confirme une meilleure régularisation.\n", + "\n", + "\n", + "L’accuracy d’entraînement et de validation sont très proches, signe que le modèle généralise bien sans apprendre excessivement les données d’entraînement.\n", + "\n", + "L’accuracy de validation dépasse légèrement celle de l’entraînement à certaines époques, ce qui peut être dû aux effets du Dropout et de la régularisation, qui rendent le modèle plus robuste sur des données non vues." + ], + "metadata": { + "id": "RYGtLqgdkmgJ" + } + }, + { + "cell_type": "markdown", + "source": [ + "## III. Adaptation du Modèle à une Résolution de 128×128" + ], + "metadata": { + "id": "zzor8VEsdZ7f" + } + }, + { + "cell_type": "markdown", + "source": [ + "Dans le cadre d'une potentielle amélioration du modèle, nous avons testé un redimensionnement des images en 128×128 au lieu de 64×64.\n", + "\n", + "L’objectif est d’exploiter plus d’informations visuelles pour améliorer la classification, au prix d’un coût computationnel plus élevé.\n", + "\n", + "Cependant, une limitation mémoire (RAM insuffisante) a empêché d’appliquer directement ce changement avec l’implémentation initiale.\n", + "\n", + "En effet, dans l’implémentation précédente, les images étaient chargées et stockées en mémoire sous forme de tableaux NumPy avant d’être traitées.\n", + "\n", + "Or, stocker des images en 128×128×3 nécessite quatre fois plus de mémoire qu’avec des images de 64×64×3.\n", + "\n", + "De ce fait, lorsque le dataset contient plusieurs dizaines de milliers d’images, la consommation mémoire explose, rendant l’entraînement impossible sur une machine avec une RAM limitée.\n", + "\n", + "\n", + "Pour contourner cette contrainte, au lieu de charger toutes les images en RAM, la solution mise en place consiste à :\n", + "\n", + " - Stocker uniquement les chemins des fichiers, sans charger directement les images.\n", + "\n", + " - Créer un dataset TensorFlow (tf.data.Dataset), qui charge les images à la demande, directement depuis le stockage.\n", + "\n", + " - Appliquer le prétraitement à la volée, au lieu de stocker des images redimensionnées.\n", + "\n", + " - Utiliser le prefetching et le batching, afin d’optimiser la rapidité du pipeline.\n", + "\n" + ], + "metadata": { + "id": "X2IgsqzunRhC" + } + }, + { + "cell_type": "code", + "source": [ + "IMG_HEIGHT = 128\n", + "IMG_WIDTH = 128\n", + "BATCH_SIZE = 32\n", + "TEST_SIZE = 0.2\n", + "VAL_SIZE = 0.2" + ], + "metadata": { + "id": "AIu1cth8dZlI" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Prétraitement des images et chargement des fichiers" + ], + "metadata": { + "id": "ZD2y0BKSpQpi" + } + }, + { + "cell_type": "code", + "source": [ + "# --- PRÉTRAITEMENT D'UNE IMAGE ---\n", + "def preprocess_image(image_path, label):\n", + " \"\"\"\n", + " Charge une image, la redimensionne, et la normalise.\n", + " \"\"\"\n", + " image = tf.io.read_file(image_path)\n", + " image = tf.image.decode_jpeg(image, channels=3)\n", + " image = tf.image.resize(image, (IMG_HEIGHT, IMG_WIDTH)) # Resize en 128*128\n", + " image = image / 255.0 # Normalisation entre [0,1]\n", + " return image, label" + ], + "metadata": { + "id": "wVC5-zfWeHlr" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# --- CHARGEMENT DES FICHIERS ---\n", + "file_paths = []\n", + "labels = []\n", + "\n", + "for file in os.listdir(DATA_DIR):\n", + " parts = file.split(\"_\")\n", + " if len(parts) < 2:\n", + " continue # Évite les fichiers mal nommés\n", + "\n", + " try:\n", + " gender = int(parts[1]) # Récupère le genre (0 = Homme, 1 = Femme)\n", + " except:\n", + " continue # Ignore les erreurs\n", + "\n", + " file_paths.append(os.path.join(DATA_DIR, file))\n", + " labels.append(gender)\n", + "\n", + "file_paths = np.array(file_paths)\n", + "labels = np.array(labels)\n", + "\n", + "print(f\"Nombre total d'images : {len(file_paths)}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lAUEk3zpojLb", + "outputId": "34d7476b-be6e-481e-9a4d-1c7d6d2b99a4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Nombre total d'images : 23708\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Division du jeu de données" + ], + "metadata": { + "id": "WH7CSJgQowsb" + } + }, + { + "cell_type": "code", + "source": [ + "# --- SPLIT TRAIN / TEST / VALIDATION ---\n", + "X_train, X_test, y_train, y_test = train_test_split(\n", + " file_paths, labels,\n", + " test_size=TEST_SIZE,\n", + " stratify=labels,\n", + " random_state=42\n", + ")\n", + "\n", + "X_train, X_val, y_train, y_val = train_test_split(\n", + " X_train, y_train,\n", + " test_size=VAL_SIZE,\n", + " stratify=y_train,\n", + " random_state=42\n", + ")\n", + "\n", + "print(f\"Taille du jeu d'entraînement : {len(X_train)}\")\n", + "print(f\"Taille du jeu de validation : {len(X_val)}\")\n", + "print(f\"Taille du jeu de test : {len(X_test)}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HfRrONVIon5e", + "outputId": "ebea2c51-2526-48b6-ae15-6c4a45c4ae63" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Taille du jeu d'entraînement : 15172\n", + "Taille du jeu de validation : 3794\n", + "Taille du jeu de test : 4742\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Création des datasets tf" + ], + "metadata": { + "id": "mTsSvGQGo0YT" + } + }, + { + "cell_type": "code", + "source": [ + "# --- CRÉATION DES DATASETS TF ---\n", + "def create_tf_dataset(X, y, batch_size=BATCH_SIZE):\n", + " dataset = tf.data.Dataset.from_tensor_slices((X, y))\n", + " dataset = dataset.map(preprocess_image, num_parallel_calls=tf.data.AUTOTUNE)\n", + " dataset = dataset.batch(batch_size).prefetch(tf.data.AUTOTUNE)\n", + " return dataset\n", + "\n", + "train_dataset = create_tf_dataset(X_train, y_train)\n", + "val_dataset = create_tf_dataset(X_val, y_val)\n", + "test_dataset = create_tf_dataset(X_test, y_test)\n" + ], + "metadata": { + "id": "eOaciUJZotr6" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Implémentation 3" + ], + "metadata": { + "id": "VB0_QMvZpcVF" + } + }, + { + "cell_type": "code", + "source": [ + "def build_model_v3(input_shape=(IMG_HEIGHT, IMG_WIDTH, 3)):\n", + " model = Sequential([\n", + " # Data Augmentation\n", + " Input(shape=input_shape),\n", + " RandomFlip(\"horizontal\"),\n", + " RandomRotation(0.1),\n", + " RandomZoom(0.1),\n", + "\n", + " # Bloc 1\n", + " Conv2D(16, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " # Bloc 2\n", + " Conv2D(32, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " # Bloc 3\n", + " Conv2D(64, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " # Bloc 4\n", + " Conv2D(128, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " # Bloc 5\n", + " Conv2D(256, (3, 3), activation='relu', padding='same'),\n", + " BatchNormalization(),\n", + " MaxPooling2D((2, 2)),\n", + "\n", + " Flatten(),\n", + "\n", + " # Couche Dense + Dropout\n", + " Dense(256, activation='relu'),\n", + " BatchNormalization(),\n", + " Dropout(0.5),\n", + "\n", + " # Sortie binaire (Homme/Femme)\n", + " Dense(1, activation='sigmoid')\n", + " ])\n", + "\n", + " # Compilation\n", + " model.compile(\n", + " optimizer=Adam(learning_rate=0.001), # LR initial\n", + " loss='binary_crossentropy',\n", + " metrics=['accuracy']\n", + " )\n", + " return model\n", + "\n", + "model_v3 = build_model_v3((IMG_HEIGHT, IMG_WIDTH, 3))\n", + "model_v3.summary()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 961 + }, + "id": "iFbhk8keeWyF", + "outputId": "62c5ab81-28d0-424e-d05c-b18f2e93befd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1mModel: \"sequential_6\"\u001b[0m\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\">Model: \"sequential_6\"</span>\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "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", + "│ random_flip_5 (\u001b[38;5;33mRandomFlip\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ random_rotation_5 (\u001b[38;5;33mRandomRotation\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ random_zoom_5 (\u001b[38;5;33mRandomZoom\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m3\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_22 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m448\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_26 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m128\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m64\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_22 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m16\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_23 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m4,640\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_27 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m64\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m128\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_23 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_24 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m18,496\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_28 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m32\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m256\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_24 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m64\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_25 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m73,856\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_29 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m16\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m512\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_25 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m128\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_26 (\u001b[38;5;33mConv2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m295,168\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_30 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m8\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,024\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_26 (\u001b[38;5;33mMaxPooling2D\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m4\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ flatten_6 (\u001b[38;5;33mFlatten\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m4096\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_12 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,048,832\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_31 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m1,024\u001b[0m │\n", + "│ (\u001b[38;5;33mBatchNormalization\u001b[0m) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dropout_5 (\u001b[38;5;33mDropout\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_13 (\u001b[38;5;33mDense\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m257\u001b[0m │\n", + "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┳â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┓\n", + "┃<span style=\"font-weight: bold\"> Layer (type) </span>┃<span style=\"font-weight: bold\"> Output Shape </span>┃<span style=\"font-weight: bold\"> Param # </span>┃\n", + "┡â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”╇â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”┩\n", + "│ random_flip_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomFlip</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ random_rotation_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomRotation</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ random_zoom_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">RandomZoom</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">3</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_22 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">448</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_26 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_22 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_23 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">4,640</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_27 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_23 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_24 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">18,496</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_28 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">32</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_24 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">64</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_25 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">73,856</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_29 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">16</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">512</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_25 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">128</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ conv2d_26 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Conv2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">295,168</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_30 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">8</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">1,024</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ max_pooling2d_26 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">MaxPooling2D</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ flatten_6 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Flatten</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">4096</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_12 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">1,048,832</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ batch_normalization_31 │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">1,024</span> │\n", + "│ (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">BatchNormalization</span>) │ │ │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dropout_5 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dropout</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">256</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">0</span> │\n", + "├──────────────────────────────────────┼─────────────────────────────┼─────────────────┤\n", + "│ dense_13 (<span style=\"color: #0087ff; text-decoration-color: #0087ff\">Dense</span>) │ (<span style=\"color: #00d7ff; text-decoration-color: #00d7ff\">None</span>, <span style=\"color: #00af00; text-decoration-color: #00af00\">1</span>) │ <span style=\"color: #00af00; text-decoration-color: #00af00\">257</span> │\n", + "└──────────────────────────────────────┴─────────────────────────────┴─────────────────┘\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m1,444,705\u001b[0m (5.51 MB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Total params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,444,705</span> (5.51 MB)\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m1,443,201\u001b[0m (5.51 MB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,443,201</span> (5.51 MB)\n", + "</pre>\n" + ] + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m1,504\u001b[0m (5.88 KB)\n" + ], + "text/html": [ + "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\"><span style=\"font-weight: bold\"> Non-trainable params: </span><span style=\"color: #00af00; text-decoration-color: #00af00\">1,504</span> (5.88 KB)\n", + "</pre>\n" + ] + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# --- CALLBACKS ---\n", + "early_stopping = EarlyStopping(\n", + " monitor='val_loss',\n", + " patience=5,\n", + " restore_best_weights=True\n", + ")\n", + "\n", + "reduce_lr = ReduceLROnPlateau(\n", + " monitor='val_loss',\n", + " factor=0.5,\n", + " patience=5,\n", + " min_lr=1e-5\n", + ")\n", + "\n", + "# --- ENTRAÃŽNEMENT ---\n", + "history_v3 = model_v3.fit(\n", + " train_dataset, # On utilise tf.data.Dataset\n", + " validation_data=val_dataset, # Dataset de validation\n", + " epochs=50,\n", + " verbose=1,\n", + " callbacks=[early_stopping, reduce_lr]\n", + ")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "L6uV8910qU68", + "outputId": "abf8475e-6e74-40dd-e6b5-bf94660f869f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m378s\u001b[0m 787ms/step - accuracy: 0.7022 - loss: 0.6864 - val_accuracy: 0.7483 - val_loss: 0.5096 - learning_rate: 0.0010\n", + "Epoch 2/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m366s\u001b[0m 770ms/step - accuracy: 0.7974 - loss: 0.4415 - val_accuracy: 0.8366 - val_loss: 0.3621 - learning_rate: 0.0010\n", + "Epoch 3/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m353s\u001b[0m 709ms/step - accuracy: 0.8398 - loss: 0.3620 - val_accuracy: 0.8569 - val_loss: 0.3304 - learning_rate: 0.0010\n", + "Epoch 4/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m341s\u001b[0m 718ms/step - accuracy: 0.8559 - loss: 0.3282 - val_accuracy: 0.8519 - val_loss: 0.3310 - learning_rate: 0.0010\n", + "Epoch 5/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m377s\u001b[0m 707ms/step - accuracy: 0.8680 - loss: 0.3132 - val_accuracy: 0.8722 - val_loss: 0.2935 - learning_rate: 0.0010\n", + "Epoch 6/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m385s\u001b[0m 715ms/step - accuracy: 0.8730 - loss: 0.2978 - val_accuracy: 0.8524 - val_loss: 0.3212 - learning_rate: 0.0010\n", + "Epoch 7/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m379s\u001b[0m 707ms/step - accuracy: 0.8744 - loss: 0.2962 - val_accuracy: 0.8748 - val_loss: 0.2893 - learning_rate: 0.0010\n", + "Epoch 8/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m384s\u001b[0m 712ms/step - accuracy: 0.8769 - loss: 0.2898 - val_accuracy: 0.8824 - val_loss: 0.2710 - learning_rate: 0.0010\n", + "Epoch 9/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m384s\u001b[0m 717ms/step - accuracy: 0.8878 - loss: 0.2683 - val_accuracy: 0.8716 - val_loss: 0.2852 - learning_rate: 0.0010\n", + "Epoch 10/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m382s\u001b[0m 718ms/step - accuracy: 0.8905 - loss: 0.2610 - val_accuracy: 0.8843 - val_loss: 0.2678 - learning_rate: 0.0010\n", + "Epoch 11/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m379s\u001b[0m 712ms/step - accuracy: 0.8993 - loss: 0.2506 - val_accuracy: 0.8822 - val_loss: 0.2586 - learning_rate: 0.0010\n", + "Epoch 12/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m384s\u001b[0m 717ms/step - accuracy: 0.8965 - loss: 0.2486 - val_accuracy: 0.8677 - val_loss: 0.2875 - learning_rate: 0.0010\n", + "Epoch 13/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m404s\u001b[0m 763ms/step - accuracy: 0.8989 - loss: 0.2423 - val_accuracy: 0.8922 - val_loss: 0.2530 - learning_rate: 0.0010\n", + "Epoch 14/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m375s\u001b[0m 748ms/step - accuracy: 0.8988 - loss: 0.2417 - val_accuracy: 0.8872 - val_loss: 0.2569 - learning_rate: 0.0010\n", + "Epoch 15/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m366s\u001b[0m 714ms/step - accuracy: 0.9020 - loss: 0.2394 - val_accuracy: 0.8969 - val_loss: 0.2469 - learning_rate: 0.0010\n", + "Epoch 16/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m385s\u001b[0m 721ms/step - accuracy: 0.9092 - loss: 0.2231 - val_accuracy: 0.9006 - val_loss: 0.2304 - learning_rate: 0.0010\n", + "Epoch 17/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m381s\u001b[0m 719ms/step - accuracy: 0.9076 - loss: 0.2231 - val_accuracy: 0.9030 - val_loss: 0.2363 - learning_rate: 0.0010\n", + "Epoch 18/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m383s\u001b[0m 721ms/step - accuracy: 0.9072 - loss: 0.2299 - val_accuracy: 0.8906 - val_loss: 0.2527 - learning_rate: 0.0010\n", + "Epoch 19/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m380s\u001b[0m 716ms/step - accuracy: 0.9057 - loss: 0.2218 - val_accuracy: 0.8991 - val_loss: 0.2414 - learning_rate: 0.0010\n", + "Epoch 20/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m384s\u001b[0m 722ms/step - accuracy: 0.9126 - loss: 0.2130 - val_accuracy: 0.9038 - val_loss: 0.2304 - learning_rate: 0.0010\n", + "Epoch 21/50\n", + "\u001b[1m475/475\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m342s\u001b[0m 720ms/step - accuracy: 0.9119 - loss: 0.2084 - val_accuracy: 0.8951 - val_loss: 0.2594 - learning_rate: 0.0010\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Analyse des métriques" + ], + "metadata": { + "id": "_GgawPG0rDF6" + } + }, + { + "cell_type": "markdown", + "source": [ + "L’objectif de V3 était d'observer l’impact de l’augmentation de la résolution des images (128×128) et de la nouvelle méthode de gestion des images sur les performances du modèle.\n", + "\n", + "\n", + "Cette version est comparée à V2 (64×64) afin d’observer les éventuelles améliorations en termes de précision, de généralisation et de stabilité de l’apprentissage." + ], + "metadata": { + "id": "L8Y2fhwdGp0a" + } + }, + { + "cell_type": "code", + "source": [ + "# --- ÉVALUATION SUR LE TEST SET ---\n", + "test_loss_v3, test_acc_v3 = model_v3.evaluate(test_dataset, verbose=0)\n", + "print(f\"[V3] Test accuracy: {test_acc_v3:.4f}\")\n", + "\n", + "# --- PRÉDICTIONS SUR LE TEST SET ---\n", + "y_pred_prob_v3 = model_v3.predict(test_dataset)\n", + "y_pred_v3 = (y_pred_prob_v3 > 0.5).astype(\"int32\")\n", + "\n", + "# Récupération des vraies étiquettes du test set\n", + "y_true_v3 = np.concatenate([y for _, y in test_dataset], axis=0)\n", + "\n", + "# Rapport de classification pour le jeu de test\n", + "print(classification_report(y_true_v3, y_pred_v3, target_names=[\"Homme\", \"Femme\"]))\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9Vf2xuFvqnqJ", + "outputId": "9dc8d344-1a8d-4ff9-967d-e43e75fea019" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[V3] Test accuracy: 0.9062\n", + "\u001b[1m149/149\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m22s\u001b[0m 149ms/step\n", + " precision recall f1-score support\n", + "\n", + " Homme 0.92 0.90 0.91 2478\n", + " Femme 0.89 0.91 0.90 2264\n", + "\n", + " accuracy 0.91 4742\n", + " macro avg 0.91 0.91 0.91 4742\n", + "weighted avg 0.91 0.91 0.91 4742\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "L’accuracy du test a légèrement diminué de 91.42 % (V2) à 90.62 % (V3), tandis que celle de validation a également baissé d’environ 1.2 %.\n", + "\n", + "Contrairement aux attentes, l’augmentation de la résolution n’a pas entraîné d’amélioration notables des performances, ce qui suggère que\n", + "\n", + "La résolution 64×64 capturait déjà suffisamment d’informations pour la classification, et la montée en 128×128 n’a pas ajouté de valeur discriminante.\n", + "La montée en résolution a augmenté la complexité du modèle, mais sans un gain clair en termes de généralisation." + ], + "metadata": { + "id": "Ad7ms1_5G1-B" + } + }, + { + "cell_type": "code", + "source": [ + "# --- ÉVALUATION SUR LE VALIDATION SET ---\n", + "val_loss_v3, val_acc_v3 = model_v3.evaluate(val_dataset, verbose=0)\n", + "print(f\"[V3] Validation accuracy: {val_acc_v3:.4f}\")\n", + "\n", + "# --- PRÉDICTIONS SUR LE VALIDATION SET ---\n", + "y_pred_prob_val_v3 = model_v3.predict(val_dataset)\n", + "y_pred_val_v3 = (y_pred_prob_val_v3 > 0.5).astype(\"int32\")\n", + "\n", + "# Récupération des vraies étiquettes du validation set\n", + "y_true_val_v3 = np.concatenate([y for _, y in val_dataset], axis=0)\n", + "\n", + "# Rapport de classification pour le jeu de validation\n", + "print(classification_report(y_true_val_v3, y_pred_val_v3, target_names=[\"Homme\", \"Femme\"]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EolP29CtrITN", + "outputId": "8e1a5304-3992-4a6a-f162-6538019ef76f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[V3] Validation accuracy: 0.9006\n", + "\u001b[1m119/119\u001b[0m \u001b[32mâ”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”â”\u001b[0m\u001b[37m\u001b[0m \u001b[1m17s\u001b[0m 145ms/step\n", + " precision recall f1-score support\n", + "\n", + " Homme 0.92 0.89 0.90 1983\n", + " Femme 0.88 0.91 0.90 1811\n", + "\n", + " accuracy 0.90 3794\n", + " macro avg 0.90 0.90 0.90 3794\n", + "weighted avg 0.90 0.90 0.90 3794\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Les scores montrent une légère baisse du rappel pour la classe \"Homme\" dans V3 (de 0.92 à 0.90), tandis que la précision de la classe \"Femme\" diminue également légèrement (de 0.91 à 0.89).\n", + "\n", + "Ces changements indiquent que le modèle V3, composé de couches et paramètres plus importants, a plus de difficultés à identifier correctement certaines classes par rapport à V2.\n", + "\n", + "Il n'y a pas d'amélioration.\n" + ], + "metadata": { + "id": "cKdWpfH8HFSv" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Visualisations de la courbe de la fonction de perte et de l'accuracy" + ], + "metadata": { + "id": "r-4iSKFuGjNC" + } + }, + { + "cell_type": "code", + "source": [ + "plt.figure(figsize=(10,4))\n", + "\n", + "# Courbe de la fonction de perte\n", + "plt.subplot(1,2,1)\n", + "plt.plot(history_v3.history['loss'], label='Train Loss')\n", + "plt.plot(history_v3.history['val_loss'], label='Val Loss')\n", + "plt.xlabel('Époques')\n", + "plt.ylabel('Perte (Loss)')\n", + "plt.legend()\n", + "plt.title('[V3] Training & Validation Loss')\n", + "\n", + "# Courbe d’accuracy\n", + "plt.subplot(1,2,2)\n", + "plt.plot(history_v3.history['accuracy'], label='Train Accuracy')\n", + "plt.plot(history_v3.history['val_accuracy'], label='Val Accuracy')\n", + "plt.xlabel('Époques')\n", + "plt.ylabel('Exactitude (Accuracy)')\n", + "plt.legend()\n", + "plt.title('[V3] Training & Validation Accuracy')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 407 + }, + "id": "3mqS6oMFfVBV", + "outputId": "ababf710-998f-44a1-8fbd-efba6729931f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1000x400 with 2 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Fonction de Perte (Loss)\n", + "\n", + "La perte d’entraînement diminue de manière continue, indiquant un bon apprentissage.\n", + "\n", + "La perte de validation montre plus de fluctuations, notamment vers la fin de l’entraînement, suggérant une moins bonne stabilité par rapport à V2.\n", + "\n", + "Une légère remontée de la validation loss vers la fin pourrait indiquer un début de surapprentissage.\n", + "\n", + "Précision (Accuracy)\n", + "L’accuracy d’entraînement et de validation suivent une trajectoire similaire, bien que l’accuracy de validation fluctue davantage que dans V2.\n", + "\n", + "À partir de la 10ᵉ époque, l’accuracy de validation cesse de progresser, ce qui peut indiquer que le modèle ne bénéficie pas autant de l'augmentation de la résolution." + ], + "metadata": { + "id": "XgQF8-bpH-ul" + } + }, + { + "cell_type": "markdown", + "source": [ + "#Conclusion" + ], + "metadata": { + "id": "nyw3d2o6IfbB" + } + }, + { + "cell_type": "markdown", + "source": [ + "L’amélioration du modèle V3 n’a pas entraîné une augmentation des performances, contrairement aux attentes. La montée en résolution à 128×128 ne semble pas apporter de bénéfice pour la tâche de classification de genre avec ce modèle.\n", + "\n", + "En effet, nous observons une très légère baisse des performances globales, malgré une meilleure définition des images ainsi qu'un début de surapprentissage vers la fin de l’entraînement (mais qui pourrait être atténué avec davantage de régularisation)\n", + "\n", + "\n", + "Cette v3 montre que l’augmentation de la résolution ne garantit pas une amélioration automatique des performances.\n", + "\n", + "Par conséquent, nous sauvegarderons le modèle v2 pour entamer les questions suviantes, sur Gradio et HuggingFace." + ], + "metadata": { + "id": "4xBAksX0IiL6" + } + }, + { + "cell_type": "code", + "source": [ + "model_v2.save(\"model_v2_Q1.keras\")\n", + "\n", + "from google.colab import files\n", + "files.download(\"model_v2_Q1.keras\")" + ], + "metadata": { + "id": "5JTu1SUkJRmh" + }, + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true, + "gpuType": "T4" + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file -- GitLab