¿Cómo crear inteligencia artificial con Redes Neuronales?

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:

Eficiencia: Al trabajar con lotes, se reduce la sobrecarga de la memoria y se optimiza la utilización de los recursos del sistema.

Flexibilidad: Los data generators se pueden adaptar fácilmente a diferentes formatos de datos y procesos de preprocesamiento.

Aumentación de datos: Los data generators también pueden aplicar técnicas de aumentación de datos en tiempo real, lo que ayuda a mejorar el rendimiento y la generalización del modelo.

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:

  1. Eliminación de ruido y valores atípicos
  2. Manejo de datos faltantes
  3. Transformación de variables categóricas en variables numéricas
  4. Mejora de la eficiencia computacional
  5. Facilita la convergencia de algoritmos de optimización

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:

  • Error cuadrático medio (MSE – Mean Squared Error): Es una función de costo comúnmente utilizada para problemas de regresión. Calcula el promedio de los cuadrados de las diferencias entre las predicciones y los valores verdaderos.
  • Error absoluto medio (MAE – Mean Absolute Error): Similar al MSE, pero en lugar de calcular el promedio de los cuadrados de las diferencias, calcula el promedio de los valores absolutos de las diferencias. También se usa principalmente en problemas de regresión.
  • Entropía cruzada binaria (Binary Cross-Entropy): Se utiliza en problemas de clasificación binaria. Mide la discrepancia entre las etiquetas verdaderas y las predicciones probabilísticas del modelo.
  • Entropía cruzada categórica (Categorical Cross-Entropy): Se utiliza en problemas de clasificación multiclase. Mide la discrepancia entre las etiquetas verdaderas codificadas en one-hot y las predicciones probabilísticas del modelo para cada clase.
  • Entropía cruzada escasa (Sparse Categorical Cross-Entropy): Es similar a la entropía cruzada categórica, pero se utiliza cuando las etiquetas verdaderas son enteros en lugar de codificación one-hot.
  • Hinge Loss: Se utiliza en máquinas de vectores de soporte (SVM) y en algunas redes neuronales para problemas de clasificación. Busca maximizar el margen entre las clases.
  • Huber Loss: Es una combinación de MSE y MAE y es menos sensible a los valores atípicos en comparación con el MSE. Se utiliza en problemas de regresión.
  • Pérdida logarítmica (Log Loss): Mide el rendimiento de un modelo de clasificación en el que la entrada de predicción es una probabilidad de pertenecer a una clase específica.
  • Pérdida de Kullback-Leibler Divergence (KL Divergence): Mide la diferencia entre dos distribuciones de probabilidad. Se utiliza en problemas de regresión y clasificación cuando se busca minimizar la discrepancia entre las distribuciones de probabilidad verdaderas y las predichas por el modelo.
  • Pérdida de Cosine Similarity: Mide la similitud entre dos vectores al calcular el coseno del ángulo entre ellos. Se puede utilizar en problemas de clasificación y regresión.
  • Pérdida de Poisson: Mide la discrepancia entre las predicciones y los valores verdaderos en función de la distribución de Poisson. Se utiliza en problemas de regresión.

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

estructura 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

# Importa las bibliotecas necesarias
import tensorflow as tf
import matplotlib.pyplot as plt
# Carga el dataset MNIST
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Encuentra el índice del primer número 8 en el conjunto de entrenamiento
index = 0
for i, label in enumerate(y_train):
    if label == 8:
        index = i
        break
# Muestra el número 8 usando Matplotlib
plt.imshow(x_train[index], cmap=”gray”)
plt.title(“Número 8”)
plt.show()
Si enviásemos como parámetro a una red neuronal los píxeles de la imagen ésta podría llegar a reconocer los patrones de la imagen y presentar buen rendimiento. Sin embargo, las redes neuronales tradicionales no son muy buenas detectando patrones en imágenes. Funcionan bien cuando las imágenes son muy pequeñas y los patrones muy simples ya que para la red neuronal es muy difícil encontrar “formas” diferentes posiciones de una imagen grande. Sin embargo, si hay pocos pixeles producir una activación en una neurona si en una zona muy concreta de la imagen hay determinado patrón distribuido siempre en los mismos pixeles es más sencillo.
La estrategia de las redes neuronales convolucionales consiste en aplicar un tipo de capas especiales al comienzo de la red neuronal para detectar esos patrones y luego conectar esas capas a una red clásica o directamente a una capa de output. Estas capas funcionan con una lógica diferente a la que hemos visto en las redes clásicas.

Entendiendo los kernel

Un kernel, también conocido como filtro, es una matriz de valores utilizada en una red neuronal convolucional (CNN) para realizar convoluciones en la imagen de entrada. La convolución es una operación matemática que implica deslizar el kernel sobre la imagen de entrada y calcular el producto punto a punto y sumar los resultados, produciendo así una nueva matriz llamada mapa de características. Esto permite que la CNN extraiga características de la imagen, como bordes, texturas y patrones.
Estas matrices se aplican pixel por pixel aplicando la operación de matrices de convolución.
GIF ilustrativo:
kernel
Dicha operación consiste en multiplicar todos los números superpuestos de la matriz y sumar el resultado de la operación.
Fuente de la imagen: https://medium.com/@bdhuma/6-basic-things-to-know-about-convolution-daef5e1bc411
¿Y cómo puede eso ayudarnos a mejorar la información? Párate a analizar qué pasaría si usaras el siguiente kernel:
matriz

Este kernel nos puede servir para detectar bordes verticales. Piénsalo, si NO hay un cambio de color en los píxeles de la izquierda respecto a los de la derecha, dado que los de la derecha se quedan igual (se multiplican por 1) y los de la derecha cambian de signo (se multiplican por -1), se cancelarán. Ahora bien, si tienen valores diferentes (hay un cambio de color en vertical) el resultado será mayor. Razón por la que podemos buscar formas de tener kernels para detección de bordes.

Por ejemplo, aquí tendríamos un kernel para detección de bordes horizontales:

matriz
En el siguiente ejemplo de detección de bordes puedes observar que en el resultado se pueden apreciar los bordes en función de la intensidad de los píxeles.
import cv2
import numpy as np
import matplotlib.pyplot as plt
from scipy.signal import convolve2d
import requests
from PIL import Image
from io import BytesIO
# Descarga una imagen del dataset Caltech101
image_url = “https://img.huffingtonpost.es/files/main_image_720_480/uploads/2023/04/21/elon-musk-en-la-alfombra-de-la-met-gala-de-2022.jpeg”
response = requests.get(image_url)
img = Image.open(BytesIO(response.content))
# 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, 0, -1],
                   [1,  0,-1],
                   [1, 0, -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 detección de bordes horizontal:
# 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()