Tensorflow y Keras.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##REDES NEURONALES\n",
    "\n",
    "# Tensorflow: paquete de paralización en Phyton para manejar objetos n-dimensionales. Para APRENDIZAJE SUPERVISADO\n",
    "# Keras: API de red neuronal\n",
    "# Input layer: la primera capa de información a procesar\n",
    "# Hidden layer: capas que activan e interactuan con el input e infieren patrones\n",
    "# Output layer: resultado final de la red neuronal\n",
    "\n",
    "# Cada neurona está conectada con otras a través de unos enlaces. \n",
    "# En estos enlaces el valor de salida de la neurona anterior es multiplicado por un valor de peso. \n",
    "# Estos pesos en los enlaces pueden incrementar o inhibir el estado de activación de las neuronas adyacentes. \n",
    "# Del mismo modo, a la salida de la neurona, puede existir una función limitadora o umbral, que modifica el valor resultado o impone un límite que se debe sobrepasar antes de propagarse a otra neurona. \n",
    "# Esta función se conoce como función de activación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor 'zeros:0' shape=(10, 299, 299, 3) dtype=float32>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "\n",
    "mamifero = tf.Variable(\"Elephant\", tf.string)\n",
    "ignition = tf.Variable(451, tf.int16)\n",
    "floating = tf.Variable(3.14159265, tf.float64)\n",
    "my_image = tf.zeros([10,299,299,3])\n",
    "my_image\n",
    "\n",
    "#Resultado: <tf.Tensor 'zeros:0' shape=(10, 299, 299, 3) dtype=float32>\n",
    "#hacemos un objeto de tipo tensorflow lleno de zeros de 4 dimensiones: \n",
    "#3 cubos de: 10 rows, 300 columnas, 300 Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5\n",
      "60000/60000 [==============================] - 3s 58us/sample - loss: 0.5000 - acc: 0.8250\n",
      "Epoch 2/5\n",
      "60000/60000 [==============================] - 3s 55us/sample - loss: 0.3758 - acc: 0.8640\n",
      "Epoch 3/5\n",
      "60000/60000 [==============================] - 3s 58us/sample - loss: 0.3373 - acc: 0.8769\n",
      "Epoch 4/5\n",
      "60000/60000 [==============================] - 4s 71us/sample - loss: 0.3151 - acc: 0.8831\n",
      "Epoch 5/5\n",
      "60000/60000 [==============================] - 3s 58us/sample - loss: 0.2962 - acc: 0.8912\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "#dataset de ejemplo\n",
    "(train_images, train_labels), (test_images, test_labels) = keras.datasets.fashion_mnist.load_data()\n",
    "# train_images.shape #(60000, 28, 28) 60000 imagenes de 28x28\n",
    "# train_labels #devuleve valores de 0 a 9 asi que es una clasificación\n",
    "\n",
    "#los datos vienen en rango de 0 a 255 asi que los normalizamos de 0 a 1. Si no los normalizaramos el aprendizaje sería muy malo o haría falta muchas mas epocas\n",
    "train_images = train_images / 255.0\n",
    "test_images = test_images / 255.0\n",
    "\n",
    "#vamos a ver el primero de los elementos de los 60000\n",
    "# plt.figure()\n",
    "# plt.imshow(train_images[0])\n",
    "# plt.show()\n",
    "\n",
    "#nuestra red neuronal\n",
    "model = keras.Sequential([\n",
    "    keras.layers.Flatten(input_shape=(28, 28)),\n",
    "    keras.layers.Dense(128, activation=tf.nn.relu), #hidden layer de 128 nodos, tf.nn.relu = rectifing linear unit activation\n",
    "    keras.layers.Dense(10, activation=tf.nn.softmax) #capa de salida con 10 outputs\n",
    "])\n",
    "\n",
    "model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy']) #adam es un algoritmo de optimización\n",
    "\n",
    "model.fit(train_images, train_labels, epochs=5) #5 periodos de entrenamiento, veremos que en cada epoca vamos mejorando la precisión\n",
    "\n",
    "#ahora que ha entrenado le pasamos una imagen de test para evaluar el modelo\n",
    "predictions = model.predict(test_images)\n",
    "np.argmax(predictions[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train: X=(60000, 28, 28), y=(60000,)\n",
      "Test: X=(10000, 28, 28), y=(10000,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/3\n",
      "60000/60000 [==============================] - 6s 102us/sample - loss: 2.3053 - acc: 0.1563 - val_loss: 2.0316 - val_acc: 0.3141\n",
      "Epoch 2/3\n",
      "60000/60000 [==============================] - 7s 114us/sample - loss: 2.0280 - acc: 0.2766 - val_loss: 1.8215 - val_acc: 0.4621\n",
      "Epoch 3/3\n",
      "60000/60000 [==============================] - 7s 113us/sample - loss: 1.8443 - acc: 0.3694 - val_loss: 1.6658 - val_acc: 0.5473\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2805c67e80>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "##Problema\n",
    "# 1- Cargar el dataset de prueba MNIST desde keras.datasets\n",
    "# 2- explorar el dataset con .shape, print() y otros métodos\n",
    "# 3- Normalizar el dataset a 255\n",
    "# 4- crear en keras un modelo sequential() con: \n",
    "#     4.1- Una capa Flatten que acepte image data como single vector\n",
    "#     4.2- Una capa Dense() con 128 unidades y funcion de activacion relu\n",
    "#     4.3- Capa de salida Dense() con 10 unidades y funcion de activacion softmax\n",
    "# 5- Compilar y salvar el fitted model como objeto con los siguientes parametros:\n",
    "#     optimizer: keras.optimezers.Adadelta()\n",
    "#     loss function: 'sparse_categorical_crossentropy'\n",
    "#     metrics: accuracy\n",
    "#     validation_dat: test images from MNIST dataset\n",
    "# 6- Tras entrenar el modelo, examinalo con .history\n",
    "# 7- Plot accuracy, validation accuracy, loss y validation loss desde el objeto .history\n",
    "\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 1- Cargar el dataset de prueba MNIST desde keras.datasets\n",
    "(train_images, train_labels), (test_images, test_labels) = keras.datasets.fashion_mnist.load_data()\n",
    "\n",
    "\n",
    "# 2- explorar el dataset con .shape, print() y otros métodos\n",
    "train_images.shape #60000 imagenes de 28x28\n",
    "\n",
    "print('Train: X=%s, y=%s' % (train_images.shape, train_labels.shape))\n",
    "print('Test: X=%s, y=%s' % (test_images.shape, test_labels.shape))\n",
    "# plot first 9 images\n",
    "for i in range(9):\n",
    "\tplt.subplot(330 + 1 + i)\n",
    "\tplt.imshow(train_images[i], cmap=plt.get_cmap('gray'))\n",
    "plt.show()\n",
    "\n",
    "\n",
    "# 3- Normalizar el dataset a 255\n",
    "train_images = train_images / 255.0\n",
    "test_images = test_images / 255.0\n",
    "\n",
    "\n",
    "# 4- crear en keras un modelo sequential() con: \n",
    "#     4.1- Una capa Flatten que acepte image data como single vector\n",
    "#     4.2- Una capa Dense() con 128 unidades y funcion de activacion relu\n",
    "#     4.3- Capa de salida Dense() con 10 unidades y funcion de activacion softmax\n",
    "model = keras.Sequential([\n",
    "    keras.layers.Flatten(input_shape=(28, 28)),\n",
    "    keras.layers.Dense(128, activation=tf.nn.relu), #hidden layer de 128 nodos, tf.nn.relu = rectifing linear unit activation\n",
    "    keras.layers.Dropout(0.5), #esta capa descarta el 50% de los componentes lo que mejorara el accuracy\n",
    "    keras.layers.Dense(10, activation=tf.nn.softmax) #capa de salida con 10 outputs\n",
    "])\n",
    "\n",
    "\n",
    "# 5- Compilar y salvar el fitted model como objeto con los siguientes parametros:\n",
    "#     optimizer: keras.optimizers.Adadelta()\n",
    "#     loss function: 'sparse_categorical_crossentropy'\n",
    "#     metrics: accuracy\n",
    "#     validation_dat: test images from MNIST dataset\n",
    "model.compile(optimizer=keras.optimizers.Adadelta(),loss='sparse_categorical_crossentropy',metrics=['accuracy'])\n",
    "model_log = model.fit(train_images, train_labels, epochs=3, validation_data=(test_images, test_labels))\n",
    "\n",
    "\n",
    "# 6- Tras entrenar el modelo, examinalo con .history\n",
    "model_log.history\n",
    "\n",
    "\n",
    "# 7- Plot accuracy, validation accuracy, loss y validation loss desde el objeto .history\n",
    "fig = plt.figure()\n",
    "plt.subplot(2,1,1)\n",
    "plt.plot(model_log.history['acc'])\n",
    "plt.plot(model_log.history['val_acc'])\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='lower right')\n",
    "\n",
    "plt.subplot(2,1,2)\n",
    "plt.plot(model_log.history['loss'])\n",
    "plt.plot(model_log.history['val_loss'])\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'test'], loc='upper right')\n",
    "\n",
    "\n",
    "##INTERPRETAR RESULTADO\n",
    "# segun las 3 epocas avanzan el accuracy mejora y la perdida decae"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_17\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d (Conv2D)              (None, 26, 26, 32)        320       \n",
      "_________________________________________________________________\n",
      "conv2d_1 (Conv2D)            (None, 24, 24, 64)        18496     \n",
      "_________________________________________________________________\n",
      "max_pooling2d (MaxPooling2D) (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "dropout_7 (Dropout)          (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "flatten_17 (Flatten)         (None, 9216)              0         \n",
      "_________________________________________________________________\n",
      "dense_34 (Dense)             (None, 128)               1179776   \n",
      "_________________________________________________________________\n",
      "dropout_8 (Dropout)          (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_35 (Dense)             (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 1,199,882\n",
      "Trainable params: 1,199,882\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/3\n",
      "60000/60000 [==============================] - 97s 2ms/sample - loss: 0.5358 - acc: 0.8099 - val_loss: 0.3405 - val_acc: 0.8785\n",
      "Epoch 2/3\n",
      "60000/60000 [==============================] - 97s 2ms/sample - loss: 0.3487 - acc: 0.8748 - val_loss: 0.2970 - val_acc: 0.8933\n",
      "Epoch 3/3\n",
      "60000/60000 [==============================] - 97s 2ms/sample - loss: 0.2996 - acc: 0.8916 - val_loss: 0.2632 - val_acc: 0.9035\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.2632025419592857, 0.9035]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##CNN Convolutional Neural Network\n",
    "# 1- Construir una red neural estandard\n",
    "# 2- Salvar el resultado del modelo con .evaulate()\n",
    "# 3- Usar add() para poder añadir a posteriori capas\n",
    "# 4- Input layer convolucional Conv2D de 32 unidades de 3x3 pixeles, funcion relu de activacion e input image shape dimension(x,y,z)\n",
    "# 5- Una segunda capa de activación Conv2D con 64 unidades y un kernel size apropiado\n",
    "# 6- Una capa MaxPooling2D con un pool size de 2x2\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras as ks\n",
    "\n",
    "(train_images, train_labels), (test_images, test_labels) = ks.datasets.fashion_mnist.load_data() #cargamos el dataset\n",
    "\n",
    "#hacemos reshape de los datos, para que el modelo sepa que dimension se usa para cambiar de imagen\n",
    "x_train = train_images.reshape(train_images.shape[0], 28, 28, 1)\n",
    "x_test = test_images.reshape(test_images.shape[0], 28, 28, 1)\n",
    "\n",
    "#normalización\n",
    "x_train = x_train.astype('float32') / 255.\n",
    "x_test = x_test.astype('float32') / 255.\n",
    "\n",
    "#convertimos las 'labels' en valores entre 0 y 1\n",
    "y_train = ks.utils.to_categorical(train_labels, 10)\n",
    "y_test = ks.utils.to_categorical(test_labels, 10)\n",
    "\n",
    "\n",
    "input_shape = (28,28,1)\n",
    "\n",
    "model = ks.Sequential()\n",
    "model.add(ks.layers.Conv2D(32, kernel_size=(3, 3), #Input layer convolucional Conv2D de 32 unidades de 3x3 pixeles, funcion relu de activacion e input image shape dimension(x,y,z)\n",
    "                 activation='relu',\n",
    "                 input_shape=input_shape))\n",
    "model.add(ks.layers.Conv2D(64, (3, 3), activation='relu')) #Una segunda capa de activación Conv2D con 64 unidades y un kernel size apropiado\n",
    "model.add(ks.layers.MaxPooling2D(pool_size=(2, 2))) #Una capa MaxPooling2D con un pool size de 2x2\n",
    "model.add(ks.layers.Dropout(0.25))\n",
    "model.add(ks.layers.Flatten())\n",
    "model.add(ks.layers.Dense(128, activation='relu'))\n",
    "model.add(ks.layers.Dropout(0.5))                     \n",
    "model.add(ks.layers.Dense(10, activation='softmax'))\n",
    "model.summary()\n",
    "\n",
    "model.compile(loss=ks.losses.categorical_crossentropy,\n",
    "              optimizer='adam',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "model.fit(x_train, y_train,\n",
    "          batch_size=128,\n",
    "          epochs=3,\n",
    "          verbose=1,\n",
    "          validation_data=(x_test, y_test))\n",
    "\n",
    "score = model.evaluate(x_test, y_test, verbose=0) #Salvamos el resultado del modelo con .evaluate()\n",
    "score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_19\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "conv2d_4 (Conv2D)            (None, 26, 26, 32)        320       \n",
      "_________________________________________________________________\n",
      "conv2d_5 (Conv2D)            (None, 24, 24, 64)        18496     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_2 (MaxPooling2 (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "dropout_11 (Dropout)         (None, 12, 12, 64)        0         \n",
      "_________________________________________________________________\n",
      "flatten_19 (Flatten)         (None, 9216)              0         \n",
      "_________________________________________________________________\n",
      "dense_38 (Dense)             (None, 128)               1179776   \n",
      "_________________________________________________________________\n",
      "dropout_12 (Dropout)         (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_39 (Dense)             (None, 10)                1290      \n",
      "=================================================================\n",
      "Total params: 1,199,882\n",
      "Trainable params: 1,199,882\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/3\n",
      "60000/60000 [==============================] - 142s 2ms/sample - loss: 0.5181 - acc: 0.8156 - val_loss: 0.3373 - val_acc: 0.8780\n",
      "Epoch 2/3\n",
      "60000/60000 [==============================] - 205s 3ms/sample - loss: 0.3387 - acc: 0.8793 - val_loss: 0.2819 - val_acc: 0.8973\n",
      "Epoch 3/3\n",
      "60000/60000 [==============================] - 213s 4ms/sample - loss: 0.2918 - acc: 0.8942 - val_loss: 0.2702 - val_acc: 0.9008\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.2701947840690613, 0.9008]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "##PROYECTO\n",
    "# 1- Process MNIST dataset\n",
    "# 2- Normalize image data, convert labels to integers\n",
    "# 3- Take note of image dimensions using (image.shape, image.channels)\n",
    "# 4- Add a convolutional layer to your sequential() model prior to your input, hidden, and output layers\n",
    "# 5- Conv2D layer with: 32 units, 3x3 kernal size, relu activation function\n",
    "# 6- Second Conv2D activation layer with: 64 units and relu activation function\n",
    "# 7- A MaxPooling2D layer with 2x2 pooling size\n",
    "# 8- Add standard input, hidden, output layers\n",
    "# 9- Save output of model into a variable using .evaluate()\n",
    "\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras as ks\n",
    "\n",
    "# 1- Process MNIST dataset\n",
    "(train_images, train_labels), (test_images, test_labels) = ks.datasets.fashion_mnist.load_data()\n",
    "\n",
    "# 2- Normalize image data, convert labels to integers\n",
    "x_train = train_images.reshape(train_images.shape[0], 28, 28, 1)\n",
    "x_test = test_images.reshape(test_images.shape[0], 28, 28, 1)\n",
    "x_train = x_train.astype('float32') / 255.\n",
    "x_test = x_test.astype('float32') / 255.\n",
    "y_train = ks.utils.to_categorical(train_labels, 10)\n",
    "y_test = ks.utils.to_categorical(test_labels, 10)\n",
    "\n",
    "# 3- Take note of image dimensions using (image.shape, image.channels)\n",
    "input_shape = (28,28,1)\n",
    "\n",
    "# 4- Add a convolutional layer to your sequential() model prior to your input, hidden, and output layers\n",
    "model = ks.Sequential()\n",
    "# 5- Conv2D layer with: 32 units, 3x3 kernal size, relu activation function\n",
    "model.add(ks.layers.Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))\n",
    "# 6- Second Conv2D activation layer with: 64 units and relu activation function\n",
    "model.add(ks.layers.Conv2D(64, (3, 3), activation='relu'))\n",
    "# 7- A MaxPooling2D layer with 2x2 pooling size\n",
    "model.add(ks.layers.MaxPooling2D(pool_size=(2, 2)))\n",
    "model.add(ks.layers.Dropout(0.25))\n",
    "# 8- Add standard input, hidden, output layers\n",
    "model.add(ks.layers.Flatten())\n",
    "model.add(ks.layers.Dense(128, activation='relu'))\n",
    "model.add(ks.layers.Dropout(0.5))                     \n",
    "model.add(ks.layers.Dense(10, activation='softmax'))\n",
    "model.summary()\n",
    "\n",
    "model.compile(loss=ks.losses.categorical_crossentropy,\n",
    "              optimizer='adam',\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "model.fit(x_train, y_train,\n",
    "          batch_size=128,\n",
    "          epochs=3,\n",
    "          verbose=1,\n",
    "          validation_data=(x_test, y_test))\n",
    "\n",
    "# 9- Save output of model into a variable using .evaluate()\n",
    "score = model.evaluate(x_test, y_test, verbose=0)\n",
    "score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}