¿Cómo crear inteligencia artificial con Redes Neuronales?

En los últimos artículos hemos comentado todos los aspectos conceptuales importantes sobre redes neuronales. Pero todavía nos queda en el tintero algunas cosas importantes y algunas incógnitas por resolver. Sí, vale, ya entiendo cómo funcionan las redes neuronales. Pero… ¿Con qué criterio escojo las propiedades de mis redes neuronales? ¿Cómo puedo entrenar redes neuronales con millones de datos como hacen las grandes compañías?

En este artículo lo aprenderemos y haremos un ejemplo en código de un clasificador de imágenes aprendiendo también el concepto de red neuronal convolucional. Como todo lo que voy a explicar son conceptos muy independientes, en esta ocasión adoptaré un formato un poco diferente y primero le daré más relevancia a lo teórico. Luego, nos pondremos manos a la obra con nuestro modelo.

Antes de nada si te has perdido los episodios anteriores aquí te dejamos los enlaces:

Capítulo 1 – Tutorial inteligencia artificial
Capítulo 2 – Entendiendo las Redes Neuronales
Capítulo 3 – Uso de la Matrices para las Redes Neuronales
Capítulo 4 –¿Qué es el overfitting?

¿Listo? ¡Vamos a por ello!

Entrenando Modelos Gigantes de Deep Learning: Descubre el Poder de los Data Generators

¿Alguna vez te has preguntado cómo se entrenan modelos de deep learning con millones de datos si éstos no caben en nuestros ordenadores? Si has estado investigando el mundo del deep learning, es probable que hayas encontrado este problema. La memoria RAM de nuestros sistemas, aunque cada vez más grande, sigue siendo limitada, y muchos conjuntos de datos superan ampliamente estas capacidades.

Aquí es donde entra en juego el concepto de data generators o generadores de datos. Pero, ¿qué son exactamente y cómo nos ayudan a entrenar modelos gigantes?

Los data generators son una solución inteligente para el problema de la falta de memoria RAM. En lugar de cargar todo el conjunto de datos en la memoria, los data generators leen y procesan los datos en pequeños lotes o batches. Esto permite a nuestros modelos trabajar con datos mucho más grandes de lo que podría caber en nuestra memoria RAM.

Bien, ¿Y cómo Funcionan los Data Generators? El proceso es bastante simple. Los data generators leen una parte del conjunto de datos (un batch) desde el almacenamiento, la procesan y la envían al modelo para el entrenamiento. Una vez que se completa el entrenamiento con ese lote, el data generator lee el siguiente lote y repite el proceso. De esta manera, el modelo puede entrenarse con todo el conjunto de datos sin la necesidad de cargarlo completamente en la memoria.

Beneficios de Usar Data Generators

Además de permitirnos trabajar con conjuntos de datos más grandes de lo que la memoria RAM puede soportar, los data generators también tienen otros beneficios, como:

Criterios para diseñar una red neuronal

Antes de empezar te advierto que para varios aspectos te encontrarás que no hay un criterio definido para definir varias características de nuestra red neuronal más que intuición y experiencia. Al final de éste apartado te mostraré una forma profesional de buscar algorítmicamente los valores más eficientes de todas esas características.

Cuando se trata de diseñar la estructura de una red neuronal, hay varias decisiones que debemos tomar, desde la cantidad de capas y neuronas hasta los optimizadores y funciones de coste. Con tantas opciones disponibles, ¿cómo podemos tomar las decisiones correctas? ¡Que alguien llame a un senior!

1. Determina la cantidad de capas y neuronas (y su función de activación)

La cantidad de capas y neuronas en cada capa puede afectar significativamente el rendimiento de tu red neuronal. Aquí hay algunas pautas para ayudarte a decidir:

• Capa de entrada: Aquí no hay mucho que discutir: El número de neuronas en la capa de entrada debe coincidir con el número de características de entrada en tus datos. Pero ten en cuenta que cuanto más sencilla sea la entrada sin perder información más fácil será que tu red aprenda. Si por ejemplo trabajas con imágenes, considera reducir su resolución a un punto donde la información relevante no se pierda.
• Capas ocultas: No hay una regla única para determinar la cantidad de capas ocultas y neuronas. Sin embargo, en general, más capas pueden ayudar a aprender patrones más complejos, pero también pueden aumentar el riesgo de overfitting y el tiempo de entrenamiento. Prueba con diferentes configuraciones y elige la que mejor funcione para tu problema. (Luego vemos una forma más interesante de enfocar esto)
• Capa de ouptut: El número de neuronas en la capa de salida depende del tipo de problema y sobre todo de la solución que quieres que tu modelo ofrezca. Para clasificación binaria, necesitas una única neurona, mientras que para clasificación multiclase, necesitas tantas neuronas como clases. Para problemas de regresión, una única neurona es suficiente.

Funciones de activación

Las funciones de activación son un componente crucial, ya que introducen no linealidades en el modelo, permitiendo que las redes aprendan patrones más complejos. Pero claro, esa no-linealidad tiene un comportamiento muy distinto entre cada función de activación. Elegir la función de activación adecuada para cada capa de la red es esencial para garantizar un buen rendimiento. A continuación, se presentan algunos criterios para elegir funciones de activación según el tipo de capa:

Capa de entrada

En general, no se aplican funciones de activación en la capa de entrada, ya que los datos de entrada suelen ser valores en bruto o características previamente procesadas. Sin embargo, sí es importante preprocesar los datos de entrada.

El preprocesamiento de datos es un paso esencial en el proceso de construcción de modelos de aprendizaje automático y profundo, ya que ayuda a mejorar la calidad de los datos y, por lo tanto, el rendimiento del modelo. Algunas razones por las que el preprocesamiento de datos es importante incluyen:

Feature Scaling (Escalado de características) es una técnica de preprocesamiento que se utiliza para garantizar que todas las características tengan la misma escala o rango, lo que facilita la comparación y la interpretación de las características. En muchos algoritmos de aprendizaje automático y profundo, el escalado de características es esencial para garantizar la convergencia rápida y un rendimiento óptimo.

Existen diferentes técnicas. Las más usuales son:

Normalización (Min-Max Scaling): Transforma las características al rango [0, 1] ajustando cada característica según sus valores mínimo y máximo.

x norm= x – x(min) / x(max) – x(min)

Estandarización (Z-score Scaling): Transforma las características para que tengan media 0 y desviación estándar 1, eliminando la unidad de medida y permitiendo comparar características con diferentes escalas y distribuciones.

x std= x – μ / σ

Escalado robusto (Robust Scaling): Utiliza la mediana y el rango intercuartil para escalar las características, lo que lo hace más resistente a los valores atípicos en comparación con la normalización y la estandarización.

x robust = x – Q1 / Q3 – Q1

Ejemplo:

Supongamos que se te pide establecer una relación entre la edad de las personas y su salario anual con la intención de compra. En este caso, la edad y el salario anual tienen diferentes escalas: la edad varía típicamente entre 0 y 100 años, mientras que el salario anual puede variar desde unos miles hasta varios millones. Si no se escalan las características, el salario anual dominará la relación debido a su mayor magnitud y la edad no tendrá tanto peso en el modelo.

Para evitar esto, puedes aplicar una técnica de escalado de características, como la estandarización. Al hacerlo, la edad y el salario anual se transformarán para que tengan una media de 0 y una desviación estándar de 1, lo que permitirá al algoritmo de aprendizaje automático considerar adecuadamente la importancia de ambas características al predecir la intención de compra.

Para desarrollar un criterio que nos permita afrontar éste desafío recomiendo estudiar ciencia de datos y realizar ejercicios.

Capas ocultas

Para las capas ocultas, hay varias opciones de funciones de activación, y elegir la adecuada dependerá del problema y del tipo de datos:

• ReLU (Rectified Linear Unit): Es la función de activación más comúnmente utilizada en las capas ocultas debido a su simplicidad y eficiencia computacional. Funciona bien en la mayoría de los casos, pero puede sufrir del problema de “neuronas muertas” si la salida de la activación es siempre negativa.
• Leaky ReLU y Parametric ReLU (PReLU): Son variantes de la ReLU que resuelven el problema de las neuronas muertas al permitir valores negativos pequeños en la salida. Pueden ser útiles en casos donde las ReLU estándar no funcionan bien.
• Sigmoid: Fue popular en el pasado, pero ahora se usa con menos frecuencia en las capas ocultas debido a problemas como el desvanecimiento del gradiente y la saturación. Sin embargo, sigue siendo útil en ciertos casos, como en modelos de redes neuronales recurrentes (RNN) y en problemas de clasificación binaria.
• Tangente hiperbólica (tanh): Es similar a la función sigmoidal, pero varía entre -1 y 1 en lugar de 0 y 1. Al igual que la sigmoidal, puede sufrir de desvanecimiento del gradiente, pero aún se usa en algunos casos, como en las RNN.
• Swish, ELU y otras funciones de activación avanzadas: Existen varias funciones de activación más avanzadas que pueden ofrecer mejoras en la convergencia y el rendimiento del modelo. Si las funciones de activación tradicionales no ofrecen buenos resultados, podrías experimentar con estas funciones más avanzadas.

Capa de output

La elección de la función de activación en la capa de salida depende del tipo de problema y de la tarea que estés resolviendo:

• Regresión: En general, no se aplica ninguna función de activación “diferente” para transformar los datos en problemas de regresión, ya que se busca una salida continua en un rango no acotado. Sin embargo, si necesitas restringir el rango de la salida, podrías usar funciones de activación como ReLU, sigmoid o tanh.
• Cuando tu tarea es clasificar algo en dos categorías (como detectar si un correo es spam o no), típicamente se utiliza la función sigmoide. Esta función convierte los números de entrada en probabilidades que suman 1, lo que es muy útil para representar la probabilidad de que una entrada pertenezca a una de las dos clases.
• Clasificación multiclase: Si estás en el negocio de clasificar cosas en más de dos categorías (como clasificar imágenes de dígitos escritos a mano), la función softmax es la que sueles querer. Similar a la sigmoide, convierte los números de entrada en probabilidades. Pero en este caso, te da un conjunto de probabilidades que suman 1 para todas las posibles clases.

2. Elige el tipo de función de coste y el optimizador

La función de coste y el optimizador son componentes críticos en el entrenamiento de una red neuronal. Algunas pautas para elegirlos son:

Función de coste

Elegir función de coste suele ser cuestión de experiencia y en función del tipo de problema a resolver. De todas las funciones que existen, las hay idóneas para un tipo de problema. Y la lógica para elegirlas suele ser mirar una tabla. Tipo, “Para problemas de clasificación, utiliza funciones como la entropía cruzada. Para problemas de regresión, el error cuadrático medio es una opción popular…”

Te dejo una tabla bastante completa recatada de mis apuntes:

Optimizador

Como vimos en el anterior post, Adam suele ser la que tiene mejor rendimiento pero hay que tener en cuenta que continuamente se están descubriendo nuevos optimizadores y esto puede quedar obsoleto. Elegir optimizador es cuestión de estar al día de las noticias de Deep Learning.

3. Configura el porcentaje de dropout, regularización y learning rate

Estos parámetros pueden ayudar a prevenir el sobreajuste y mejorar el rendimiento del modelo:

• Dropout: Utiliza dropout en las capas ocultas para evitar la “coadaptación” que comentamos en el artículo del overfitting. Los valores típicos varían entre 0.2 y 0.5 y no hay un criterio fijo.
• Learning rate: Elige un learning rate que permita una convergencia estable y rápida. Prueba con diferentes valores y monitorea el progreso del entrenamiento. Pero bueno, con la propiedad adaptativa del learning rate en el uso de optimizadores como Adam pese a ser cuestión de try and error suele no dar dolor de cabeza.
• Regularización: La elección entre regularización L1 y L2 en redes neuronales depende del problema a resolver. L1 genera soluciones dispersas, favoreciendo modelos más interpretables y seleccionando características importantes, mientras que L2 reduce suavemente los coeficientes para modelos más equilibrados. Si se esperan pocas características importantes, se puede usar L1; si se cree que todas son relevantes, se puede optar por L2. También se puede utilizar “Elastic Net”, que combina L1 y L2.

4. Establece la duración del entrenamiento o criterios de early stopping

• Duración del entrenamiento: Puedes establecer un número fijo de épocas para el entrenamiento. Sin embargo, esto puede resultar en underfitting o overfitting. Lo mejor es aplicar un criterio para parar el entrenamiento cuando el modelo no mejora sus resultados. (veremos esto más abajo)

El Arte de encontrar la Combinación Idónea: Automatiza el Proceso con KerasTuner

Encontrar la combinación perfecta de ajustes para todos los parámetros mencionados en la sección anterior puede ser un proceso complicado y lleno de prueba y error. Afortunadamente, existen herramientas como KerasTuner que pueden facilitar esta tarea al automatizar el proceso de búsqueda de la configuración óptima para tu red neuronal.

Nosotros usaremos KerasTuner. Se trata de una biblioteca de Python para ajuste de hiperparámetros en modelos de aprendizaje profundo creados con Keras (que es parte de TensorFlow). Esta herramienta simplifica el proceso de encontrar la combinación idónea de hiperparámetros al realizar búsquedas automatizadas y eficientes.

La idea es definir un espacio de búsqueda para los hiperparámetros que deseas optimizar, como la cantidad de capas ocultas, el número de neuronas, la tasa de aprendizaje, el optimizador, entre otros. Luego, KerasTuner evalúa diferentes combinaciones de estos hiperparámetros y encuentra la configuración que produce el mejor rendimiento en función de una métrica de validación predefinida.

Aplicando todo lo aprendido con Tensorflow y Keras programando una CNN

¿Alguna vez te has preguntado cómo es posible que aplicaciones como Facebook o Google Fotos puedan reconocer a tus amigos en las fotos que subes? ¡La respuesta está en las redes neuronales convolucionales (CNN)! Sigue leyendo y descubre cómo estas asombrosas arquitecturas de deep learning están revolucionando el mundo de la clasificación de imágenes.

Estructura de una CNN

Imagina que quieres que una red neuronal detecte los patrones para detectar si una foto de un carácter escrito a mano es un dígito entre 0 y 9. Probablemente pienses, “oh claro, la red neuronal buscará patrones de formas a través de píxeles contiguos”. Por ejemplo, un “8” son 2 círculos posicionados uno encima del otro. Un “1” es un palo o un palo cuya parte superior tiene un palito pequeño en diagonal y la parte inferior puede tener un palito pequeño perpendicular.

Ejemplo para el dígito 8

# Convierte la imagen a escala de grises y a un array de NumPy
img_gray = img.convert(‘L’)
img_gray_np = np.array(img_gray)# Define un kernel para la detección de bordes
kernel = np.array([[1, 1, 1],
[0, 0,0],
[-1, -1, -1]])# Aplica el kernel a la imagen utilizando convolución 2D
img_edges = convolve2d(img_gray_np, kernel, mode=’same’)# Aplica el umbral a la imagen de bordes
threshold = 50
img_edges[img_edges > threshold] = 255
img_edges[img_edges <= threshold] = 0# Muestra la imagen original y la imagen con bordes detectados
fig, axes = plt.subplots(1, 2, figsize=(10, 5))axes[0].imshow(img)
axes[0].set_title(‘Imagen original’)axes[1].imshow(img_edges, cmap=’gray’)
axes[1].set_title(‘Imagen con bordes detectados’)plt.show()

Ejemplo con otros kernels de detección de bordes

# Convierte la imagen a escala de grises y a un array de NumPy
img_gray = img.convert(‘L’)
img_gray_np = np.array(img_gray)# Define un kernel para la detección de bordes
kernel = np.array([[-1, -1, -1],
[-1, 8,-1],
[-1, -1, -1]])# Aplica el kernel a la imagen utilizando convolución 2D
img_edges = convolve2d(img_gray_np, kernel, mode=’same’)# Aplica el umbral a la imagen de bordes
threshold = 50
img_edges[img_edges > threshold] = 255
img_edges[img_edges <= threshold] = 0# Muestra la imagen original y la imagen con bordes detectados
fig, axes = plt.subplots(1, 2, figsize=(10, 5))axes[0].imshow(img)
axes[0].set_title(‘Imagen original’)axes[1].imshow(img_edges, cmap=’gray’)
axes[1].set_title(‘Imagen con bordes detectados’)plt.show()

Como ya te habrás imaginado, para una red neuronal es mucho más fácil detectar patrones de formas con ésta información que sin ella. Por ello, la detección de bordes es algo fundamental para detectar patrones de formas en imágenes. Aunque realmente los kernels de las CNNs se crean con valores aleatorios y es el entrenamiento de la red el que los va definiendo.

Teniendo en cuenta que las imágenes tienen tres datos por píxel (intensidad del color rojo, verde y azul) las convoluciones también sirven para detectar patrones relacionados con colores. O patrones de colores y formas combinados.

A este proceso de aplicar kernels a una imagen se le conoce como capas de convolución. Existen formas más avanzadas de trabajar con kernels y si quieres buscar más información te recomiendo que te informes acerca de el padding y los strides de un Kernel.

Cada capa de convolución aplica más de un kernel para tratar de detectar tipos de patrones diferentes. ¿Problema? Pues cada vez que aplicas una convolución obtienes más información ya que, por ejemplo, pasas de tener una sola imagen a una imagen con los bordes verticales y otra con las horizontales. Mientras antes ibas a usar como parámetro de tu red una sola imagen ahora son 2. De forma que conforme más convoluciones apliques más lenta será tu red. Precisamente comentamos que las redes clásicas son malas posicionando patrones en imágenes grandes…

Para solucionar éste problema se usan las capas de Pooling. Existen varios tipos pero principalmente se usa MaxPooling ya que es la que generalmente da mejor resultado. Funciona como la capa de convolución solo que en lugar de realizar la operación de convolución matricial lo que hace es quedarse solamente con el valor máximo.

GIF ilustrativo:

Las capas de Pooling solucionan nuestros dos principales problemas:

Por un lado generan un output más pequeño que el input sin perder información, ya que al quedarse con los valores más altos reduce la escala de los patrones conservándolos.

Por otro lado, al generar imágenes de los patrones más pequeñas, hace que estas sean más afines a una red neuronal convencional.

Probablemente pienses… ¿Seguro que no se pierde información? Si el output es más pequeño… ¿no estamos bajando la resolución? Para que estés seguro de lo que digo, te muestro un ejemplo:

Volvamos a analizar la arquitectura de una red neuronal convolucional…

Básicamente lo que haremos es tratar de generar muchas imágenes de detección de patrones pero muy pequeñas para que nuestra red neuronal clásica pueda detectar los patrones. Para ello, iremos alternando entre capas de convolución y de pooling. Básicamente alternamos entre “buscar patrones” y “condensar información encontrada”, luego reanudar el ciclo hasta que las imágenes de los patrones sean lo suficientemente pequeñas para ser digeridas por nuestra red convencional o, en casos sencillos, directamente conectar las capas con el output.

Explicadas las CNNS estamos listos para practicar todo lo que hemos aprendido.

Importamos dependencias

Usamos un “data generator” para tener un dataset más grande. Básicamente ésto lo que hace es crear imágenes nuevas a partir del dataset original. Lo hace aplicando transformaciones como zoom, traslación o rotación.

Paso muy importante, buscamos los hyperparámetros ideales para nuestro modelo.

Por aquí personalizamos un callback que se llamará cada época para detener el entrenamiento si llegamos al 0.99 de accuracy en los datos de validación.

Configuramos el criterio para guardar los pesos del modelo para que se guarde el punto del entrenamiento con mejor accuracy en los datos de validación.

Instanciamos el modelo con los parámetros más eficientes.

Si ya lo tuviéramos guardado, lo gargaríamos del siguiente modo:

Procedemos al entrenamiento:

Guardamos el modelo: ¡Qué no se pierda!

Observamos los resultados:

Función para graficar entrenamiento:

Con esta explicación quedaría concluido el tutorial de las IA, hemos pasado de forma detallada desde cómo funciona hasta cómo crearla, explicando muchos conceptos específicos y mostrando con código ejemplos de cómo funciona de forma interna ¡Espero que os haya sido de utilidad y nos veremos dentro de poco con otros artículos!