Tutorial de Keras: ejemplo de aprendizaje profundo con Keras y Python

Keras es una biblioteca de código abierto para crear aplicaciones de aprendizaje profundo. Keras está escrita en Python y ofrece una interfaz uniforme para varios backends de aprendizaje profundo, como TensorFlow y Theano. El aprendizaje profundo, o deep learning, es una rama del aprendizaje automático y se basa en redes neuronales artificiales.

El propósito de Keras es hacer que el deep learning nos resulte menos abrumador. En este tutorial de Keras, exploraremos las diferentes funciones de Keras utilizando un simple ejemplo.

Backup cloud por Acronis
Protege tu infraestructura y reduce el tiempo de inactividad
  • Copias de seguridad automáticas y fácil recuperación
  • Gestión y planificación intuitiva
  • Protección contra las amenazas basadas en IA
  • Incluye crédito inicial de 250 € el primer mes

Cómo preparar tu sistema para utilizar Keras

La mejor manera de preparar tu sistema para utilizar Keras es instalando el paquete de software Anaconda. Anaconda es una plataforma libre que se utiliza en la ciencia de datos. Incluye herramientas y bibliotecas útiles y viene con una instalación de Python3 como estándar.

Cómo instalar Anaconda y Python

A continuación, te explicamos e incluimos el código previsto para usuarios de macOS. En principio, el código también debería servir para otros sistemas operativos. No obstante, quizás debas realizar algunos ajustes, sobre todo si eres usuario de Windows.

Si estás acostumbrado a trabajar con la línea de comandos y tienes el sistema de gestión de paquetes de software libre Homebrew instalado en tu Mac, puedes utilizarlo para instalar Anaconda. Para ello, abre la línea de comandos (Terminal.App en Mac), copia la siguiente línea de código en el terminal y ejecuta.

brew cask install anaconda

Si no conoces Homebrew o quieres instalar Anaconda en Windows o Linux, puedes descargarte el paquete de instalación adecuado para tu sistema desde la siguiente página: Anaconda – Individual Edition.

Prueba de instalación de Anaconda y Python

Para asegurarte de haber instalado correctamente Anaconda y Python, ejecuta los siguientes comandos en la línea de comandos:

Para mostrar la versión del gestor de paquetes Conda

conda –version

Para mostrar la versión del intérprete de Python

python --version

Si al escribir recibes el mensaje de error “Comando no encontrado”, quizá necesites establecer la ruta a los binarios de Anaconda. Para hacerlo, sigue leyendo. Si la prueba ha funcionado, puedes pasar a la siguiente sección.

Establecer la ruta a binarios de Anaconda

La variable de entorno PATH contiene información sobre en qué parte del sistema de archivos se encuentran ciertos programas de utilidad. Las rutas individuales dentro de la variable de entorno se separan con una coma. Puedes incluir más rutas, tal y como te mostramos a continuación para Anaconda en la versión 3:

export PATH=/usr/local/anaconda3/bin:"$PATH"

Para asegurarte de que la ruta está activa, tienes que almacenar esta línea de código en el sistema. Dependiendo del sistema que tengas y la shell que utilices (bash, zsh, etc.), el archivo en el que se hacen los cambios varía. Más abajo, lo ilustramos con un ejemplo para bash en macOS.

Ejecuta estás líneas de código en la línea de comando para ajustar la variable de ruta en el archivo “.bash_profile”:

Variable de ruta para ampliar la instalación Anaconda

echo -n 'export PATH=/usr/local/anaconda3/bin:"$PATH"' >> "$HOME/.bash_profile"

Cargar el archivo “.bash_profile”

source "$HOME/.bash_profile"
Consejo

Utiliza el comando cat "$HOME/.bash_profile" en la línea de comandos para ver el archivo “.bash_profile” existente.

A continuación, repite la prueba:

Mostrar versión del administrador de paquetes Conda

conda –version

Mostrar versión del intérprete de Python

python --version

Ahora deberías poder ver los números de la versión. Si es así, continúa con los siguientes pasos.

Actualizar las instalaciones de Anaconda y Python a la última versión

Antes de iniciar un nuevo proyecto, es mejor actualizar las bibliotecas subyacentes. La plataforma Anaconda viene con el administrador de paquetes Conda. Utiliza los siguientes comandos de Conda para aprovechar las actualizaciones disponibles.

Instalar actualizaciones para el gestor de paquetes Conda

conda update conda

Instalar actualizaciones de Anaconda

conda update anaconda

Comprobar el número de la versión de los paquetes instalados

Keras está escrito en Python y se sustenta en diversos módulos de Python. Ejecuta el siguiente bloque de código en la línea de comandos para mostrar el número de la versión de los paquetes de deep learning de Keras más utilizados.

python << EOF
print()
# scipy
import scipy
print('scipy: %s' % scipy.__version__)
# numpy
import numpy
print('numpy: %s' % numpy.__version__)
# matplotlib
import matplotlib
print('matplotlib: %s' % matplotlib.__version__)
# pandas
import pandas
print('pandas: %s' % pandas.__version__)
# statsmodels
import statsmodels
print('statsmodels: %s' % statsmodels.__version__)
# scikit-learn
import sklearn
print('sklearn: %s' % sklearn.__version__)
print()
EOF

Instalar Keras en tu sistema

Ahora que hemos preparado el sistema, podemos instalar Keras. Para hacerlo, ejecuta las siguientes líneas de código en la línea de comandos:

Instalar TensorFlow

pip install tensorflow

Instalar Keras

pip install keras

Igual que antes, es conveniente comprobar la versión de Keras que tienes instalada. Para conocerla, usa esta línea de código:

python -c "import keras; print(keras.__version__)"

Si hace tiempo que instalaste Keras, no es mala idea buscar actualizaciones disponibles e instalarlas si las hay. La siguiente línea de código te las mostrará. Cópiala como siempre y ejecuta el código en la línea de comandos:

pip install --upgrade keras

El deep learning puede ser fácil con Keras: un ejemplo

El equipo de Keras publica una lista con ejemplos de Keras con una licencia gratuita de GitHub. Examinemos en concreto el ejemplo “mnist_cnn.py”. En este caso, el código crea una red neuronal convolucional (también conocida como CNN o ConvNet) y la entrena con un set de datos de entrenamiento.

Para entrenar y testear datos, el ejemplo del script de Keras utiliza el set de datos MNIST. Se trata de una amplia colección de imágenes pequeñas, cada una de unos 28x28 píxeles. Cada imagen contiene un número escrito a mano. El set de datos de MNIST es el estándar del reconocimiento de patrones y Keras lo proporciona.

Si quieres saber más, puedes consultar los datos de entrenamiento y test. Para ello, copia el bloque de código que mostramos a continuación y ejecútalo en la línea de comandos. Cada vez que lo ejecutes, verás una de las imágenes de entrenamiento.

python << EOF
# Cargar Keras 
import keras
# Cargar sets de datos de entrenamiento y test MNIST 
from keras.datasets import mnist
# cargar biblioteca para representación gráfica
import matplotlib.pyplot as plt
# Cargar función para selección aleatoria de imagen
from random import randint
# Cargar sets de datos
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
# Mostrar imagen
plt.figure()
plt.imshow(train_images[randint(1, len(train_images) - 1)])
plt.grid(False)
plt.show()
EOF

A continuación, entrenaremos la red neuronal para que asigne correctamente los números escritos a mano. El entrenamiento de la red es computacionalmente demandante así que no te sorprendas si tu ordenador deje de funcionar correctamente; es normal. Si estás usando un dispositivo móvil, asegúrate de que tiene suficiente batería o conecta el dispositivo a una fuente de alimentación.

Primero crearemos una carpeta de prueba en el escritorio, pasaremos a esa carpeta y montaremos ahí un script de Python vacío. Usa las siguientes líneas de código. Cópialas y ejecútalas en la línea de comandos:

Para crear una carpeta “keras-test” en el escritorio

mkdir "$HOME/Desktop/keras-test/" && cd "$HOME/Desktop/keras-test/"

Para crear un guion vacío de Python

touch keras-test.py

Luego, hay que copiar el script al archivo “keras-test.py” y guardarlo.

Una vez has creado la carpeta de prueba, el siguiente paso es crear el script de ejemplo de Keras. Para eso, copia el código que encontrarás al final del artículo y pégalo en un documento de texto vacío. Guarda el documento en la carpeta “keras-test” que acabas de crear en el escritorio dentro del archivo “keras-test.py”. Por último, para ejecutar el script de ejemplo de Keras con el intérprete de Python, introduce las líneas de código siguientes en la línea de comandos:

cd "$HOME/Desktop/keras-test/" && python keras-test.py

Ahora deberías ver información sobre el estado. A continuación, el script empezará a entrenar ConvNet, mostrando el progreso conforme vas pasando cada epoch. Una vez ejecutas el script, ConvNet está entrenado y disponible para la clasificación de los números escritos a mano.

Nota

Utiliza únicamente un editor de código o un editor de texto plano para guardar el código. No utilices bajo ningún concepto un software de procesamiento de texto como Word, OpenOffice o LibreOffice para esto.

# Guardar código en archivo “keras-test.py” en la carpeta “keras-test”
from __future__ import print_function
# Cargar Keras 
import keras
# Cargar sets de datos de entrenamiento y test MNIST
from keras.datasets import mnist
# Cargando modelo secuencial
from keras.models import Sequential
# Cargar capas de la red neuronal
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
# Número de diferentes características de datos: dígitos 0–9
num_classes = 10
# Números de pases por entrenar la red neuronal
epochs = 12
# Número de archivos usados durante un pase
batch_size = 128
# Dimensiones de las pantallas de entrada (28 x 28 píxeles por imagen)
img_rows, img_cols = 28, 28
# Cargar datos de entrenamiento y test
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
if K.image_data_format() == 'channels_first':
    train_images = train_images.reshape(train_images.shape[0], 1, img_rows, img_cols)
    test_images = test_images.reshape(test_images.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    train_images = train_images.reshape(train_images.shape[0], img_rows, img_cols, 1)
    test_images = test_images.reshape(test_images.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)
# Establecer tipo de dato de punto flotante 
train_images = train_images.astype('float32')
test_images = test_images.astype('float32')
# Normalizar datos de imagen
train_images /= 255
test_images /= 255
print('train_images shape:', train_images.shape)
print(train_images.shape[0], 'train samples')
print(test_images.shape[0], 'test samples')
# Convertir vectores de clase en matrices de clase binaria
train_labels = keras.utils.to_categorical(train_labels, num_classes)
test_labels = keras.utils.to_categorical(test_labels, num_classes)
# Crear modelo
model = Sequential()
# Añadir capas al modelo
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
# Recopilar capas
model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.Adadelta(),
              metrics=['accuracy'])
# Entrenar modelo
model.fit(train_images, train_labels,
          batch_size=batch_size,
          epochs=epochs,
          verbose=1,
          validation_data=(test_images, test_labels))
# Evaluar modelo
score = model.evaluate(test_images, test_labels, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
¿Le ha resultado útil este artículo?