Deep Learning para visión por computador con R y Keras

Materiales sobre esta primera unidad del curso.

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

Coste, sesgo y función de activación

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.

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:

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

Sesión de teoría - Background

Sesión de teoría - Fundamentos de las CNNs

Sesión de teoría - Operación Convolución

Sesión de teoría - Operación Pooling

Sesión de teoría - Capas Fully-Connect

Sesión de teoría - GPUs para mejorar el rendimiento

Sesión de teoría - Conclusiones sobre CNNs

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

Las redes neuronales convolucionales son una poderosa técnica de redes neuronales artificiales. Estas redes preservan la estructura espacial del problema y fueron desarrolladas para tareas de reconocimiento de objetos como el reconocimiento de dígitos escritos a mano. Son populares porque las personas están logrando resultados de vanguardia en tareas difíciles de procesamiento de lenguaje natural y visión por computadora. En esta lección, descubrirá las redes neuronales convolucionales para el Deep Learning, también llamadas ConvNets o CNN. Después de completar este curso intensivo, sabrá:

• Los componentes básicos utilizados en las CNN, como las capas convolucionales y las capas de agrupación.

• Cómo encajan los bloques de construcción con un breve ejemplo resuelto.

• Mejores prácticas para configurar CNN en sus propias tareas de reconocimiento de objetos.

Comprender el aprendizaje profundo requiere estar familiarizado con muchos conceptos matemáticos simples: tensores, operaciones de tensores, diferenciación, descenso de gradientes, etc. Nuestro objetivo en este capítulo será desarrollar su intuición sobre estas nociones sin ser demasiado técnico. En particular, nos alejaremos de la notación matemática, que puede resultar desagradable para quienes no tienen conocimientos de matemáticas y no es estrictamente necesaria para explicar bien las cosas.

En general, todos los sistemas actuales de aprendizaje automático utilizan tensores como estructura de datos básica. Los tensores (matrices multidimensionales) son fundamentales para el campo, tan fundamentales que TensorFlow de Google recibió su nombre. Entonces, ¿qué es un tensor?

Los tensores son una generalización de vectores y matrices a un número arbitrario de dimensiones (tenga en cuenta que en el contexto de tensores, "dimensión" a menudo se llama "eje"). Dentro de R, los vectores se utilizan para crear y manipular tensores 1D y las matrices se utilizan para tensores 2D. Para dimensiones de nivel superior, se utilizan objetos de matriz (que admiten cualquier número de dimensiones).

Un tensor se define por tres atributos clave:

• Número de ejes (rango): por ejemplo, un tensor 3D tiene tres ejes y una matriz tiene dos ejes.

• Forma: este es un vector entero que describe cuántas dimensiones tiene el tensor a lo largo de cada eje. Por ejemplo, el ejemplo de matriz anterior tiene forma (3, 5) y el ejemplo de tensor 3D tiene forma (3, 3, 5). Un vector tiene una forma con un solo elemento, como (5). Puede acceder a las dimensiones de cualquier matriz utilizando la función dim().

• Tipo de datos: este es el tipo de datos contenidos en el tensor; por ejemplo, el tipo de un tensor podría ser entero o doble. En raras ocasiones, es posible que vea un tensor de caracteres. Sin embargo, dado que los tensores viven en segmentos de memoria contiguos preasignados, y las cadenas, que son de longitud variable, impedirían el uso de esta implementación, se utilizan con menos frecuencia.

El problema MNIST es un conjunto de datos desarrollado por Yann LeCun, Corinna Cortes y Christopher Burges para evaluar modelos de Machine Learning en el problema de clasificación de dígitos escritos a mano. El conjunto de datos se construyó a partir de varios conjuntos de datos de documentos escaneados disponibles del Instituto Nacional de Estándares y Tecnología (NIST). De aquí es de donde proviene el nombre del conjunto de datos, como el conjunto de datos NIST modificado o MNIST.

Se tomaron imágenes de dígitos de una variedad de documentos escaneados, normalizados en tamaño y centrados. Esto lo convierte en un excelente conjunto de datos para evaluar modelos, lo que permite al desarrollador concentrarse en el Machine Learning con muy poca limpieza o preparación de datos requerida. Cada imagen es un cuadrado de 28×28

píxeles (784 píxeles en total). Se usa una división estándar del conjunto de datos para evaluar y comparar modelos, donde se usan 60,000 imágenes para entrenar un modelo y se usa un conjunto separado de 10,000 imágenes para probarlo.

Es una tarea de reconocimiento de dígitos. Como tal, hay 10 dígitos (0 a 9) o 10 clases para predecir. Los resultados se informan mediante el error de predicción, que no es más que la precisión de clasificación invertida. Los excelentes resultados logran un error de predicción de menos del 1%. Se puede lograr un error de predicción de última generación de aproximadamente el 0,2% con grandes redes neuronales convolucionales. En la página web de Rodrigo Benenson hay una lista de los resultados más avanzados y enlaces a los artículos relevantes sobre el MNIST y otros conjuntos de datos.

Ahora estamos listos para crear nuestro modelo de red neuronal simple. Definiremos nuestro modelo en una función. Esto es útil si desea ampliar el ejemplo más adelante e intentar obtener una mejor puntuación.

1. El modelo es una red neuronal simple con una capa oculta con el mismo número de neuronas que entradas (784).

2. Se utiliza una función de activación ReLu para las neuronas de la capa oculta.

3. Se utiliza una función de activación Softmax en la capa de salida para convertir las salidas en valores de probabilidad y permitir que se seleccione una clase de las 10 como predicción de salida del modelo.

4. La pérdida logarítmica se utiliza como función de pérdida (denominada categorical_crossentropy) y

5. el eficiente algoritmo Gradiente Descendiente ADAM se utiliza para aprender los pesos.

Ahora que hemos visto cómo cargar el conjunto de datos MNIST y entrenar un modelo simple de perceptrón multicapa en él, es hora de desarrollar una red neuronal convolucional más sofisticada o un modelo CNN.

Crearemos una CNN simple para MNIST que demuestra cómo utilizar todos los aspectos de una implementación de CNN moderna, incluidas las capas convolucionales, las capas de agrupación y las capas de dropout.

Ahora que hemos visto cómo crear una CNN simple, echemos un vistazo a un modelo capaz de obtener resultados cercanos a los más avanzados. Importamos las clases y funciones, luego cargamos y preparamos los datos de la misma manera que en el ejemplo anterior de CNN. Esta vez definimos una arquitectura CNN más grande con capas de agrupación máxima convolucionales adicionales y capas completamente conectadas. La topología de la red se puede resumir de la siguiente manera.

1. Capa convolucional con 30 mapas de características de tamaño 5×5.

2. Capa de agrupación tomando el máximo de patch de 2×2.

3. Capa convolucional con 15 mapas de características de tamaño 3×3.

4. Capa de agrupación tomando el máximo de patch de 2×2.

5. Capa de Dropout con una probabilidad del 20%.

6. Aplanar la capa.

7. Capa completamente conectada con 128 neuronas y ReLu.

8. Capa completamente conectada con 50 neuronas y ReLu

9. Capa de salida con activación Softmax.

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

Las redes neuronales convolucionales son una forma especial de red neuronal. En una red neuronal tradicional, la entrada se pasa al modelo como vectores; sin embargo, para los datos de imagen, es más útil disponer los datos como matrices porque queremos capturar la relación de los valores de los píxeles en un espacio bidimensional. Las redes neuronales convolucionales pueden capturar estas relaciones bidimensionales mediante el uso de un filtro que convoluciona sobre los datos de la imagen.

El siguiente es un ejemplo de una CNN simple con capas de convolución y agrupación.

• La operación de convolución es una multiplicación y suma de elementos entre la matriz de entrada y el filtro utilizado. El filtro es una matriz con valores constantes y dimensiones más pequeñas que los datos de la imagen. Los valores constantes se multiplican por los valores subyacentes y la suma de los productos resultantes se transfiere a una función de activación.

• La capa de agrupación (pooling) procesa los datos. La función de la capa de agrupación es concentrar la señal capturada en el paso anterior y al mismo tiempo reducir la dimensionalidad de los datos. La capa de agrupación dará como resultado una matriz más pequeña que los datos de entrada. A menudo, se utilizará una capa de agrupación de 2 x 2 que reduce el tamaño de los datos de entrada a la mitad.

Desarrollamos nuestro modelo secuencial de linea base. Posteriormente a ello verificaremos los resultados con Redes neuronales convolucionales:

1. El primer paso será definir la capa que toma los datos de una gran variedad de matrices y transforma los datos para que todos los valores de una imagen dada estén en una sola fila (aplane la imagen). Para hacer esto, usamos la función layer_flatten() y pasamos la forma de la matriz como argumento.

2. Añadimos una capa densa de 256 neuronas con ReLU

3. Añadimos la capa de salida con las 10 neuronas (una por clase con activación Softmax).

En esta receta, aprenderemos sobre dos hiperparámetros de configuración clave de CNN, padding y stride.

• Stride se utiliza principalmente para reducir el tamaño del volumen de salida.

• Padding es otra técnica que nos permite preservar las dimensiones del volumen de entrada en el volumen de salida, lo que nos permite extraer las características de bajo nivel de manera eficiente.

Además de los parámetros tamaño del filtro (kernel_size) y el número de filtros (filters), hay dos parámetros más de una capa de convolución que se pueden configurar para una mejor extracción de características, y estos son stride y padding.

1. Pasamos un vector de dos números enteros (ancho y alto), especificando los pasos de la convolución a lo largo del ancho y alto.

2. El argumento padding toma dos valores:

   • valid: sin relleno

   • same: los tamaños de entrada y salida siguen siendo los mismos.

3. Imprimimos un resumen del modelo.

Las CNN utilizan capas de agrupación (pooling) para reducir el tamaño de la representación, acelerar el cálculo de la red y garantizar una extracción de características. La capa de agrupación se apila principalmente sobre la capa convolucional y esta capa reduce considerablemente la dimensión de entrada para reducir el cálculo en la red y también reducir el sobreajuste. En la siguiente imagen podemos observar estas dos operaciones, convolución y pooling:

Hay dos tipos de técnicas de agrupación más utilizadas:

• Agrupación máxima (Max-pooling): reduce la resolución al dividir la matriz de entrada en regiones de agrupación y luego calcular los valores máximos de cada región.

• Agrupación promedio (Average-pooling): este tipo de agrupación reduce el muestreo dividiendo la matriz de entrada en regiones de agrupación y luego calcula los valores promedio de cada región.

• Agrupación promedio global (Global average pooling): realiza una reducción extrema de la dimensionalidad.

En este modelo:

1. Agregamos una capa de Max-Pooling seguida de dos capas densas.

2. La última capa de la red tuvo activación softmax con 24 unidades ya que teníamos 24 etiquetas de salida.

3. A continuación, miramos el resumen del modelo y observamos que el número de parámetros entrenables en la capa de agrupación es cero porque no tiene pesos ni sesgos para entrenar.

4. La forma de salida de la capa de Max-pooling se puede determinar mediante: floor (input size / pool size).

Mientras se entrena redes neuronales profundas, la distribución de las entradas de cada a capa cambia y ralentiza el entrenamiento, ya que necesitamos mantener tasas de aprendizaje más bajas y realizar una inicialización de parámetros cuidadosa para entrenar el modelo correctamente. Este fenómeno se conoce como cambio de covariables interno y se aborda realizando la normalización para cada mini-lote de entrenamiento.

La normalización de lotes (batch normalization) normaliza cada lote por referencia de varianza y media, lo que nos permite utilizar tasas de aprendizaje más altas. También actúa como un regularizador, en algunos casos eliminando la necesidad de dropout. La normalización por lotes facilita las inicializaciones de peso.

El sobreajuste es un desafío común en escenarios en los que solo tenemos unas pocas muestras de datos de las que aprender. Esto evita que nuestro modelo funcione de manera robusta con datos invisibles.

Data Augmentation es una técnica que reduce el sobreajuste al generar más datos de entrenamiento a partir de muestras existentes en los datos y aumentar las muestras a través de varias transformaciones aleatorias que producen imágenes de apariencia creíble. Crea versiones modificadas aplicando operaciones como cambiar, voltear, hacer zoom, etc. También enriquece nuestros datos, lo que ayuda a generalizar nuestro modelo y hacerlo más robusto. El aumento de datos se realiza solo en el conjunto de entrenamiento.

Como el resto de Keras, la API de aumento de imagen es simple y poderosa. Keras proporciona la clase image_data_generator() que define la configuración para la preparación y el aumento de datos de imágenes. Esto incluye capacidades como:

• Estandarización de características.

• Blanqueamiento ZCA.

• Rotación aleatoria, cambios, cizallamiento y volteretas.

• Reordenamiento de dimensiones.

• Guarde las imágenes aumentadas en el disco.

Transfer Learning nos ayuda a resolver un nuevo problema utilizando menos ejemplos al utilizar la información obtenida al resolver otras tareas relacionadas. Es una técnica en la que reutilizamos un modelo entrenado en un conjunto de datos diferente para resolver un problema similar pero diferente.

En Transfer Learning ampliamos el aprendizaje de un modelo preentrenado en nuestra red y construimos un nuevo modelo para resolver un nuevo problema de aprendizaje.

Hay principalmente tres formas de implementar el aprendizaje por transferencia:

• Utilice un modelo previamente entrenado con pesos y sesgos previamente realizados; es decir, congele completamente el modelo previamente entrenado de su red y entrene en un nuevo conjunto de datos.

• Congele parcialmente algunas capas del modelo previamente entrenado de nuestra red y entrenelo en un nuevo conjunto de datos.

• Conserve solo la arquitectura del modelo previamente entrenado y entrene a su red completa para nuevos pesos y sesgos.

Creamos una instancia de un modelo base previamente entrenado, VGG16, con pesos entrenados en datos de ImageNet. ImageNet es una gran base de datos visual que contiene imágenes de 1000 clases diferentes.

Tenga en cuenta que hemos establecido el valor de include_top como FALSE. Establecerlo en falso no incluye las capas densamente conectadas predeterminadas de la red VGG16, que corresponden a 1,000 clases de datos de ImageNet.

Después de cargar nuestros datos, creemos una instancia de un modelo VGG16 previamente entrenado. Yendo más allá, nos referiremos a este modelo como modelo base:

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

Antes de empezar vamos a repasar en que consiste la base de datos MNIST y a cargar los datos. MNIST es una base de datos que consta de imágenes de tamaño 28x28 de dígitos escritos a mano que van del 0 al 9 y que han sido etiquetadas con el número representado en la imagen. Inicialmente, tenemos 60.000 imágenes en el conjunto de train y 10.000 en el de test, sin embargo, el conjunto de train lo vamos a partir en entrenamiento y validación, siguiendo las prácticas anteriores.

Nosotros vamos a utilizar Sequential. Este objeto define un grafo lineal, donde las capas se van interconectando por en el orden en el que las vamos añadiendo. Trabajar con Sequential es igual que utilizar una lista de python, donde con la función add() vamos añadiendo capas. Además, también podemos inicializar el objeto con una lista.

Veamos un ejemplo de ambos casos definiendo una red para MNIST con dos capas ocultas Fully connected (Dense en Keras) con 32 nodos cada una, ReLU como función de activación y softmax en la salida.

El problema de identificar automáticamente objetos en fotografías es difícil debido al número casi infinito de permutaciones de objetos, posiciones, iluminación, etc. Es un problema realmente difícil. Este es un problema bien estudiado en la visión por computadora y, más recientemente, una demostración importante de la capacidad del Deep Learning.

El Instituto Canadiense de Investigación Avanzada (CIFAR, por sus siglas en inglés) desarrolló un conjunto de datos estándar de visión artificial y Deep Learning para este problema.

El conjunto de datos CIFAR-10 consta de 60.000 fotos divididas en 10 clases (de ahí el nombre CIFAR-10). Las clases incluyen objetos comunes como aviones, automóviles, pájaros, gatos, etc. El conjunto de datos se divide de forma estándar, donde se utilizan 50.000 imágenes para entrenar un modelo y las 10.000 restantes para evaluar su rendimiento. Las fotos son en color con canales rojo, verde y azul, pero son pequeños cuadrados de 32×3232×32 píxeles.

Se pueden lograr resultados de vanguardia utilizando redes neuronales convolucionales muy grandes. Puede obtener información sobre los resultados más recientes de CIFAR-10 en la página web de Rodrigo Benenson. El rendimiento del modelo se informa en el Accuracy de clasificación, con muy buen rendimiento por encima del 90% con el rendimiento humano en el problema al 94% y los resultados de vanguardia al 96%.

Comencemos por definir una estructura CNN de linea base y evaluar qué tan bien se desempeña en el problema. Usaremos una estructura con dos capas convolucionales seguidas de agrupación máxima y un aplanamiento de la red a capas completamente conectadas para hacer predicciones. Nuestra estructura de red de referencia se puede resumir de la siguiente manera:

1. Capa de entrada convolucional, 32 mapas de características con un tamaño de 3×33×3, una función de activación ReLu y una restricción de peso de la norma máxima establecida en 3.

2. Dropout en 20%.

3. Capa convolucional, 32 mapas de características con un tamaño de 3×33×3, una función de activación ReLu y una restricción de peso de la norma máxima establecida en 3.

4. Capa Max Pool con el tamaño 2×22×2.

5. Aplanar la capa.

6. Capa totalmente conectada con 512 unidades y función de activación de rectificador.

7. Dropout en 50%.

8. Capa de salida totalmente conectada con 10 unidades y función de activación Softmax.

Podemos resumir una nueva arquitectura de red de la siguiente manera:

1. Capa de entrada convolucional, 32 mapas de características con un tamaño de 3×33×3 y una función de activación ReLU.

2. Dropout al 20%.

3. Capa convolucional, 32 mapas de características con un tamaño de 3×33×3 y una función de activación ReLU.

4. Capa Max Pool con tamaño 2×22×2.

5. Capa convolucional, 64 mapas de características con un tamaño de 3×33×3 y función de activación ReLU.

6. Dropout al 20%.

7. Capa convolucional, 64 mapas de características con un tamaño de 3×33×3 y función de activación ReLU.

8. Capa Max Pool con tamaño 2×22×2.

9. Capa convolucional, 128 mapas de características con un tamaño de 3×33×3 y función de activación ReLU.

10. Dropout al 20%.

11. Capa convolucional, 128 mapas de características con un tamaño de 3×33×3 y función de activación ReLU.

12. Capa Max Pool con tamaño 2×22×2.

13. Aplanar la capa.

14. Dropout al 20%.

15. Capa totalmente conectada con 1.024 unidades y función de activación ReLU.

16. Dropout al 20%.

17. Capa totalmente conectada con 512 unidades y función de activación ReLU.

18. Dropout al 20%.

19. Capa de salida totalmente conectada con 10 unidades y función de activación softmax.

Esta es una red más grande y un poco difícil de visualizar.

Keras proporciona acceso al conjunto de datos de IMDB integrado. La función imdb.load data() permite cargar el conjunto de datos en un formato que está listo para usar en modelos. Las palabras han sido reemplazadas por números enteros que indican la popularidad absoluta de la palabra en el conjunto de datos. Por lo tanto, las oraciones de cada revisión se componen de una secuencia de números enteros.

Llamar a imdb.load data() por primera vez descargará el conjunto de datos IMDB a su computadora y lo almacenará en su directorio personal en ~/.keras/datasets/imdb.pkl como un archivo de 32 megabytes.

De manera útil, la función imdb.load data() proporciona argumentos adicionales, como:

1. El número de palabras principales para cargar (donde las palabras con un número entero inferior se marcan como cero en los datos devueltos)

2. El número de palabras principales para omitir (como "the's")

3. La duración máxima de las revisiones para respaldar.

Carguemos el conjunto de datos y calculemos algunas de sus propiedades. Comenzaremos cargando algunas bibliotecas y cargando todo el conjunto de datos de IMDB como un conjunto de datos de entrenamiento.

Un avance reciente en el campo del procesamiento del lenguaje natural se llama incrustación de palabras (word embeddings). Se trata de una técnica en la que las palabras se codifican como vectores de valor real en un espacio de alta dimensión, donde la similitud entre palabras en términos de significado se traduce en cercanía en el espacio vectorial. Las palabras discretas se asignan a vectores de números continuos. Esto es útil cuando se trabaja con problemas de lenguaje natural con redes neuronales, ya que necesitamos números como valores de entrada.

Keras proporciona una forma conveniente de convertir representaciones enteras positivas de palabras en una incrustación de palabras mediante una capa de incrustación. La capa toma argumentos que definen el mapeo, incluido el número máximo de palabras esperadas, también llamado tamaño de vocabulario (por ejemplo, el valor entero más grande que se verá como entrada). La capa también le permite especificar la dimensionalidad de cada vector de palabra, denominada dimensión de salida.

Nos gustaría utilizar una representación de incrustación de palabras para el conjunto de datos de IMDB. Supongamos que solo nos interesan las primeras 5,000 palabras más utilizadas en el conjunto de datos. Por lo tanto, nuestro tamaño de vocabulario será de 5,000. Podemos optar por utilizar un vector de 32 dimensiones para representar cada palabra. Finalmente, podemos optar por limitar la extensión máxima de la reseña a 500 palabras, truncando las reseñas más largas y rellenando las reseñas más cortas con valores 0. Cargaríamos el conjunto de datos de IMDB de la siguiente manera:

    dataset_imdb(num_words=5000)

Luego, usaríamos la utilidad Keras para truncar o rellenar el conjunto de datos a una longitud de 500 para cada observación usando la función pad_sequences().

    X_train <- pad_sequences(X_train, maxlen=500)

    X_test <- pad_sequences(X_test, maxlen=500)

Las redes neuronales convolucionales se diseñaron para honrar la estructura espacial en los datos de la imagen y al mismo tiempo ser robustas a la posición y orientación de los objetos aprendidos en la escena. Este mismo principio se puede utilizar en secuencias, como la secuencia unidimensional de palabras en una reseña de películas.

Las mismas propiedades que hacen atractivo el modelo de CNN para aprender a reconocer objetos en imágenes pueden ayudar a aprender la estructura en párrafos de palabras, es decir, las técnicas de invarianza a la posición específica de las características.

Ahora podemos definir nuestro modelo de red neuronal convolucional. Esta vez:

1. Después de la capa de entrada Embedding, insertamos una capa layer_conv_1d.

   • Esta capa convolucional tiene 32 mapas de características y lee representaciones de palabras incrustadas 3 elementos vectoriales de la palabra incrustada a la vez.

   • Con una capa de convolución 2D, una ventana de convolución de 3×3 contiene 3 * 3 = 9 vectores de características; pero

   • Con una capa de convolución 1D, una ventana de convolución de tamaño 3 contiene solo 3 vectores de características. Por lo tanto, puede permitirse fácilmente ventanas de convolución 1D de tamaño 7 o 9.

2. La capa convolucional va seguida de una capa MaxPooling1D con una longitud y un paso de 2 que divide a la mitad el tamaño de los mapas de características de la capa convolucional.

3. El resto de la red es igual que la red neuronal anterior.

Hasta aquí todo es igual que lo que hemos realizado hasta ahora de preprocesamiento de imágenes. Ahora vamos a utilizar las funciones de Keras para preparar un iterador que recorra las imágenes de la carpeta y así poder entrenar nuestra red neuronal. Extisten varias opciones para realizar este iterador, así como formas de hacer data augmentation y de extender dichas opciones a las predefinidas en Keras.

En este caso vamos a empezar leyendo de un DataFrame de pandas con dos columnas, una con la ruta a la imagen y otra con la etiqueta correspondiente. Todo esto lo haremos a través de la clase image_data_generator, que se divide en dos partes como veremos a continuación. En este caso vamos a dividirlas en un 80/20 para tener datos de validación

Posterior a ello usamos el iterador flow_images_from_directory para poder recorrer las imágenes e ir teniendo nuestro conjunto de datos en perfecto estado para analizarlo

Vamos a continuar con el dataset de flores y para ello vamos a definir un nuevo image_data_generator pero solo para el train. Esta clase la hemos visto más arriba, pero vamos a definirla un poco más en detalle, ya que se divide principalmente en dos partes:

• Primero, en el constructor definimos las operaciones o modificaciones que vamos a realizar a los datos.

• Segundo, con las funciones flow generamos un iterador que se va a encargar de leer los datos. Por eso los parámetros de entrada de las funciones flow indican donde se encuentran las imágenes, el formato de estas y el tamaño de salida. También indicamos aquí el tamaño del batch del iterador.

Con esto el iterador obtenido primero cargará el batch de datos según lo indicado en los parámetros de las funicones flow y luego aplicará las funciones definidas en el constructor de image_data_generator. Estas funciones consisten en data augmentation estocástico, es decir, cada operación que se ha indicado se aplica de forma aleatoria a las diferentes datos, en este caso imágenes, de los batches.

En puntos anteriores ya hemos visto algunos conceptos básicos sobre como crear nuestras propias redes neuronales. Durante el desarrollo de las mismas habréis observado que conforme va aumentando la complejidad de la red, asi como el tamaño de nuestros datos, los resultados mejoran, a costa del tiempo de entrenamiento.

Sin embargo, ¿qué ocurre cuando no disponemos de datos suficientes o de los recursos necesarios? ¿Es posible utilizar deep learning?

1. Si la cantidad de datos que tenemos es pequeña, entrenar una red neuronal es una tarea complicada.

2. Si reducimos el tamaño de la red, los resultados que obtengamos pueden que no sean del todo satisfactorios, ya que se va a tratar de un modelo relativamente simple.

3. Si la red es demasiado grande, los pesos no se ajustarán adecuadamente con los pocos datos de entrenamiento y puede que incluso sobreajustemos a dicha información.

Otra de las limitaciones de las redes neuronales son los tiempos de entrenamiento. Cuando contamos con suficientes datos como para entrenar una red, podemos permitirnos aumentar el tamaño de esta. Sin embargo, esto aumenta el tiempo de los procesos forward y backward y la complejidad para ajustar los hiperparámetros.

Por todos estos motivos surge el Transfer Learning, donde las redes neuronales aprendidas en problemas en los que hay más disponibilidad de datos se utilizan para resolver otros problemas para los que no fueron diseñadas.

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