CODE/Modelo_clasificacion.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jh-vDfmHMytW"
      },
      "source": [
        "Librerías necesarias para el proyecto:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "dWdFcdhakDXf"
      },
      "outputs": [],
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import os\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "import tensorflow as tf\n",
        "from tensorflow.keras.models import Sequential\n",
        "from tensorflow.keras.layers import Dense, Flatten, Conv2D,MaxPooling2D,Dropout, Input, Concatenate, Lambda, GlobalAveragePooling2D\n",
        "from tensorflow.keras.utils  import to_categorical\n",
        "from tensorflow.keras.models import Model\n",
        "from tensorflow.keras.applications import  VGG16\n",
        "\n",
        "from keras.callbacks import EarlyStopping\n",
        "\n",
        "import sklearn\n",
        "from   sklearn.model_selection import train_test_split\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos a establecer la semilla de la biblioteca numpy para que las pariciones y ejecuciones tengan el mismo resultado siempre que se ejecuten."
      ],
      "metadata": {
        "id": "FhodxE5ZR5aq"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "2MUPML5x4W-w"
      },
      "outputs": [],
      "source": [
        "np.random.seed(0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Lf18B3xXM4t5"
      },
      "source": [
        "Acceder al drive con el dataset:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WW4AUpWO-oKC",
        "outputId": "a8485cc8-833f-4055-aa48-897bf78928b8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ],
      "source": [
        "#Para acceder a nuestros ficheros de Google Drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "# La carpeta datos (que contiene X_train.npy, y_train.npy, X_test.npy y y_test.npy)\n",
        "# debe estar en vuestro Drive, dentro de la carpeta 'Colab Notebooks'"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Izkei3lCBm5T"
      },
      "source": [
        "Vamos a mapear cada clase para etiquetar las clases con valores numéricos además de la etiqeuea original que se trataba del nombre en formato string."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QwCvdodoBeSP"
      },
      "outputs": [],
      "source": [
        "map_labels = {\n",
        "    'Apple Braeburn':0,\n",
        "  'Apple Granny Smith':1,\n",
        "  'Apricot':2,\n",
        "  'Avocado':3,\n",
        "  'Banana':4,\n",
        "  'Blueberry':5,\n",
        "  'Cactus fruit':6,\n",
        "  'Cantaloupe':7,\n",
        "  'Cherry':8,\n",
        "  'Clementine':9,\n",
        "  'Corn':10,\n",
        "  'Cucumber Ripe':11,\n",
        "  'Grape Blue':12,\n",
        "  'Kiwi':13,\n",
        "  'Lemon':14,\n",
        "  'Limes':15,\n",
        "  'Mango':16,\n",
        "  'Onion White':17,\n",
        "  'Orange':18,\n",
        "  'Papaya':19,\n",
        "  'Passion Fruit':20,\n",
        "  'Peach':21,\n",
        "  'Pear':22,\n",
        "  'Pepper Green':23,\n",
        "  'Pepper Red':24,\n",
        "  'Pineapple':25,\n",
        "  'Plum':26,\n",
        "  'Pomegranate':27,\n",
        "  'Potato Red':28,\n",
        "  'Raspberry':29,\n",
        "  'Strawberry':30,\n",
        "  'Tomato':31,\n",
        "  'Watermelon':32\n",
        "}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "36vakboXM9g2"
      },
      "source": [
        "Para poder cargar los datos en el colab hace falta que se añadan el conjunto de datos al drive personal en la carpeta `drive/MyDrive/Colab Notebooks/datos/` o cambiar el valor de `file_pat`h a la dirección donde se ha cargado el arhcivo con los datos `total_data.npz`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XlFg2waKWdHo",
        "outputId": "3be84a14-a066-4de6-f42e-05078147a801"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Forma de vector trainX de muestras: (10112, 100, 100, 3)\n",
            "Forma de vector trainY de etiquetas: (10112,)\n",
            "Forma de vector testX de muestras: (6742, 100, 100, 3)\n",
            "Forma de vector testY de etiquetas: (6742,)\n"
          ]
        }
      ],
      "source": [
        "#Primera parte de los datos (parte de entrenamiento)\n",
        "file_path = 'drive/MyDrive/Colab Notebooks/datos/total_data.npz'\n",
        "\n",
        "loaded_data = np.load(file_path)\n",
        "trainX = loaded_data['trainX'] # cargar el array con los valores de cada imagen de train\n",
        "trainY_names = loaded_data['trainY'] # cargar el array con los valores de las etiquetas de train\n",
        "testX = loaded_data['testX'] # cargar el array con los valores de cada imagen de test\n",
        "testY_names = loaded_data['testY'] # cargar el array con los valores de las etiquetas de test\n",
        "\n",
        "\n",
        "trainY = [map_labels[label] for label in trainY_names]\n",
        "testY = [map_labels[label] for label in testY_names]\n",
        "\n",
        "\n",
        "# Trasnformar en arrays de numpy para mayor eficiencia\n",
        "trainX = np.array(trainX)\n",
        "trainY = np.array(trainY)\n",
        "testX = np.array(testX)\n",
        "testY = np.array(testY)\n",
        "#print(trainX[0])\n",
        "#print(trainY[0])\n",
        "# Mostrar dimension del conjunto de muestras total\n",
        "print(\"Forma de vector trainX de muestras:\", trainX.shape)\n",
        "print(\"Forma de vector trainY de etiquetas:\", trainY.shape)\n",
        "print(\"Forma de vector testX de muestras:\", testX.shape)\n",
        "print(\"Forma de vector testY de etiquetas:\", testY.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Mw1HbC6zrc9P"
      },
      "source": [
        "Cada caso representa una imagen de una fruta y posee 100x100 píxeles a color, y por lo tanto los datos de cada caso consisten en una matriz con tres dimensiones de la forma (100,100,3) ya que cada píxel se compone de 3 valores enteros entre 0 y 255 que representan los tres colores Rojo Verde y Azul (RGB)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hhS0eTTHw0wh"
      },
      "source": [
        "Inicialmente en la página web donde se obtienen los datos solo disponemos de los datos de train con sus etiquetas, los datos de test que hay en la página web no tienen etiquetas y por tanto no podemos usarlos para entrenar ni comprobar como test."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JCF_UXtWxmVo"
      },
      "source": [
        "De forma local , al extraer los vectores de píxeles de las imágenes, hemos obtenido el conjunto total de muestras.\n",
        "\n",
        "Después de obtener el conjunto total de datos hemos separado los datos en un conjunto de entrenamiento y otro de test. Realizamos esto lo primero para evitar observar los datos de test y realizar \"Data Snooping\" donde el conjunto de datos podría influenciar nuestra elección sobre el modelo a utilizar para resolver el problema de aprendizaje automático. Para separar las muestras en train y test, el rango de distribuciones comunes en la práctica es entre 60% train - 40% test y 90% train - 10% test. Al utilizar una distribución con mayor porcentaje para test obtendríamos una estimación mejor del error  $E_{out}$  a partir del error  $E{test}$  que con una distribución con menor porcentaje para test, ya que se utilizaría un número mayor de muestras para obtener la estimación. Sin embargo, al utilizar una distribución con mayor porcentaje para train obtendríamos un mejor ajuste del problema al entrenar el modelo de aprendizaje con más datos que con una distribución con menor porcentaje para train, teniendo una mejor generalización en el conjunto de entrenamiento de la función que tratamos de aproximar. En general cuantos más datos se utilicen en test mejor será la estimación del error $E_{out}$  y cuantos más datos se utilicen en el entrenamiento, el clasificador calculado se ajustará mejor al problema, ya que tiene más datos con los que aprender.  \n",
        "En este problema además del objetivo de clasificar también se pretende generar muestras nuevas a partir de un número muy reducido de muestras y comparar el rendimiento del modelo de clasificación con ambos conjuntos de datos, el original y el creado. Es por eso que la estimación del error $E_{out}$ es importante en este problema y por lo tanto hemos elegido una distribución de 60% para entrenamiento y 40% de test, teniendo en cuenta que con esta distribución se tiene un número menor de datos para entrenar, pero se tiene un número mayor de datos para  estimar el error  Eout  y obtener una estimación del rendimiento del modelo con cada conjunto de datos más robusta.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t3wZjLM5Tysm"
      },
      "source": [
        "# Preprocesado de los Datos"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FbEtaUL9XWJ-"
      },
      "source": [
        "Vamos a modificar el vector de etiquetas ya que inicialmente cada etiqueta se ha representado como un número\n",
        "$y_i \\in \\{0, 1, ..., 33\\}$, a partir del mapeado de los nombres de las clases, y por tanto vamos a transformar estas etiquetas al espacio de salida $\\mathcal Y$ donde cada etiqueta $y_i \\in \\mathcal Y$ identifica una clase de nuestro problema $C_{i}$ y es representado por un vector de 33 valores binarios donde todos los valores del vector toman el valor 0 excepto el valor en la posición $i$ que toma el valor 1 representando que la etiqueta es la clase $ i \\in \\{0,1,2,3...33\\}$.\n",
        "\n",
        "Para ello aplicamos One-Hot encoding a las etiquetas empleando la clase OneHotEncoder utilizando los siguiente parámetros para crear el objeto codificado:\n",
        "*   categories: se especifica la lista categ que contiene las categorías de cada variable.\n",
        "*   sparse_output=False: se establece en False para obtener una matriz densa en lugar de una matriz dispersa, para obtener una matriz con las columnas de cada nueva variable unificadas para añadirlas directamente al conjunto de datos.\n",
        "*   drop=None: se establece en None para mantener todas las categorías en cada variable.\n",
        "Después se utiliza el método fit_transform del objeto codificador para realizar la codificación One-Hot de las variables categóricas elegidas.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XiIdfqT2FCrq"
      },
      "source": [
        "La técnica One-Hot encoding se utiliza para evitar que los algoritmos de aprendizaje automático aprendan relaciones entre el orden númerico que existe entre los números consecutivos o rangos que se utilizan para los atributos de los datos. Por eso se utiliza un vector de valores binarios para evitar que las clases puedan inferir relaciones erroneas y confundan al algoritmo a la hora de entrenar con los datos."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "46kvuhLWRHTp",
        "outputId": "98c29a55-bdb7-4130-87b5-021075acbba3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Forma de vector Y del conjunto total de etiquetas: (10112, 33)\n",
            "Forma de vector Y del conjunto total de etiquetas: (6742, 33)\n"
          ]
        }
      ],
      "source": [
        "# Etiquetas numéricas\n",
        "categorias =  [np.arange(len(map_labels))]\n",
        "\n",
        "# Reshape del vector de etiquetas a una matriz columna para aplicar el codificador al vector\n",
        "trainY_reshaped = trainY.reshape(-1, 1)\n",
        "testY_reshaped = testY.reshape(-1, 1)\n",
        "\n",
        "#Funcion para codificar\n",
        "encoder = OneHotEncoder(\n",
        "     categories=categorias,  # Categorías de cada variable\n",
        "     sparse_output=False,  # crea una matriz sparse cuando se pone TRUE\n",
        "     drop  = None  #  No quitar categorías en cada variable\n",
        "     )\n",
        "\n",
        "trainY_encoded = encoder.fit_transform(trainY_reshaped) # Aplicar One Hot Encoding al conjunto entrenamiento\n",
        "testY_encoded = encoder.fit_transform(testY_reshaped) # Aplicar One Hot Encoding al conjunto entrenamiento\n",
        "print(\"Forma de vector Y del conjunto total de etiquetas:\",trainY_encoded.shape)\n",
        "print(\"Forma de vector Y del conjunto total de etiquetas:\",testY_encoded.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NxgUuLpT2VTv"
      },
      "source": [
        "#### Desequilibrio de clases\n",
        "\n",
        "Una parte importante a tener en cuenta sobre nuestro conjunto de datos es el desequilibrio de las clases presentes en nuestro dataset, esto es el nivel de representación de cada caracter de nuestro conjunto de training. Cuando hay un desbalanceo de una o más clases, ocurre una dominancia de una clase sobre otra, esto quiere decir, que nuestros modelos pueden aprender mucha información sobre un conjunto de clases que está muy representada en los datos y aprender muy poca información de otros más infrarepresentados. Nos interesa que todas las clases estén bien representadas para poder tener un modelo final de clasificación lo más potente y capáz posible en el dominio del problema y así poder tener una capacidad de clasificación sobre todas las clases posibles.\n",
        "\n",
        "Hay que tener en cuenta que cuando particionamos el conjunto de datos en datos de training y test, puede haber cierto desbalanceo que depende de la partición concreta que hemos realizado, esto lo hemos abordado realizando una separación de los datos con previa aleatorización del conjunto entero, de manera que la distribución sea lo más independiente posible de la partición que hemos hecho.\n",
        "\n",
        "Si visualizamos el conteo de todas las etiquetas $y$ para todos los ejemplos del conjunto de training podemos comprobar la distribución de las clases y tener una mejor percepción de este problema."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 564
        },
        "id": "1vj_usVJ6SIQ",
        "outputId": "850df8b9-b9c6-40a3-a98d-c0bcaf61798a"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1200x600 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plt.figure(figsize=(12, 6))\n",
        "sns.countplot(x=trainY)\n",
        "\n",
        "plt.title('Distribución de clases en Train')\n",
        "plt.xlabel(f'Labels (y)')\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UB2puahU8rwZ"
      },
      "source": [
        "Como podemos observar, existen algunas clases que tienen una cantidad mayor de muestras que el resto, pero en general la distribución es uniforme y por lo tanto no va a existir problemas durante el entrenamiento del modelo ya que al no existir clases sobrerepresentadas ni infrarepresentadas el modelo no va a favorecer ni desfavorecer a ninguna de las clases."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uvahk1gdxRI7"
      },
      "source": [
        "Como las variables consisten en píxeles a color con valores entre 0 y 255 para cada color, todas las variables están en la misma escala. Es importante destacar que estos análisis de los datos han de hacerse únicamente en el conjunto de entrenamiento ya que el conjunto de test es el que será utilizado para evaluar el modelo final y las elecciones tanto del modelo como de las transformaciones no deben influenciarse por la información de este conjunto, y así evitar cometer Data Snooping."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7fULAq-boMii"
      },
      "source": [
        "#Modelo de clasificación"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YfxaLFlJq0r-"
      },
      "source": [
        "Para los problemas de clasificación de imágenes, es común utilizar Redes Neuronales Convolucionales ya que han demostrado ser los mejores modelos para clasificar e identificar objetos y formas dentro de imágenes. Es por eso que hemos elegido un modelo de Red Neuronal Convolucional. El modelo consistirá en una serie de capas de modelo de Neuronas Convolucionales para extraer las carácterísticas más importantes de las imagenes y despúes una serie de capas de modelo de Red Neuronal Densa para aprender las características de las imágenes y clasificar según el tipo de fruta que aparezca en la imágen.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ckHhJFjwpFl0"
      },
      "source": [
        "## Métricas de error\n",
        "\n",
        "#### Métricas de error\n",
        "A continuación vamos a definir cuales son las métricas de error a usar en este problema de clasificación así como decir para cada una que información nos aporta.\n",
        "\n",
        "Las métricas que usaremos son por una parte, sacadas de la matriz de confusión, y otras, son específicas para problemas de clasificación multietiqueta. La matriz de confusión es una herramienta muy usada en Machine Learning para evaluar el rendimiento de un modelo de ML. Se suele usar mayoritariamente en problemas de clasificación y tiene una estructura tabular y que compara la frecuencia de clases predichas por el modelo y su valor real.\n",
        "\n",
        "![](https://dataaspirant.com/3_confusion_matrix/)\n",
        "_Figura tomada de https://dataaspirant.com/wp-content/uploads/2020/08/3_confusion_matrix.png_\n",
        "\n",
        "A partir de la matriz de confusión se pueden calcular métricas para evaluar un modelo de clasificación. Entre ellas se encuentran las que usaremos que son:\n",
        "\n",
        "- _Accuracy_ o exactitud: nos permite medir su tasa de clasificación correcta, es decir, la fracción de ejemplos que ha clasificado correctamente (independientemente de su clase). Se calcula como:\n",
        "$$\\frac{TP + TN}{TP + TN + FP + FN}$$\n",
        "- _Specificity_ o especificidad: Mide la fracción de las muestras que han sido clasificadas como negativas y que realmente fueron negativas, es decir, nos da una métrica para medir que tan bien clasifica la clase negativa. Se calcula como:\n",
        "$$\\frac{TN}{TN + FP}$$\n",
        "- F1-Score: Esta métrica combina dos métricas denominadas _Recall_ y _Precision_ en un valor único, y es especialmente útil cuando queremos encontrar un equilibrio entre los falsos positivos y falsos negativos. Se calcula como:\n",
        "$$\\frac{2\\cdot (\\text{Precision}\\cdot \\text{Recall})}{(\\text{Precision}+ \\text{Recall})}$$\n",
        "\n",
        "Todas estas métricas se pueden adaptar facilmente a la clasificación multiclase calculando el valor de las métrica de las clases por separado y promediando todas las clases obteniendo el valor general de las métricas del modelo.\n",
        "\n",
        "Como podemos observar, estamos eligiendo las métricas que nos pueden dar una mejor percepción global del rendimiento de un modelo. Si observamos por un lado la _Accuracy_ engloba la tasa de clasificación correcta de nuestro modelo, es decir, cuanto acierta nuestro modelo en proporción, esta métrica se considera de las más importantes porque es la que más engloba el rendimiento de un clasificador sin importar la clase que esta prediciendo. Sin embargo,distintos modelos mejores y peores pueden obtener valores parecidos en la métrica de accuracy debido a su estructura interna ya que solo mide los aciertos promedios y no tiene en cuenta que tipo de fallos comete ni en que partes de la clasificación.\n",
        "\n",
        "Por lo tanto para tener más valoraciones de los modelos y poder evaluar sus rendimientos en este caso utilizamos por un lado F1-Score, ya que se considera un métrica muy robusta que balancea el peso de la clase menos representada realizando la media armónica de la métrica _Recall_ y de la _Precision_. Sin embargo, el _Recall_ y la _Precision_ solo tienen en cuenta la clase positiva y ahí es donde entra la última métrica, la _Specificity_ que mide como de bien clasifica la clase negativa, completando el cálculo del rendimiento de un modelo.\n",
        "\n",
        "Con estas métricas seremos capaces de elegir de forma sensata y con bastante criterio aquel modelo que mejor clasifica una muestra de datos.\n",
        "\n",
        "\n",
        "Como valoración global vamos a definir nuestro criterio de selección. Para ello vamos a crear una métrica que comprende estas tres métricas que cabamos de explicar y es una suma ponderada de estas tres:\n",
        "$$\\alpha_1 \\cdot Acc + \\alpha_2 \\cdot Spec + \\alpha_3 \\cdot \\text{F1}$$\n",
        "\n",
        "De esta manera, podemos definir los coeficientes $\\alpha_i$ según que métricas resultan más importantes o con más peso a la hora de elegir un modelo u otro. Por tanto definiremos estos coeficientes tomándo en cuenta lo siguiente:\n",
        "- Sabemos que las clases de nuestro conjunto de entrenamiento no tienen algún tipo de desbalanceo importante, por lo que realmente la medición de la _accuracy_ resulta una buena métrica en este caso para comparar los modelos, ya que al estar las clases aproximadamente equitativamente bien representadas entonces un modelo con un _accuracy_ muy alto significa un modelo que está clasificando la mayoría de los ejemplos correctamente y no porque sea una clase mayoritaria. Por tanto, a esta métrica le daremos un peso importante.\n",
        "- Por otro lado, el F1-Score es una métrica que combina el _Precision_ y el _Recall_ en una sola métrica, por tanto, resulta útil cuando queremos evitar la sobreestimación o subestimación de los errores en la clasificación. En nuestro caso, los errores en clasificación de frutas no son tan relevantes como lo son los aciertos, sobre todo en clasificación multietiqueta donde la clasificación de no pertenencia de una clase es casi una forma de comportamiento por defecto, ya que la gran mayoría de clases responderan negativamente a la pertenencia del ejemplo a ellas y solo una responderá positivamente; por lo que nos interesa elegir un modelo que clasifica bien un ejemplo. Por tanto, al F1-Score tendrá un peso más bien bajo.\n",
        "- Finalmente, la especificidad mide que tan bien clasifica los casos negativos, en sí el caso es muy similar al de F1-Score, donde nos interesa más premiar los modelos que acierten mejor, por lo que este tendrá un peso muy similar al F1-Score.\n",
        "\n",
        "Por tanto, podemos asignar unos valores aproximados según las consideraciones de cada métrica con el problema al que nos enfrentamos. Por lo que proporcionamos la siguiente asignación:\n",
        "$$\\text{Score}(h) = 0.7 \\cdot Acc(h) + 0.15 \\cdot Spec(h) + 0.15\\cdot F1(h)$$\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "08AuOTVU3tyP"
      },
      "source": [
        "En la biblioteca de TensorFlow ya existen implementaciones de las métricas de Accuracy y de F1-Score, pero no de Sensitivity. Por lo tanto vamos a crear una métrica personalizada para Sensitivity y también para la métrica que acabamos de definir. Por motivos de la implementación de la biblioteca hace falta definir una clase para cada métrica con unas funciones auxiliares heredadas, pero la implementación de la métrica está en la función `result()` dentro de las clases deifinidas."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ukaQbArUy_mr"
      },
      "outputs": [],
      "source": [
        "class CustomSensitivity(tf.keras.metrics.Metric):\n",
        "    def __init__(self, name='sensitivity', **kwargs):\n",
        "        super(CustomSensitivity, self).__init__(name=name, **kwargs)\n",
        "        self.true_positives = self.add_weight('tp', initializer='zeros')\n",
        "        self.false_negatives = self.add_weight('fn', initializer='zeros')\n",
        "\n",
        "    def update_state(self, y_true, y_pred, sample_weight=None):\n",
        "        y_true = tf.cast(y_true, dtype=tf.bool)\n",
        "        y_pred = tf.cast(y_pred > 0.5, dtype=tf.bool)  # Assuming binary classification with a threshold of 0.5\n",
        "\n",
        "        true_positives = tf.math.logical_and(y_true, y_pred)\n",
        "        false_negatives = tf.math.logical_and(y_true, tf.math.logical_not(y_pred))\n",
        "\n",
        "        self.true_positives.assign_add(tf.reduce_sum(tf.cast(true_positives, tf.float32)))\n",
        "        self.false_negatives.assign_add(tf.reduce_sum(tf.cast(false_negatives, tf.float32)))\n",
        "\n",
        "    def result(self):\n",
        "        return self.true_positives / (self.true_positives + self.false_negatives)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "g0ms0gVm01o8"
      },
      "outputs": [],
      "source": [
        "class CustomScoreMetric(tf.keras.metrics.Metric):\n",
        "    def __init__(self, **kwargs):\n",
        "        super(CustomScoreMetric, self).__init__(name='custom_score', **kwargs)\n",
        "        self.cat_accuracy = tf.keras.metrics.CategoricalAccuracy()\n",
        "        self.f1_score = tf.keras.metrics.F1Score()\n",
        "        self.custom_sensitivity = CustomSensitivity()\n",
        "\n",
        "    def update_state(self, y_true, y_pred, sample_weight=None):\n",
        "        self.cat_accuracy.update_state(y_true, y_pred)\n",
        "        self.f1_score.update_state(y_true, y_pred)\n",
        "        self.custom_sensitivity.update_state(y_true, y_pred)\n",
        "\n",
        "    def result(self):\n",
        "        acc = self.cat_accuracy.result()\n",
        "        f1 = self.f1_score.result()\n",
        "        sens = self.custom_sensitivity.result()\n",
        "\n",
        "        return 0.7 * acc + 0.15 * sens + 0.15 * f1\n",
        "\n",
        "    def reset_state(self):\n",
        "        self.cat_accuracy.reset_state()\n",
        "        self.f1_score.reset_state()\n",
        "        self.custom_sensitivity.reset_state()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TCEUgSGEoa80"
      },
      "source": [
        "##Red Neuronal Convolucional (CNN)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TFU2cppJpiEP"
      },
      "source": [
        "Para crear el modelo de Red Neuronal Convolucional se utiliza la  la biblioteca de Python Keras, que tiene una interfaz de alto nivel para redes neuronales que trabaja sobre varios motores de cálculo subyacentes, y en este caso utilizaremos TensorFlow. Keras funciona sobre varios motores de cálculo, pero TensorFlow es uno de los backends más utilizados por Keras. TensorFlow provee herramientas para construir y entrenar redes neuronales, y es utilizado comúnmente en conjunción con Keras para el desarrollo de modelos de aprendizaje profundo.\n",
        "En detalle se explican las funciones y parametros que se utilizan para crear el modelo:\n",
        "- `Sequential()`: Se crea un modelo secuencial de Keras. Este tipo de modelo permite agregar capas secuencialmente, una tras otra para crear el modelo personalizado.\n",
        "\n",
        "- `Conv2D`: Capa convolucional que aplica un conjunto de filtros convolucionales a la entrada. La función de activación ReLU se aplica después de la convolución. Los parámetros de entrada de la función representan lo siguiente:\n",
        "\n",
        "  - Número de filtros/neuronas convolucionales (32, 64, 128 dependiendo de cada capa).\n",
        "  - Tamaño de la ventana de convolución en Conv2D: Determina las dimensiones del filtro que se desplaza sobre la imagen de entrada. Un valor como (3, 3) especifica un filtro de 3x3 píxeles que busca patrones locales, influyendo en la extracción de características, la cantidad de parámetros del modelo y la información espacial capturada en la imagen.\n",
        "  - Función de activación ReLU.\n",
        "\n",
        "- `MaxPooling2D`: Capa de submuestreo que reduce el tamaño espacial de la salida y reduce la cantidad de parámetros a aprender. Los parámetros de entrada de la función representan lo siguiente:\n",
        "  - Tamaño de la ventana de pooling en MaxPooling2D: Define las dimensiones de la ventana que reduce el tamaño espacial de la salida de la capa previa. Por ejemplo, (2, 2) indica una ventana de 2x2 píxeles. Esto controla la reducción de la resolución espacial y la retención de características relevantes al realizar el submuestreo.\n",
        "\n",
        "- `Flatten()`: Capa que convierte los mapas de características bidimensionales en un vector unidimensional para alimentar las capas densas.\n",
        "\n",
        "- `Dense`: Capa densa o completamente conectada. Se definen las neuronas y la función de activación para las capas densas. Los parámetros de entrada de la función representan lo siguiente:\n",
        "  - Número de neuronas (64 en una capa).\n",
        "  - Función de activación ReLU en capas densas.\n",
        "  - Capa de salida con un número de neuronas igual al número de clases en el problema.\n",
        "  - Utiliza la función de activación Softmax para obtener probabilidades de cada clase.\n",
        "\n",
        "- `modeloCNN.summary()`: Muestra un resumen detallado de la arquitectura del modelo, incluyendo el tipo de capa, el tamaño de salida y la cantidad de parámetros entrenables en cada capa.\n",
        "\n",
        "Este modelo es una red neuronal convolucional para clasificación de imágenes, compuesta por capas convolucionales, capas de submuestreo, capas completamente conectadas y una capa de salida para clasificación multi-clase.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Como función de pérdida para el modelo utilizamos la función de entropía cruzada ya que experimentalmente se ha visto que esta función obtiene buenos resultados en modelos de redes neuronales.  \n",
        "\n",
        "**Entropía Cruzada (Cross Entropy)** es una función de pérdida comúnmente utilizada en problemas de clasificación en modelos de aprendizaje automático, incluyendo redes neuronales, para evaluar la discrepancia entre la distribución de probabilidad estimada por el modelo y la distribución real de los datos.\n",
        "\n",
        "Aspectos clave de la Entropía Cruzada en el modelo:\n",
        "\n",
        "- **Métrica de discrepancia:** Evalúa la diferencia entre la distribución de probabilidad predicha por el modelo y la distribución real de las etiquetas. En clasificación, se centra en la predicción de la clase correcta.\n",
        "\n",
        "- **Utilizada en problemas de clasificación:** Es particularmente efectiva en problemas de clasificación multiclase, donde la red debe asignar una clase a una entrada entre múltiples clases posibles.\n",
        "\n",
        "- **Función de pérdida para entrenamiento:** La Entropía Cruzada se utiliza como una función de pérdida durante el entrenamiento del modelo, donde se busca minimizar la discrepancia entre las predicciones y las etiquetas reales.\n",
        "\n",
        "- **Múltiplas variantes:** Hay diferentes tipos de Entropía Cruzada, como Categórica (Categorical), Binaria (Binary), o Sparce, cada una adecuada para diferentes tipos de problemas de clasificación. En nuestro caso utilizamos la variante categórica ya que tenemos 33 clases de frutas distintas.\n",
        "\n",
        "La función de Entropía Cruzada (Cross Entropy) se expresa matemáticamente como:\n",
        "\n",
        "$$ H(y, \\hat{y}) = - \\frac{1}{N} \\sum_{i=1}^{N} \\left( y_i \\cdot \\log(\\hat{y}_i) + (1 - y_i) \\cdot \\log(1 - \\hat{y}_i) \\right) $$\n",
        "\n",
        "Donde:\n",
        "- $y$ representa las etiquetas reales.\n",
        "- $\\hat{y}$ representa las predicciones del modelo.\n",
        "- $N$ es el número de ejemplos.\n",
        "\n",
        "\n",
        "Al utilizar la Entropía Cruzada como función de pérdida en un modelo de CNN, se busca minimizar la discrepancia entre las predicciones del modelo y las etiquetas reales, optimizando así la capacidad del modelo para realizar predicciones precisas en problemas de clasificación.\n"
      ],
      "metadata": {
        "id": "_ik8Fg8IWCXg"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UnReCKsIu5yi"
      },
      "source": [
        "La **función de activación ReLU (Rectified Linear Unit)** es una de las funciones más utilizadas en redes neuronales. Su definición matemática es  \n",
        ">$ f(x) = \\max(0, x) $  \n",
        "\n",
        "\n",
        "lo que implica que si el valor de entrada $ x $ es mayor que cero, la función retorna el mismo valor $ x $; en caso contrario, retorna cero.\n",
        "\n",
        "En el modelo de red neuronal convolucional (CNN) se utiliza la función ReLU después de las capas convolucionales y en la capa completamente conectada. Se implementa mediante el parámetro `activation='relu'` en las capas `Conv2D` y `Dense`.\n",
        "\n",
        "Las razones clave para el uso de ReLU son las siguientes:\n",
        "\n",
        "- **No tiene valor máximo:** ReLU no tiene un límite superior y no satura en la región positiva, lo que ayuda a evitar el problema de saturación presente en funciones como la sigmoide o la tangente hiperbólica, donde el gradiente en valores cercanos al máximo y mínimo tiende a desvanecerse y a decrecer significativamente, provocando que el entrenamiento se relentice. De este modo ReLu permite un entrenamiento más rápido. Además esto favorece la convergencia durante el entrenamiento.\n",
        "\n",
        "- **Eficiencia computacional:** También es más eficiente en términos de cómputo que algunas funciones de activación más complejas.\n",
        "\n",
        "La utilización de ReLU en el modelo permite la introducción de no linealidad en las capas, lo que posibilita que el modelo capture y aprenda patrones complejos presentes en los datos de entrada. En resumen, su aplicación en las operaciones de convolución y las capas densas mejora la capacidad del modelo para aprender y extraer características relevantes favoreciendo la clasificación de imágenes.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "URrASWREx4_7"
      },
      "source": [
        "La función de activación Softmax se utiliza comúnmente en la capa de salida de una red neuronal, especialmente en problemas de clasificación multiclase.  \n",
        "Su definición matemática es  \n",
        ">$ \\sigma(z)_j = \\frac{e^{z_j}}{\\sum_{k=1}^{K} e^{z_k}} $  \n",
        "\n",
        "donde $ z $ es un vector de entradas a la función, $ K $ es el número total de clases y $ j $ es la clase específica. En el modelo se utiliza esta función de activación en la capa de salida para generar como resultado las probabilidades de pertenencer a cada clase en el formato de salida indicado para este problema.\n",
        "\n",
        "Principales aspectos de la función Softmax:\n",
        "\n",
        "- **Probabilidades normalizadas:** Transforma un vector de números reales en un vector de probabilidades normalizadas que suman 1. Estas probabilidades representan la confianza del modelo en cada clase para una entrada dada.\n",
        "\n",
        "- **Útil en clasificación multiclase:** Es útil en problemas donde se requiere asignar una sola etiqueta a cada ejemplo de entrada entre varias clases posibles.\n",
        "\n",
        "- **Salida para clasificación:** La clase con la probabilidad más alta después de aplicar Softmax se considera la predicción del modelo para la entrada dada.\n",
        "\n",
        "La función Softmax es crucial en la etapa de clasificación, ya que proporciona una salida interpretable y adecuada para la toma de decisiones sobre la pertenencia de una entrada a diferentes categorías.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "74ERuFai4l4X"
      },
      "source": [
        "**Early Stopping (Detención Temprana)** es una técnica de regularización utilizada durante el entrenamiento de modelos de aprendizaje automático, en particular, redes neuronales. Su objetivo principal es evitar el sobreajuste del modelo y mejorar la capacidad de generalización.\n",
        "\n",
        "Principales aspectos de Early Stopping:\n",
        "\n",
        "- **Control del rendimiento:** Durante el entrenamiento, Early Stopping supervisa el rendimiento del modelo en un conjunto de validación. Este rendimiento se mide utilizando una métrica, como la fucnión de pérdida u otras métricas como accuracy.\n",
        "\n",
        "- **Detención cuando empeora:** Early Stopping detiene el entrenamiento si el rendimiento en el conjunto de validación empeora en comparación con iteraciones anteriores. Este empeoramiento se conoce como \"sobreajuste\" y se puede detectar por un aumento en la pérdida en lugar de una disminución.\n",
        "\n",
        "- **Mejora de la generalización:** Al detener el entrenamiento en el momento adecuado, Early Stopping ayuda a que el modelo mantenga su capacidad de generalización y evita que memorice el conjunto de entrenamiento.\n",
        "\n",
        "- **Ajuste de hiperparámetros:** Los hiperparámetros importantes en Early Stopping incluyen la métrica de evaluación, la paciencia (número de épocas sin mejora antes de detener) y la restauración de los pesos del modelo en la última iteración de mejora.\n",
        "\n",
        "Early Stopping es una herramienta esencial para mejorar la robustez y el rendimiento de los modelos de aprendizaje automático al evitar el sobreajuste y promover una mejor generalización.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kOdLe1w5QSSl"
      },
      "source": [
        "**Adam** es un algoritmo de optimización comúnmente utilizado en el entrenamiento de modelos de aprendizaje automático, incluyendo redes neuronales, que combina la técnica de descenso de gradiente estocástico con adaptabilidad en la tasa de aprendizaje.\n",
        "\n",
        "Aspectos clave de Adam como optimizador en `model.compile`:\n",
        "\n",
        "- **Adaptabilidad de la tasa de aprendizaje:** Adam ajusta automáticamente la tasa de aprendizaje del modelo a lo largo del entrenamiento para cada parámetro, basándose en estimaciones de primer y segundo momento de los gradientes.\n",
        "\n",
        "- **Eficiencia y rapidez:** Integra las ventajas del descenso de gradiente estocástico con tasas de aprendizaje adaptativas, lo que lo hace efectivo en una amplia gama de problemas de optimización y lo hace converger más rápidamente.\n",
        "\n",
        "- **Tasa de aprendizaje adaptativa por parámetro:** Adam mantiene tasas de aprendizaje independientes por parámetro y las adapta según la magnitud del gradiente, resultando en un entrenamiento más suave y eficiente.\n",
        "\n",
        "- **Valores predeterminadas eficaces:** Adam posee valores predeterminados que suelen funcionar bien en una variedad de tareas, lo que facilita su uso y configuración.\n",
        "\n",
        "Al utilizar Adam como optimizador en `model.compile`, se emplea un algoritmo robusto y eficiente que adaptativamente ajusta las tasas de aprendizaje para acelerar la convergencia y mejorar el rendimiento del modelo durante el entrenamiento.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kDU02qe4fF4d"
      },
      "source": [
        "**MaxPooling2D** es una capa comúnmente empleada en las redes neuronales convolucionales (CNN) para el procesamiento de imágenes y otros datos con estructura similar. Su principal objetivo es realizar el submuestreo (downsampling) de las características extraídas de la capa anterior, reduciendo la resolución espacial.\n",
        "\n",
        "Aspectos clave de MaxPooling2D en el modelo:\n",
        "\n",
        "- **Reducción de la dimensionalidad:** MaxPooling2D reduce la resolución espacial de la salida de la capa anterior al seleccionar el valor máximo de una ventana deslizante (kernel) en la entrada. Esto disminuye la cantidad de parámetros y cálculos necesarios en capas subsiguientes.\n",
        "\n",
        "- **Conservación de características relevantes:** MaxPooling2D conserva las características más prominentes en cada ventana, permitiendo que el modelo se enfoque en las características más importantes mientras reduce el ruido o detalles menos significativos.\n",
        "\n",
        "- **Parámetros configurables:** La dimensión de la ventana de MaxPooling2D se configura, por ejemplo, `(2, 2)` indica una ventana de 2x2 píxeles, y el stride (desplazamiento) controla la cantidad de traslape entre ventanas.\n",
        "\n",
        "- **Utilización en arquitecturas CNN:** MaxPooling2D es un componente fundamental en las CNN para crear representaciones jerárquicas de características en imágenes y otras estructuras de datos.\n",
        "\n",
        "Al utilizar MaxPooling2D en un modelo de CNN, se logra la reducción de la resolución espacial en las características, lo que simplifica el modelo y mejora la capacidad de generalización.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vW-faOfezadZ"
      },
      "source": [
        "## Elección de Hiperparámetros"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "La elección de los hiperparámetros del modelo se realiza en otro cuaderno de colab para no tener que ejecutar todo el proceso, ya que conlleva entrenar una cantidad significativa de modelos con distintos hiperparámetros y comparar su rendimiento para elegir los mejores hiperparámetros mediante las técnicas que en ese cuaderno se explican. Este proceso lleva bastante tiempo de computación y por tanto se pueden observar los resultados obtenidos en las tablas de los hiperparámetros sin ejecutarlo para comprobar el rendimiento del modelo con los distintos hiperparámetros. Finalmente, como resultado del proceso de elección de hiperparámetros se han obtenido los valores ideales obteniendo el modelo con el que vamos a comparar los resultados."
      ],
      "metadata": {
        "id": "pamhtjMfS1LB"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D1P2eEip4T80"
      },
      "source": [
        "## Modelo Final"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finalmente establecemos el modelo final con los hiperparámetros elegidos como se ha explicado antes:"
      ],
      "metadata": {
        "id": "qoeAdVDa4XeC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "input_shape = trainX[0].shape\n",
        "num_classes = len(map_labels)"
      ],
      "metadata": {
        "id": "J5mpW0pPcEX8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Definir hiperparámetros:"
      ],
      "metadata": {
        "id": "W7Rrl-WW5GuK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Valores de los hiperparámetros\n",
        "conv_neurons = [32,64,128]\n",
        "conv_window = [[3,3],[3,3],[3,3]]\n",
        "num_maxPooling = [[2,2],[2,2],[2,2]]\n",
        "dense_neurons = 64\n",
        "batch_size = 96\n",
        "epochs = 4"
      ],
      "metadata": {
        "id": "3rjTmiKEakD5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Crear modelo"
      ],
      "metadata": {
        "id": "iVldIXww5FPW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "modeloCNN = Sequential()\n",
        "\n",
        "# Capa convolucional 1\n",
        "modeloCNN.add(Conv2D(conv_neurons[0], conv_window[0], activation='relu', input_shape=input_shape))\n",
        "modeloCNN.add(MaxPooling2D(num_maxPooling[0]))\n",
        "\n",
        "# Capa convolucional 2\n",
        "modeloCNN.add(Conv2D(conv_neurons[1], conv_window[1], activation='relu'))\n",
        "modeloCNN.add(MaxPooling2D(num_maxPooling[1]))\n",
        "\n",
        "# Capa convolucional 3\n",
        "modeloCNN.add(Conv2D(conv_neurons[2], conv_window[2], activation='relu'))\n",
        "modeloCNN.add(MaxPooling2D(num_maxPooling[2]))\n",
        "\n",
        "# Capa de aplanamiento\n",
        "modeloCNN.add(Flatten())\n",
        "\n",
        "# Capa completamente conectada\n",
        "modeloCNN.add(Dense(dense_neurons, activation='relu'))\n",
        "\n",
        "# Capa de salida\n",
        "modeloCNN.add(Dense(num_classes, activation='softmax'))\n",
        "\n",
        "modeloCNN.summary()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ju2X11Y5bDG5",
        "outputId": "4affa500-579c-4205-958a-d8b6c93646d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            " Layer (type)                Output Shape              Param #   \n",
            "=================================================================\n",
            " conv2d (Conv2D)             (None, 98, 98, 32)        896       \n",
            "                                                                 \n",
            " max_pooling2d (MaxPooling2  (None, 49, 49, 32)        0         \n",
            " D)                                                              \n",
            "                                                                 \n",
            " conv2d_1 (Conv2D)           (None, 47, 47, 64)        18496     \n",
            "                                                                 \n",
            " max_pooling2d_1 (MaxPoolin  (None, 23, 23, 64)        0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " conv2d_2 (Conv2D)           (None, 21, 21, 128)       73856     \n",
            "                                                                 \n",
            " max_pooling2d_2 (MaxPoolin  (None, 10, 10, 128)       0         \n",
            " g2D)                                                            \n",
            "                                                                 \n",
            " flatten (Flatten)           (None, 12800)             0         \n",
            "                                                                 \n",
            " dense (Dense)               (None, 64)                819264    \n",
            "                                                                 \n",
            " dense_1 (Dense)             (None, 33)                2145      \n",
            "                                                                 \n",
            "=================================================================\n",
            "Total params: 914657 (3.49 MB)\n",
            "Trainable params: 914657 (3.49 MB)\n",
            "Non-trainable params: 0 (0.00 Byte)\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Compilamos el modelo"
      ],
      "metadata": {
        "id": "zdubmoS6367j"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "modeloCNN.compile(\n",
        "    optimizer='adam',\n",
        "    loss='categorical_crossentropy',\n",
        "    metrics=[\n",
        "        tf.keras.metrics.CategoricalAccuracy(),\n",
        "        tf.keras.metrics.F1Score(),\n",
        "        CustomSensitivity(),\n",
        "        CustomScoreMetric()\n",
        "    ],\n",
        ")"
      ],
      "metadata": {
        "id": "N2Mg7jm4bMl4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aplicamos Early Stopping:"
      ],
      "metadata": {
        "id": "rFKkd-0l33zn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Define Early Stopping\n",
        "early_stopping = EarlyStopping(monitor='loss', patience=3, restore_best_weights=True)"
      ],
      "metadata": {
        "id": "K0gJ3YUycUGO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Crear conjunto de validación:"
      ],
      "metadata": {
        "id": "Eike8VRW3zb3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Obtener conjuntos de validación y train\n",
        "trainX_CNN, valX_CNN, trainY_CNN, valY_CNN = train_test_split(trainX, trainY_encoded, test_size=0.40)"
      ],
      "metadata": {
        "id": "C7cbTJ9wbC7w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Entrenamos el modelo"
      ],
      "metadata": {
        "id": "zHGvZz405LkK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Entrenar el modelo\n",
        "history = modeloCNN.fit(\n",
        "  trainX_CNN, trainY_CNN,\n",
        "  epochs=epochs,\n",
        "  batch_size=batch_size,\n",
        "  verbose = 1, # Cantidad de información a mostrar mientras se entrena\n",
        "  callbacks=[early_stopping]\n",
        ")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hayhku54c6HR",
        "outputId": "4a3b53e1-c4dc-4ea5-b0a8-6bd4817ccf59"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/4\n",
            "64/64 [==============================] - 56s 849ms/step - loss: 8.2912 - categorical_accuracy: 0.3143 - f1_score: 0.2833 - sensitivity: 0.1737 - custom_score: 0.2886\n",
            "Epoch 2/4\n",
            "64/64 [==============================] - 63s 991ms/step - loss: 0.2610 - categorical_accuracy: 0.9332 - f1_score: 0.9301 - sensitivity: 0.8958 - custom_score: 0.9272\n",
            "Epoch 3/4\n",
            "64/64 [==============================] - 60s 938ms/step - loss: 0.0159 - categorical_accuracy: 0.9982 - f1_score: 0.9983 - sensitivity: 0.9975 - custom_score: 0.9981\n",
            "Epoch 4/4\n",
            "64/64 [==============================] - 56s 885ms/step - loss: 0.0042 - categorical_accuracy: 0.9997 - f1_score: 0.9997 - sensitivity: 0.9997 - custom_score: 0.9997\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Evaluamos el modelo con el conjunto de validación:"
      ],
      "metadata": {
        "id": "c4IhQqyx5NSb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluar el modelo\n",
        "results = modeloCNN.evaluate(valX_CNN,valY_CNN)\n",
        "\n",
        "funcionPerdidaTabla = []\n",
        "accuracyTabla = []\n",
        "f1Tabla = []\n",
        "sensitivityTabla = []\n",
        "customScoreTabla = []\n",
        "accuracyTabla.append(results[1])\n",
        "f1Tabla.append(results[2].mean())\n",
        "funcionPerdidaTabla.append(results[0])\n",
        "sensitivityTabla.append(results[3])\n",
        "customScoreTabla.append(results[4].mean())\n",
        "\n",
        "\n",
        "#Crear DataFrame y mostrarlo\n",
        "tableFrame = pd.DataFrame({'Error de validación (función de pérdida)':funcionPerdidaTabla,\n",
        "                           'Accuracy':accuracyTabla,'F1-Score':f1Tabla,'Sensitivity':sensitivityTabla, 'Métrica personalizada':customScoreTabla})\n",
        "display(tableFrame)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 98
        },
        "id": "UcsS2Y8hdEac",
        "outputId": "ece422a5-be03-414b-b6f5-22511b8d5d75"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "127/127 [==============================] - 10s 75ms/step - loss: 0.0080 - categorical_accuracy: 0.9985 - f1_score: 0.9983 - sensitivity: 0.9983 - custom_score: 0.9985\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "   Error de validación (función de pérdida)  Accuracy  F1-Score  Sensitivity  \\\n",
              "0                                  0.008019  0.998517  0.998334     0.998269   \n",
              "\n",
              "   Métrica personalizada  \n",
              "0               0.998452  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-8ba2a919-efd3-41a3-9e95-6233f64a9762\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Error de validación (función de pérdida)</th>\n",
              "      <th>Accuracy</th>\n",
              "      <th>F1-Score</th>\n",
              "      <th>Sensitivity</th>\n",
              "      <th>Métrica personalizada</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0.008019</td>\n",
              "      <td>0.998517</td>\n",
              "      <td>0.998334</td>\n",
              "      <td>0.998269</td>\n",
              "      <td>0.998452</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-8ba2a919-efd3-41a3-9e95-6233f64a9762')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-8ba2a919-efd3-41a3-9e95-6233f64a9762 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-8ba2a919-efd3-41a3-9e95-6233f64a9762');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A partir de los resultados podemos ver que en el conjunto de validación el modelo obtiene muy buenos resultados, casi perfectos. Se podría pensar que esto es debido a un sobreajuste del modelo pero ya que se ha utilizado un conjunto de validación que el modelo no utiliza para entrenar y solo lo utiliza para evaluar el modelo con las métricas, el modelo no está influenciado por este conjunto y las imagenes son una muestra del conjunto de posibles muestras en general y por tanto el resultado del rendimiento es un buen resultado que muestra que el modelo se ha ajustado bien a problema."
      ],
      "metadata": {
        "id": "XxUvbJ8oKsc1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Comparación de Conjuntos de Datos"
      ],
      "metadata": {
        "id": "n1XMUdQO5ZXu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Vamos a cargar todos los conjuntos de datos generados y a compararlos entrenando el modelo con cada uno y evaluando su rendimeinto con el conjunto de test, que fue apartado del conjunto global al principio para evaluar el modelo sobre los distintos conjuntos de entrenamiento y no se ha utilizado para nada más para evitar cometer Data Snooping."
      ],
      "metadata": {
        "id": "aApnRkweRHzB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c3c19735-3d74-43ab-8a1e-2463a3a2e2af",
        "id": "S_K-Jm0e7Lib"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Forma de vector trainX_2 de muestras: (13200, 100, 100, 3)\n",
            "Forma de vector trainY_2 de etiquetas: (13200,)\n",
            "Forma de vector trainX_3 de muestras: (33000, 100, 100, 3)\n",
            "Forma de vector trainY_3 de etiquetas: (33000,)\n",
            "Forma de vector trainX_4 de muestras: (66000, 100, 100, 3)\n",
            "Forma de vector trainY_4 de etiquetas: (66000,)\n"
          ]
        }
      ],
      "source": [
        "file_path2 = 'drive/MyDrive/Colab Notebooks/datos/data_dos_transformaciones.npz'\n",
        "file_path3 = 'drive/MyDrive/Colab Notebooks/datos/data_tres_transformaciones.npz'\n",
        "file_path4 = 'drive/MyDrive/Colab Notebooks/datos/data_cuatro_transformaciones.npz'\n",
        "\n",
        "loaded_data2 = np.load(file_path2)\n",
        "trainX_2 = loaded_data2['data'] # cargar el array con los valores de cada imagen de train\n",
        "trainY_2 = loaded_data2['labels'] # cargar el array con los valores de las etiquetas de train\n",
        "\n",
        "loaded_data3 = np.load(file_path3)\n",
        "trainX_3 = loaded_data3['data'] # cargar el array con los valores de cada imagen de train\n",
        "trainY_3 = loaded_data3['labels'] # cargar el array con los valores de las etiquetas de train\n",
        "\n",
        "loaded_data4 = np.load(file_path4)\n",
        "trainX_4 = loaded_data4['data'] # cargar el array con los valores de cada imagen de train\n",
        "trainY_4 = loaded_data4['labels'] # cargar el array con los valores de las etiquetas de train\n",
        "\n",
        "\n",
        "\n",
        "# Transformar en arrays de numpy para mayor eficiencia\n",
        "trainX_2 = np.array(trainX_2)\n",
        "trainY_2 = np.array(trainY_2)\n",
        "\n",
        "trainX_3 = np.array(trainX_3)\n",
        "trainY_3 = np.array(trainY_3)\n",
        "\n",
        "trainX_4 = np.array(trainX_4)\n",
        "trainY_4 = np.array(trainY_4)\n",
        "\n",
        "\n",
        "# Mostrar dimension del conjunto de muestras total\n",
        "print(\"Forma de vector trainX_2 de muestras:\", trainX_2.shape)\n",
        "print(\"Forma de vector trainY_2 de etiquetas:\", trainY_2.shape)\n",
        "\n",
        "print(\"Forma de vector trainX_3 de muestras:\", trainX_3.shape)\n",
        "print(\"Forma de vector trainY_3 de etiquetas:\", trainY_3.shape)\n",
        "\n",
        "print(\"Forma de vector trainX_4 de muestras:\", trainX_4.shape)\n",
        "print(\"Forma de vector trainY_4 de etiquetas:\", trainY_4.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Mismo preprocesado de datos"
      ],
      "metadata": {
        "id": "VhvavoqlRk8_"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d9f95d26-a4c6-414d-8667-68a8ca83be3c",
        "id": "CjMG7a-M7Lii"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Forma de vector Y del conjunto total de etiquetas: (13200, 33)\n",
            "Forma de vector Y del conjunto total de etiquetas: (33000, 33)\n",
            "Forma de vector Y del conjunto total de etiquetas: (66000, 33)\n"
          ]
        }
      ],
      "source": [
        "# Etiquetas numéricas\n",
        "categorias =  [np.arange(len(map_labels))]\n",
        "\n",
        "# Reshape del vector de etiquetas a una matriz columna para aplicar el codificador al vector\n",
        "trainY_2reshaped = trainY_2.reshape(-1, 1)\n",
        "trainY_3reshaped = trainY_3.reshape(-1, 1)\n",
        "trainY_4reshaped = trainY_4.reshape(-1, 1)\n",
        "\n",
        "#Funcion para codificar\n",
        "encoder = OneHotEncoder(\n",
        "     categories=categorias,  # Categorías de cada variable\n",
        "     sparse_output=False,  # crea una matriz sparse cuando se pone TRUE\n",
        "     drop  = None  #  No quitar categorías en cada variable\n",
        "     )\n",
        "\n",
        "trainY_2encoded = encoder.fit_transform(trainY_2reshaped) # Aplicar One Hot Encoding al conjunto entrenamiento\n",
        "trainY_3encoded = encoder.fit_transform(trainY_3reshaped) # Aplicar One Hot Encoding al conjunto entrenamiento\n",
        "trainY_4encoded = encoder.fit_transform(trainY_4reshaped) # Aplicar One Hot Encoding al conjunto entrenamiento\n",
        "print(\"Forma de vector Y del conjunto total de etiquetas:\",trainY_2encoded.shape)\n",
        "print(\"Forma de vector Y del conjunto total de etiquetas:\",trainY_3encoded.shape)\n",
        "print(\"Forma de vector Y del conjunto total de etiquetas:\",trainY_4encoded.shape)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Entrenamiento con los conjuntos"
      ],
      "metadata": {
        "id": "spm_Bm7kBg2h"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "vamos a entrenar el modelo con cada conjunto de datos y evaluar el rendimiento del modelo con el conjunto de test. Los resultados los mostramos en una tabla para poder comparar entre ellos."
      ],
      "metadata": {
        "id": "SThqhCfxSENo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "funcionPerdidaTabla = []\n",
        "accuracyTabla = []\n",
        "f1Tabla = []\n",
        "sensitivityTabla = []\n",
        "customScoreTabla = []\n",
        "modeloTabla = []"
      ],
      "metadata": {
        "id": "dNP9gNCfBrwR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "epochs = 4"
      ],
      "metadata": {
        "id": "SRgvbP_NCgHW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        ">Conjunto Original"
      ],
      "metadata": {
        "id": "6xqnxUrfCIxZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Entrenar el modelo\n",
        "history = modeloCNN.fit(\n",
        "  trainX, trainY_encoded,\n",
        "  epochs=epochs,\n",
        "  batch_size=batch_size,\n",
        "  verbose = 1, # Cantidad de información a mostrar mientras se entrena\n",
        "  callbacks=[early_stopping]\n",
        ")\n",
        "\n",
        "# Evaluar el modelo\n",
        "results = modeloCNN.evaluate(testX,testY_encoded)\n",
        "\n",
        "modeloTabla = 'Conjunto Original'\n",
        "accuracyTabla.append(results[1])\n",
        "f1Tabla.append(results[2].mean())\n",
        "funcionPerdidaTabla.append(results[0])\n",
        "sensitivityTabla.append(results[3])\n",
        "customScoreTabla.append(results[4].mean())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "60645d08-c73c-424e-98bd-740a408ed5b6",
        "id": "IcCvhokOBmbN"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/4\n",
            "106/106 [==============================] - 175s 2s/step - loss: 0.5673 - categorical_accuracy: 0.8273 - f1_score: 0.8037 - sensitivity: 0.7732 - custom_score: 0.8157\n",
            "Epoch 2/4\n",
            "106/106 [==============================] - 168s 2s/step - loss: 0.0827 - categorical_accuracy: 0.9795 - f1_score: 0.9785 - sensitivity: 0.9706 - custom_score: 0.9780\n",
            "Epoch 3/4\n",
            "106/106 [==============================] - 169s 2s/step - loss: 0.0201 - categorical_accuracy: 0.9961 - f1_score: 0.9960 - sensitivity: 0.9952 - custom_score: 0.9960\n",
            "Epoch 4/4\n",
            "106/106 [==============================] - 172s 2s/step - loss: 0.0293 - categorical_accuracy: 0.9923 - f1_score: 0.9921 - sensitivity: 0.9915 - custom_score: 0.9921\n",
            "211/211 [==============================] - 31s 149ms/step - loss: 0.0244 - categorical_accuracy: 0.9932 - f1_score: 0.9927 - sensitivity: 0.9917 - custom_score: 0.9929\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ">Conjunto Generado 2"
      ],
      "metadata": {
        "id": "OS_4NQGnEQNz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Entrenar el modelo\n",
        "history = modeloCNN.fit(\n",
        "  trainX_2, trainY_2encoded,\n",
        "  epochs=epochs,\n",
        "  batch_size=batch_size,\n",
        "  verbose = 1, # Cantidad de información a mostrar mientras se entrena\n",
        "  callbacks=[early_stopping]\n",
        ")\n",
        "\n",
        "# Evaluar el modelo\n",
        "results = modeloCNN.evaluate(testX,testY_encoded)\n",
        "\n",
        "modeloTabla = 'Conjunto generado 2'\n",
        "accuracyTabla.append(results[1])\n",
        "f1Tabla.append(results[2].mean())\n",
        "funcionPerdidaTabla.append(results[0])\n",
        "sensitivityTabla.append(results[3])\n",
        "customScoreTabla.append(results[4].mean())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3267d8a0-7e0d-40a8-baf1-656d56e67019",
        "id": "zIq4qvBnEQNz"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/4\n",
            "138/138 [==============================] - 219s 2s/step - loss: 0.9131 - categorical_accuracy: 0.7555 - f1_score: 0.7564 - sensitivity: 0.6800 - custom_score: 0.7443\n",
            "Epoch 2/4\n",
            "138/138 [==============================] - 217s 2s/step - loss: 0.1617 - categorical_accuracy: 0.9483 - f1_score: 0.9485 - sensitivity: 0.9405 - custom_score: 0.9472\n",
            "Epoch 3/4\n",
            "138/138 [==============================] - 216s 2s/step - loss: 0.0846 - categorical_accuracy: 0.9722 - f1_score: 0.9722 - sensitivity: 0.9688 - custom_score: 0.9717\n",
            "Epoch 4/4\n",
            "138/138 [==============================] - 223s 2s/step - loss: 0.0311 - categorical_accuracy: 0.9900 - f1_score: 0.9900 - sensitivity: 0.9893 - custom_score: 0.9899\n",
            "211/211 [==============================] - 36s 172ms/step - loss: 1.5268 - categorical_accuracy: 0.8994 - f1_score: 0.8785 - sensitivity: 0.8984 - custom_score: 0.8961\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ">Conjunto Generado 3"
      ],
      "metadata": {
        "id": "jb37aEfIEQVH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Entrenar el modelo\n",
        "history = modeloCNN.fit(\n",
        "  trainX_3, trainY_3encoded,\n",
        "  epochs=epochs,\n",
        "  batch_size=batch_size,\n",
        "  verbose = 1, # Cantidad de información a mostrar mientras se entrena\n",
        "  callbacks=[early_stopping]\n",
        ")\n",
        "\n",
        "# Evaluar el modelo\n",
        "results = modeloCNN.evaluate(testX,testY_encoded)\n",
        "\n",
        "modeloTabla = 'Conjunto Generado 3'\n",
        "accuracyTabla.append(results[1])\n",
        "f1Tabla.append(results[2].mean())\n",
        "funcionPerdidaTabla.append(results[0])\n",
        "sensitivityTabla.append(results[3])\n",
        "customScoreTabla.append(results[4].mean())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37377ec2-e551-4b24-f229-d40727cc843b",
        "id": "mon5UZFjEQVH"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/4\n",
            "344/344 [==============================] - 542s 2s/step - loss: 1.3725 - categorical_accuracy: 0.5987 - f1_score: 0.6007 - sensitivity: 0.4777 - custom_score: 0.5809\n",
            "Epoch 2/4\n",
            "344/344 [==============================] - 549s 2s/step - loss: 0.5163 - categorical_accuracy: 0.8260 - f1_score: 0.8255 - sensitivity: 0.7804 - custom_score: 0.8191\n",
            "Epoch 3/4\n",
            "344/344 [==============================] - 611s 2s/step - loss: 0.3213 - categorical_accuracy: 0.8902 - f1_score: 0.8900 - sensitivity: 0.8668 - custom_score: 0.8867\n",
            "Epoch 4/4\n",
            "344/344 [==============================] - 554s 2s/step - loss: 0.2324 - categorical_accuracy: 0.9222 - f1_score: 0.9220 - sensitivity: 0.9075 - custom_score: 0.9199\n",
            "211/211 [==============================] - 29s 139ms/step - loss: 0.9233 - categorical_accuracy: 0.8839 - f1_score: 0.8689 - sensitivity: 0.8799 - custom_score: 0.8810\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ">Conjunto Generado 4"
      ],
      "metadata": {
        "id": "HgzSa-1-EQnU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Entrenar el modelo\n",
        "history = modeloCNN.fit(\n",
        "  trainX_4, trainY_4encoded,\n",
        "  epochs=epochs,\n",
        "  batch_size=batch_size,\n",
        "  verbose = 1, # Cantidad de información a mostrar mientras se entrena\n",
        "  callbacks=[early_stopping]\n",
        ")\n",
        "\n",
        "# Evaluar el modelo\n",
        "results = modeloCNN.evaluate(testX,testY_encoded)\n",
        "\n",
        "modeloTabla = 'Conjunto Generado 4'\n",
        "accuracyTabla.append(results[1])\n",
        "f1Tabla.append(results[2].mean())\n",
        "funcionPerdidaTabla.append(results[0])\n",
        "sensitivityTabla.append(results[3])\n",
        "customScoreTabla.append(results[4].mean())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d588fcc-ce69-4e7c-b31c-6c0e937bbc25",
        "id": "I0lyDXigEQnU"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/4\n",
            "688/688 [==============================] - 1146s 2s/step - loss: 0.2886 - categorical_accuracy: 0.9081 - f1_score: 0.9080 - sensitivity: 0.8911 - custom_score: 0.9055\n",
            "Epoch 2/4\n",
            "688/688 [==============================] - 1080s 2s/step - loss: 0.1496 - categorical_accuracy: 0.9508 - f1_score: 0.9508 - sensitivity: 0.9436 - custom_score: 0.9498\n",
            "Epoch 3/4\n",
            "688/688 [==============================] - 1070s 2s/step - loss: 0.1186 - categorical_accuracy: 0.9607 - f1_score: 0.9607 - sensitivity: 0.9560 - custom_score: 0.9600\n",
            "Epoch 4/4\n",
            "688/688 [==============================] - 1071s 2s/step - loss: 0.1004 - categorical_accuracy: 0.9672 - f1_score: 0.9672 - sensitivity: 0.9633 - custom_score: 0.9667\n",
            "211/211 [==============================] - 29s 139ms/step - loss: 1.5065 - categorical_accuracy: 0.8670 - f1_score: 0.8456 - sensitivity: 0.8637 - custom_score: 0.8633\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Crear DataFrame y mostrarlo\n",
        "tableFrame = pd.DataFrame({'Conjunto utilizado': modeloTabla,'Error de test (función de pérdida)':funcionPerdidaTabla,\n",
        "                           'Accuracy':accuracyTabla,'F1-Score':f1Tabla,'Sensitivity':sensitivityTabla, 'Métrica personalizada':customScoreTabla})\n",
        "display(tableFrame)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 175
        },
        "outputId": "64362166-4ad3-45eb-f2e2-fac6f615b14d",
        "id": "NVG24kmmBmbV"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "    Conjunto utilizado  Error de test (función de pérdida)  Accuracy  \\\n",
              "0  Conjunto Generado 4                            0.024357  0.993177   \n",
              "1  Conjunto Generado 4                            1.526816  0.899436   \n",
              "2  Conjunto Generado 4                            0.923319  0.883862   \n",
              "3  Conjunto Generado 4                            1.506544  0.866953   \n",
              "\n",
              "   F1-Score  Sensitivity  Métrica personalizada  \n",
              "0  0.992709     0.991694               0.992884  \n",
              "1  0.878473     0.898398               0.896136  \n",
              "2  0.868885     0.879858               0.881015  \n",
              "3  0.845595     0.863690               0.863260  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-01b318a9-22b6-4427-9ea8-d5180f094759\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Conjunto utilizado</th>\n",
              "      <th>Error de test (función de pérdida)</th>\n",
              "      <th>Accuracy</th>\n",
              "      <th>F1-Score</th>\n",
              "      <th>Sensitivity</th>\n",
              "      <th>Métrica personalizada</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Conjunto Generado 4</td>\n",
              "      <td>0.024357</td>\n",
              "      <td>0.993177</td>\n",
              "      <td>0.992709</td>\n",
              "      <td>0.991694</td>\n",
              "      <td>0.992884</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>Conjunto Generado 4</td>\n",
              "      <td>1.526816</td>\n",
              "      <td>0.899436</td>\n",
              "      <td>0.878473</td>\n",
              "      <td>0.898398</td>\n",
              "      <td>0.896136</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Conjunto Generado 4</td>\n",
              "      <td>0.923319</td>\n",
              "      <td>0.883862</td>\n",
              "      <td>0.868885</td>\n",
              "      <td>0.879858</td>\n",
              "      <td>0.881015</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Conjunto Generado 4</td>\n",
              "      <td>1.506544</td>\n",
              "      <td>0.866953</td>\n",
              "      <td>0.845595</td>\n",
              "      <td>0.863690</td>\n",
              "      <td>0.863260</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-01b318a9-22b6-4427-9ea8-d5180f094759')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-01b318a9-22b6-4427-9ea8-d5180f094759 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-01b318a9-22b6-4427-9ea8-d5180f094759');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-b3445be9-1643-470c-bc5d-5f5d0f158ee5\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-b3445be9-1643-470c-bc5d-5f5d0f158ee5')\"\n",
              "            title=\"Suggest charts.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-b3445be9-1643-470c-bc5d-5f5d0f158ee5 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "modeloTabla = []\n",
        "modeloTabla.append('Conjunto Generado 1')\n",
        "modeloTabla.append('Conjunto Generado 2')\n",
        "modeloTabla.append('Conjunto Generado 3')\n",
        "modeloTabla.append('Conjunto Generado 4')"
      ],
      "metadata": {
        "id": "w3GpSKecmgPr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Crear DataFrame y mostrarlo\n",
        "tableFrame = pd.DataFrame({'Conjunto utilizado': modeloTabla,'Error de test (función de pérdida)':funcionPerdidaTabla,\n",
        "                           'Accuracy':accuracyTabla,'F1-Score':f1Tabla,'Sensitivity':sensitivityTabla, 'Métrica personalizada':customScoreTabla})\n",
        "display(tableFrame)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 175
        },
        "outputId": "119cfa9a-03ff-4115-bdc9-cf1011578c5f",
        "id": "XiRKGT4EpONW"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "    Conjunto utilizado  Error de test (función de pérdida)  Accuracy  \\\n",
              "0  Conjunto Generado 1                            0.024357  0.993177   \n",
              "1  Conjunto Generado 2                            1.526816  0.899436   \n",
              "2  Conjunto Generado 3                            0.923319  0.883862   \n",
              "3  Conjunto Generado 4                            1.506544  0.866953   \n",
              "\n",
              "   F1-Score  Sensitivity  Métrica personalizada  \n",
              "0  0.992709     0.991694               0.992884  \n",
              "1  0.878473     0.898398               0.896136  \n",
              "2  0.868885     0.879858               0.881015  \n",
              "3  0.845595     0.863690               0.863260  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-35196786-be81-4bbf-9f87-9607d4109190\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Conjunto utilizado</th>\n",
              "      <th>Error de test (función de pérdida)</th>\n",
              "      <th>Accuracy</th>\n",
              "      <th>F1-Score</th>\n",
              "      <th>Sensitivity</th>\n",
              "      <th>Métrica personalizada</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Conjunto Generado 1</td>\n",
              "      <td>0.024357</td>\n",
              "      <td>0.993177</td>\n",
              "      <td>0.992709</td>\n",
              "      <td>0.991694</td>\n",
              "      <td>0.992884</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>Conjunto Generado 2</td>\n",
              "      <td>1.526816</td>\n",
              "      <td>0.899436</td>\n",
              "      <td>0.878473</td>\n",
              "      <td>0.898398</td>\n",
              "      <td>0.896136</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Conjunto Generado 3</td>\n",
              "      <td>0.923319</td>\n",
              "      <td>0.883862</td>\n",
              "      <td>0.868885</td>\n",
              "      <td>0.879858</td>\n",
              "      <td>0.881015</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Conjunto Generado 4</td>\n",
              "      <td>1.506544</td>\n",
              "      <td>0.866953</td>\n",
              "      <td>0.845595</td>\n",
              "      <td>0.863690</td>\n",
              "      <td>0.863260</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-35196786-be81-4bbf-9f87-9607d4109190')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-35196786-be81-4bbf-9f87-9607d4109190 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-35196786-be81-4bbf-9f87-9607d4109190');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-93292642-e0f7-4252-8312-2792698cc00b\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-93292642-e0f7-4252-8312-2792698cc00b')\"\n",
              "            title=\"Suggest charts.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-93292642-e0f7-4252-8312-2792698cc00b button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Crear DataFrame y mostrarlo\n",
        "tableFrame = pd.DataFrame({'Conjunto utilizado': modeloTabla,'Error de test (función de pérdida)':funcionPerdidaTabla,\n",
        "                           'Accuracy':accuracyTabla,'F1-Score':f1Tabla,'Sensitivity':sensitivityTabla, 'Métrica personalizada':customScoreTabla})\n",
        "display(tableFrame)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 175
        },
        "outputId": "119cfa9a-03ff-4115-bdc9-cf1011578c5f",
        "id": "uOJ1TQokqEbN"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "    Conjunto utilizado  Error de test (función de pérdida)  Accuracy  \\\n",
              "0  Conjunto Generado 1                            0.024357  0.993177   \n",
              "1  Conjunto Generado 2                            1.526816  0.899436   \n",
              "2  Conjunto Generado 3                            0.923319  0.883862   \n",
              "3  Conjunto Generado 4                            1.506544  0.866953   \n",
              "\n",
              "   F1-Score  Sensitivity  Métrica personalizada  \n",
              "0  0.992709     0.991694               0.992884  \n",
              "1  0.878473     0.898398               0.896136  \n",
              "2  0.868885     0.879858               0.881015  \n",
              "3  0.845595     0.863690               0.863260  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-35196786-be81-4bbf-9f87-9607d4109190\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Conjunto utilizado</th>\n",
              "      <th>Error de test (función de pérdida)</th>\n",
              "      <th>Accuracy</th>\n",
              "      <th>F1-Score</th>\n",
              "      <th>Sensitivity</th>\n",
              "      <th>Métrica personalizada</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>Conjunto Generado 1</td>\n",
              "      <td>0.024357</td>\n",
              "      <td>0.993177</td>\n",
              "      <td>0.992709</td>\n",
              "      <td>0.991694</td>\n",
              "      <td>0.992884</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>Conjunto Generado 2</td>\n",
              "      <td>1.526816</td>\n",
              "      <td>0.899436</td>\n",
              "      <td>0.878473</td>\n",
              "      <td>0.898398</td>\n",
              "      <td>0.896136</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>Conjunto Generado 3</td>\n",
              "      <td>0.923319</td>\n",
              "      <td>0.883862</td>\n",
              "      <td>0.868885</td>\n",
              "      <td>0.879858</td>\n",
              "      <td>0.881015</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>Conjunto Generado 4</td>\n",
              "      <td>1.506544</td>\n",
              "      <td>0.866953</td>\n",
              "      <td>0.845595</td>\n",
              "      <td>0.863690</td>\n",
              "      <td>0.863260</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-35196786-be81-4bbf-9f87-9607d4109190')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-35196786-be81-4bbf-9f87-9607d4109190 button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-35196786-be81-4bbf-9f87-9607d4109190');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-93292642-e0f7-4252-8312-2792698cc00b\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-93292642-e0f7-4252-8312-2792698cc00b')\"\n",
              "            title=\"Suggest charts.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-93292642-e0f7-4252-8312-2792698cc00b button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "    </div>\n",
              "  </div>\n"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Creamos y compilamos el modelo:"
      ],
      "metadata": {
        "id": "b_tbDtGMkam5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "modeloCNN1 = Sequential()\n",
        "modeloCNN1.add(Conv2D(conv_neurons[0], conv_window[0], activation='relu', input_shape=input_shape))\n",
        "modeloCNN1.add(MaxPooling2D(num_maxPooling[0]))\n",
        "modeloCNN1.add(Conv2D(conv_neurons[1], conv_window[1], activation='relu'))\n",
        "modeloCNN1.add(MaxPooling2D(num_maxPooling[1]))\n",
        "modeloCNN1.add(Conv2D(conv_neurons[2], conv_window[2], activation='relu'))\n",
        "modeloCNN1.add(MaxPooling2D(num_maxPooling[2]))\n",
        "modeloCNN1.add(Flatten())\n",
        "modeloCNN1.add(Dense(dense_neurons, activation='relu'))\n",
        "modeloCNN1.add(Dense(num_classes, activation='softmax'))\n",
        "modeloCNN1.compile(\n",
        "    optimizer='adam',\n",
        "    loss='categorical_crossentropy',\n",
        "    metrics=[\n",
        "        tf.keras.metrics.CategoricalAccuracy(),\n",
        "        tf.keras.metrics.F1Score(),\n",
        "        CustomSensitivity(),\n",
        "        CustomScoreMetric()\n",
        "    ],\n",
        ")"
      ],
      "metadata": {
        "id": "2h5_IjyajWTE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Entrenamos y evaluamos el modelo:"
      ],
      "metadata": {
        "id": "E5AOQVLNkdjF"
      }
    }
  ],
  "metadata": {
    "colab": {
      "collapsed_sections": [
        "B03NMmxBS0jv",
        "hvz-WR0WUTR1"
      ],
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}