Keras es una librería de Python que proporciona de manera limpia y sencilla la creación de una gama de modelos de Deep Learning encima de otras librerías TensorFlow, Theano o CNTK. Keras fue desarrollado y es mantenido por François Chollet, un ingeniero de Google, y su código ha sido liberado bajo la licencia permisiva del MIT.

Características básicas de Keras (*)

Desconozco si fue la intención de François Chollet, pero personalmente valoro la austeridad y simplicidad que presenta este modelo de programación, sin adornos y maximizando la legibilidad. Permite expresar redes neuronales de una manera muy modular, considerando un modelo como una secuencia o un solo grafo. Una buena aproximación, a mi entender, porque los componentes de un modelo de Deep Learning son elementos discretos que se pueden combinar de manera arbitraria. Los nuevos componentes son fácilmente agregables y modificables dentro del marco diseñado para que los ingenieros prueben y exploren nuevas ideas rápidamente. Por último, pero no menos importante, creo que es un gran acierto haberse decantado por usar el lenguaje de programación Python.

Definir el modelo

La estructura de datos principal en Keras es un modelo (model), que está pensada para facilitar la organización de capas, pues en realidad los modelos en Keras son básicamente una secuencia de capas. La clase keras.models.Sequential es una envoltura para el modelo de red neuronal:

    from keras.models import Sequential

    model = Sequential()

Como hemos dicho, los modelos en Keras se definen como una secuencia de capas. Hay capas fully connected, capas de max pool, capas de activación, etc. Se puede agregar fácilmente una capa al modelo mediante su función add( ): por ejemplo, un modelo simple podría ser de la siguiente manera:

 

    from keras.models import Sequential

    from keras.layers.core import Dense, Activation




    #Create the Sequential model

    model = Sequential()




    #1st Layer - Add an input layer of 32 nodes

    model.add(Dense, input_dim=32)




    #2nd Layer - Add a fully connected layer of 128 nodes

    model.add(Dense(units=128))




    #3rd Layer - Add a softmax activation layer

    model.add(Activation('softmax'))




    #4th Layer - Add a fully connected layer

    model.add(Dense(10))




    #5th Layer - Add a Sigmoid activation layer

    model.add(Activation('sigmoid'))

 

Keras deducirá automáticamente la forma de todas las capas después de la primera capa. Esto significa que el ingeniero solo tiene que establecer las dimensiones de entrada para la primera capa.

 

La primera capa desde arriba, model.add(Dense(input_dim=32)), establece la dimensión de entrada en 32, (lo que significa que los datos que entran tienen 32 dimensiones). La segunda capa toma la salida de la primera,y establece las dimensiones de salida en 128. Esto significa que la segunda capa tiene 128 nodos. Esta cadena que enlaza la salida de una capa con la siguiente se realiza capa a capa hasta la última, que es la salida del modelo. Podemos ver que en nuestro ejemplo la salida tiene dimensión 10.

Aprendizaje

Una vez que tengamos nuestro modelo construido y se vea bien, podemos configurar su proceso de aprendizaje con .compile( ). La compilación del modelo utiliza las eficaces librerías numéricas de que dispone el nivel inferior utilizado, sea TensorFlow, Theano o CNTK (backend). El backend selecciona automáticamente la mejor forma de representar la red para el entrenamiento, y hacer que las predicciones se ejecuten en el hardware.

Al compilar, debemos especificar algunas propiedades adicionales requeridas para entrenar la red, como la función de loss, para evaluar un conjunto de pesos, el optimizador utilizado para buscar en diferentes pesos de la red o cualquier métrica opcional que deseemos recopilar durante el entrenamiento. Por ejemplo:

model.compile(loss="categorical_crossentropy", optimizer="sgd", metrics = ['accuracy'])

En este ejemplo especificamos que la función de loss es categorical_crossentropy. También podemos especificar el optimizador; en este caso utilizaremos el stocastic gradient descent (sgd). Y finalmente, podemos especificar con qué métricas queremos evaluar el modelo. Aquí utilizaremos la precisión (accuracy) como una métrica.

Podemos comprobar nuestra arquitectura de modelo con el siguiente comando:

model.summary()

 

Entrenamiento

Ya hemos definido y compilado nuestro modelo y ya está listo para ser computado eficientemente. Ahora es el momento de ejecutarlo  con algunos datos. Podemos entrenar o ajustar el modelo con nuestros datos cargados llamando a la función .fit( ) del modelo.

El proceso de formación se ejecutará para un número fijo de iteraciones a través del conjunto de datos llamado epochs. Definiremos el número de instancias que se evaluarán antes de que se realice una actualización de pesos en la red con el argumento batch_size. Finalmente, podemos usar un parámetro opcional, parámetro verbose , para controlar la cantidad de información que queremos mostrar sobre la ejecución en la salida estándar.

model.fit(x_train, y_train, epochs=1000, batch_size=32)

 

Evaluar el modelo

En este punto ya hemos entrenado nuestra red neuronal y ahora podemos evaluar si eficiencia con la función .evaluate( ) utilizando el conjunto de datos apropiado:

loss_and_metrics = model.evaluate(x_test, y_test)

 

Generar predicciones

Con el fin de generar predicciones sobre nuevos datos, se puede utilizar la función .predict( ):

classes = model.predict(x_test, batch_size=128)

 

Hasta aquí hemos visto de manera muy rápida un ejemplo de cómo se puede crear un  modelo de red neural en Keras. Por lo tanto, ahora estamos listos para poder coger el teclado y poner en práctica nuestros conocimientos: ¿tse apunta?

Instalación de Keras

Keras es una API ligera y en lugar de ofrecer una implementación de las operaciones matemáticas necesarias para el Deep learning, proporciona una interfaz coherente a las librerías numéricas eficientes, como son TensorFlow, Theano o CNTK. Keras es relativamente sencillo de instalar si ya se tiene un entorno Python y SciPy en funcionamiento en la plataforma. También se debe tener una instalación de TensorFlow (Theano o CNTK) donde vamos a instalar la API.

Puede seguir los siguientes pasos para instalar Keras en su ordenador usando TensorFlow como backend:

1- Para instalar Tensorflow en su ordenador portátil, siga las instrucciones de instalación de www.tensorflow.org/install/. Recomiendo la instalación con virtualenv.

2- Puede verificar su instalación de TensorFlow con los siguientes comandos (asumiendo que su directorio virtualenv  es ~/tensorflow ):

$ source ~/tensorflow/bin/activate

$ python

import tensorflow as tf

hello = tf.constant('Hello, TensorFlow!')

sess = tf.Session()

print(sess.run(hello))

Si la salida de esta ejecución es la siguiente línea,

 Hello, TensorFlow!

ya está preparado para instalar Keras.

3- Keras puede ser instalado de manera muy sencilla usando PyPI, de la siguiente manera: (**)

$ source ~/tensorflow/bin/activate

$ pip install keras

4- Puede validar su instalación comprobando su versión de Keras utilizando la siguiente secuencia de comandos:

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

que le debería imprimir algo equivalente a:

Using TensorFlow backend.

2.0.5

(En el momento de escribir este artículo, la versión más reciente de Keras es la 2.0.5.).

Para obtener más opciones de instalación, puede ver la página oficial de instalación de Keras en https://keras.io.

(**)En caso de utilizar Tensorflow 1.1 o superior como backend, Keras se encuentra incluido en Tensorflow en los paquetes contrib. En este caso, puede acceder a Keras con la siguiente instrucción:

import tensorflow.contrib.keras as keras

 

Programación de un Perceptron de múltiples capas

Para demostrar lo fácil que resulta programar en Keras, vamos a construir un simple Perceptron de varias capas (Multi-Layer Perceptron) en unas pocas líneas de código basado en el proporcionado por François Chollet en su Github.

Este ejemplo entrena una red neuronal Deep learning simple sobre el conjunto de datos MNIST. Este conjunto está compuesto por imágenes en blanco y negro que contienen dígitos escritos a mano, con más de 60.000 ejemplos para entrenar el modelo, y 10.000 para probarlo. Las imágenes en blanco y negro (bilevel) se han normalizado en imágenes de 20 × 20 píxeles, preservando la relación de aspecto. Después de eso, las imágenes se centran en cuadros de 28 × 28 (784) píxeles, calculando el centro de masa y moviéndolo hacia el centro del marco.

La idea general de este ejemplo es que primero se cargarás los datos, luego se definirá la red y finalmente se entrenará dicha red.

import keras

from keras.datasets import mnist

from keras.models import Sequential

from keras.layers import Dense, Dropout

from keras.optimizers import adam, sgd




batch_size = 128

num_classes = 10

# epochs = 20

epochs = 5

print('epochs:', epochs)




# the data, shuffled and split between train and test sets

(x_train, y_train), (x_test, y_test) = mnist.load_data()




x_train = x_train.reshape(60000, 784)

x_test = x_test.reshape(10000, 784)

x_train = x_train.astype('float32')

x_test = x_test.astype('float32')

x_train /= 255

x_test /= 255

print(x_train.shape[0], 'train samples')

print(x_test.shape[0], 'test samples')




# convert class vectors to binary class matrices

y_train = keras.utils.to_categorical(y_train, num_classes)

y_test = keras.utils.to_categorical(y_test, num_classes)




model = Sequential()

model.add(Dense(512, activation='relu', input_shape=(784,)))

model.add(Dropout(0.2))

# model.add(Dense(512, activation='relu'))

# model.add(Dropout(0.2))

model.add(Dense(10, activation='softmax'))




model.summary()




model.compile(loss='categorical_crossentropy',

#             optimizer='adam',

              optimizer='sgd',

              metrics=['accuracy'])




history = model.fit(x_train, y_train,

                    batch_size=batch_size,

                    epochs=epochs,

#                   verbose=1,

                    verbose=0,

                    validation_data=(x_test, y_test))




score = model.evaluate(x_test, y_test, verbose=0)

print('Test loss:', score[0])

print('Test accuracy:', score[1])

Running the above program you will see:

$ python mnist_mlp.py

Using TensorFlow backend.

60000 train samples

10000 test samples

______________________________________________________________

Layer (type)                 Output Shape              Param #  

==============================================================

dense_1 (Dense)              (None, 512)               262656   

______________________________________________________________

dropout_1 (Dropout)          (None, 512)               0        

______________________________________________________________

dense_2 (Dense)              (None, 512)               262656   

______________________________________________________________

dropout_2 (Dropout)          (None, 512)               0        

______________________________________________________________

dense_3 (Dense)              (None, 10)                5130     

==============================================================

Total params: 407,050

Trainable params: 407,050

Non-trainable params: 0

______________________________________________________________

Test loss: 0.317686294222

Test accuracy: 0.9121

Este código se encuentra disponible en mi GitHub .

Si se desea mejorar los resultados se puede cambiar, por ejemplo, el optimizador sgd por adam y obtener una accucary de 0,979; también es posible aumentar el número de epochs a 20, obteniendo un valor de 0.9842. Incluso puede agregar dos capas simplemente descomentar en el código proporcionado las líneas correspondientes a las capas de ReLu y Dropout, y obtener una precisión de 0.9849. Sin embargo, en este caso las ganancias en accuracy son escasas y el número de parámetros del modelo aumenta enormemente (de 407.050 pasa a 669.706); esto implica aumentar en gran medida el tiempo de ejecución del proceso de aprendizaje.

 

Pero, en cualquier caso, me gustaría destacar con qué facilidad un ingeniero puede probar sus ideas para encontrar el mejor modelo. Suponiendo, claro está, que dicho ingeniero tiene suficientes recursos informáticos para entrenar sus modelos, que en realidad ¡este sí que es un problema!

Para acabar

Bastante fácil, ¿verdad?

Para un tutorial más detallado sobre Keras, puede consultar:

En la carpeta de ejemplos del repositorio de Keras en Github, puede encontrar varios modelos avanzados: question-answering with memory networks, text generation with stacked LSTMs, etc.

Y ahí tiene, has entrenado tu primera red neuronal usando Keras para analizar el conjunto de datos MNIST. Sin embargo, aún necesitas aprender muchas técnicas disponibles para mejorar el proceso de entrenamiento dependiendo de los caso. Lo intentaré ir haciendo en el futuro a través de este blog.

(*) En este post estoy asumiendo que el lector tiene algunos conocimientos básicos de los conceptos de redes neuronales, como la función de activación o gradient descent. De lo contrario, recomiendo comenzar a leer los capítulos introductorios del libro “Hello World en TensorFlow”.

 

2017-08-17T16:32:00+00:00 June 20th, 2017|