Construyendo redes neuronales

Vamos a construir una red neuronal usando Python y Keras para clasificación con TensorFlow como backend. Keras es una biblioteca de Python poderosa y simplificada que podemos usar para construir redes neuronales y redes de aprendizaje profundo.

La primera tarea es importar todas las bibliotecas necesarias para TensorFlow y Keras. En la primera celda de código, especificamos las declaraciones para importar todas las bibliotecas necesarias para crear un entorno de TensorFlow.

from __future__ import absolute_import, division, print_function, unicode_literals

# TensorFlow y Keras

import tensorflow as tf

from tensorflow import keras

También necesitaremos algunas bibliotecas auxiliares. Importamos numpy  y matplotlib. La tarea final consiste en imprimir la versión de TensorFlow para la que hemos especificado la versión de impresión en la última línea de la celda de código.

#librerías de ayuda

import numpy as np

import matplotlib.pyplot as plt

print(tf.__version__)

Al ejecutar esta celda, la última línea nos devuelve la versión de TensorFlow que tenemos instalada. 

La siguiente tarea será cargar los datos para construir el modelo de red neuronal. Keras proporciona varios conjuntos de datos que podemos utilizar para construir un modelo de red neuronal. Utilizaremos un conjunto de datos llamado fashion_mnist, que contiene varias imágenes que se pueden clasificar en diferentes tipos.

dataset_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = dataset_mnist.load_data()

Para acceder al conjunto de datos fashion_mnist, declaramos una variable en la primera línea llamada dataset_mnist y le asignamos keras.datasets.fashion_mnist para cargar los datos en dicha variable. Los datos que estamos cargando ya están etiquetados, para el conjunto de entrenamiento, contamos con train_images y train_labels.

Y para el conjunto de prueba, se proporcionan test_images y test_labels. Para generar estos dos conjuntos diferentes de datos de prueba y de entrenamiento, llamamos a la función load_data. 

 

La siguiente tarea consiste en definir varios tipos de clases. Hay varios tipos de clases que se pueden encontrar en el conjunto de datos fashion_mnist.

class_types = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

Hay diez etiquetas diferentes que se almacenarán en una matriz NumPy donde la primera etiqueta es asignada al número 0 y los números apuntarán a clases particulares. Por ejemplo, la etiqueta de la camiseta / top, 'T-shirt/top' será 0. La etiqueta para los pantalones 'Trouser' será 1 y así sucesivamente.

Al ejecutar la celda, se han definen los class_types. A continuación exploraremos los datos y el formato de los datos que usaremos para entrenar la red neuronal nuestro conjunto de entrenamiento.

train_images.shape

Si ejecutamos esta instrucción,  nos muestra el número de imágenes y la forma de estas. Indica que hay 60.000 imágenes y el tamaño de cada imagen es de 28 por 28 píxeles. 

len(train_labels)

Cuando ejecutamos la instrucción len(train_labels), la salida indica que hay 60.000 etiquetas en el conjunto de entrenamiento actual. Exploraremos las etiquetas en el conjunto de entrenamiento, que debería ser un número entero dentro de un rango particular. 

train_labels

Al ejecutar esta línea, se muestra el siguiente resultado: 

array([9, 0, 0, ..., 3, 0, 5], dtype = uint8

Esta matriz representa las etiquetas que están dentro del rango de 0 y 9. 

Para ver el número de imágenes y su dimensión en el conjunto de datos de prueba, ejecutaremos.

test_images.shape

Después de la ejecución, se muestra el siguiente resultado: (10000, 28, 28). Que indica que hay 10.000 imágenes y el tamaño de cada imagen es de 28 por 28 píxeles. 

Ahora vamos a preprocesar los datos de las imágenes. Para ello utilizaremos  plt, que es un objeto de Matplotlib que importamos anteriormente.

plt.figure()

plt.imshow(train_images[0])

plt.colorbar()

plt.grid(False)

plt.show()

Queremos inspeccionar la primera imagen y, para ello, hemos especificado las declaraciones plt.figure y plt.imshow. A la que le estamos pasando el índice 0 para obtener la primera imagen del conjunto de entrenamiento. 

 

Tras la ejecución, se nos proporciona la primera imagen, pero no se escala correctamente. Así que la siguiente tarea consistirá en escalar la imagen. 

train_images = train_images /  255

test_images = test_images /  255

Hacemos lo mismo con test_images, para asegurarnos de que estamos escalando correctamente el valor de las imágenes de entrenamiento y las imágenes de prueba antes de que se envíen a la red neuronal. Las imágenes de entrenamiento de prueba se factorizarán en 255. 

Ahora verificamos los datos, para ello, trazamos ciertos rangos de los datos, y usamos un tamaño de figura de 10 por 10.  Y especificamos xticks e yticks, que representan el eje x y eje y.

plt.figure(figsize=(10,10))

for i in range(25):

    plt.subplot(5,5,i+1)

    plt.xticks([ ])

    plt.yticks([ ])

    plt.grid(False)

    plt.imshow(train_images[i], cmap=plt.cm.binary)

    plt.xlabel(class_types[train_labels[i]])

    plt.show()

La declaración plt.imshow mostrará las imágenes. Después de extraerlas de  train_images, la instrucción que tiene justo debajo garantiza que las imágenes estén etiquetadas con los tipos de clase adecuados.

 

Podemos observar que cada una de las imágenes están etiquetadas con sus respectivos tipos de clases. Habiendo explorado los datos, la siguiente tarea es construir el modelo de red neuronal. Para construir el modelo, primero configuraremos la etiqueta del modelo y luego compilaremos el modelo.

model = keras.Sequential([

     keras.layers.Flatten(input_shape=(28, 28)),

     keras.layers.Dense(128, activation=tf.nn.relu),

     keras.layers.Dense(10, activation=tf.nn.softmax)

 ])

Hemos especificado el modelo utilizando la declaración model = keras.Sequential.  Y hemos agregado tres capas diferentes, la primera capa es la capa de entrada. La segunda capa es la capa oculta y la tercera capa es la capa de salida.

En la capa de entrada, estamos usando la función Aplanar (Flatten), a la que le estamos pasando el tamaño de entrada como 28 por 28, que es el tamaño real de la imagen. En la capa oculta, estamos usando la función Dense, a la que le estamos pasando un 128 como el número de nodos o neuronas, seguido de la función de activación relu. Finalmente, en la capa de salida estamos usando la función Dense y estamos pasando el valor del nodo como 10 seguido de la función de activación softmax. 

La tarea final es compilar el modelo. Tenemos que compilar y configurar el modelo con ciertas configuraciones importantes antes de que el modelo esté listo para entrenarlo. 

model.compile(optimizer='adam',

    loss='sparse_categorical_crossentropy',

    metrics=['accuracy'])

La primera parte contiene el optimizador, que indica cómo se actualiza el modelo en función de los datos proporcionados y la función de pérdida aplicada. La función de pérdida es la medida de precisión que generalmente está involucrada durante el proceso de entrenamiento.

La función de pérdida que hemos especificado es sparse_categorical_crossentropy. Las métricas, son el elemento de configuración final, se utilizan para especificar el aspecto de monitoreo de los pasos o procesos de capacitación y prueba. La métrica que hemos especificado es la precisión:  accuracy.  

Hemos construido y compilado nuestro modelo con éxito, y podemos comenzar a usar la red neuronal para entrenar. Hay una última línea que entrena el modelo.

model.fit(train_images, train_labels, epochs = 5)