Keras es una bi­blio­te­ca de código abierto para crear apli­ca­cio­nes de apre­n­di­za­je profundo. Keras está escrita en Python y ofrece una interfaz uniforme para varios backends de apre­n­di­za­je profundo, como Te­n­so­r­Flow y Theano. El apre­n­di­za­je profundo, o deep learning, es una rama del apre­n­di­za­je au­to­má­ti­co y se basa en redes neu­ro­na­les ar­ti­fi­cia­les.

El propósito de Keras es hacer que el deep learning nos resulte menos abrumador. En este tutorial de Keras, ex­plo­ra­re­mos las di­fe­re­n­tes funciones de Keras uti­li­za­n­do un simple ejemplo.

Backup cloud por Acronis
Protege tu in­frae­s­tru­c­tu­ra y reduce el tiempo de inac­ti­vi­dad
  • Copias de seguridad au­to­má­ti­cas y fácil re­cu­pe­ra­ción
  • Gestión y pla­ni­fi­ca­ción intuitiva
  • Pro­te­c­ción contra las amenazas basadas en IA
  • Incluye crédito inicial de $5250 el primer mes

Cómo preparar tu sistema para utilizar Keras

La mejor manera de preparar tu sistema para utilizar Keras es in­s­ta­la­n­do el paquete de software Anaconda. Anaconda es una pla­ta­fo­r­ma libre que se utiliza en la ciencia de datos. Incluye he­rra­mie­n­tas y bi­blio­te­cas útiles y viene con una in­s­ta­la­ción de Python3 como estándar.

Cómo instalar Anaconda y Python

A co­n­ti­nua­ción, te ex­pli­ca­mos e incluimos el código previsto para usuarios de macOS. En principio, el código también debería servir para otros sistemas ope­ra­ti­vos. No obstante, quizás debas realizar algunos ajustes, sobre todo si eres usuario de Windows.

Si estás aco­s­tu­m­bra­do 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 uti­li­zar­lo 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 de­s­ca­r­gar­te el paquete de in­s­ta­la­ción adecuado para tu sistema desde la siguiente página: Anaconda – In­di­vi­dual Edition.

Prueba de in­s­ta­la­ción de Anaconda y Python

Para ase­gu­rar­te de haber instalado co­rre­c­ta­me­n­te Anaconda y Python, ejecuta los si­guie­n­tes 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 in­té­r­pre­te de Python

python --version

Si al escribir recibes el mensaje de error “Comando no en­co­n­tra­do”, quizá necesites es­ta­ble­cer la ruta a los binarios de Anaconda. Para hacerlo, sigue leyendo. Si la prueba ha fu­n­cio­na­do, puedes pasar a la siguiente sección.

Es­ta­ble­cer la ruta a binarios de Anaconda

La variable de entorno PATH contiene in­fo­r­ma­ción sobre en qué parte del sistema de archivos se en­cue­n­tran ciertos programas de utilidad. Las rutas in­di­vi­dua­les dentro de la variable de entorno se separan con una coma. Puedes incluir más rutas, tal y como te mostramos a co­n­ti­nua­ción para Anaconda en la versión 3:

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

Para ase­gu­rar­te de que la ruta está activa, tienes que almacenar esta línea de código en el sistema. De­pe­n­die­n­do 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 ilu­s­tra­mos 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 in­s­ta­la­ció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 co­n­ti­nua­ción, repite la prueba:

Mostrar versión del ad­mi­ni­s­tra­dor de paquetes Conda

conda –version

Mostrar versión del in­té­r­pre­te de Python

python --version

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

Ac­tua­li­zar las in­s­ta­la­cio­nes de Anaconda y Python a la última versión

Antes de iniciar un nuevo proyecto, es mejor ac­tua­li­zar las bi­blio­te­cas su­b­ya­ce­n­tes. La pla­ta­fo­r­ma Anaconda viene con el ad­mi­ni­s­tra­dor de paquetes Conda. Utiliza los si­guie­n­tes comandos de Conda para apro­ve­char las ac­tua­li­za­cio­nes di­s­po­ni­bles.

Instalar ac­tua­li­za­cio­nes para el gestor de paquetes Conda

conda update conda

Instalar ac­tua­li­za­cio­nes de Anaconda

conda update anaconda

Comprobar el número de la versión de los paquetes in­s­ta­la­dos

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 uti­li­za­dos.

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 si­guie­n­tes líneas de código en la línea de comandos:

Instalar Te­n­so­r­Flow

pip install tensorflow

Instalar Keras

pip install keras

Igual que antes, es co­n­ve­nie­n­te 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 in­s­ta­la­s­te Keras, no es mala idea buscar ac­tua­li­za­cio­nes di­s­po­ni­bles e in­s­ta­lar­las 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. Exa­mi­ne­mos en concreto el ejemplo “mnist_cnn.py”. En este caso, el código crea una red neuronal co­n­vo­lu­cio­nal (también conocida como CNN o ConvNet) y la entrena con un set de datos de en­tre­na­mie­n­to.

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 re­co­no­ci­mie­n­to de patrones y Keras lo pro­po­r­cio­na.

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

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 co­n­ti­nua­ción, en­tre­na­re­mos la red neuronal para que asigne co­rre­c­ta­me­n­te los números escritos a mano. El en­tre­na­mie­n­to de la red es co­mpu­tacio­na­l­me­n­te de­ma­n­da­n­te así que no te so­r­pre­n­das si tu ordenador deje de funcionar co­rre­c­ta­me­n­te; es normal. Si estás usando un di­s­po­si­ti­vo móvil, asegúrate de que tiene su­fi­cie­n­te batería o conecta el di­s­po­si­ti­vo a una fuente de ali­me­n­ta­ción.

Primero crearemos una carpeta de prueba en el es­cri­to­rio, pasaremos a esa carpeta y mo­n­ta­re­mos ahí un script de Python vacío. Usa las si­guie­n­tes líneas de código. Cópialas y eje­cú­ta­las en la línea de comandos:

Para crear una carpeta “keras-test” en el es­cri­to­rio

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 en­co­n­tra­rá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 es­cri­to­rio dentro del archivo “keras-test.py”. Por último, para ejecutar el script de ejemplo de Keras con el in­té­r­pre­te de Python, introduce las líneas de código si­guie­n­tes en la línea de comandos:

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

Ahora deberías ver in­fo­r­ma­ción sobre el estado. A co­n­ti­nua­ción, el script empezará a entrenar ConvNet, mostrando el progreso conforme vas pasando cada epoch. Una vez ejecutas el script, ConvNet está entrenado y di­s­po­ni­ble para la cla­si­fi­ca­ción de los números escritos a mano.

Nota

Utiliza úni­ca­me­n­te 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 pro­ce­sa­mie­n­to de texto como Word, Ope­nO­f­fi­ce o Li­breO­f­fi­ce 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])
Ir al menú principal