Practica2_VGG_X_Ray.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YQ-FWjG_pv_C"
      },
      "source": [
        "\n",
        "# 📝 **Práctica #2:** 🚀  Entrenamiento de una red neuronal para la clasificación de caras de actores.\n",
        "\n",
        "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/LoboaTeresa/Workshop-COF-23/blob/master/Practica2_VGG_X_Ray.ipynb)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DKhUrbR2i6a6"
      },
      "source": [
        "# **Práctica #2.1.:** Entrenamiento desde cero"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D-oBtggQp6o8"
      },
      "source": [
        "### 1. Importar librerías necesarias"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "aoQiPNxwYgnI"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import cv2\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A069Cku6p-aN"
      },
      "source": [
        "### 2. Cargar el dataset\n",
        "\n",
        "Trabajaremos con un dataset con imágenes de caras de 17 actores y actrices. El dataset contiene 1000 imágenes de cada actor.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IrD1NG4KqLHP",
        "outputId": "271c900c-01a0-41ad-dc0d-91db81ac1fa7"
      },
      "outputs": [],
      "source": [
        "# descarga el dataset:\n",
        "!git clone https://github.com/LoboaTeresa/Workshop-COF-23.git\n",
        "!cp /content/Workshop-COF-23/assets/Celebrity_Faces_Dataset.zip /content/Celebrity_Faces_Dataset.zip\n",
        "!unzip /content/Celebrity_Faces_Dataset.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "uM_GPFj2KgLf"
      },
      "outputs": [],
      "source": [
        "VGG_INPUT_SIZE = (224,225,3)\n",
        "image_size = VGG_INPUT_SIZE[:-1]\n",
        "BATCH_SIZE = 64"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yGYSM8cHNBya"
      },
      "source": [
        "Obtendremos las anotaciones a partir de la estructura de carpetas de nuestro dataset usando ImageDataGenerator"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ITmPwTvtNG-w",
        "outputId": "15c6ce10-4e78-4af8-e013-65a7b9b397a1"
      },
      "outputs": [],
      "source": [
        "from keras.preprocessing.image import ImageDataGenerator\n",
        "\n",
        "train_path=\"Celebrity_Faces_Dataset/train\"\n",
        "test_path=\"Celebrity_Faces_Dataset/test\"\n",
        "class_subset = sorted(os.listdir('Celebrity_Faces_Dataset/train'))[:10] # Using only the first 10 classes\n",
        "\n",
        "# Generate batches of tensor image data with real-time data augmentation.\n",
        "train_datagen = ImageDataGenerator(rotation_range=10,\n",
        "                                   brightness_range=[0.4, 1.0],\n",
        "                                   rescale = 1./255,\n",
        "                                   shear_range=0.1,\n",
        "                                   horizontal_flip=True,\n",
        "                                   fill_mode='nearest')\n",
        "val_datagen = ImageDataGenerator(rescale = 1./255)\n",
        "test_datagen = ImageDataGenerator(rescale = 1./255)\n",
        "\n",
        "\n",
        "# Generates dataset (+labels) from reading images in directories\n",
        "training_set = train_datagen.flow_from_directory(train_path,\n",
        "                                                 classes=class_subset,\n",
        "                                                 target_size = image_size,\n",
        "                                                 batch_size = BATCH_SIZE,\n",
        "                                                 shuffle=True,\n",
        "                                                 seed=42,\n",
        "                                                 class_mode = 'categorical')\n",
        "val_set = val_datagen.flow_from_directory(train_path,\n",
        "                                          classes=class_subset,\n",
        "                                          target_size = image_size,\n",
        "                                          batch_size = BATCH_SIZE,\n",
        "                                          shuffle=True,\n",
        "                                          seed=42,\n",
        "                                          class_mode = 'categorical')\n",
        "\n",
        "test_set = test_datagen.flow_from_directory(test_path,\n",
        "                                            classes=class_subset,\n",
        "                                            target_size = image_size,\n",
        "                                            batch_size = 1,\n",
        "                                            class_mode = None)\n",
        "\n",
        "n_classes = list(training_set.class_indices.keys())\n",
        "class_names = len(n_classes)\n",
        "\n",
        "# labels\n",
        "train_y=training_set.classes\n",
        "val_y=val_set.classes\n",
        "test_y=test_set.classes"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Example of augmented image\n",
        "img = np.asarray(training_set[0][0][10])\n",
        "plt.imshow(img)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g7aWE4rqqKl7"
      },
      "source": [
        "### 3. Definición de la arquitectura:\n",
        "\n",
        "Keras es una librería de código abierto que proporciona una interfaz Python para redes neuronales artificiales. Keras actúa como interfaz para la librería TensorFlow desarrollada por Google.\n",
        "\n",
        "[Documentación de Keras](https://keras.io/api/layers/). Échale un ojo :)\n",
        "\n",
        "Vamos a construir una red neuronal de 4 capas densas o completamente conectadas.\n",
        "\n",
        "![VGG16](https://www.researchgate.net/publication/350828239/figure/fig1/AS:1017585780924416@1619622764106/Architecture-of-the-modified-VGG16-model.ppm)\n",
        "\n",
        "* 2 x convolution layer of 64 channel of 3x3 kernel and same padding.\n",
        "* 1 x maxpool layer of 2x2 pool size and stride 2x2.\n",
        "* 2 x convolution layer of 128 channel of 3x3 kernel and same padding.\n",
        "* 1 x maxpool layer of 2x2 pool size and stride 2x2.\n",
        "* 3 x convolution layer of 256 channel of 3x3 kernel and same padding.\n",
        "* 1 x maxpool layer of 2x2 pool size and stride 2x2.\n",
        "* 3 x convolution layer of 512 channel of 3x3 kernel and same padding.\n",
        "* 1 x maxpool layer of 2x2 pool size and stride 2x2.\n",
        "* 3 x convolution layer of 512 channel of 3x3 kernel and same padding.\n",
        "* 1 x maxpool layer of 2x2 pool size and stride 2x2.\n",
        "* 1 x Dense layer of 4096 units.\n",
        "* 1 x Dense layer of 4096 units.\n",
        "* 1 x Dense Softmax layer of 18 units (there are 18 classes).\n",
        "\n",
        "We also added the rectified linear unit (ReLU) activation to each layer so that the negative values aren’t passed to the next layer. The last layer will have a softmax activation function."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "kI6Dq7FeoF2D"
      },
      "outputs": [],
      "source": [
        "class_names = list(training_set.class_indices.keys())\n",
        "n_classes = len(class_names)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "ocSc5BdsiMyP"
      },
      "outputs": [],
      "source": [
        "import keras\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Conv2D, MaxPool2D , Flatten\n",
        "\n",
        "model = Sequential()  #  initializing the model\n",
        "\n",
        "model.add(Conv2D(input_shape=VGG_INPUT_SIZE,filters=64,kernel_size=(3,3),padding=\"same\", activation=\"relu\"))  # tamaño de las imágenes: 224, 224, 3 colores\n",
        "model.add(Conv2D(filters=64,kernel_size=(3,3),padding=\"same\", activation=\"relu\"))\n",
        "model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))\n",
        "\n",
        "model.add(Conv2D(filters=128, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(Conv2D(filters=128, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))\n",
        "\n",
        "model.add(Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(Conv2D(filters=256, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))\n",
        "\n",
        "model.add(Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))\n",
        "\n",
        "model.add(Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(Conv2D(filters=512, kernel_size=(3,3), padding=\"same\", activation=\"relu\"))\n",
        "model.add(MaxPool2D(pool_size=(2,2),strides=(2,2)))\n",
        "\n",
        "model.add(Flatten())\n",
        "model.add(Dense(units=4096,activation=\"relu\"))  # 4096 neuronas\n",
        "model.add(Dense(units=4096,activation=\"relu\"))  # 4096 neuronas\n",
        "model.add(Dense(units=n_classes, activation=\"softmax\"))  # 17 neuronas, 17 actores"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MhFcF7BfpvYt"
      },
      "source": [
        "### 4. Compilar el modelo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HIK4RlsY5Lkw",
        "outputId": "a99bdc28-ea92-4cb1-8016-a76f126d5357"
      },
      "outputs": [],
      "source": [
        "model.compile(optimizer=\"adam\", loss=keras.losses.categorical_crossentropy, metrics=['accuracy'])\n",
        "model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1mqgdS4c5aIN"
      },
      "source": [
        "### 5. Entrenar el modelo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Xpr7Rz2fVPKQ",
        "outputId": "c7e16db4-08a4-4bab-ffc3-73d394eea36c"
      },
      "outputs": [],
      "source": [
        "history = model.fit(x=training_set, validation_data=val_set, epochs=2, batch_size= BATCH_SIZE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TQFPyNh56SBs"
      },
      "source": [
        "### 7. Inferencia: hora de ponerlo a prueba!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 471
        },
        "id": "DDP-7ca2Ir-D",
        "outputId": "fb1507f0-8e08-4362-ec02-2a2df11bd400"
      },
      "outputs": [],
      "source": [
        "from keras.preprocessing import image\n",
        "\n",
        "img = image.load_img(\"/content/Celebrity_Faces_Dataset/test/Denzel_Washington/094_7858a9ff.jpg\",target_size=image_size)\n",
        "img = np.asarray(img)\n",
        "plt.imshow(img)\n",
        "img = np.expand_dims(img, axis=0)\n",
        "output = model.predict(img)\n",
        "print(class_names[np.argmax(output)])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NrhX87uKpDf4"
      },
      "source": [
        "# **Práctica #2.2.:** Entrenamiento a partir de un modelo pre-entrenado\n",
        "\n",
        "### 1. Cargar el modelo pre entrenado"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "2KUVwXQ3W9Ni"
      },
      "outputs": [],
      "source": [
        "import keras\n",
        "from keras.applications.vgg16 import VGG16\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Dense, Conv2D, MaxPool2D , Flatten\n",
        "\n",
        "class_names = list(training_set.class_indices.keys())\n",
        "n_classes = len(class_names)\n",
        "\n",
        "vgg_model = Sequential()\n",
        "\n",
        "pretrained_model= keras.applications.VGG16(include_top=False,\n",
        "                   input_shape=VGG_INPUT_SIZE,\n",
        "                   pooling='avg',classes=?,\n",
        "                   weights='imagenet')\n",
        "\n",
        "# Congelar las capas del modelo pre-entrenado: especificar que los pesos no cambien  durante el entrenamiento\n",
        "for layer in pretrained_model.layers:\n",
        "        layer.trainable=False\n",
        "\n",
        "# Añadir un par de capas extras, la última con 17 neuronas (n_classes)\n",
        "vgg_model.add(pretrained_model)\n",
        "vgg_model.add(_INSERT_LAYER_HERE_())\n",
        "vgg_model.add(_INSERT_LAYER_HERE_(4096, activation='relu'))\n",
        "vgg_model.add(_INSERT_LAYER_HERE_(1072, activation='relu'))\n",
        "vgg_model.add(_INSERT_LAYER_HERE_(?, activation='softmax'))  # Capa de predicción. SOftmax se suele usar para tareas de clasificaciónmulti-categoría."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tnQI0o5nppMR"
      },
      "source": [
        "### 2. Compilar el modelo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "12JYe81AqJ4A",
        "outputId": "60312060-e7fb-4b47-bea6-d2d99f9a9217"
      },
      "outputs": [],
      "source": [
        "vgg_model.compile(optimizer='adam',\n",
        "                  loss='categorical_crossentropy',\n",
        "                  metrics=['accuracy'])\n",
        "vgg_model.summary()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cux6rAy0qTtc"
      },
      "source": [
        "### 3. Entrenar modelo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "from keras.callbacks import EarlyStopping\n",
        "\n",
        "# EarlyStopping\n",
        "early_stop = EarlyStopping(monitor='val_loss',\n",
        "                           patience=10,\n",
        "                           restore_best_weights=True,\n",
        "                           mode='min')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cMEveGa9qXit",
        "outputId": "b8de1bff-d969-4b01-c48d-2e40ec11787f"
      },
      "outputs": [],
      "source": [
        "VGG_INPUT_SIZE = (224,224,3)\n",
        "image_size = VGG_INPUT_SIZE[:-1]\n",
        "BATCH_SIZE = 64\n",
        "N_EPOCHS = 50\n",
        "\n",
        "history = vgg_model.fit(training_set,\n",
        "                        validation_data=test_set,\n",
        "                        epochs=N_EPOCHS,\n",
        "                        batch_size= BATCH_SIZE,\n",
        "                        steps_per_epoch=training_set.samples // BATCH_SIZE,\n",
        "                        validation_steps=test_set.samples // BATCH_SIZE,\n",
        "                        callbacks=early_stop)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 736
        },
        "id": "GWz36SVFqwws",
        "outputId": "5291c360-aebc-402d-da86-764ff5c3b82f"
      },
      "outputs": [],
      "source": [
        "train_losss = history.history['loss']\n",
        "train_accu = history.history['accuracy']\n",
        "test_losss = history.history['val_loss']\n",
        "test_accu = history.history['val_accuracy']\n",
        "\n",
        "f, axarr = plt.subplots(1,2, figsize=(10,5))\n",
        "axarr[0].plot(train_losss, label=\"Train Loss\")\n",
        "axarr[0].set_title(\"Train Loss\")\n",
        "axarr[0].plot(test_losss, label='Test Loss')\n",
        "axarr[0].set_title(\"Loss\")\n",
        "axarr[0].set_xlabel('Epochs')\n",
        "axarr[0].legend()\n",
        "axarr[1].plot(train_accu, label=\"Train Acc\")\n",
        "axarr[1].plot(test_accu, label=\"Test Loss\")\n",
        "axarr[1].set_title(\"Accuracy\")\n",
        "axarr[1].set_xlabel('Epochs')\n",
        "axarr[1].legend()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7VoSXxJrry4x"
      },
      "source": [
        "### 4. Hacer predicciones (inferencia). ¡Hora de ponerlo a prueba!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 471
        },
        "id": "5RPy1imkr2iX",
        "outputId": "d51d9fa6-655f-45bd-ada4-4ce9de1ac5ea"
      },
      "outputs": [],
      "source": [
        "from keras.preprocessing import image\n",
        "\n",
        "img = image.load_img(\"/content/Celebrity_Faces_Dataset/test/Angelina_Jolie/095_0be163a1.jpg\",target_size=image_size)\n",
        "img = np.asarray(img)\n",
        "plt.imshow(img)\n",
        "img = np.expand_dims(img, axis=0)\n",
        "output = vgg_model.predict(img)\n",
        "print(class_names[np.argmax(output)])"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}