Deep Learning para datos tabulares con el lenguaje R y Keras

Materiales sobre esta primera unidad del curso.

Sesión práctica de programación en R sobre Asignaciones con R.

Sesión práctica de programación en R sobre Estructura de datos.

Sesión práctica de programación en R sobre Estructuras de Control.

Sesión práctica de programación en R sobre Uso de Funciones.

Sesión práctica de programación en R sobre Paquetes.

Sesión práctica de programación en R sobre Conjunto de datos Estándar.

Sesión práctica de programación en R sobre Conjunto de Datos mlbench.

Sección que dispondrá de una serie de recursos y enlaces interesantes para poder complementar eficazmente la formación del curso.

Material tipo presentación de esta sección

Clase con conceptos teóricos - Parte 1

Clase con conceptos teóricos - Parte 2

Clase con conceptos teóricos - Parte 3

En esta sesión veremos como instalar Anaconda y Jupyter Notebook como alternativa a RStudio

Clase sobre como se utiliza Jupyter Notebook con el lenguaje de programación R

Sección que dispondrá de una serie de recursos y enlaces interesantes para poder complementar eficazmente la formación del curso.

Materiales que se utilizarán en esta sección de aprendizaje.

Abstracción básica de la Unidad fundamental - La neurona

Desempeño gráfico de cómo trabaja una neurona

Explicación de una red neuronal artificial

Cómo opera el MLP

Qué es y cómo opera Backpropagation

Simulación de una arquitectura de red neuronal

Sección que dispondrá de una serie de recursos y enlaces interesantes para poder complementar eficazmente la formación del curso.

La API secuencial de Keras es fácil de entender e implementar. Nos permite crear una red neuronal de forma lineal; es decir, podemos construir una red neuronal capa por capa donde inicializamos un modelo secuencial y luego apilamos una serie de capas ocultas y de salida en él. En sí, estudiaremos:

• Como desarrollar un MLP en R con Keras

Ahora vamos a desarrollar con keras nuestro primera red neuronal. Seguidamente vamos a crear unos datos sintéticos para poder desarrollar nuestra red neuronal

Se realizan los siguientes pasos:

1. Inicializamos un modelo secuencial llamando a la función keras_model_sequential().

2. Apilamos capas ocultas y de salida mediante el uso de una serie de funciones de capa. La función layer_dense() agrega una capa densamente conectada al modelo definido.

   • La primera capa del modelo secuencial necesita saber qué forma de entrada debe esperar, por lo que pasamos un valor al argumento input_shape de la primera capa.

     • En nuestro caso, la forma de entrada era igual a la cantidad de características en el conjunto de datos.

     • Cuando agregamos capas al modelo secuencial de keras, el objeto del modelo se modifica en el lugar y no es necesario volver a asignar el objeto actualizado al original.

3. Para nuestro modelo, usamos la función de activación ReLU.

   • La función layer_activation() crea una capa de activación que toma la entrada de la capa oculta anterior y aplica la activación a la salida de nuestra capa oculta anterior.

   • También podemos usar diferentes funciones, como ReLU con fugas, Softmax y más (las funciones de activación se discutirán en Implementación de una receta de red neuronal de una sola capa).

4. En la capa de salida de nuestro modelo, no se aplicó ninguna activación.

   • También podemos implementar varias funciones de activación para cada capa pasando un valor al argumento de activation en la función layer_dense() en lugar de agregar una capa de activación explícitamente.

5. Para entrenar un modelo, necesitamos configurar el proceso de aprendizaje. Hicimos esto usando la función compile()

6. En nuestro proceso de entrenamiento, aplicamos un optimizador de descenso de gradiente estocástico para encontrar los pesos y sesgos que minimizan nuestra función de pérdida objetiva; es decir, el error cuadrático medio.

7. El argumento de métricas calcula la métrica que el modelo evaluará durante train/test.

8. Miramos el resumen del modelo; nos muestra información sobre cada capa, como la forma de la salida de cada capa y los parámetros de cada capa.

9. En el último paso, entrenamos nuestro modelo para un número fijo de iteraciones en el conjunto de datos.

   • Aquí, el argumento epochs define el número de iteraciones.

   • El argumento validation_split puede tomar valores flotantes entre 0 y 1. Especifica una fracción de los datos de entrenamiento que se utilizarán como datos de validación.

   • Finalmente, batch_size define el número de muestras que se propagan a través de la red.

En este tutorial vamos a utilizar el conjunto de datos Pima Indians Diabetes. Describe los datos de los registros médicos de los pacientes y si tuvieron una aparición de diabetes dentro de los cinco años. Es un problema de clasificación binaria (aparición de diabetes como 1 o no como 0). Las variables de entrada que describen a cada paciente son numéricas y tienen escalas variables. A continuación, se enumeran los ocho atributos del conjunto de datos:

• Número de embarazos.

• Concentración de glucosa en plasma a 2 horas en una prueba de tolerancia a la glucosa oral.

• Presión arterial diastólica (mm Hg).

• Espesor del pliegue cutáneo del tríceps (mm).

• Insulina sérica de 2 horas (mu U/ml).

• Índice de masa corporal.

• Función del pedigrí de la diabetes.

• Años de edad.

• Clase, aparición de diabetes en cinco años.

Dado que todos los atributos son numéricos, es fácil de usar directamente con redes neuronales que esperan entradas y valores de salida numéricos, y es ideal para nuestra primera red neuronal en Keras.

Los modelos en Keras se definen como una secuencia de capas. Creamos un modelo Secuencial y agregamos capas de una en una hasta que estemos satisfechos con nuestra topología de red.

Lo primero que debe hacer bien es asegurarse de que la capa de entrada tenga el número correcto de entradas. Esto se puede especificar al crear la primera capa con el argumento input_shape y establecerlo en 8 para las 8 variables de entrada.

¿Cómo sabemos la cantidad de capas que debemos usar y sus tipos?

• Ésta es una pregunta muy difícil. Hay heurísticas que podemos usar y, a menudo, la mejor estructura de red se encuentra a través de un proceso de experimentación de prueba y error. Por lo general, necesita una red lo suficientemente grande para capturar la estructura del problema. En este ejemplo usaremos una estructura de red completamente conectada con tres capas.

En sí el procedimiento a utilizar será:

1. Creamos un modelo secuencial con la clase keras_model_sequential().

2. Las capas completamente conectadas se definen mediante la clase layer_dense(). Se puede especificar:

   • El número de neuronas en la capa como primer argumento units.

   • Especificar la función de activación usando el parámetro activation.

   • El tercer argumento es input_shape que indica el número de variables en la capa de entrada.

3. Usaremos la función de activación del rectificador (ReLU), activation = relu, en las dos primeras capas. Solía ser el caso que las funciones de activación Sigmoid y TANH eran preferidas para todas las capas pero ReLU obtiene mejores resultados.

4. Usamos una función de activación sigmoidea, activation = sigmoid, en la capa de salida para garantizar que la salida de nuestra red esté entre 0 y 1 y sea fácil de asignar a una probabilidad de clase 1 o ajustar a una clasificación estricta de cualquier clase con un umbral predeterminado de 0,5.

Podemos juntarlo todo agregando cada capa:

• La primera capa oculta tiene 12 neuronas y espera 8 variables de entrada (por ejemplo, input_shape = 8).

• La segunda capa oculta tiene 8 neuronas y finalmente la capa de salida tiene 1 neurona para predecir la clase (aparición de diabetes o no).

Hemos entrenado nuestra red neuronal en todo el conjunto de datos y podemos evaluar el rendimiento de la red en el mismo conjunto de datos. Esto solo nos dará una idea de qué tan bien hemos modelado el conjunto de datos (por ejemplo, Accuracy en el entrenamiento), pero no tenemos idea de qué tan bien podría funcionar el algoritmo con los datos nuevos. Hemos hecho esto por simplicidad, pero idealmente, podría separar sus datos en conjuntos de datos en entrenamiento/validación.

Puedes evaluar tu modelo en tu conjunto de datos de entrenamiento usando la función evaluate() en tu modelo y pasarle la misma entrada y salida que usaste para entrenar el modelo. Esto generará una predicción para cada par de entrada y salida y recopilará puntuaciones, incluida la pérdida promedio y cualquier métrica que haya configurado, como la Accuracy.

Keras puede separar una parte de sus datos de entrenamiento/validación y evaluar el rendimiento del modelo en cada época. Puede hacer esto configurando el argumento validation_split en la función fit() en un porcentaje del tamaño de su conjunto de datos de entrenamiento.

• Por ejemplo, un valor razonable podría ser 0,2 o 0,33 para el 20% o el 33% de sus datos de entrenamiento para validación.

Al ejecutar el ejemplo, puede ver que la salida detallada en cada época muestra la pérdida y Accuracy tanto en el conjunto de datos de entrenamiento como en el conjunto de datos de validación.

Keras también le permite especificar manualmente el conjunto de datos que se utilizará para la validación durante el entrenamiento. En este ejemplo usamos la práctica clase createDataPartition() de la biblioteca de aprendizaje automático caret de R para separar nuestros datos en entrenamiento/validación.

El estándar para la evaluación de modelos de aprendizaje automático es la validación cruzada de k-fold. Proporciona una estimación sólida del rendimiento de un modelo sobre datos no etiquetados.

La validación cruzada a menudo no se usa para evaluar modelos de aprendizaje profundo debido al mayor gasto computacional. Por ejemplo, la validación cruzada de k-fold se usa a menudo con 5 o 10 fold. Como tal, se deben construir y evaluar 5 o 10 modelos, lo que aumenta considerablemente el tiempo de evaluación de un modelo. Sin embargo, cuando el problema es lo suficientemente pequeño o si tiene suficientes recursos informáticos, la validación cruzada puede brindarle una estimación menos sesgada del rendimiento de su modelo.

En el siguiente ejemplo, vamos a ver como podemos realizar una validación cruzada. Uno de los problemas principales que tenemos es que en R no tenemos como en Scikit-learn de Python una clase para poder realizarlo; así, nos toca tener que realizar una validación cruzada manual con una estructura de repetición.

El ejemplo crea y evalúa 10 modelos utilizando las 10 divisiones de los datos y recopila todas las puntuaciones. La salida detallada para cada época se desactiva pasando verbose = 0 a las funciones fit() y evaluate() en el modelo. La desviación promedio y estándar del rendimiento del modelo se imprime al final de la ejecución para proporcionar una estimación del Accuracy del modelo.

Una buena práctica es poder realizar nuestro modelo en una función para poder tener ordenado elcódigo correctamente. En este ejemplo vamos a ver como poder crear un modelo en una función y tenerlo disponible en cualquier momento que lo necesitemos.

Vemos que esto es muy importante, por ejemplo si lo comparamos con la unidad anterior podemos tener esta función de manera que en cada fold se llame a la función.

El paquete tfruns proporciona un conjunto de herramientas para rastrear, visualizar y administrar ejecuciones de entrenamiento y experimentos de TensorFlow desde R. Entre estas podemos observar:

• Realicar un seguimiento de los hiperparámetros, las métricas, la salida y el código fuente de cada ejecución de entrenamiento.

• Comparar hiperparmaeters y métricas entre ejecuciones para encontrar el modelo de mejor rendimiento.

• Generar informes automáticamente para visualizar ejecuciones de entrenamiento individuales o comparaciones entre ejecuciones.

• No se requieren cambios en el código fuente (los datos de ejecución se capturan automáticamente para todos los modelos de Keras).

El paquete tfruns proporciona un conjunto de herramientas para rastrear, visualizar y administrar ejecuciones de entrenamiento y experimentos de TensorFlow desde R. Entre estas podemos observar:

• Realicar un seguimiento de los hiperparámetros, las métricas, la salida y el código fuente de cada ejecución de entrenamiento.

• Comparar hiperparmaeters y métricas entre ejecuciones para encontrar el modelo de mejor rendimiento.

• Generar informes automáticamente para visualizar ejecuciones de entrenamiento individuales o comparaciones entre ejecuciones.

• No se requieren cambios en el código fuente (los datos de ejecución se capturan automáticamente para todos los modelos de Keras).

Sección que dispondrá de una serie de recursos y enlaces interesantes para poder complementar eficazmente la formación del curso.

Antes de realizar cualquier transformación en el conjunto de datos, analizaremos las propiedades de los datos, como sus dimensiones, sus variables y su resumen:

En esta sección cargamos los datos de iris de la biblioteca de conjuntos de datos en R. Siempre se recomienda estar al tanto de los datos y sus características antes de comenzar a construir modelos. Por lo tanto, estudiamos la estructura y el tipo de variables en los datos. Vimos que, aparte de Species (nuestra variable de target (objetivo)), todas las demás variables eran numéricas. Luego, verificamos las dimensiones de nuestro conjunto de datos.

Así mismo, Para trabajar con el paquete keras, necesitamos convertir los datos en una matriz o una matriz. En esta sección hacemos las transformaciones de datos necesarias. Para trabajar con el paquete keras, necesitamos convertir los datos en una matriz o una matriz. En nuestro ejemplo, cambiamos nuestra columna de destino del tipo de datos del factor a numérico y convertimos los datos en un formato de matriz. A partir del resumen del conjunto de datos, quedó claro que no necesitábamos normalizar estos datos.

En esta sección dividimos los datos en train/test en una proporción de 70:30. Tenga en cuenta que antes de dividir los datos en train/test, establecemos la semilla, pasándole un entero aleatorio como argumento.

Además, la variable de salida contiene tres valores de cadena diferentes. Al modelar problemas de clasificación multiclase utilizando redes neuronales, es una buena práctica remodelar el atributo de salida de un vector que contiene valores para cada valor de clase para que sea una matriz con un booleano para cada valor de clase y si una instancia determinada tiene o no ese valor de clase. o no. Esto se denomina One-Hot Encoding.

Por ejemplo, en este problema los tres valores de clase son Iris-setosa, Iris-versicolor e Iris-virginica. Si tuviéramos las tres observaciones:

    Iris-setosa

    Iris-versicolor

    Iris-virginica

Podemos convertir esto en una matriz binaria codificada en caliente para cada instancia de datos que se vería de la siguiente manera:

    Iris-setosa, Iris-versicolor, Iris-virginica

        1,             0,              0

        0,             1,              0

        0,             0,              1

A continuación se muestra una función que creará una red neuronal de referencia para el problema de clasificación de Iris.

1. Crea una red simple completamente conectada con una capa oculta que contiene 8 neuronas.

2. La capa oculta utiliza una función de activación ReLU, lo cual es una buena práctica.

3. Debido a que utilizamos una One-Hot Encoding para nuestro conjunto de datos de Iris, la capa de salida debe crear 3 valores de salida, uno para cada clase.

4. El valor de salida con el valor más grande se tomará como la clase predicha por el modelo.

5. Tenga en cuenta que usamos una función de activación Softmax en la capa de salida. Esto es para asegurar que los valores de salida estén en el rango de 0 y 1 y puedan usarse como probabilidades predichas.

6. Finalmente, la red utiliza el eficiente algoritmo de optimización Gradiente Descendiente de Adam con una función de pérdida logarítmica, que se denomina categorical_crossentropy en Keras.

En este tutorial del proyecto, descubrirá cómo utilizar eficazmente la biblioteca de Keras en su proyecto de aprendizaje automático trabajando paso a paso en un proyecto de clasificación binaria. Después de completar este tutorial paso a paso, sabrá:

• Cómo realizar la preparación de datos para mejorar la habilidad al usar redes neuronales.

• Cómo cargar datos de entrenamiento y ponerlos a disposición de Keras.

• Cómo diseñar y entrenar una red neuronal para datos tabulares.

Para Keras usaremos el conjunto de datos del censo de adultos, que usa los datos del censo de EE. UU. para predecir si alguien gana más o menos de USD 50,000 al año.

A continuación, combinaremos los conjuntos de datos para poder realizar algunos cambios en todos los datos al mismo tiempo:

• Usaremos la función complete.cases() para eliminar filas con NA en aras de la simplicidad de estos ejemplos.

• Eliminaremos los espacios en blanco alrededor de los términos de los caracteres para que términos como Male y "Male " se traten como el mismo término.

También realizaremos algunos pasos adicionales de preprocesamiento en el conjunto de datos de train.

1. Primero, usamos la función filter() para extraer los datos de train del marco de datos combinado etiquetado como all.

2. Después de eso, extraeremos la columna a predecir (target) income como un vector y luego eliminaremos las columnas income y label.

3. Aislamos los datos train y las variables target train utilizando el siguiente código:

En este ejemplo, entrenaremos un perceptrón multicapa en el conjunto de datos del censo de adultos que acabamos de preparar.

Este ejemplo se incluye para presentar la sintaxis del paquete y mostrar que se puede completar un ejercicio básico sin una cantidad excesiva de código.

En esta sección crearemos un modelo de red neuronal de referencia para el problema de regresión. Comencemos importando todas las funciones y objetos que necesitaremos para este tutorial.

Posteriormente, cargamos nuestro conjunto de datos desde un archivo en el directorio local. Luego, podemos dividir los atributos de entrada (X) y salida (Y) para que sean más fáciles de modelar con Keras.

Hay una librería muy interesante, neuronalnet, que nos permite dibujar una red neuronal para comprender su desarrollo. En esta sección veremos como dibujar, además de entender su comportamiento

Es un hecho que las redes neuronales funcionan mejor cuando los datos están normalizados. Aunque puede probar con el paquete caret para realizar una normalización aquí lo vamos a realizar de manera directa con la siguiente fórmula.

Construimos nuestro modelo secuencial con Keras. Esta clase toma una función que crea y devuelve nuestro modelo de red neuronal. También toma argumentos que pasará a la llamada a fit() como el número de épocas y el tamaño del batch. Comencemos por definir la función que crea nuestro modelo de línea de base.

1. Es un modelo secuencial con `keras_model_sequential() que tiene una sola capa oculta completamente conectada con el mismo número de neuronas que los atributos de entrada (13).

2. La red utiliza buenas prácticas como la función de activación ReLu para la capa oculta.

   • No se utiliza ninguna función de activación para la capa de salida porque es un problema de regresión y estamos interesados en predecir valores numéricos directamente sin transformar.

   • Creamos una priemra capa oculta, layer_dense, de 5 neuronas y función de activación ReLU.

   • Una capa de salida, layer_dense, con una neurona.

3. Se utiliza el algoritmo de optimización rmsprop y se optimiza una función de pérdida de error cuadrático medio.

   • Es una métrica deseable porque al sacar la raíz cuadrada de un valor de error nos da un resultado que podemos entender directamente en el contexto del problema con las unidades en miles de dólares.

   • En Loss utilizamos del Error Cuadrático Medio (mae)

4. Creamos el modelo de red neuronal como algunos parámetros para pasar a la función fit() del modelo, como el número de épocas y el tamaño de batchs.

5. El paso final es evaluar este modelo de línea de base. Usaremos una validación cruzada una partición de 80:20.

Hay muchas preocupaciones que se pueden optimizar para un modelo de red neuronal. Quizás el punto de mayor apalancamiento es la estructura de la red en sí, incluida la cantidad de capas y la cantidad de neuronas en cada capa. En esta sección evaluaremos dos topologías en un esfuerzo por mejorar aún más el rendimiento del modelo. Examinaremos una topología de red tanto más profunda como más amplia.

Esto viene justificado ya que anteriormente nos ha dado un error muy alto aspecto que debe de replantearse con la adición de más capas ocultas, por ejemplo.

Veamos un ejemplo concreto de una red neuronal que usa el paquete Keras para aprender a clasificar dígitos escritos a mano.

El problema que estamos tratando de resolver aquí es clasificar las imágenes en escala de grises de dígitos escritos a mano (28 píxeles por 28 píxeles) en sus 10 categorías (0 a 9). Usaremos el conjunto de datos MNIST, un conjunto de datos clásico en la comunidad de aprendizaje automático, que ha existido casi tanto tiempo como el campo mismo y se ha estudiado intensamente.

Es un conjunto de 60,000 imágenes de entrenamiento, más 10,000 imágenes de prueba, reunidas por el Instituto Nacional de Estándares y Tecnología (el NIST en MNIST) en la década de 1980. Puede pensar en "resolver" MNIST como el "Hola mundo" del aprendizaje profundo; es lo que hace para verificar que sus algoritmos funcionan como se esperaba. A medida que se convierta en un practicante del aprendizaje automático, verá que MNIST aparece una y otra vez, en artículos científicos, publicaciones de blogs, etc. Un ejemplo de MNIST se muestra a continuación.

Construyamos la red; nuevamente, recuerde que no se supone que usted comprenda todo acerca de este ejemplo todavía.

Aquí nuestra red consta de:

1. Una secuencia de dos capas, que son capas neuronales densamente conectadas (también llamadas totalmente conectadas).

2. En la primera capa el argumento input_shape es la forma de los datos de entrada; es decir, es un vector numérico de longitud 28x28, es decir, 784 y representa una imagen en escala de grises.

3. La segunda (y última) capa es una capa softmax de 10 neuronas, lo que significa que devolverá una matriz de 10 puntuaciones de probabilidad (sumando 1).

4. La capa final genera un vector numérico de longitud 10 (probabilidades para cada dígito de 0 a 9) usando una función de activación softmax.

5. Cada puntuación será la probabilidad de que la imagen del dígito actual pertenezca a una de nuestras clases de 10 dígitos.

Antes del entrenamiento, preprocesaremos los datos dándoles la forma que espera la red y escalando para que todos los valores estén en el intervalo [0, 1].

Anteriormente, nuestras imágenes de entrenamiento se almacenaban en una matriz de forma (images, width, height), en este caso como (60000, 28, 28) de tipo entero con valores en el intervalo [0, 255]. Lo transformamos en una matriz doble de forma (60000, 28 * 28) con valores entre 0 y 1.

Tenga en cuenta que usamos la función array_reshape() en lugar de la función dim <- () para remodelar la matriz.

Por tanto, convertimos los datos de 3 dimensiones a un arreglo de 1 dimensión

Ahora, ajustemos los datos de entrenamiento al modelo configurado:

1. El número de épocas en 30.

2. El tamaño del lote en 128

3. El porcentaje de validación en 20:

Material tipo presentación de esta sección

Sesión teórica sobre Background sobre Redes Neuronales

Sesión teórica sobre Parámetros en redes neuronales

Sesión teórica sobre Algoritmo de Gradiente Descendiente

Sesión teórica sobre Multilayer Perceptron

Sesión teórica sobre Coste, sesgo y activación

Sesión teórica sobre Backpropagation

Sección que dispondrá de una serie de recursos y enlaces interesantes para poder complementar eficazmente la formación del curso.

Dado que los modelos de aprendizaje profundo pueden tardar horas, días e incluso semanas en entrenarse, es importante saber cómo guardarlos y cargarlos desde el disco. En esta lección, descubrirá cómo puede guardar sus modelos Keras en un archivo y volver a cargarlos para hacer predicciones. Después de completar esta lección, sabrá:

• Cómo guardar y cargar con el formato SavedModel de TensorFlow.

• Cómo guardar y cargar los pesos del modelo Keras en archivos formateados HDF5.

Se puede llamar a la función save_model_*() (el * puede sustituirse por objetos personalizados (por ejemplo, capas o modelos en subclases) requieren una atención especial al guardar y cargar) para guardar la arquitectura, los pesos y la configuración de entrenamiento de un modelo en un solo archivo / carpeta. Esto le permite exportar un modelo para que pueda usarse sin acceso al código original.

• Los objetos personalizados (por ejemplo, capas o modelos en subclases) requieren una atención especial al guardar y cargar. Lo veremos posteriormente.

Dado que se recupera el estado del optimizador, puede reanudar el entrenamiento desde exactamente donde lo dejó.

Entrenar un modelo de aprendizaje profundo es una tarea que requiere mucho tiempo. Si el entrenamiento se detiene inesperadamente, podemos perder gran parte de nuestro trabajo.

La biblioteca de keras en R nos proporciona la funcionalidad para guardar el progreso de un modelo durante y después del entrenamiento. Un modelo guardado contiene los valores de peso, la configuración del modelo y la configuración del optimizador. Si el proceso de entrenamiento se interrumpe de alguna manera, podemos retomar el entrenamiento desde allí.

El siguiente bloque de código muestra cómo podemos guardar el modelo después del entrenamiento:

    # Save model

    model_sequential %>% save_model_hdf5("my_model.h5")

Los modelos de aprendizaje profundo pueden tardar horas, días o incluso semanas en entrenarse y si una ejecución de entrenamiento se detiene inesperadamente, puede perder mucho trabajo. En esta lección, descubrirá cómo puede verificar sus modelos de aprendizaje profundo durante el entrenamiento en R utilizando la biblioteca de Keras. Después de completar esta lección, sabrá:

• La importancia de controlar los modelos de redes neuronales durante el entrenamiento.

• Cómo comprobar cada mejora de un modelo durante el entrenamiento.

• Cómo comprobar el mejor modelo observado durante el entrenamiento.

La API le permite especificar qué métrica monitorear, como la pérdida o la métrica en el conjunto de datos de entrenamiento o validación. Puede especificar si buscar una mejora para maximizar o minimizar la puntuación.

Finalmente, el nombre de archivo que usa para almacenar los pesos puede incluir variables como el número de época o métrica. La instancia de callback_model_checkpoint() se puede pasar al proceso de entrenamiento al llamar a la función fit() en el modelo.

Si queremos guardar el modelo después de cada iteración durante el entrenamiento, necesitamos crear un objeto de punto de control. Para realizar esta tarea:

• Usamos la función callback_model_checkpoint().

• El valor del argumento filepath define el nombre del modelo que queremos guardar al final de cada iteración.

• Por ejemplo, si la ruta del archivo es {epoch: 02d} - {val_loss: .2f}.hdf5, el modelo se guardará con el número de época y la pérdida de validación en el nombre del archivo.

La devolución de llamada callback_model_checkpoint() requiere un par de argumentos para configurar los puntos de control. De forma predeterminada, save_weights_only se establece en FALSE, lo que significa que se está guardando el modelo completo, incluida la arquitectura y la configuración.

Los puntos de control están configurados para guardar los pesos de la red solo cuando hay una mejora en el Accuracy de la clasificación en el conjunto de datos de validación.

Podemos ver que para guardar con los mejores pesos se tiene que poner el párametro save_best_only

Los puntos de control están configurados para guardar los pesos de la red solo cuando hay una mejora en el Accuracy de la clasificación en el conjunto de datos de validación (monitor = 'val_accuracy' y mode = 'max').

El argumento de la ruta del archivo puede contener opciones de formato con nombre, por ejemplo: si la ruta del archivo es {epoch:02d}-{val_loss:.2f}.hdf5, los puntos de control del modelo se guardarán con el número de época y la pérdida de validación en el nombre del archivo.

Una estrategia de punto de control más simple es guardar los pesos del modelo en el mismo archivo, si y solo si mejora la precisión de la validación. Esto se puede hacer fácilmente usando el mismo código de arriba y cambiando el nombre del archivo de salida para que sea fijo (no incluya información de puntuación o época).

En este caso, los pesos del modelo se escriben en el archivo weights.best.hdf5 solo si el Accuracy de clasificación del modelo en el conjunto de datos de validación mejora con respecto al mejor visto hasta ahora.

Keras proporciona la capacidad de registrar devoluciones de llamada al entrenar un modelo. Una de las devoluciones de llamada predeterminadas que se registra al entrenar todos los modelos es la devolución de llamada del historial. Registra métricas de entrenamiento para cada época. Esto incluye la pérdida (Loss) y el Porcentaje de acierto (Accuracy) tanto para train como para validación en problemas de clasificación. El objeto histórico se devuelve de las llamadas a la función fit() utilizada para entrenar el modelo.

En el siguiente ejemplo, creamos una pequeña red para modelar el problema de clasificación binaria. El ejemplo recopila el historial, devuelto por el entrenamiento del modelo y crea dos gráficos:

1. Un gráfico de Accuracy en los conjuntos de datos de entrenamiento y validación durante épocas de entrenamiento.

2. Un gráfico de la pérdida (Loss) en los conjuntos de datos de entrenamiento y validación durante épocas de entrenamiento.

Dropuot es una técnica de regularización para modelos de redes neuronales propuesta por Srivastava, et al. en su artículo de 2014 Dropout: A Simple Way to Prevent Neural Networks from Overfitting. Dropout es una técnica en la que se ignoran las neuronas seleccionadas al azar durante el entrenamiento. Se eliminan al azar. Esto significa que su contribución a la activación de las neuronas siguiente se elimina temporalmente en el pase hacia adelante y las actualizaciones de peso no se aplican a la neurona en el pase hacia atrás.

A medida que aprende una red neuronal, los pesos de las neuronas se asientan en su contexto dentro de la red. Los pesos de las neuronas se ajustan a características específicas que brindan cierta especialización. Las neuronas vecinas llegan a depender de esta especialización, que si se lleva demasiado lejos puede resultar en un modelo aleatorio demasiado especializado para los datos de entrenamiento y no generalice correctamente.

Esta dependencia del contexto de una neurona durante el entrenamiento se denomina coadaptaciones complejas. Puede imaginar que si las neuronas se eliminan aleatoriamente de la red durante el entrenamiento, otras neuronas tendrán que intervenir y manejar la representación requerida para hacer predicciones para las neuronas faltantes. Se cree que esto da como resultado que la red aprenda múltiples representaciones internas independientes.

El efecto es que la red se vuelve menos sensible a los pesos específicos de las neuronas. Esto, a su vez, da como resultado una red que es capaz de una mejor generalización y es menos probable que se adapte demasiado a los datos de entrenamiento.

Llegados a este punto vamos a realizar un modelo de línea base sin aplicar Dropout para ver el efecto que tiene. Para ellos vamos a crear un modelo de linea base para poder comparar. Además vamos a realizar un procesamiento previo, en este caso, una estandarización para preparar los datos.

Hay un parámetro, kernel_regularizer que nos permite realizar una regularización directa en la capa en el cual le podemos pasar una regularización de normas algebráicas L1 (regularizer_l1()), L2 (regularizer_l2()) y L1-L2 (regularizer_l1_l2()). Este tipo de regularización lo que realiza es una penalización en las mismas neuronas.

Dropuot se implementa fácilmente seleccionando aleatoriamente los nodos que se eliminarán con una probabilidad determinada (por ejemplo, 20%) en cada ciclo de actualización de peso. Así es como se implementa Dropout en Keras. Dropuot solo se usa durante el entrenamiento de un modelo y no se usa al evaluar la habilidad del modelo. A continuación, exploraremos algunas formas diferentes de usar Dropout en Keras.

Dropout se puede aplicar a las neuronas de entrada llamadas capa visible. En el siguiente ejemplo:

1. Agregamos una nueva capa de exclusión entre la entrada (o capa visible) y la primera capa oculta.

2. La tasa de dropuot se establece en 20%, lo que significa que una de cada cinco entradas se excluirá al azar de cada ciclo de actualización.

3. Además, como se recomienda en el documento original sobre dropout, se impone una restricción en los pesos para cada capa oculta, lo que garantiza que la norma máxima de los pesos no exceda un valor de 3.

   • Esto se hace estableciendo el argumento de kernel_constraint en el clase Dense al construir las capas.

4. La tasa de aprendizaje se elevó en un orden de magnitud y se incrementó a 0.9.

   • Estos aumentos en la tasa de aprendizaje también se recomendaron en el documento de abandono original.

5. Continuando con el ejemplo de línea de base anterior, el código siguiente ejercita la misma red con dropuot de entrada.

Dropuot se puede aplicar a neuronas ocultas en el cuerpo de su modelo de red. En el siguiente ejemplo:

1. Dropuot se aplica entre las dos capas ocultas y entre la última capa oculta y la capa de salida.

2. Nuevamente, se usa una tasa de dropuot del 20% como restricción de peso en esas capas.

Adaptar la tasa de aprendizaje para su procedimiento de optimización puede aumentar el rendimiento y reducir el tiempo de entrenamiento. A veces, esto se denomina como tasas de aprendizaje adaptativo.

Llamaremos a este enfoque una planificación de tasa de aprendizaje, donde la planificación predeterminada es usar una tasa de aprendizaje constante para actualizar los pesos de la red para cada época de entrenamiento.

La adaptación más simple y quizás más utilizada de las tasas de aprendizaje durante el entrenamiento son las técnicas que reducen la tasa de aprendizaje con el tiempo. Estos tienen la ventaja de realizar grandes cambios al comienzo del procedimiento de entrenamiento cuando se utilizan valores de tasa de aprendizaje más grandes, y disminuyen la tasa de aprendizaje de manera que se realicen una tasa menor y, por lo tanto, actualizaciones de entrenamiento más pequeñas a los pesos más adelante en el procedimiento de entrenamiento. Esto tiene el efecto de aprender rápidamente buenos pesos desde el principio y ajustarlos más tarde. Dos planificaciones de tasas de aprendizaje populares y fáciles de usar son los siguientes:

• Disminuya la tasa de aprendizaje gradualmente según la época.

• Disminuya la tasa de aprendizaje usando grandes drops en épocas específicas.

El siguiente ejemplo demuestra el uso de la adaptación de la tasa de aprendizaje basado en el tiempo en Keras.

1. Se construye un pequeño modelo de red neuronal con una sola capa oculta con 34 neuronas y utilizando la función de activación ReLU.

2. La capa de salida tiene una sola neurona y usa la función de activación sigmoidea para generar valores similares a la probabilidad.

3. La tasa de aprendizaje para el optimizer_sgd() se ha establecido en un valor más alto de 0,1.

4. El modelo está entrenado para 50 épocas y el argumento decay se ha establecido en 0,002, calculado como 0.150

1. .

2. Además, puede ser una buena idea aprovechar el momentum cuando se usa una tasa de aprendizaje adaptativo. En este caso usamos un momentum de 0.8.

La API secuencial de Keras es fácil de entender e implementar. Nos permite crear una red neuronal de forma lineal; es decir, podemos construir una red neuronal capa por capa donde inicializamos un modelo secuencial y luego apilamos una serie de capas ocultas y de salida en él. En sí, estudiaremos:

• Crear un módulo con múltiples salidas.

• Crear un módulo con múltiples entradas.

El procedimiento que vamos a realizar es el siguiente:

1. Para crear un modelo usando la API funcional, necesitamos crear las capas de entrada y salida de forma independiente, y luego pasarlas a la función keras_model() para definir el modelo completo.

   • Creamos un tensor de entrada usando la función layer_input(), que es un punto de entrada en un gráfico de cálculo que ha sido generado por el modelo de keras.

2. Creamos un modelo con dos capas de salida diferentes que comparten una capa/tensor de entrada. Definimos dos capas de salida diferentes.

   • Estas capas de salida tienen diferentes configuraciones; es decir, las funciones de activación y el número de unidades de perceptrón.

   • El tensor de entrada fluye a través de estos y produce dos salidas diferentes.

3. Llegados aquí, definimos nuestro modelo usando la función keras_model().

   • Toma dos argumentos: entradas y salidas. Estos argumentos especifican qué capas actúan como capas de entrada y salida del modelo.

4. En el caso de modelos de múltiples entradas / salidas, puede usar un vector de capas de entrada y capas de salida, como se muestra aquí:

   keras_model (inputs = c(input_layer_1, input_layer_2), outputs = c(output_layer_1, output_layer_2))

5. Configuramos nuestro modelo, definimos el proceso de aprendizaje, entrenamos nuestro modelo y visualizamos las métricas de pérdida y MAE utilizando las funciones compile() y fit().

Se encontrará con escenarios en los que querrá la salida de un modelo para alimentarlo en otro modelo junto con otra entrada.

El procedimiento es muy parecido a lo descrito anteriormente, aunque en este caso utilizamos la función layer_concatenate() que nos permite concatenar las salidas con nuevas entradas. Definamos una nueva entrada que concatenaremos con la capa de salida predictions1.

¡Enhorabuena, finalizaste con éxito la formación!

En esta última clase podrás solicitar tu certificado de finalización del curso, que te será de gran ayuda para complementar tu curriculum vitae.

En esta clase dispones de un espacio para resolver las dudas y consultas que te surjan durante el curso.

Plantea tus dudas y te ayudaré a resolverla. De esta forma todos los alumnos de esta formación podrán participar de las aportaciones mías como instructor como del resto de compañeros del curso.