15_TensorFlow_Keras_MLP_Clasificacion_Textos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 15 - TensorFlow - Keras: Clasificación de textos con Redes Neuronales  (Perceptron Multicapa)\n",
    "\n",
    "\n",
    "* En este notebook vamos a ver como crear un modelo que clasifique las frases según su polaridad (Positiva o Negativa) con una red neuronal, en particular con un ***Perceptrón Multicapa***.\n",
    "\n",
    "\n",
    "* Este ejemplo resuelve el mismo problema que el notebook \"*08_NLTK_Clasificacion_Textos_Naive_Bayes.ipynb*\" para que puedan compararse los resultados.\n",
    "\n",
    "\n",
    "\n",
    "* En este notebook vamos a tener dos conjuntos de frases clasificadas según su polaridad:\n",
    "    1. **train**: Conjunto de frases clasificadas para entrenar la red.\n",
    "    3. **Test**: Conjunto de frases de test a predecir por la red.\n",
    "    \n",
    "    \n",
    "* Los pasos que vamos a dar son los siguientes:\n",
    "\n",
    "    1. Normalización de las frases.\n",
    "    2. Bolsa de palabras y codificación del target\n",
    "    3. Definición de la Red Neuronal\n",
    "    4. Entrenamiento de la Red Neuronal\n",
    "    5. Evaluación del modelo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "# Frases a clasificar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = [('I love this car', 'positive'),\n",
    "         ('This view is amazing', 'positive'),\n",
    "         ('I feel great this morning', 'positive'),\n",
    "         ('I am so excited about the concert', 'positive'),\n",
    "         ('He is my best friend', 'positive'),\n",
    "         ('Going well', 'positive'),\n",
    "         ('Thank you', 'positive'),\n",
    "         ('Hope you are doing well', 'positive'),\n",
    "         ('I am very happy', 'positive'),\n",
    "         ('Good for you', 'positive'),\n",
    "         ('It is all good. I know about it and I accept it.', 'positive'),\n",
    "         ('This is really good!', 'positive'),\n",
    "         ('Tomorrow is going to be fun.', 'positive'),\n",
    "         ('These are great apples today.', 'positive'),\n",
    "         ('How about them apples? Thomas is a happy boy.', 'positive'),\n",
    "         ('I love this sandwich.', 'positive'),\n",
    "         ('This is an amazing place!', 'positive'),\n",
    "         ('I feel very good about these beers.', 'positive'),\n",
    "         ('This is my best work.', 'positive'),\n",
    "         ('What an awesome view', 'positive'),\n",
    "         ('I do not like this car', 'negative'),\n",
    "         ('This view is horrible', 'negative'),\n",
    "         ('I feel tired this morning', 'negative'),\n",
    "         ('I am not looking forward to the concert', 'negative'),\n",
    "         ('He is my enemy', 'negative'),\n",
    "         ('I am a bad boy', 'negative'),\n",
    "         ('This is not good', 'negative'),\n",
    "         ('I am bothered by this', 'negative'),\n",
    "         ('I am not connected with this', 'negative'),\n",
    "         ('Sadistic creep you ass. Die.', 'negative'),\n",
    "         ('All sorts of crazy and scary as hell.', 'negative'),\n",
    "         ('Not his emails, no.', 'negative'),\n",
    "         ('His father is dead. Returned obviously.', 'negative'),\n",
    "         ('He has a bomb.', 'negative'),\n",
    "         ('Too fast to be on foot. We cannot catch them.', 'negative'),\n",
    "         ('I do not like this restaurant', 'negative'),\n",
    "         ('I am tired of this stuff.', 'negative'),\n",
    "         (\"I can't deal with this\", 'negative'),\n",
    "         ('He is my sworn enemy!', 'negative'),\n",
    "         ('My boss is horrible.', 'negative')]\n",
    "\n",
    "test = [('I feel happy this morning', 'positive'),\n",
    "        ('Larry is my friend', 'positive'),\n",
    "        ('I do not like that man', 'negative'),\n",
    "        ('My house is not great', 'negative'),\n",
    "        ('Your song is annoying', 'negative'),\n",
    "        ('The beer was good.', 'positive'),\n",
    "        ('I do not enjoy my job', 'negative'),\n",
    "        (\"I feel amazing!\", 'positive'),\n",
    "        ('Gary is a friend of mine.', 'positive'),\n",
    "        (\"I can't believe I'm doing this.\", 'negative')]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "## Normalización\n",
    "\n",
    "* En primer lugar vamos a pasar a normalizar las frases. Para ello realizaremos lo siguiente:\n",
    "\n",
    "    - Eliminamos los signos de puntuación\n",
    "    - Pasamos el texto a minúsculas\n",
    "    - Eliminamos las Stop-Words\n",
    "    - Eliminamos las palabras con menos de 3 caracteres\n",
    "    \n",
    "* Nos creamos una función que realice este procesamiento para las frases dadas.\n",
    "\n",
    "\n",
    "***NOTA***: *Para este ejemplo en particular se hace una normalización muy básica pero suficiente para realizar este ejemplo con caracter didáctico*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "import re\n",
    "\n",
    "from nltk.corpus import stopwords\n",
    "\n",
    "def normalize(sentenses):\n",
    "    \"\"\"normalizamos la lista de frases\"\"\"\n",
    "    sen = []\n",
    "    for (words, sentiment) in sentenses:\n",
    "        words_filtered = []\n",
    "        for word in words.split():\n",
    "            # Eliminamos signos de puntuación y lo pasamos a minusculas\n",
    "            word = re.sub(r'[^\\w\\s]', '', word).lower()\n",
    "            # Filtramos stop words y las palabras con menos de 3 caracteres\n",
    "            if len(word) > 2 and word not in stopwords.words():\n",
    "                words_filtered.append(word)\n",
    "        sen.append(words_filtered)\n",
    "    return sen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pasamos a normalizar los conjuntos de entrenamiento y test.\n",
    "\n",
    "\n",
    "* Obtenemos en una lista el target de los conjunto de entrenamiento y test."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = normalize(train)\n",
    "y_train = [sentiment for (words, sentiment) in train]\n",
    "X_test = normalize(test)\n",
    "y_test = [sentiment for (words, sentiment) in test]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "# Bolsa de palabras y codificación del target\n",
    "\n",
    "* Cuando trabajamos con redes neuronales para la clasificación de textos es necesario tener:\n",
    "\n",
    "    1. ***Input***: Un vector por documento en el que en cada posición del vertor represente el peso que tiene la palabra en ese documento bien sea por frecuencia, por aparición de la palabra en el documento (One-Hot-Encode) o por su TF-IDF.\n",
    "<span></span><br><br>    \n",
    "    2. ***Output***: Al resolver la red neuronal un problema de clasificación de textos, la salida de la red tiene que ser un valor numérico, por lo que el target hay que codificalo en valores numéricos. En este ejemplo al ser una clasificación binaria (positivo o negativo) codificaremos estos dos valores en '0' y '1'.\n",
    "    \n",
    "    \n",
    "* A continuación pasamos a crear la bolsa de palabras.\n",
    "\n",
    "\n",
    "* Para realizar esta labor vamos a usar la clase '***Tokenizer***' de Tensorflow: https://www.tensorflow.org/api_docs/python/tf/keras/preprocessing/text\n",
    "\n",
    "\n",
    "* Lo que vamos a hacer es crear una ***bolsa de palabras de frecuencias*** cogiendo las 'N' palabras más frecuentes del Corpus. En este caso el Corpus tiene 63 palabras por lo que vamos a seleccionar todas las palabras.\n",
    "\n",
    "\n",
    "* Es muy importante saber la ***dimensión (longitud) del vector de palabras*** que representará al documento ya que esa dimensión será el ***número de neuronas de entrada*** (+1) que tendrá nuestra red neuronal.\n",
    "\n",
    "\n",
    "* La bolsa de palabras la vamos a crear como una matriz llamando a la función '***text_to_matrix***'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dimensión de la matriz de entrenamiento: (40, 64)\n",
      "\n",
      "Bolsa de palabras de los datos de entrenamiento:\n",
      "OrderedDict([('love', 2), ('car', 2), ('view', 3), ('amazing', 2), ('feel', 3), ('great', 2), ('morning', 2), ('excited', 1), ('concert', 2), ('best', 2), ('friend', 1), ('going', 2), ('well', 2), ('thank', 1), ('hope', 1), ('happy', 2), ('good', 5), ('know', 1), ('accept', 1), ('really', 1), ('tomorrow', 1), ('fun', 1), ('apples', 2), ('today', 1), ('thomas', 1), ('boy', 2), ('sandwich', 1), ('place', 1), ('beers', 1), ('work', 1), ('awesome', 1), ('like', 2), ('horrible', 2), ('tired', 2), ('looking', 1), ('forward', 1), ('enemy', 2), ('bad', 1), ('bothered', 1), ('connected', 1), ('sadistic', 1), ('creep', 1), ('ass', 1), ('sorts', 1), ('crazy', 1), ('scary', 1), ('hell', 1), ('emails', 1), ('father', 1), ('dead', 1), ('returned', 1), ('obviously', 1), ('bomb', 1), ('fast', 1), ('foot', 1), ('cannot', 1), ('catch', 1), ('restaurant', 1), ('stuff', 1), ('cant', 1), ('deal', 1), ('sworn', 1), ('boss', 1)])\n",
      "\n",
      "Índice de las palabras en la Matriz:\n",
      "{'good': 1, 'view': 2, 'feel': 3, 'love': 4, 'car': 5, 'amazing': 6, 'great': 7, 'morning': 8, 'concert': 9, 'best': 10, 'going': 11, 'well': 12, 'happy': 13, 'apples': 14, 'boy': 15, 'like': 16, 'horrible': 17, 'tired': 18, 'enemy': 19, 'excited': 20, 'friend': 21, 'thank': 22, 'hope': 23, 'know': 24, 'accept': 25, 'really': 26, 'tomorrow': 27, 'fun': 28, 'today': 29, 'thomas': 30, 'sandwich': 31, 'place': 32, 'beers': 33, 'work': 34, 'awesome': 35, 'looking': 36, 'forward': 37, 'bad': 38, 'bothered': 39, 'connected': 40, 'sadistic': 41, 'creep': 42, 'ass': 43, 'sorts': 44, 'crazy': 45, 'scary': 46, 'hell': 47, 'emails': 48, 'father': 49, 'dead': 50, 'returned': 51, 'obviously': 52, 'bomb': 53, 'fast': 54, 'foot': 55, 'cannot': 56, 'catch': 57, 'restaurant': 58, 'stuff': 59, 'cant': 60, 'deal': 61, 'sworn': 62, 'boss': 63}\n",
      "\n",
      "Matriz de entrenamiento:\n",
      "[[0. 0. 0. ... 0. 0. 0.]\n",
      " [0. 0. 1. ... 0. 0. 0.]\n",
      " [0. 0. 0. ... 0. 0. 0.]\n",
      " ...\n",
      " [0. 0. 0. ... 1. 0. 0.]\n",
      " [0. 0. 0. ... 0. 1. 0.]\n",
      " [0. 0. 0. ... 0. 0. 1.]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing.text import Tokenizer\n",
    "\n",
    "\n",
    "num_words = 64\n",
    "\n",
    "# Creamos un objeto de la clase Tokenizer indicandole el número de palabras\n",
    "tokenizer = Tokenizer(num_words=num_words)\n",
    "\n",
    "# Calculamos la bolsa de palabras (generamos el vocabulario)\n",
    "tokenizer.fit_on_texts(X_train)\n",
    "\n",
    "# Creamos una matriz de bolsa de palabras donde:\n",
    "#     Fila: Representa a un documento\n",
    "#     Columna: Representa a una palabra\n",
    "X_matrix_train = tokenizer.texts_to_matrix(X_train, mode='count')\n",
    "X_matrix_test = tokenizer.texts_to_matrix(X_test, mode='count')\n",
    "\n",
    "print('Dimensión de la matriz de entrenamiento: {dim}\\n'.format(dim=X_matrix_train.shape))\n",
    "\n",
    "print('Bolsa de palabras de los datos de entrenamiento:\\n{bolsa}\\n'.format(bolsa=tokenizer.word_counts))\n",
    "\n",
    "print('Índice de las palabras en la Matriz:\\n{index}\\n'.format(index=tokenizer.word_index))\n",
    "\n",
    "print('Matriz de entrenamiento:\\n{matrix}\\n'.format(matrix=X_matrix_train))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Lo siguiente que vamos a hacer en codificar la salida\n",
    "    - Negativo: 0\n",
    "    - Positivo: 1\n",
    "    \n",
    "\n",
    "* Esto lo vamos a hacer con la clase '***LabelEncoder***' de scikit: https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.LabelEncoder.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,\n",
       "       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "encoder = LabelEncoder()\n",
    "encoder.fit(y_train)\n",
    "y_train = encoder.transform(y_train)\n",
    "y_test = encoder.transform(y_test)\n",
    "y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "# Definición de la Red Neuronal\n",
    "\n",
    "\n",
    "* Para clasificar los textos en positivo o negativo vamos a crear una red con la siguiente arquitectura:\n",
    "<span></span><br><br>\n",
    "    - ***Capa 1***: Capa de entrada con 64 Neuronas (una por palabra del corpus)\n",
    "<span></span><br><br>\n",
    "    - ***Capa 2***: 20 Neuronas con una función de activación 'relu'\n",
    "<span></span><br><br>\n",
    "    - ***Capa 3***: 5 Neuronas con una función de activación 'relu'\n",
    "<span></span><br><br>\n",
    "    - ***Capa 4***: Capa de salida con 1 neurona y una función de activación 'sigmoidal'\n",
    "    \n",
    "    \n",
    "* Para las capas 2 y 3 vamos a poner un dropout del 10% para que nuestra red no se sobreajuste y generalize mejor.\n",
    "    \n",
    "    \n",
    "* Por último utilizaremos:\n",
    "<span></span><br><br>\n",
    "    - ***Función de perdida: 'binary_crossentropy'*** (Funciones de Perdida: https://keras.io/losses/)\n",
    "<span></span><br><br>\n",
    "    - ***Optimizador: 'adam'*** (Optimizadores: https://keras.io/optimizers/)\n",
    "<span></span><br><br>    \n",
    "    - Metricas: en cada epoch pediremos que nos muestre el accuracy (Métricas: https://keras.io/metrics/)\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Se fuerza a usar la CPU y no la GPU en caso de tener GPU en el ordenador\n",
    "import os \n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '-1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense, Dropout\n",
    "from tensorflow.keras import metrics\n",
    "\n",
    "np.random.seed(2)\n",
    "model = Sequential()\n",
    "model.add(Dense(20, activation='relu', input_dim=num_words))\n",
    "model.add(Dropout(0.1))\n",
    "model.add(Dense(5, activation='relu'))\n",
    "model.add(Dropout(0.1))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Una vez creada la red mostramos su arquitectura:\n",
    "    - 64 Neuronas de entrada\n",
    "    - Capa 2: 20 neuronas\n",
    "    - Conexiones \"capa de entrada -> Capa 2\" = (64*20) + 20 = 1300 Conexiones\n",
    "    - Capa 3: 5 neuronas\n",
    "    - Conexiones \"Capa 2 -> Capa 3\" = (20*5) + 5 = 105 Conexiones\n",
    "    - Capa de salida: 1 Neurona\n",
    "    - Conexiones \"Capa 3 -> Capa de salida\" = (5*1) + 1 = 6 Conexiones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense (Dense)                (None, 20)                1300      \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 20)                0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 5)                 105       \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 5)                 0         \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 6         \n",
      "=================================================================\n",
      "Total params: 1,411\n",
      "Trainable params: 1,411\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "# Entrenamos la red\n",
    "\n",
    "\n",
    "* Una vez definida la Red Nuronal y compilada ya podemos entrenarla (ajustar los pesos de las conexiones).\n",
    "\n",
    "\n",
    "* Para entrenar la Red Nuronal (model) vamos a llamar al método '***fit()***' que recibe los siguientes parámetros:\n",
    "<span></span><br><br>\n",
    "    - ***datos de entrada*** (X_matrix_train)\n",
    "<span></span><br><br>\n",
    "    - ***target*** (y_train)\n",
    "<span></span><br><br>\n",
    "    - ***batch_size***: Número de muestras por epoch que utilizará para actualizar los pesos\n",
    "<span></span><br><br>\n",
    "    - ***epochs***: Número de veces que recorrerá el dataset para entrenar la red\n",
    "<span></span><br><br>\n",
    "    - ***verbose***: 3 tipos de verbosidad mientras entrena la red (0,1,2)\n",
    "<span></span><br><br>\n",
    "    - ***validation_split***: Porcentaje de los datos de entrenamiento que utiliza para validar el modelo en cada epoch.\n",
    "<span></span><br><br>\n",
    "    \n",
    "    \n",
    "* Como lo que estamos haciendo es un ejemplo didáctico vamos a poner los siguientes valores:\n",
    "<span></span><br><br>\n",
    "    - *batch_size = 1* : Como tenemos pocos datos, podemos ajustar los pesos de la Red Neuronal cada vez que se calcule una muestra.\n",
    "        + batch_size con valores muy pequeños: En teoria la red neuronal estaría muy bien entrenada pero tardaría mucho tiempo en entrenarse.\n",
    "        + batch_size con valores muy grandes: En teoria la red neuronal estaría peor entrenada que con valores pequeños pero tardaría menos tiempo en ejecutarse.\n",
    "<span></span><br><br>\n",
    "    - *epochs = 20* : Como es un dataset pequeño no es necesario entrenar la red muchas veces por eso ponemos un valor relativamente pequeño.\n",
    "<span></span><br><br>\n",
    "    - *validation_split = 0.1* : Al ser un dataset con 40 frases, elegiremos en cada pasada solo 4 frases para evaluarlas. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "36/36 - 1s - loss: 0.6981 - accuracy: 0.3889 - val_loss: 0.6568 - val_accuracy: 0.7500\n",
      "Epoch 2/20\n",
      "36/36 - 0s - loss: 0.6875 - accuracy: 0.5833 - val_loss: 0.6581 - val_accuracy: 0.7500\n",
      "Epoch 3/20\n",
      "36/36 - 0s - loss: 0.6807 - accuracy: 0.6389 - val_loss: 0.6543 - val_accuracy: 0.7500\n",
      "Epoch 4/20\n",
      "36/36 - 0s - loss: 0.6797 - accuracy: 0.6667 - val_loss: 0.6548 - val_accuracy: 0.7500\n",
      "Epoch 5/20\n",
      "36/36 - 0s - loss: 0.6748 - accuracy: 0.6111 - val_loss: 0.6491 - val_accuracy: 1.0000\n",
      "Epoch 6/20\n",
      "36/36 - 0s - loss: 0.6655 - accuracy: 0.7222 - val_loss: 0.6442 - val_accuracy: 1.0000\n",
      "Epoch 7/20\n",
      "36/36 - 0s - loss: 0.6656 - accuracy: 0.7500 - val_loss: 0.6389 - val_accuracy: 1.0000\n",
      "Epoch 8/20\n",
      "36/36 - 0s - loss: 0.6477 - accuracy: 0.8333 - val_loss: 0.6330 - val_accuracy: 1.0000\n",
      "Epoch 9/20\n",
      "36/36 - 0s - loss: 0.6382 - accuracy: 0.8889 - val_loss: 0.6244 - val_accuracy: 1.0000\n",
      "Epoch 10/20\n",
      "36/36 - 0s - loss: 0.6250 - accuracy: 0.8611 - val_loss: 0.6184 - val_accuracy: 1.0000\n",
      "Epoch 11/20\n",
      "36/36 - 0s - loss: 0.6314 - accuracy: 0.8889 - val_loss: 0.6074 - val_accuracy: 1.0000\n",
      "Epoch 12/20\n",
      "36/36 - 0s - loss: 0.6178 - accuracy: 0.8611 - val_loss: 0.5934 - val_accuracy: 1.0000\n",
      "Epoch 13/20\n",
      "36/36 - 0s - loss: 0.5954 - accuracy: 0.9167 - val_loss: 0.5895 - val_accuracy: 1.0000\n",
      "Epoch 14/20\n",
      "36/36 - 0s - loss: 0.5783 - accuracy: 0.9167 - val_loss: 0.5740 - val_accuracy: 1.0000\n",
      "Epoch 15/20\n",
      "36/36 - 0s - loss: 0.5611 - accuracy: 0.9444 - val_loss: 0.5519 - val_accuracy: 1.0000\n",
      "Epoch 16/20\n",
      "36/36 - 0s - loss: 0.5307 - accuracy: 0.9167 - val_loss: 0.5252 - val_accuracy: 1.0000\n",
      "Epoch 17/20\n",
      "36/36 - 0s - loss: 0.5255 - accuracy: 0.9167 - val_loss: 0.5137 - val_accuracy: 1.0000\n",
      "Epoch 18/20\n",
      "36/36 - 0s - loss: 0.4807 - accuracy: 0.9444 - val_loss: 0.5064 - val_accuracy: 1.0000\n",
      "Epoch 19/20\n",
      "36/36 - 0s - loss: 0.4718 - accuracy: 0.9722 - val_loss: 0.4852 - val_accuracy: 1.0000\n",
      "Epoch 20/20\n",
      "36/36 - 0s - loss: 0.4523 - accuracy: 0.9167 - val_loss: 0.4753 - val_accuracy: 1.0000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x229529a9b08>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_matrix_train, y_train, batch_size=1, epochs=20, verbose=2, validation_split=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "# Evaluamos el modelo\n",
    "\n",
    "\n",
    "* Al tratarse de un ejemplo didáctico vamos a medir solamente el accuracy.\n",
    "\n",
    "\n",
    "* Para ello utilizaremos el método '***evaluate()***' que pasandole los datos de entrenamiento (datos y target), predice los datos y nos calcula el accuracy entre otras métricas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 155ms/step - loss: 0.6216 - accuracy: 0.9000\n",
      "Porcentaje acierto: accuracy: 90.00%\n"
     ]
    }
   ],
   "source": [
    "# Evaluación del modelo con los mismos datos de entrenamiento\n",
    "scores = model.evaluate(X_matrix_test, y_test)\n",
    "print(\"Porcentaje acierto: %s: %.2f%%\" % (model.metrics_names[1], scores[1] * 100))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Llamando al método '***predict()***' y pasandole unos datos de entrada, nos devuelve el valor de la salida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.5708303 ]\n",
      " [0.50959945]\n",
      " [0.44290107]\n",
      " [0.572927  ]\n",
      " [0.4873795 ]\n",
      " [0.5677743 ]\n",
      " [0.4873795 ]\n",
      " [0.6634451 ]\n",
      " [0.50959945]\n",
      " [0.42782333]]\n"
     ]
    }
   ],
   "source": [
    "predict = model.predict(X_matrix_test)\n",
    "print(predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Como lo que nos interesa en un problema de clasificación es la categoria en que nos clasifica el documento y no el valor de salida de la red neuronal, podemos obtener la categoria de cada predicción llamando al método '***predict_classes()***', pasandole el/los dato/s de entrada.\n",
    "\n",
    "\n",
    "* Hay que tener cuidado ya que nos va a dar un número entero (0 o 1) ya que hemos realizado el LabelEncoder previamente y tenemos que hacer el \"encodeado inverso\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 - I feel happy this morning \n",
      "\t Real: positive - Predicción: positive - Acierto: True\n",
      "1 - Larry is my friend \n",
      "\t Real: positive - Predicción: positive - Acierto: True\n",
      "2 - I do not like that man \n",
      "\t Real: negative - Predicción: negative - Acierto: True\n",
      "3 - My house is not great \n",
      "\t Real: negative - Predicción: positive - Acierto: False\n",
      "4 - Your song is annoying \n",
      "\t Real: negative - Predicción: negative - Acierto: True\n",
      "5 - The beer was good. \n",
      "\t Real: positive - Predicción: positive - Acierto: True\n",
      "6 - I do not enjoy my job \n",
      "\t Real: negative - Predicción: negative - Acierto: True\n",
      "7 - I feel amazing! \n",
      "\t Real: positive - Predicción: positive - Acierto: True\n",
      "8 - Gary is a friend of mine. \n",
      "\t Real: positive - Predicción: positive - Acierto: True\n",
      "9 - I can't believe I'm doing this. \n",
      "\t Real: negative - Predicción: negative - Acierto: True\n"
     ]
    }
   ],
   "source": [
    "# Predecimos los resultados del conjunto de test\n",
    "y_predict = np.where(model.predict(X_matrix_test) > 0.5, 1, 0)\n",
    "for index, prediction in enumerate(y_predict):\n",
    "    text = test[index][0]\n",
    "    y_true = test[index][1]\n",
    "    y_predict = encoder.inverse_transform(prediction)\n",
    "    print('{i} - {text} \\n\\t Real: {y_true} - Predicción: {y_predict} - Acierto: {acierto}'\n",
    "          .format(i=index, text=text, y_true=y_true, y_predict=y_predict[0], acierto = y_true==y_predict[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "\n",
    "# Bonus Track I - Perceptrón Multicapa (MLP) -\n",
    "\n",
    "\n",
    "* El Perceptrón Multicapa (Multilayer Perceptron- MLP) es una Red Neuronal Artificial que tiene como objetivo la resolución de problemas de clasificación o regresión que no son linealmente separables.\n",
    "\n",
    "\n",
    "* El MLP esta formado por una serie de capas compuesta por neuronas, estando cada neurona de una capa conectada con todas las neuronas de la capa posterior. Las capas de una red neuronal las podemos dividir en 3 tipos que son:\n",
    "<span></span><br><br>\n",
    "    - ***Capa de entrada***: Esta formada por tantas neuronas como variables tengan los elementos de entrada. Las Neuronas de la capa de entrada no realizan ningún tipo de procesamiento.\n",
    "<span></span><br><br>\n",
    "    - ***Capas ocultas***: Esta compuesta por una serie de neuronas cuyas entradas provienen de las salidas de las neuronas de la capa anterior y sus salidas sirven como entrada a cada una de las neuronas de la capas posterior.\n",
    "<span></span><br><br>\n",
    "    - ***Capas de salida***: Esta compuesta por una o más neuronas, y los valores de estas neuronas corresponden con la salida de la red.\n",
    "    \n",
    "    \n",
    "* Un ejemplo de arquitectura de una red neuronal con una capa de entrada de 2 neuronas, 3 capas ocultas de 5, 3 y 2 neuronas respectivamente y una capa de salida de una neurona, sería la siguiente:\n",
    "\n",
    "<img src=\"./imgs/024_mlp.png\" style=\"width: 700px;\"/>\n",
    "\n",
    "\n",
    "## Entrenar una Red Neuronal\n",
    "\n",
    "\n",
    "* De manera \"general\", pera crear y entrenar una Red Neuronal (un Perceptrón Multicapa) tenemos que seguir los siguientes pasos:\n",
    "<span></span><br>\n",
    "    1. ***Recopilar conjunto de datos*** (Cuantos más datos mejor).\n",
    "<span></span><br><br>\n",
    "    2. ***Diseñar una función de perdida*** (loss function) apropiada para el problema; por ejemplo:\n",
    "        + MSE para problemas de regresión.\n",
    "        + Cross Entropy para problemas de clasificación (Clasificación binaria: “binary crossentropy” y Clasificación Múltiple: “categorical_crossentropy”).\n",
    "<span></span><br><br>\n",
    "    3. ***Definir la arquitectura de la Red Neuronal*** y sus hiperparámetros.\n",
    "        + Número de Capas y Neuronas por Capa.\n",
    "        + Funciones de Activación.\n",
    "        + Hiperparámetros: Learning Rate, Regularization Rate, Epochs, Batch Size, etc.\n",
    "<span></span><br><br>\n",
    "    4. ***Aplicar un algoritmo de optimización*** para minimizar la función de pérdida para que ajuste los pesos de la red:\n",
    "        + Stochastic Gradient Descent (SGD)\n",
    "        + RMSProp\n",
    "        + Adam\n",
    "        + AdaGrad\n",
    "        + AdaDelta\n",
    "        + AdaMax\n",
    "\n",
    "\n",
    "## Dropout\n",
    "\n",
    "\n",
    "* El Dropout es un método que se utilizada para la regularización y tiene como objetivo reducir el overfiting.\n",
    "\n",
    "\n",
    "* Consiste en ***perturbar la red*** en cada pasada de entrenamiento (feed-forward y backpropagation), ***eliminando al azar algunas de las unidades de cada capa***.\n",
    "\n",
    "\n",
    "<img src=\"./imgs/027_drop_out.png\" style=\"width: 1100px;\"/>\n",
    "\n",
    "\n",
    "* El objeto es que al introducir ruido en el proceso de entrenamiento evitamos el overfiting, pues en cada paso de la iteración estamos limitando el número de unidades que la red puede usar para ajustar las respuestas. \n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## Hiperparámetros de la Red\n",
    "\n",
    "### Epochs\n",
    "\n",
    "\n",
    "* Los Epochs (las épocas en Castellano) es un hiperparámetro que indica el ***número de veces que la Red Neuronal aprenderá de todas las observaciones de Dataset***.\n",
    "\n",
    "\n",
    "* Por ejemplo, si tenemos un Dataset con 200K observaciones y le indicamos a la red que realice 50 epochs, esto significa que la Red Neuronal leerá y aprenderá 50 veces las 200K observaciones del Dataset; es decir, que leerá 10.000K observaciones (200k x 50).\n",
    "\n",
    "<img src=\"./imgs/025_epochs.png\" style=\"width: 800px;\"/>\n",
    "\n",
    "\n",
    "### Batch Size\n",
    "\n",
    "\n",
    "* El Batch Size es un hiperparámetro que indica el ***número de observaciones que tiene que leer la Red Neuronal antes de actualizar el modelo*** (los pesos de la Red Neuronal).\n",
    "\n",
    "\n",
    "* Por ejemplo con un Batch Size de 100 lo que haremos será calcular la salida para 100 Observaciones y calcular sus errores en función de la predicción que realice la Red. Posteriormente se calcula el error medio de las 100 observaciones y se actualizan los pesos de la Red Neuronal.\n",
    "\n",
    "    + Un Batch Size pequeño:  la Red Neuronal aprenda muy bien pero tardará mucho tiempo en calcular el modelo.\n",
    "    \n",
    "    + Barch Size grande: la Red Neuronal no aprenda tan bien pero tardará menos tiempo en calcular el modelo.\n",
    "\n",
    "\n",
    "<img src=\"./imgs/026_batch_size.png\" style=\"width: 800px;\"/>\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<hr>\n",
    "\n",
    "\n",
    "\n",
    "# Bonus Track II - TensorFlow - Keras -\n",
    "\n",
    "* TensorFlow es una librería de Deep Learning en Python desarrollada por google.\n",
    "\n",
    "\n",
    "* Keras es una librería en Python desarrollada por François Chollet (ingeniero de Google) que en esencia es un wrapper sobre TensorFlow (version 1), Theano y CNTK: https://github.com/keras-team/keras\n",
    "\n",
    "\n",
    "* TensorFlow (V1), Theano y CNTK son librería muy potentes pero tienen el “problema” que de son muy difíciles de utilizar, por lo que Keras empezó a desarrollarse por Chollet con el objetivo de crear una librería sencilla de utilizar para temas de Deep Learning.\n",
    "\n",
    "\n",
    "* TensorFlow (con el objetivo de simplificar y democratizar el uso de su librería) se integro con el API de Keras, para hacer un uso más sencillo de su librería. Esto es así a partir de la versión 2 de TensorFlow.\n",
    "\n",
    "* Los principios en los que se basaba Keras (y de ahi la integración con TensorFlow) son los siguientes:\n",
    "<span></span><br><br>\n",
    "    - ***Modularidad***: Una red neuronal se entiende como una secuencia o grafo de capas de neuronas.\n",
    "<span></span><br><br>\n",
    "    - ***Minimalismo***: La librería proporciona lo justo y necesario para crear y entrenar redes maximizando la legibilidad del código.\n",
    "<span></span><br><br>\n",
    "    - ***Extensibilidad***: Los nuevos componentes tienen que ser fáciles de añadirse a Keras.\n",
    "<span></span><br><br>\n",
    "    - ***Python***: Keras es Python nativo.\n",
    "\n",
    "\n",
    "\n",
    "## Como Construir modelos en TensorFlow - Keras\n",
    "\n",
    "\n",
    "* Lo que a continuación se cuenta se hace de manera muy genérica pero podemos definir los pasos que se deben de dar para contruir una red neuronal:\n",
    "<span></span><br><br>\n",
    "    1. ***Definir el modelo***: crear el ***Sequential*** model y añadir las capas con su configuración (https://www.tensorflow.org/api_docs/python/tf/keras/Sequential).\n",
    "<span></span><br><br>\n",
    "    2. ***Compilar el modelo***: definir o especificar la función de pérdida y llamar al método ***compile()***.\n",
    "<span></span><br><br>\n",
    "    3. ***Ajustar (fit) el modelo***: entrenar el modelo con los datos de entrenamiento llamando al método ***fit()***.\n",
    "<span></span><br><br>\n",
    "    4. ***Realizar predicciones***: usando el modelo se pueden realizar predicciones con nuevos datos llamando a los métodos ***evaluate()*** o ***predict()***.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}