Curso de Keras: Configurar Keras

Keras es un interfaz de programación de aplicaciones de alto nivel, o API, que se ejecuta sobre un back-end de bajo nivel para crear redes neuronales profundas. Podemos utilizar TensorFlow, Microsoft Cognitive Tool Kit o Theano para el back-end. Keras está escrito e interactúa con Python. Suponiendo que tengamos un entorno Python configurado, y que Microsoft Cognitive Toolkit esté instalado, ahora estamos listos para instalar Keras. Abrimos el editor de comandos de Anaconda y escribimos el comando: pip install keras

Al ejecutar el comando se descargan y se extraen los paquetes, una vez instalado Keras, necesitamos modificar la configuración para utilizar el back-end CNTK. Para ello vamos a  modificar el archivo JSON, llamado keras.json que se encuentra en el perfil de usuario /.keras.  (C:\ Users\Admin\ Keras.json)  y modificamos la entrada backend, donde ponemos “cntk”,. 

Una vez hecho esto, estamos listos para iniciar nuestro entorno Python. Volveremos al editor de comandos de Anaconda y ponemos:

Set  KERAS_BACKEND = cntk

Luego teclamos en el editor Python. Y finalmente tecleamos import keras. 

Hay que tener en cuenta las mayúsculas y  minúsculas.

Keras trabaja el concepto de modelo. El tipo más simple de modelo (red neuronal) es una secuencia de  pilas de capas. Creamos una secuencia con capas agregadas en orden al cálculo a realizar. Una vez definido el modelo, se compila. Y utilizamos un marco para optimizar el cálculo que realizará que permite que se especifiquen ciertas configuraciones, como el optimizador y las funciones de pérdida. Y después de compilarlo, el modelo debe ajustarse a los datos. Esto se conoce como entrenamiento de la máquina. finalmente, cuando se termina el entrenamiento, el modelo puede usarse para hacer predicciones sobre nuevos datos.

Tipos de modelos (redes neuronales) en Keras

Keras contiene  dos tipos de modelos: secuenciales y funcionales.

El secuencial, permite crear modelos por capas de forma lineal. Pero estos no permiten compartir capas o tener múltiples entradas o salidas. Por otra parte un modelo funcional puede crear modelos que tienen más flexibilidad. Permiten modelos donde las capas se conectan a más que solo las capas en contacto directo con ellas, e incluso permiten tratar un modelo ya entrenado como una capa. Esto permite redes complejas con múltiples entradas y salidas. 

Entrenar un modelo requiere, como mínimo, dos argumentos.

El primero es el optimizador, se utiliza el conocimiento obtenido de la función de pérdida para cambiar los pesos de los modelos, en un esfuerzo por dirigir el cálculo de la manera más eficiente posible. 

El otro argumento es la función de pérdida. Esta es la medida de lo bueno que es el modelo para predecir el resultado esperado. Es una métrica. Un uno de salida representa el éxito y un cero representa el fracaso. La salida puede ser cualquier valor entre 0 y 1. 

Abrimos el editor de comandos de anaconda y tecleamos: Python y luego importamos numpy tecleando: import numpy as np

Esta acción importa algunos paquetes de keras, como keras.models, o keras.layers

A continuación creamos algunos datos aleatorios con algunas variables. xtraining, ytraining, xtesting, ytesting y otras llamadas var1, 2 y 3 y les asignamos algunos valores aleatorios.

Luego creamos algunos índices, y los dividimos entre prueba y entrenamiento, y asignamos estas funciones a dat_train y dat_test. El objetivo principal de esto es tener algunas variables completamente rellenas con algunos datos aleatorios que podremos utilizar en nuestro modelo.

Antes de empezar, si estamos trabajando con colaboratory, actualizamos la versión de tensorflow.

%tensorflow_version 2.x

Ahora ya podemos ejecutar las instrucciones para crear nuestra red neuronal.

import numpy as np

from keras.layers import Dense, Dropout

import matplotlib.pyplot as plt

from keras.models import Input, Model

from keras.models import Sequential

# Generamos los datos aleatorios

xtraining = np.random.random((2000,5))

ytraining = np.random.randint(2, size=(2000,1))

xtesting = np.random.random((2000,5))

ytesting = np.random.randint(2, size=(2000,1))

var1 = np.random.randn(1550)

var2 = np.random.randn(1550)

var3 = np.random.randn(1550)

y_class =np.array([1 if (var1[i] + var2[i] + (var3[i])/3 + np.random.rand(1) > 1) else 0 for i in range(1550)])

y_con = var1 + var2 + var3/3 + np.random.randn(1550)

dat = np.array([var1, var2, var3]).transpose()

#generamos índices para testear y entrenar

in_list = np.linspace(0,999,num=1550)

in_test = np.random.choice(1550, size = 200, replace = False)

in_train = np.delete(in_list, in_test).astype('int')

#parte los datos entre entrenamiento y prueba

dat_train = dat[in_train,:]

dat_test = dat[in_test,:]

y_class_train = y_class[in_train]

y_class_test = y_class[in_test]

y_con_train = y_con[in_train]

y_con_test = y_con[in_test]

Para ver qué hay en estas variables, escribimos print <xtraining>.

Una vez generamos los datos tecleamos.

model = Sequential()

model.add(Dense(64, input_dim=5, activation='relu'))

model.add(Dense(64, activation='relu'))

model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy', optimizer='rmsprop',

metrics=['accuracy'])

model.fit(xtraining, ytraining, epochs=20, batch_size = 128)

Estas líneas configuran el tipo en secuencial y agregan tres capas. La primera capa no comprende el número de entradas, por lo que requiere las dimensiones o la forma de entrada. En este caso, es 5 para la forma dimensional, la siguiente capa espera 64 entradas, y la tercera capa, 1 entrada.  Finalmente en la penúltima línea compilamos el modelo, el tipo de pérdida es binary_crossentropy, el optimizador utilizado es rmsprop y la métrica definida es la precisión del modelo. 

La última línea proporciona las funciones de ajuste. Seguimos adelante y ejecutamos estos comandos. 

Las épocas son el número de veces que los datos se leen y analizan en su totalidad. El tamaño del lote es el número de muestras por gradiente. Cuanto mayor sea el conjunto de datos, más tiempo llevará su entrenamiento y por supuesto, cuantas más épocas se especifiquen, llevará aún más tiempo. 

La salida muestra la cantidad de puntos de datos leídos en cada época. Entonces, en este caso, nuevamente estamos haciendo 2000. A la derecha de la barra de progreso se muestra el tiempo necesario para procesar cada época en segundos y microsegundos.  La cantidad de pérdida, y la precisión del análisis.

Definimos el score

score = model.evaluate(xtesting, ytesting, batch_size= 128)

Y una vez entrenado el modelo tecleamos print(score), esto nos muestra dos números, el primero es la pérdida encontrada  y el segundo, la precisión de la predicción. 

En nuestro caso, los datos tienen una gran pérdida 0.69 → 69%  y una precisión media, 0.49 → 49%  Esto es porque son números al azar. En un análisis real con más datos en una regresión lineal propuesta, se podría esperar que los datos tengan menos pérdida y, por supuesto, mayor precisión. Así que ahora echaremos un vistazo a un modelo funcional. Para el siguiente ejemplo, tenemos un conjunto de datos creado. Incluye tres predictores y dos variables de respuesta que se generarán aleatoriamente. 

Tecleamos:

plt.scatter (dat [:, 0], dat [:, 1], c = y_class)

plt.show ()

Lo que nos muestra la matriz del clasificador. Esto es un diagrama de dispersión

Cerramos esto y hacemos otro. 

plt.scatter (dat [:, 0], dat [:, 1], c = y_con)

plt.show ()

Ahora estamos utilizando una variable continua. 

A continuación agregamos tres capas.

n_layers = 3

inputs = Input(shape=(3,))

x = Dense (200, activation = 'relu') (inputs)

for layer in range (n_layers-1):

  x = Dense (200, activation = 'relu') (x)

output = Dense(1, activation= 'sigmoid')(x)

Tenemos una variable de entrada y una salida especificada. 

A continuación vamos a crear una red neuronal profunda. 

Dnn= Model (inputs, output)

Lo que hacemos aquí es compilar el modelo usando el optimizador sgd, nuevamente con un tipo de pérdida de binary_crossentropy, y definiendo la precisión como métrica. El último paso es ajustar el modelo, para ello hacemos: 

Dnn.fit(dat_train, y_class_train, epochs = 20, verbose =1, validation_data=(dat_test, y_class_test))

En este caso, la pérdida es menor y la precisión mayor que en el ejemplo puesto al principio. Los datos se validan simultáneamente con los datos de prueba y la salida muestra resultados similares, lo que nos indica que el modelo es válido.  Utilizamos un modelo secuencial para el análisis básico y un modelo de función, si necesitamos una mayor complejidad.