3_2_Clasificacion_multiclase_noticias.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.5.2"
    },
    "colab": {
      "name": "3_2_Clasificacion_multiclase_noticias.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/carlosemiliorabazo/deepLearning/blob/master/3_2_Clasificacion_multiclase_noticias.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Dmi65Nt7nxld",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9e91f5bc-43ab-417e-dc54-0638ff6500e5"
      },
      "source": [
        "import keras\n",
        "keras.__version__"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'2.6.0'"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TkrnDKKMnxlg"
      },
      "source": [
        "# Clasificación de noticias: un ejemplo de clasificación multiclase\n",
        "----\n",
        "Ya hemos visto cómo clasificar las entradas vectoriales en dos clases mutuamente excluyentes utilizando una red neuronal densamente conectada.\n",
        "Pero, ¿qué pasa cuando tienes más de dos clases?\n",
        "\n",
        "Ahora crearemos una red para clasificar las noticias de Reuters en **46 temas mutuamente excluyentes**. Como cada noticia debe clasificarse en una sola categoría, es un problema de **\"clasificación multiclase de una sola etiqueta\"**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Izoyxmwbnxli"
      },
      "source": [
        "## El conjunto de datos de Reuters\n",
        "\n",
        "El Reuters dataset es un conjunto de noticias breves y sus temas, publicado por Reuters en 1986. Son 46 temas diferentes; **algunos temas están más representados que otros**, pero cada uno tiene, al menos, **10 ejemplos en el conjunto** de entrenamiento.\n",
        "\n",
        "Al igual que IMDB y MNIST, el conjunto de datos de Reuters viene **empaquetado como parte de Keras**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "9NaMkWBXnxli",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "86496ed7-77b2-4a40-dd93-0cdce01ed132"
      },
      "source": [
        "from keras.datasets import reuters\n",
        "\n",
        "(train_data, train_labels), (test_data, test_labels) = reuters.load_data(num_words=10000)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/reuters.npz\n",
            "2113536/2110848 [==============================] - 0s 0us/step\n",
            "2121728/2110848 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CozwLpAvnxli"
      },
      "source": [
        "Al igual que con el conjunto de datos de IMDB, el argumento `num_words = 10000` restringe los datos a las 10.000 palabras más frecuentes que se encuentran en los datos.\n",
        "\n",
        "Tenemos 8.982 ejemplos de entrenamiento y 2.246 ejemplos de prueba:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0HJcxlr1nxlj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "33b75549-26e1-47d8-ce1e-9417a5060a62"
      },
      "source": [
        "len(train_data)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8982"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LbKH6-Cpnxlj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "09c44d48-2239-4525-de51-fe4e7c3631ca"
      },
      "source": [
        "len(test_data)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2246"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rRQ7AWE5nxlk"
      },
      "source": [
        "Al igual que con las críticas de IMDB, cada ejemplo es una lista de números enteros (índices de palabras): "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x7Sfvxm-nxlk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e2c8c84e-79c9-41a3-aa90-6465fb4be86c"
      },
      "source": [
        "train_data[10]"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1,\n",
              " 245,\n",
              " 273,\n",
              " 207,\n",
              " 156,\n",
              " 53,\n",
              " 74,\n",
              " 160,\n",
              " 26,\n",
              " 14,\n",
              " 46,\n",
              " 296,\n",
              " 26,\n",
              " 39,\n",
              " 74,\n",
              " 2979,\n",
              " 3554,\n",
              " 14,\n",
              " 46,\n",
              " 4689,\n",
              " 4329,\n",
              " 86,\n",
              " 61,\n",
              " 3499,\n",
              " 4795,\n",
              " 14,\n",
              " 61,\n",
              " 451,\n",
              " 4329,\n",
              " 17,\n",
              " 12]"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ys_v0Ykknxlk"
      },
      "source": [
        "Así es como podemos decodificarlo para volverlo a convertir en palabras, por si tenéis curiosidad:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "B4N2Ygn0nxll",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "135f7573-bbfd-48d7-9c3c-d4d16543811f"
      },
      "source": [
        "word_index = reuters.get_word_index()\n",
        "reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])\n",
        "# Los índices están desviados en 3 porque 0, 1 y 2 don índices reservados para \n",
        "# \"relleno\", \"comienzo de secuencia\" y \"desconocido\"\n",
        "decoded_newswire = ' '.join([reverse_word_index.get(i - 3, '?') for i in train_data[0]])"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/reuters_word_index.json\n",
            "557056/550378 [==============================] - 0s 0us/step\n",
            "565248/550378 [==============================] - 0s 0us/step\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wMcRFJbXnxll",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 70
        },
        "outputId": "9b1b0b20-de51-467c-ff95-57ae19663f38"
      },
      "source": [
        "decoded_newswire"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'? ? ? said as a result of its december acquisition of space co it expects earnings per share in 1987 of 1 15 to 1 30 dlrs per share up from 70 cts in 1986 the company said pretax net should rise to nine to 10 mln dlrs from six mln dlrs in 1986 and rental operation revenues to 19 to 22 mln dlrs from 12 5 mln dlrs it said cash flow per share this year should be 2 50 to three dlrs reuter 3'"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9AyXoYH0nxlm"
      },
      "source": [
        "La etiqueta asociada con el ejemplo es un entero entre 0 y 45 (un índice del tema)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oxcy5sxjnxlm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "20933ff2-111c-4cf9-c8a6-30275328c1d1"
      },
      "source": [
        "train_labels[10]"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DOzhvd6Znxlm"
      },
      "source": [
        "## Preparando los datos \n",
        "\n",
        "Podemor vectorizar los datos con el mismo código que en ejemplo de las críticas de cine."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "x2ERdKRQnxlm"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "def vectorize_sequences(sequences, dimension=10000):\n",
        "    results = np.zeros((len(sequences), dimension))\n",
        "    for i, sequence in enumerate(sequences):\n",
        "        results[i, sequence] = 1.\n",
        "    return results\n",
        "\n",
        "# Datos de entrenamiento vectorizados\n",
        "x_train = vectorize_sequences(train_data)\n",
        "# Datos de test vectorizados\n",
        "x_test = vectorize_sequences(test_data)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wPom4deInxln"
      },
      "source": [
        "Para vectorizar las etiquetas, hay dos posibilidades\n",
        "1. Podríamos simplemente convertir la lista de etiquetas como un tensor entero\n",
        "2. Podríamos usar un \"one-hot\"codification. La codificación one-hot es un formato ampliamente utilizado para datos categóricos, también llamado \"codificación categórica\".\n",
        "\n",
        "En nuestro caso, la codificación **one-hot** de nuestras etiquetas consiste en incrustar cada etiqueta como un **vector con todo ceros (46), salvo un 1 en el lugar del índice de la etiqueta**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "TH9mRCzInxln",
        "outputId": "5c04edcf-4531-448c-c663-6bb8bbe40519",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "def to_one_hot(labels, dimension=46):\n",
        "    results = np.zeros((len(labels), dimension))\n",
        "    for i, label in enumerate(labels):\n",
        "        results[i, label] = 1.\n",
        "    return results\n",
        "\n",
        "# Datos de entrenamiento vectorizados\n",
        "one_hot_train_labels = to_one_hot(train_labels)\n",
        "# Datos de test vectorizados\n",
        "one_hot_test_labels = to_one_hot(test_labels)\n",
        "print(one_hot_test_labels)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0. 0. ... 0. 0. 0.]\n",
            " [0. 0. 0. ... 0. 0. 0.]\n",
            " [0. 1. 0. ... 0. 0. 0.]\n",
            " ...\n",
            " [0. 0. 0. ... 0. 0. 0.]\n",
            " [0. 0. 0. ... 0. 0. 0.]\n",
            " [0. 0. 0. ... 0. 0. 0.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-FUV8ItHnxln"
      },
      "source": [
        "Tener en cuenta que hay una manera integrada de hacer esto en Keras, que ya hemos visto en nuestro ejemplo de MNIST:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "oLUqfGUCnxlo",
        "outputId": "903b609b-a059-4c44-b939-7f5f54776953",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "from keras.utils.np_utils import to_categorical\n",
        "\n",
        "one_hot_train_labels = to_categorical(train_labels)\n",
        "one_hot_test_labels = to_categorical(test_labels)\n",
        "print(one_hot_test_labels)"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0. 0. 0. ... 0. 0. 0.]\n",
            " [0. 0. 0. ... 0. 0. 0.]\n",
            " [0. 1. 0. ... 0. 0. 0.]\n",
            " ...\n",
            " [0. 0. 0. ... 0. 0. 0.]\n",
            " [0. 0. 0. ... 0. 0. 0.]\n",
            " [0. 0. 0. ... 0. 0. 0.]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0y7X1miPnxlo"
      },
      "source": [
        "## Crear la red\n",
        "\n",
        "\n",
        "Este problema de clasificación es parecido al anterior de películas solo que con una nueva restricción: el número de clases de salida ha pasado de 2 a 46, es decir, **la dimensionalidad del espacio de salida es mucho mayor**.\n",
        "\n",
        "En una pila de capas `Dense` como la que estábamos usando, cada capa solo puede acceder a la información presente en la salida de la capa anterior.\n",
        "Si una capa abandona una información relevante para el problema de clasificación, dicha información nunca podrá ser recuperada por capas posteriores: **cada capa puede, potencialmente, convertirse en un \"cuello de botella\" u obstáculo para la información\"**. En nuestro ejemplo anterior, estábamos usando capas intermedias de 16 dimensiones, pero un espacio de **16 dimensiones puede ser demasiado limitado para aprender a separar 46 clases diferentes**: capas tan pequeñas pueden actuar como cuellos de botella de información, abandonando permanentemente información relevante.\n",
        "\n",
        "Por esta razón usaremos capas más grandes. **Vayamos con 64 unidades**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "9DauD9tcnxlo"
      },
      "source": [
        "from keras import models\n",
        "from keras import layers\n",
        "\n",
        "model = models.Sequential()\n",
        "model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))\n",
        "model.add(layers.Dense(64, activation='relu'))\n",
        "model.add(layers.Dense(46, activation='softmax'))"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yIZfUHTTnxlo"
      },
      "source": [
        "Hay otras dos cosas que debe tener en cuenta sobre esta arquitectura:\n",
        "\n",
        "* Terminamos la red con una capa \"Densa\" de tamaño 46. Para cada muestra de entrada, nuestra red generará un vector de 46 dimensiones. Cada entrada en este vector (cada dimensión) codificará una clase de salida diferente.\n",
        "* La última capa utiliza una activación \"softmax\". Esto significa que la red\n",
        "genera una **distribución de probabilidad** sobre las 46 clases de salida diferentes, es decir, para cada muestra de entrada, la red producirá un\n",
        "vector de salida de 46 dimensiones donde \"salida [i]\" es la probabilidad de que la muestra pertenezca a la clase \"i\". Las 46 puntuaciones sumarán 1.\n",
        "\n",
        "La mejor función de pérdida para usar en este caso es `categorical_crossentropy`. Mide la distancia entre dos distribuciones de probabilidad: en nuestro caso, entre la distribución de probabilidad de salida de nuestra red y la distribución real de las etiquetas. Minimizando el\n",
        "distancia entre estas dos distribuciones, entrenamos nuestra red para generar algo lo más cercano posible a las etiquetas verdaderas."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "H58tHWI6nxlp"
      },
      "source": [
        "model.compile(optimizer='rmsprop',\n",
        "              loss='categorical_crossentropy',\n",
        "              metrics=['accuracy'])"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k_ZvZWM6nxlp"
      },
      "source": [
        "## Validar el enfoque:\n",
        "\n",
        "Vamos a separar 1.000 muestras en los datos de entrenamiento para utilizarlas como conjunto de validación :"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "8C9_lrCUnxlp"
      },
      "source": [
        "x_val = x_train[:1000]\n",
        "partial_x_train = x_train[1000:]\n",
        "\n",
        "y_val = one_hot_train_labels[:1000]\n",
        "partial_y_train = one_hot_train_labels[1000:]"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H_sWy-GOnxlp"
      },
      "source": [
        "Ahora entrenamos nuestra red con 20 épocas:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0nmfVLisnxlq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c153242-b2c6-49b3-8ddc-8a93f872d3e2"
      },
      "source": [
        "history = model.fit(partial_x_train,\n",
        "                    partial_y_train,\n",
        "                    epochs=20,\n",
        "                    batch_size=512,\n",
        "                    validation_data=(x_val, y_val))"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "16/16 [==============================] - 2s 74ms/step - loss: 2.6437 - accuracy: 0.4922 - val_loss: 1.7379 - val_accuracy: 0.6340\n",
            "Epoch 2/20\n",
            "16/16 [==============================] - 1s 51ms/step - loss: 1.3975 - accuracy: 0.7091 - val_loss: 1.2926 - val_accuracy: 0.7220\n",
            "Epoch 3/20\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 1.0194 - accuracy: 0.7886 - val_loss: 1.1184 - val_accuracy: 0.7640\n",
            "Epoch 4/20\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 0.8021 - accuracy: 0.8332 - val_loss: 1.0363 - val_accuracy: 0.7920\n",
            "Epoch 5/20\n",
            "16/16 [==============================] - 1s 50ms/step - loss: 0.6398 - accuracy: 0.8647 - val_loss: 0.9731 - val_accuracy: 0.8070\n",
            "Epoch 6/20\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 0.5134 - accuracy: 0.8914 - val_loss: 0.9719 - val_accuracy: 0.7950\n",
            "Epoch 7/20\n",
            "16/16 [==============================] - 1s 50ms/step - loss: 0.4189 - accuracy: 0.9151 - val_loss: 0.9401 - val_accuracy: 0.8130\n",
            "Epoch 8/20\n",
            "16/16 [==============================] - 1s 50ms/step - loss: 0.3407 - accuracy: 0.9280 - val_loss: 0.9165 - val_accuracy: 0.8130\n",
            "Epoch 9/20\n",
            "16/16 [==============================] - 1s 51ms/step - loss: 0.2848 - accuracy: 0.9372 - val_loss: 0.9429 - val_accuracy: 0.8120\n",
            "Epoch 10/20\n",
            "16/16 [==============================] - 1s 47ms/step - loss: 0.2407 - accuracy: 0.9451 - val_loss: 0.9407 - val_accuracy: 0.8210\n",
            "Epoch 11/20\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 0.2099 - accuracy: 0.9491 - val_loss: 0.9492 - val_accuracy: 0.8150\n",
            "Epoch 12/20\n",
            "16/16 [==============================] - 1s 48ms/step - loss: 0.1856 - accuracy: 0.9498 - val_loss: 1.0244 - val_accuracy: 0.8010\n",
            "Epoch 13/20\n",
            "16/16 [==============================] - 1s 50ms/step - loss: 0.1665 - accuracy: 0.9533 - val_loss: 1.0289 - val_accuracy: 0.8000\n",
            "Epoch 14/20\n",
            "16/16 [==============================] - 1s 47ms/step - loss: 0.1532 - accuracy: 0.9538 - val_loss: 1.0190 - val_accuracy: 0.8060\n",
            "Epoch 15/20\n",
            "16/16 [==============================] - 1s 48ms/step - loss: 0.1441 - accuracy: 0.9558 - val_loss: 1.0476 - val_accuracy: 0.8140\n",
            "Epoch 16/20\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 0.1371 - accuracy: 0.9569 - val_loss: 1.0785 - val_accuracy: 0.8010\n",
            "Epoch 17/20\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 0.1258 - accuracy: 0.9570 - val_loss: 1.1537 - val_accuracy: 0.8050\n",
            "Epoch 18/20\n",
            "16/16 [==============================] - 1s 48ms/step - loss: 0.1218 - accuracy: 0.9569 - val_loss: 1.1451 - val_accuracy: 0.7880\n",
            "Epoch 19/20\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 0.1178 - accuracy: 0.9578 - val_loss: 1.1435 - val_accuracy: 0.8060\n",
            "Epoch 20/20\n",
            "16/16 [==============================] - 1s 48ms/step - loss: 0.1151 - accuracy: 0.9567 - val_loss: 1.1456 - val_accuracy: 0.7950\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xtxo4WFmnxlq"
      },
      "source": [
        "Vamos a ver las curvas de pérdida y precisión:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PkGCFJ1-nxlq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "outputId": "27e297ea-d289-433c-fd29-7da2ac3d9ccb"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "loss = history.history['loss']\n",
        "val_loss = history.history['val_loss']\n",
        "\n",
        "epochs = range(1, len(loss) + 1)\n",
        "\n",
        "plt.plot(epochs, loss, 'bo', label='Pérdida del entreno')\n",
        "plt.plot(epochs, val_loss, 'b', label='Pérdida de la validación')\n",
        "plt.title('Perdidas del entreno y la validación')\n",
        "plt.xlabel('Épocas')\n",
        "plt.ylabel('Pérdida')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P3dcRt8inxlq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "outputId": "fdaf59b8-7dc2-49c2-d634-76273264640d"
      },
      "source": [
        "plt.clf()   # Limpiamos el gráfico\n",
        "\n",
        "acc = history.history['accuracy']\n",
        "val_acc = history.history['val_accuracy']\n",
        "\n",
        "plt.plot(epochs, acc, 'bo', label='Precisión de entrenamiento')\n",
        "plt.plot(epochs, val_acc, 'b', label='Precisión de validación')\n",
        "plt.title('Precisión de entreno y validación')\n",
        "plt.xlabel('Épocas')\n",
        "plt.ylabel('Precisión')\n",
        "plt.legend()\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GPrPZk-xnxlr"
      },
      "source": [
        "Parece que la red comienza a sobreajustarse después de 8 repeticiones (épocas). Entrenemos una nueva red desde cero durante 5 épocas, luego evaluémosla con el conjunto de prueba:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mGO6girWnxlr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b2a64028-cfa1-4667-fe78-6742a6f6969e"
      },
      "source": [
        "model = models.Sequential()\n",
        "model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))\n",
        "model.add(layers.Dense(64, activation='relu'))\n",
        "model.add(layers.Dense(46, activation='softmax'))\n",
        "\n",
        "model.compile(optimizer='rmsprop',\n",
        "              loss='categorical_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "model.fit(partial_x_train,\n",
        "          partial_y_train,\n",
        "          epochs=8,\n",
        "          batch_size=512,\n",
        "          validation_data=(x_val, y_val))\n",
        "results = model.evaluate(x_test, one_hot_test_labels)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/8\n",
            "16/16 [==============================] - 2s 60ms/step - loss: 2.5919 - accuracy: 0.5120 - val_loss: 1.7192 - val_accuracy: 0.6300\n",
            "Epoch 2/8\n",
            "16/16 [==============================] - 1s 48ms/step - loss: 1.4220 - accuracy: 0.7078 - val_loss: 1.2902 - val_accuracy: 0.7140\n",
            "Epoch 3/8\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 1.0355 - accuracy: 0.7844 - val_loss: 1.1171 - val_accuracy: 0.7570\n",
            "Epoch 4/8\n",
            "16/16 [==============================] - 1s 47ms/step - loss: 0.8148 - accuracy: 0.8175 - val_loss: 1.0345 - val_accuracy: 0.7740\n",
            "Epoch 5/8\n",
            "16/16 [==============================] - 1s 48ms/step - loss: 0.6491 - accuracy: 0.8624 - val_loss: 0.9929 - val_accuracy: 0.7890\n",
            "Epoch 6/8\n",
            "16/16 [==============================] - 1s 50ms/step - loss: 0.5214 - accuracy: 0.8951 - val_loss: 0.9373 - val_accuracy: 0.8020\n",
            "Epoch 7/8\n",
            "16/16 [==============================] - 1s 49ms/step - loss: 0.4269 - accuracy: 0.9133 - val_loss: 0.9022 - val_accuracy: 0.8150\n",
            "Epoch 8/8\n",
            "16/16 [==============================] - 1s 47ms/step - loss: 0.3490 - accuracy: 0.9282 - val_loss: 0.9028 - val_accuracy: 0.8090\n",
            "71/71 [==============================] - 0s 3ms/step - loss: 0.9995 - accuracy: 0.7805\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1EG6Oap7nxls",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6e680e70-226e-4395-fc0f-6769b143f8e1"
      },
      "source": [
        "results"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0.9994946718215942, 0.7804986834526062]"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RiPAYJiwnxls"
      },
      "source": [
        "Este enfoque alcanza una precisión de ~ 78%. Con un problema de clasificación binaria equilibrada, la precisión alcanzada por un clasificador puramente aleatorio sería del 50%, pero en nuestro caso está más cerca del 19%, por lo que nuestros resultados parecen bastante buenos, al menos en comparación con una línea de base aleatoria:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LFolLeyfnxls",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c9458c20-4c28-41ab-cfb9-719512376a13"
      },
      "source": [
        "import copy\n",
        "\n",
        "test_labels_copy = copy.copy(test_labels)\n",
        "np.random.shuffle(test_labels_copy)\n",
        "float(np.sum(np.array(test_labels) == np.array(test_labels_copy))) / len(test_labels)"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.18744434550311664"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0riNA9vQnxlt"
      },
      "source": [
        "## Generar predicciones en datos nuevos\n",
        "\n",
        "Podemos verificar que el método `predict` de nuestra instancia del modelo devuelve una distribución de probabilidad sobre los 46 temas. Generemos tema\n",
        "predicciones para todos los datos de prueba:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "gOZrZvFmnxlt"
      },
      "source": [
        "predictions = model.predict(x_test)"
      ],
      "execution_count": 26,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1bL0CtdInxlt"
      },
      "source": [
        "Cada entrada en `predictions` es un vector de longitud 46:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tdlqjT_Mnxlt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0d74abaf-9a89-4b8b-8f44-fc3f3e613f1e"
      },
      "source": [
        "predictions[0].shape"
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(46,)"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x3nDGb7lnxlt"
      },
      "source": [
        "Los coeficientes en este vector suman 1:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ha0GKlU7nxlu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1c978035-6727-4a91-e3cc-effe84d14e34"
      },
      "source": [
        "np.sum(predictions[0])"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.99999994"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zF6lPgbJnxlu"
      },
      "source": [
        "La mayor entrada es la clase predicha, es decir, la clase con la probabilidad más elevada:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FkZyZdwdnxlu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cfa30b18-7e3b-4c38-da40-5e52757cc516"
      },
      "source": [
        "np.argmax(predictions[0])"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y7EzvpvYnxlu"
      },
      "source": [
        "## Una forma diferente de manejar las etiquetas y la pérdida\n",
        "\n",
        "Mencionamos anteriormente que otra forma de codificar las etiquetas sería convertirlas en un tensor entero, como tal: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "oSa9FT4qnxlv",
        "outputId": "c53484f3-7f53-407a-87e5-bc8ccfb95c4b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "source": [
        "y_train = np.array(train_labels)\n",
        "y_test = np.array(test_labels)\n",
        "print(test_labels)"
      ],
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 3 10  1 ...  3  3 24]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-JSB82gnnxlv"
      },
      "source": [
        "Lo único que cambiaría es la elección de la función de pérdida. Nuestra pérdida anterior, `categorical_crossentropy`, espera que las etiquetas sigan una codificación categórica. Con etiquetas enteras, deberíamos usar `sparse_categorical_crossentropy`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "j13JZMBInxlv"
      },
      "source": [
        "model.compile(optimizer='rmsprop', loss='sparse_categorical_crossentropy', metrics=['acc'])"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eY3c2X5Tnxlv"
      },
      "source": [
        "Esta nueva función de pérdida sigue siendo matemáticamente la misma que `categorical_crossentropy`; simplemente tiene una interfaz diferente."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k5OWwHpEnxlv"
      },
      "source": [
        "## Lo importante de tener capas intermedias lo bastante grandes:\n",
        "\n",
        "Mencionamos anteriormente que dado que nuestras salidas finales eran de 46 dimensiones, deberíamos evitar capas intermedias con mucho menos de 46 unidades ocultas. Ahora intentemos ver qué sucede cuando introducimos un cuello de botella de información al tener capas intermedias significativamente menores que\n",
        "46 dimensiones, p. Ej. 4 dimensiones."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MfIYddxPnxlw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c8b98ba3-e839-4762-8266-11b67ba119b4"
      },
      "source": [
        "model = models.Sequential()\n",
        "model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))\n",
        "model.add(layers.Dense(4, activation='relu'))\n",
        "model.add(layers.Dense(46, activation='softmax'))\n",
        "\n",
        "model.compile(optimizer='rmsprop',\n",
        "              loss='categorical_crossentropy',\n",
        "              metrics=['accuracy'])\n",
        "model.fit(partial_x_train,\n",
        "          partial_y_train,\n",
        "          epochs=20,\n",
        "          batch_size=128,\n",
        "          validation_data=(x_val, y_val))"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1/20\n",
            "63/63 [==============================] - 2s 20ms/step - loss: 2.6200 - accuracy: 0.4676 - val_loss: 1.8630 - val_accuracy: 0.5670\n",
            "Epoch 2/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 1.6408 - accuracy: 0.5719 - val_loss: 1.5868 - val_accuracy: 0.5900\n",
            "Epoch 3/20\n",
            "63/63 [==============================] - 1s 18ms/step - loss: 1.3535 - accuracy: 0.6496 - val_loss: 1.4143 - val_accuracy: 0.6530\n",
            "Epoch 4/20\n",
            "63/63 [==============================] - 1s 18ms/step - loss: 1.1549 - accuracy: 0.6963 - val_loss: 1.3337 - val_accuracy: 0.6780\n",
            "Epoch 5/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 1.0122 - accuracy: 0.7432 - val_loss: 1.2899 - val_accuracy: 0.7010\n",
            "Epoch 6/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.9073 - accuracy: 0.7663 - val_loss: 1.2636 - val_accuracy: 0.7100\n",
            "Epoch 7/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.8297 - accuracy: 0.7737 - val_loss: 1.2989 - val_accuracy: 0.7110\n",
            "Epoch 8/20\n",
            "63/63 [==============================] - 1s 18ms/step - loss: 0.7667 - accuracy: 0.7850 - val_loss: 1.3360 - val_accuracy: 0.6980\n",
            "Epoch 9/20\n",
            "63/63 [==============================] - 1s 18ms/step - loss: 0.7149 - accuracy: 0.8024 - val_loss: 1.3391 - val_accuracy: 0.7200\n",
            "Epoch 10/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.6680 - accuracy: 0.8198 - val_loss: 1.3677 - val_accuracy: 0.7180\n",
            "Epoch 11/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.6277 - accuracy: 0.8314 - val_loss: 1.3931 - val_accuracy: 0.7240\n",
            "Epoch 12/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.5921 - accuracy: 0.8385 - val_loss: 1.4039 - val_accuracy: 0.7230\n",
            "Epoch 13/20\n",
            "63/63 [==============================] - 1s 18ms/step - loss: 0.5597 - accuracy: 0.8439 - val_loss: 1.4892 - val_accuracy: 0.7180\n",
            "Epoch 14/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.5317 - accuracy: 0.8474 - val_loss: 1.5085 - val_accuracy: 0.7210\n",
            "Epoch 15/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.5082 - accuracy: 0.8530 - val_loss: 1.5484 - val_accuracy: 0.7230\n",
            "Epoch 16/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.4856 - accuracy: 0.8604 - val_loss: 1.5552 - val_accuracy: 0.7240\n",
            "Epoch 17/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.4639 - accuracy: 0.8672 - val_loss: 1.6762 - val_accuracy: 0.7150\n",
            "Epoch 18/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.4490 - accuracy: 0.8695 - val_loss: 1.6878 - val_accuracy: 0.7180\n",
            "Epoch 19/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.4266 - accuracy: 0.8755 - val_loss: 1.7458 - val_accuracy: 0.7180\n",
            "Epoch 20/20\n",
            "63/63 [==============================] - 1s 17ms/step - loss: 0.4142 - accuracy: 0.8761 - val_loss: 1.8080 - val_accuracy: 0.7190\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<keras.callbacks.History at 0x7f8a56567f10>"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yEHDBm4Dnxlw"
      },
      "source": [
        "Ahora la red llega aproximadamente al 71% de exactitud de la validación, una caída absoluta del 8%. Esta caída se debe principalmente al hecho de que ahora estamos tratando de comprimir mucha información (información suficiente para recuperar los hiperplanos de separación de 46 clases) en un espacio intermedio de muy pocas dimensiones. La red es capaz de meter la mayor parte de la información necesaria en estas representaciones de 4 dimensiones, pero no toda."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DAITmJA4nxlw"
      },
      "source": [
        "## Más experimentos\n",
        "\n",
        "* Intenta usar capas más grandes o más pequeñas: 32 unidades, 128 unidades ...\n",
        "* Estábamos usando dos capas ocultas. Ahora intenta crear una sola capa oculta o tres capas ocultas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f3RF6XMlnxlx"
      },
      "source": [
        "## Resumen\n",
        "\n",
        "Esto es lo que debéis sacar de este ejemplo:\n",
        "\n",
        "* Si estáis intentando clasificar puntos de datos entre N clases, vuestra red debería terminar con una capa `Dense` de tamaño N.\n",
        "* En un problema de clasificación de una sola etiqueta asignada y varias clases, la red debe terminar con una activación tipo \"softmax\", de modo que genere un distribución de probabilidad sobre las N clases de salida.\n",
        "* `categorical_crossentropy` es casi siempre la función de pérdida que debe usar para estos problemas. Minimiza la distancia entre las distribuciones de probabilidad producidas por la red y la verdadera distribución de los objetivos.\n",
        "* Hay dos formas de manejar etiquetas en clasificación multiclase:\n",
        "  - Codificar las etiquetas a través de \"codificación categórica\" ​​(también conocida como \"codificación one-hot\") y usar `categorical_crossentropy` como su función de pérdida.\n",
        "  - Codificando las etiquetas como números enteros y usando la función de pérdida `sparse_categorical_crossentropy`.\n",
        "* Si necesitamos clasificar datos en una gran cantidad de categorías, debemos evitar crear cuellos de botella de información en la red al tener\n",
        "capas intermedias que son demasiado pequeñas."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-F0O6iSjQHWq"
      },
      "source": [
        "---"
      ]
    }
  ]
}