Tu primera red neuronal con Tensorflow

Seguro que muchas veces te has preguntado ¿qué es una red neuronal? ¿cómo funciona? ¿qué utilidad tienen?

Las redes neuronales son sistemas computacionales que los componen neuronas artificiales las cuales están conectadas entre sí,

En el mundo real las neuronas son sistemas complejos, por lo que cuando hablamos de las neuronas en una red neuronal nos referimos a una simplificación de las mismas. Esta simplificación permite analizar el funcionamiento de las mismas mediante operaciones matemáticas. Las neuronas tienen un conjunto de entradas y salidas, que permiten conectarlas entre sí y formar una red. Para simplificar, en una neurona metemos valores numericos en la entrada y se computa uno o varios valores numéricos a la salida, finalmente conectamos la salida de esta neurona con la entrada de otra para formar la red.

Esta técnica ha resultado muy exitosa permitiendo desarrollar tecnologías nunca antes vistas. Para que entiendas el alcance de las redes neuronales estas hacen funcionar aplicaciones como Alexa, Filtros de Instagram, conducción autónoma (si, los coches de Tesla tienen procesadores específicos para computar redes neuronales) entre otros.

Hoy en dia la mayoría de smartphones tienen procesadores dedicados al cómputo de redes neuronales. Un ejemplo es Neural Engine de Apple que desde 2011 puedes encontrar en todos los iPhone que salen al mercado.

Tensorflow

La librería por excelencia para trabajar con redes neuronales es Tensorflow, de Google. Esta es de código abierto y permite desarrollar nuestra red neuronal en lenguajes como Python, Go, Java y C. En este ejemplo usaremos python. Desarrollar y entrenar una red neuronal es una tarea que requiere mucho poder de cálculo, este ejemplo funcionará mejor si tu ordenador dispone de un Chip gráfico potente (GPU) que es lo recomendado cuando trabajamos con Tensorflow o en general para tareas de Machine Learning.

Su instalación es sencilla si tienes ya un entorno python instalado. Ejecuta el siguiente comando en la terminal:

bash
pip install --upgrade tensorflow

Si todavía no tienes instalado un entorno de desarrollo para Python en tu ordenador, te recomiendo instalar Conda.

Fashion Mnist

En nuestro editor de texto (Visual Studio Code por ejemplo), vamos a crear un fichero que llamaremos nn_example.py en el ir copiando el código que iré presentando. Puedes ejecutar el código usando:

bash
python nn_example.py

Para este ejemplo usaremos un Dataset llamado Fashion MNIST. Este dataset está formado por un conjunto de imagenes de prendas de ropa categorizadas según el tipo de prenda, jersey, bolso, camiseta. En el dataset hay un total de 10.000 imágenes con su correspondiente etiqueta y un total de 10 etiquetas de ropa diferentes

Fashion Mnist Labels

Importamos el dataset Fashion MNIST, el cual consiste en imagenes de prendas de ropa

python
#dataset Fashion MNIST
from tensorflow.keras.datasets import fashion_mnist
(X, y), (X_test, y_test) = fashion_mnist.load_data()

Para saber que nuestro dataset en este caso se ha creado bien, deberíamos ver lo siguiente al ejecutarlo

Explorando el dataset

Podemos explorar un poco el dataset de la siguiente forma, con este código vamos a poder observar las imagenes que nos entrega.

python
# Cargamos los labels del dataset.
labels = ["T-shirt/top",
          "Trouser",
          "Pullover",
          "Dress",
          "Coat",
          "Sandal",
          "Shirt",
          "Sneaker",
          "Bag",
          "Ankle boot"]

# Mostramos una tabla con las algunas imagenes del dataset
plt.figure(figsize=(14,8))
ind = np.random.choice(X.shape[0],20)
for i,img in enumerate(ind):
    plt.subplot(5,10,i+1)
    plt.title(labels[y[img]])
    plt.imshow(X[img], cmap="binary")
    plt.axis("off")

Preparando el dataset

Ahora que ya conocemos los datos con los que vamos a trabajar para crear nuestra primera red neuronal. Importemos entonces las bibliotecas necesarias para empezar el diseño de la topología y el entrenamiento de nuestra primera red neuronal.

python
# TensorFlow y tf.keras
import tensorflow as tf
from tensorflow import keras

# Librerias de ayuda
import numpy as np
import matplotlib.pyplot as plt

La primera tares que realizaremos será la de separar los datos de nuestro dataset en dos conjuntos, uno para que pueda entrenarse y otro para testear luego su rendimiento. X_train son las imágenes de 28x28 píxeles de entrenamiento y X_test las de test.

python
# Dividimos el dataset en dos partes 10% de las imagenes totales serán para testeo y el 90% restante para entrenamiento
X_train, X_test, y_train, y_test = train_test_split(X,y, test_size=0.1)
print("Imágenes de entrenamiento", X_train.shape)
print("Imágenes de test", X_test.shape)

La red

A continuación vamos a definir como serán las neuronas que compondrán la topología de nuestra red. Esta tarea requiere de cierta investigación, por lo que no se espera que comprendas al detalle porqué ha sido diseñada de esta forma. Empecemos por el principio, la red que hemos diseñado consta de 3 capas. Este sería el código que define nuestro modelo de red neuronal.

python
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

La primera capa Flatten realiza un "aplanado" de la imagen en 2D en de 28x28 píxeles de nuestro dataset y crea un vector de 1 dimensión de 784 parámetros. Esta capa es una operación sencilla, la verdadera mágia está en las dos capas Dense que tenemos a continuación. En ella se definen un total de 128 neuronas cuya salida está conectada con la siguiente capa de 10 neuronas. Es decir, cada una de las 128 neuronas conecta su salida con cada una de las 10 de la siguiente capa formando un total de 128·10=1280 conexiones.

Imagina que esas 10 neuronas de la capa final son 10 bombillas y que cada bombilla representa una etiqueta de prenda de ropa de nuestro dataset. En este caso, la red encenderá la bombilla "Camiseta" cuando a la entrada le enseñemos una imagen de una camiseta. ¿Fascinante verdad?.

Pero para que eso sea posible, antes tenemos que entrenar la red neuronal. En un lenguaje llano, esto representa hacer que la red aprenda cuando tiene que encender cada bombilla dependiendo de la imagen que le mostremos. El proceso de entrenamiento de una red implica modificar la intensidad de las conexiones entre neuronas (entre capas) para conseguir el resultado que queremos.

Entrenamiento

Ya teniendo los datos separados y la topología de la red con sus capsas, estamos listos para entrenarla y evaluar sus resultados.

python

# Configuramos como se entrenará la red
model.compile(
    loss="sparse_categorical_crossentropy",
    optimizer=keras.optimizers(learning_rate=0.001),
    metrics=["accuracy"]
)

# Definimos los parametros de entrenamiento
params = {
    "validation_data": (X_val,y_val),
    "epochs": 100,
    "verbose": 2,
    "batch_size":256,
}

# Iniciamos el entrenamiento
model.fit(X_train,y_train,**params)

Durante el entrenamiento

Como resultado de iniciar el entrenamiento vamos a ver los Epoch pasar. Un epoch es un ciclo completo de entrenamiento de la red neuronal.

Tensorflow training epochs

Resultados

Ya lo tenemos todo listo, con la siguiente linea vamos a poder evaluar la capacidad de nuestra red para predecir una prenda de ropa. Usaremos la parte del dataset destinado a pruebas. Recordemos que partimos de una imagen de 28x28 píxeles de la misma.

python
model.evaluate(X_test,y_test)

Al ejecutar el código debería dar el siguiente resultado o similar en la terminal. En el vemos el valor de accuracy calculado con los datos que habíamos apartado al inicio y con los que NO hemos entrenado. ¡Enhorabuena nuestra red acierta un 84.21% de las veces la prenda de ropa correcta!

bash
313/313 [==============================] - 0s 657us/step - loss: 0.4998 - accuracy: 0.8421