Artificial Neural Nets con Keras Framework. Functional API

En artículos anteriores mostramos como programar de forma sencilla redes neuronales (MLP, CNN y RNN) basándose en el API secuencial de Keras sobre un backend Tensorflow. 

Sin embargo dicho API se queda corto a la hora de programar redes más complejas como Ensemble NN, Autoencoders, GAN o Reinforce Learning donde múltiples inputs/outputs y Neural Nets tienen que combinarse entre si para la consecución el objetivo de aprendizaje.

Recordemos que Keras es Keras es una API de redes neuronales de alto nivel, escrita en Python y capaz de funcionar sobre TensorFlow, CNTK o Theano. Fue desarrollado con el objetivo de permitir una rápida experimentación. 

Retomado el caso de experimentación anterior, que podreis encontrar en el artículo Artificial Neural Nets con Keras Framework compararemos la diferencia en la estructura del código utilizando el API Sequential y el Functional del framework para después ver su aplicación en el ensamblado de modelos neuronales.

Vamos a ver las diferencias de implementación de una red simple MLP en ambos modelos para analizar las diferencias.

Codificación de una Red MLP basado en el API secuencial.

model = Sequential()
model.add(Dense(best_model['conf'][0], input_shape=(input_dimension,)))
model.add(Activation('relu'))
model.add(Dropout(best_model['conf'][4]))
model.add(Dense(best_model['conf'][1]))
model.add(Activation('relu'))
model.add(Dropout(best_model['conf'][4]))
model.add(Dense(output_dimension))
model.add(Activation('softmax'))

Codificación de una Red MLP basado en el API Funcional.

input_1 = Input(shape=(input_dimension,))
x = input_1
x = Dense(best_model['conf'][0])(x)
x = Activation('relu')(x)
x = Dropout(best_model['conf'][4])(x)
x = Dense(best_model['conf'][1])(x)
x = Activation('relu')(x)
x = Dropout(best_model['conf'][4])(x)
output = Dense(output_dimension, activation = 'softmax' )(x)
model = Model([input_1], output)

Como podemos comprobar el modelo secuencial se comporta como un a lista a la que vamos añadiendo elementos, capas al modelo, que se ejecutarán de forma lineal, mientras que en el enfoque funcional actúan como una formulación matemática o programática  y = F(x).

Pero si ambos APIs obtienen al final el mismo resultado, ¿para que necesitamos el API funcional?

La respuesta la encontramos en los modelos complejos que no tienen solución en la implementación secuencial del Framework. 

Para ello vamos a utilizar el siguiente ejemplo.

¿Como implementaríamos la siguiente ANN sin el API Functional?

La respuesta es sencilla, no se puede, ya que contradice el principio de linealidad de la agregación en las listas.

Implementación de un Modelo Ensamblado con Functional API.

Los modelos ensamblados se basan en aprovechar la combinación de modelos sub-óptimos para conseguir modelos optimizados minimizando el consumo de recursos y maximizando la capacidad aprendizaje de cada modelo esperando que cada modelo aprenda sobre elementos no cubiertos del otro complementándose entre sí. 

Para ello lo primero que necesitamos es importar las clases que van a sustituir a Sequential Class.  

from keras.models import Model 

from keras.layers import Dense, Activation, Dropout, Input, Conv2D, MaxPooling2D, Flatten 

from keras.layers.merge import concatenate

Tras esto compondremos nuestro modelo tras generar las adaptaciones en los datos necesarias para compatibilizar los dataframes con las input de redes MPL y CNN. 

Esta información como el código ejecutable con todos los parámetros está disponible en github en formato .ipynb.

Primero crearemos el modelo MLP:

input_1 = Input(shape=(input_dimension,)) 

x = input_1 

x = Dense(best_model['conf'][0][0])(x) 

x = Activation('relu')(x) 

x = Dropout(best_model['conf'][4])(x) 

x = Dense(best_model['conf'][0][1])(x) 

x = Activation('relu')(x) 

x = Dropout(best_model['conf'][4]) (x)

Tras esto creamos el modelo CNN: 

input_2 = Input(shape=cinput_dimension) 

y = input_2 

y = Conv2D(filters = best_model['conf'][1][0], kernel_size = best_model['conf'][1][1],activation = 'relu', data_format = 'channels_last',padding='same')(y) 

y = MaxPooling2D(best_model['conf'][1][2])(y) 

y = Flatten()(y)y = Dense(cdense)(y) 

y = Activation('relu')(y)

Y finalmente concatenamos las salidas en un modelo único:

y = concatenate([x,y])                         

output = Dense(output_dimension, activation='softmax')(y) 

model = Model([input_1, input_2], output)

Una vez que tenemos esto solo nos faltaría seleccionar el optimizador y la función de perdida y ejecutar el entrenamiento del modelo. en nuestro caso utilizamos un optimizador Adam, crossentropy como función de pérdida y como medida de validación usaremos la "accuracy" o porcentaje de aciertos.

# loss function for one-hot vector
# use of adam optimizer
# accuracy is a good metric for classification tasks

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

# train the network

model_history = model.fit(x = [x_train, c_train], y = y_train, batch_size = best_model['conf'][2], epochs = best_model['bepoch'])

Finalmente comprobaremos los resultados obtenidos con los datos de entrenamiento y de test (no usados durante el entrenamiento del modelo) y comprobaremos su adecuación al problema.

print ('Train : Loss(%s) - Accuracy: (%s)' %(model_history.history['loss'][-1], model_history.history['acc'][-1]))

Train : Loss(0.48775133260613274) - Accuracy: (0.787648013750955)

print ('Train : Loss(%s) - Accuracy: (%s)' %(model_history.history['loss'][-1], model_history.history['acc'][-1]))

 Test : Loss(0.5097890445164271) - Accuracy: (0.8085714343615941)

Siguientes pasos

Una vez que ya conocemos el uso del API Funcional de Keras con Tensorflow lo que os queda es analizar cada una de los tipos de redes existente y decidir cuál es la necesaria para resolver cada problema concreto y lanzarse a disfrutar de la experimentación.

• Autoencoders: se usan para validar la adecuación de un conjunto de datos contra un patrón de comportamiento. Aplica a problemas de detección de anomalías en procesos, sensorización o fraude.
• Generative Adversarial Networks: Se basa en aprender a "falsificar" datos. Esto es, la generación de Fake Data. Si bien puede sonar raro, su aplicación es muy potente ya que permite generar conjuntos de datos validados para entornos de simulación para test de carga y stress de sistemas y aplicaciones tan conocidas como el coloreados de imágenes o el "DeepFake".
• Reinforce Deep Learning: Si bien está en sus estadíos iniciales las Redes DQNN permiten la resolución de problemas, principalmente en el espacio continuo, imposibles o muy complicados de modelar por sistemas de Q-Learning tradicionales.  

Como siempre, todo el código completo de los experimentos se pueden encontrar en github.

Artificial Neural Nets con Keras Framework

En el siguiente articulo mostraremos como programar de forma sencilla redes neuronales (MLP, CNN y RNN) basándose en el API secuencial de Keras sobre un backend Tensorflow.

Keras es una API de redes neuronales de alto nivel, escrita en Python y capaz de funcionar sobre TensorFlow, CNTK o Theano. Fue desarrollado con el objetivo de permitir una rápida experimentación.

Todo el código completo se puede encontrar en github - https://github.com/e2its/Neural-Nets-practica

Requisitos

• Python 3.6
• Jupyter notebooks
• Pandas 0.25
• numpy 1.16.4
• scikit-learn 0.21.2
• keras 2.2.4
• tensorflow 1.14

Descripción

Para los experimentos usaremos un conjunto de datos orientados al reconocimiento de la actividad. Estos se basan en la información aportada por 3 sensores de forma que podamos realizar un análisis de patrones (5 series temporales consecutivas en intervalos de 250 ms) para detectar la actividad física que se esta realizando (sitting, bending, cycling, lying, walking, standing) mediante tres tipos de redes neuronales MLP (Multi-Layer Perceptron), CNN (Convolutional Neural Nets) y RNN (Recurrent Neural Nets).

En cada archivo, cada fila corresponde a 5 mediciones (en orden temporal con una diferencial de 250 ms) conteniendo la siguiente información: 

Add caption

(0) avg_rss12, var_rss12, avg_rss13, var_rss13, avg_rss23, var_rss23

(+250ms) avg_rss12_1, var_rss12_1, avg_rss13_1, var_rss13_1, avg_rss23_1, var_rss23_1

(+500ms) avg_rss12_2, var_rss12_2, avg_rss13_2, var_rss13_2, avg_rss23_2, var_rss23_2

(+750ms) avg_rss12_3, var_rss12_3, avg_rss13_3, var_rss13_3, avg_rss23_3, var_rss23_3

(+1000ms) avg_rss12_4, var_rss12_4, avg_rss13_4, var_rss13_4, avg_rss23_4, var_rss23_4

donde avg y var son la media y los valores de varianza respectivamente.

La descripción y los datasets originales pueden ser encontrados en el siguiente enlace Activity Recognition system based on Multisensor data fusion (AReM) Data Set


Lo primero que tenemos que hacer es cargar los datasets de entrenamiento y test desde github.



Tras esto codificaremos los datos de actividad, nuestras Labels (ATYPE), como valores numéricos aptos para los modelos de Redes Neuronales.



Normalizamos los datos para que los modelos trabajen de forma más óptima con media a 0 y desviación estándar a 1.




Y finalmente convertimos nuestros datasets a arrays Numpy ('x_' para características e 'y_' para labels) :




En este punto ya estamos listos para operar con las distintas redes a través del API Secuencial de Keras.


Multilayer Perceptron (MLP)

Una red multilayer perceptron (MLP) es una clase de red neuronal artificial que consta de al menos tres capas de nodos: una capa de entrada, una capa oculta y una capa de salida.
A excepción de los nodos de entrada, cada nodo es una neurona que utiliza una función de activación no lineal. MLP utiliza una técnica de aprendizaje supervisado llamada backpropagation para el entrenamiento.

Para implementar una red MLP lo primero que tenemos que hacer es adaptar los arrays Numpy a las estructuras de datos que espera el modelo. En nuestro caso no hay que hacer ningún cambio ya que el modelo espera exactamente la estructura base definida anteriormente.

Para localizar el mejor modelo implementamos un análisis de varias configuraciones basadas en iteraciones sobre distintos valores de los parámetros clave del modelo.



Y ejecutamos los modelos.



Tras esto seleccionamos el mejor modelo



siendo la estructura de dicho modelo:



y los resultados obtenidos tras la re-ejecución del modelo:



Convolutional Neural Nets (CNN)

Una red neuronal convolucional es un tipo de red neuronal artificial donde las neuronas corresponden a campos receptivos de una manera muy similar a las neuronas en la corteza visual primaria (V1) de un cerebro biológico.Este tipo de red es una variación de un perceptron multicapa, sin embargo, debido a que su aplicación es realizada en matrices bidimensionales, son muy efectivas para tareas de visión artificial, como en la clasificación y segmentación de imágenes
Como redes de clasificación, al principio se encuentra la fase de extracción de características, compuesta de neuronas convolucionales y de reducción de muestreo. Al final de la red se encuentran neuronas de perceptron sencillas para realizar la clasificación final sobre las características extraídas. La fase de extracción de características se asemeja al proceso estimulante en las células de la corteza visual. Esta fase se compone de capas alternas de neuronas convolucionales y neuronas de reducción de muestreo.

Las redes convolucionales asemejan el proceso de reconocimiento visual cerebral, pero ¿es aplicable a nuestros experimento?. Para ello solo tenemos que transformar nuestro conjunto de datos en una estructura bidimensional con sentido, esto es, convertirla en una estructura similar a un array de imágenes. Esto lo conseguimos modificando la dimensionalidad de nuestro dataset de la siguiente forma.



consiguiendo una estructura de este tipo



Implementando la misma secuencia de pasos que para las redes MLP pero adaptados a una modelo de extracción de características (convolución) y reducción (pooling).





Seleccionamos el mejor modelo


siendo la estructura de dicho modelo




y los resultados obtenidos tras la re-ejecución del modelo:



Recurrent Neural Nets (RNN)

Red neuronal que integra bucles de realimentación, permitiendo a través de ellos que la información persista durante algunos pasos ó épocas de entrenamiento, (epochs) a través conexiones desde las salidas de las capas, que “incrustan” (embedding) sus resultados en los datos de entrada. Las conexiones entre nodos forman un gráfico dirigido a lo largo de una secuencia temporal. Funciona como una red con múltiples copias de sí misma, cada una con un mensaje a su sucesor. Cuanto más larga sea la secuencia temporal a analizar, mayor será el número de capas debe desenrollar, puede aparecer el problema de desvanecimiento del gradiente (Vanishin Gradient). Esto se soluciona incorporando capas de tipo LSTM o GRU que permiten el backpropagation through time conectando eventos que aparezcan muy alejados en los datos de entrada, sin que su peso se diluye entre las capas.

Al igual que ocurría con las redes neuronales convolucionales, para trabajar con las redes RNN, también tenemos que adaptar la estructura y dimensionalidad de los datos a la requerida para este tipo de modelos.






Implementando la misma secuencia de pasos que para las redes MLP pero adaptados a una modelo de recurrente basado en unidades LSTM.





Seleccionamos el mejor modelo

siendo la estructura de dicho modelo




y los resultados obtenidos tras la re-ejecución del modelo:

Como hemos presentado en este articulo, la implementación de Redes Neuronales con el API secuencial de Keras es tan sencilla como útil, sin embargo, esta limitada. En próximos artículos introduciremos nuevos tipos de redes Neuronales más complejas junto con el API funcional de Keras, de mayor versatilidad y potencia.

Todo el código completo de los experimentos se pueden encontrar en github.

DayF (Decisions at your Fingertips)

Modelado y Análisis de Flujos Dinámicos de Información. Necesidades y Demandas del Usuario.

El estado actual del arte y la proliferación de plataformas Data-Driven han generado una creciente necesidad de información para la toma de decisiones. Esto ha supuesto la aparición en escena de nuevos roles especializados necesarios para el proceso de predicción y simulación, como el Data Scientist pero, realmente ¿qué papel juega el Experto de Dominio?.

Sin duda este perfil es el más adecuado para realizar los modelados y la caracterización de los análisis pero, ¿es necesario adquirir las competencias de un científico de datos para que realice sus propios modelos?.  

Actualmente sí.

Aun cuando una organización pueda permitirse un departamento de Científicos de Datos el GAP existente entre la nueva necesidad, en un sistema dinámico Real Time, y el feedback asociado a dicha necesidad es inevitable.

Si, adicionalmente, le unimos un entorno cambiante y realimentado de forma dinámica, como pueden ser los sistemas de generación energética, los sistemas de abastecimiento, cadenas de producción en base a demanda o incluso la regulación automática de semáforos en base al tráfico, donde las decisiones automáticas tienen que ser fiables e incluir predicciones de comportamiento del sistema en los tramos y componentes vecinos, los sistemas de apoyo a la decisión son planteados como productos llave en mano, con unos costes de implantación, mantenimiento y evolución altos y recurrentes, o como características adicionales desarrolladas sobre productos de base, orientados a otras funciones, como los Scadas o los BI, soluciones que, por otro lado, nunca llegan a cubrir las expectativas.

Las cuestiones por tanto son:

•          ¿Es posible realizar un producto para la toma de decisiones predictiva y automática partiendo de una topología de red, una caracterización de los elementos, una algorítmica adecuada y existente y unas series históricas de datos?
•          ¿Es posible generar el producto de forma que sea user-friendly y con una curva de aprendizaje adecuada?
•          ¿Es posible abstraer al usuario de la complejidad matemática de los modelos y meta-modelos?
•          ¿Es posible modificar la topología, caracterización de los componentes o inclusión de nueva algorítmica y que el modelo simulado se reajuste automáticamente a su comportamiento óptimo en tiempo y forma?

Y una cuestión adicional: ¿es posible llevarlo a mercado en un modelo Open Source y sus variantes y tener acceso a la financiación necesaria para desarrollarlo?

Sin duda la siguiente evolución del Machine Learning y la cuarta revolución industrial tendrán que resolver estos aspectos.

En los próximos meses analizaremos esta problemática intentando dar solución, en forma de producto, a este comportamiento al que denominaremos data-flow-driven.

La iniciativa DayF (Decisions at your Fingertips) se pone en marcha.