Capas y nodos

En Keras, una capa es una estructura fundamental que permite realizar operaciones en los datos que pasan a través de una red neuronal. Cada capa está compuesta por nodos o neuronas, que son los puntos donde se lleva a cabo el procesamiento de la información. La combinación de capas y nodos permite a la red neuronal aprender a partir de los datos, aplicando operaciones como multiplicaciones, sumas y activaciones.

1. Capas en Keras

Cada capa en Keras realiza una operación específica sobre los datos y permite definir el tipo de procesamiento que se llevará a cabo. Existen distintos tipos de capas, como densas, de convolución y recurrentes, que se eligen según el tipo de problema (clasificación de imágenes, procesamiento de texto, etc.).

Las capas se agregan al modelo en el orden en que deben ser aplicadas a los datos. Aquí explicamos las capas más comunes:

• Dense (densa): Es una capa totalmente conectada, donde cada nodo está conectado con todos los nodos de la capa anterior. Es la capa más común en redes neuronales estándar.
• Conv2D (convolucional): Capa que se usa para reconocer patrones espaciales en datos 2D (como imágenes), aplicando filtros que destacan características relevantes.
• LSTM (Long Short-Term Memory): Una capa recurrente que es ideal para el procesamiento de secuencias de datos, como texto o series temporales.

2. Nodos (Neurons)

Cada nodo (o neurona) en una capa aplica una operación matemática sobre los datos de entrada. Los datos de entrada pasan por un nodo, se multiplican por un peso, se le suma un sesgo y, finalmente, se aplica una función de activación para producir una salida. El conjunto de nodos en una capa aprende a detectar patrones específicos en los datos de entrenamiento.

Ejemplo Detallado

Aquí construimos un modelo sencillo en Keras con una capa de entrada, una capa oculta y una capa de salida. El modelo es secuencial, es decir, las capas se aplican en el orden en que se definen.

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense

# Definimos un modelo secuencial
model = Sequential()

# 1. Capa de entrada y oculta
# Dense(5) crea una capa completamente conectada con 5 nodos, que toma una entrada de dimensión 3
model.add(Dense(5, input_shape=(3,), activation='relu'))

# 2. Segunda capa oculta
# Dense(4) crea una capa completamente conectada con 4 nodos, que toma la salida de la capa anterior
model.add(Dense(4, activation='relu'))

# 3. Capa de salida
# Dense(1) crea una capa completamente conectada con 1 nodo para producir una sola salida
model.add(Dense(1, activation='sigmoid'))

# Resumen del modelo
model.summary()

Explicación del Modelo

1. Primera Capa (Dense(5, input_shape=(3,), activation='relu')):
   • Tipo de capa: Dense, lo que significa que es una capa totalmente conectada.
   • Nodos: Tiene 5 nodos.
   • Dimensión de entrada: input_shape=(3,) indica que la entrada tendrá 3 características (es decir, un vector de 3 elementos).
   • Función de activación: relu (Rectified Linear Unit) introduce no linealidad, lo cual ayuda a la red a aprender patrones complejos.
   • Parámetros aprendibles: Cada nodo en esta capa tiene 3 pesos (uno para cada entrada) y un sesgo. Esto significa que la capa tiene un total de (3 \times 5 + 5 = 20) parámetros (15 pesos + 5 sesgos).
2. Segunda Capa Oculta (Dense(4, activation='relu')):
   • Tipo de capa: Dense, nuevamente una capa totalmente conectada.
   • Nodos: Tiene 4 nodos.
   • Función de activación: relu.
   • Dimensión de entrada: Automáticamente toma la salida de la capa anterior (5 valores).
   • Parámetros aprendibles: Cada nodo tiene 5 pesos (uno para cada salida de la capa anterior) y un sesgo. La capa tiene un total de (5 \times 4 + 4 = 24) parámetros (20 pesos + 4 sesgos).
3. Capa de Salida (Dense(1, activation='sigmoid')):
   • Tipo de capa: Dense.
   • Nodos: Tiene 1 nodo (porque es una salida única).
   • Función de activación: sigmoid, que mapea la salida en el rango (0, 1), ideal para clasificación binaria.
   • Dimensión de entrada: Toma la salida de la capa anterior (4 valores).
   • Parámetros aprendibles: Tiene 4 pesos y 1 sesgo, para un total de (4 + 1 = 5) parámetros.

Resumen del Modelo

Al ejecutar model.summary(), verás algo como:

Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #
=================================================================
 dense (Dense)               (None, 5)                 20
 dense_1 (Dense)             (None, 4)                 24
 dense_2 (Dense)             (None, 1)                 5
=================================================================
Total params: 49
Trainable params: 49
Non-trainable params: 0
_________________________________________________________________

Este resumen indica que el modelo tiene un total de 49 parámetros entrenables, que serán ajustados durante el proceso de entrenamiento para aprender de los datos.

Ejemplo Completo con Entrenamiento

Supongamos que queremos entrenar este modelo en datos ficticios. Aquí un ejemplo:

import numpy as np

# Datos de entrenamiento aleatorios (10 muestras, 3 características cada una)
x_train = np.random.random((10, 3))
y_train = np.random.randint(0, 2, 10)  # Etiquetas de clase 0 o 1

# Compilación del modelo
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Entrenamiento del modelo
model.fit(x_train, y_train, epochs=10)

Explicación de la Compilación y Entrenamiento

• Compilación (compile):
  • Optimizador: adam, que es un algoritmo de optimización que ajusta los parámetros para reducir el error.
  • Función de pérdida: binary_crossentropy, utilizada para problemas de clasificación binaria.
  • Métrica: accuracy, que mide la precisión del modelo.
• Entrenamiento (fit):
  • x_train y y_train son los datos de entrada y sus etiquetas.
  • epochs=10 significa que el modelo pasará por todo el conjunto de datos 10 veces.

Keras ajustará los pesos y sesgos de las capas durante el entrenamiento para minimizar la función de pérdida y mejorar la precisión del modelo.