Redes neuronales artificiales

📐 Fundamento

Funciones de activación:

¿Por qué se necesita la no linealidad?

Sin funciones de activación no lineales, apilar capas lineales equivale a una sola transformación lineal — el modelo no puede aprender patrones complejos. ReLU introduce la no linealidad necesaria con una operación muy barata.

El perceptrón (una sola neurona):

import numpy as np

def perceptron(x, w, b, activacion='relu'):
    z = np.dot(w, x) + b
    if activacion == 'relu':
        return max(0, z)
    elif activacion == 'sigmoid':
        return 1 / (1 + np.exp(-z))

# Ejemplo: neurona que predice "¿vale la pena hacer descuento?"
# Features: [gasto_promedio, frecuencia_visitas, cantidad_personas]
w = np.array([0.3, 0.5, 0.2])
b = -0.8
x = np.array([50.0, 8.0, 3.0])  # cliente con buen historial
print(perceptron(x, w, b, 'sigmoid'))  # probabilidad de descuento

📐 Fundamento

Arquitectura de una red MLP:

Entrada:        Capa oculta 1:    Capa oculta 2:    Salida:
x1 ─────────┐   [neuron 1]       [neuron A]         [ŷ]
x2 ─────────┼─→ [neuron 2] ─────→ [neuron B] ──────→
x3 ─────────┘   [neuron 3]       [neuron C]

Implementación con Keras/TensorFlow:

import tensorflow as tf
from tensorflow import keras

# Arquitectura
modelo = keras.Sequential([
    keras.layers.Dense(64, activation='relu', input_shape=(4,)),  # 4 features
    keras.layers.Dense(32, activation='relu'),
    keras.layers.Dense(1, activation='sigmoid')   # salida binaria
])

# Compilar: elegir optimizador, función de pérdida, métricas
modelo.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

# Ver la arquitectura
modelo.summary()
# Total params: 64*4+64 + 32*64+32 + 1*32+1 = 2,369 parámetros

# Entrenar
historial = modelo.fit(
    X_train, y_train,
    epochs=50,
    batch_size=32,
    validation_split=0.2,
    verbose=1
)

# Evaluar
loss, acc = modelo.evaluate(X_test, y_test)
print(f"Test accuracy: {acc:.2%}")

Hiperparámetros clave:

📐 Fundamento

Función de pérdida (loss function):

Mide qué tan equivocada está la predicción:

(Binary Crossentropy para clasificación binaria)

Descenso de gradiente:

donde $\alpha$ es el learning rate y $\nabla_\theta J$ es el gradiente de la pérdida respecto a los parámetros.

Variantes del descenso de gradiente:

Optimizadores modernos:

# Adam: adapta el learning rate por parámetro — el más usado
optimizer = keras.optimizers.Adam(learning_rate=0.001)

# SGD con momentum
optimizer = keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)

# RMSprop: bueno para RNNs
optimizer = keras.optimizers.RMSprop(learning_rate=0.001)

El problema del gradiente que desaparece (vanishing gradient):

En redes muy profundas con sigmoid/tanh, los gradientes se hacen exponencialmente pequeños al propagarse hacia atrás — las primeras capas aprenden muy lento.

Soluciones:

• Usar ReLU (gradiente = 1 para valores positivos, no desaparece).
• Batch Normalization.
• Arquitecturas residuales (ResNet).

📐 Fundamento

Capas de una CNN:

Imagen → [Conv + ReLU] → [Pooling] → [Conv + ReLU] → [Pooling] → [Flatten] → [Dense] → Salida

Convolución: aplica un filtro (ej: 3×3) deslizándolo sobre la imagen:

# Ejemplo conceptual de una convolución 1D
señal = [1, 2, 3, 4, 5, 6, 7]
filtro = [1, 0, -1]  # detector de bordes

resultado = []
for i in range(len(señal) - len(filtro) + 1):
    conv = sum(señal[i+j] * filtro[j] for j in range(len(filtro)))
    resultado.append(conv)
# resultado: [-2, -2, -2, -2, -2]

Pooling: reduce la dimensión tomando el máximo (MaxPooling) o promedio de cada región:

Antes de pooling (4×4):     Después de MaxPool 2×2:
1 3 2 4                     3 4
5 6 1 2    ─MaxPool──→      6 3
8 2 3 1    (2×2)
4 1 0 3

CNN simple en Keras:

from tensorflow.keras import layers, models

cnn = models.Sequential([
    # Capa convolucional: 32 filtros 3×3
    layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
    layers.MaxPooling2D((2,2)),
    
    layers.Conv2D(64, (3,3), activation='relu'),
    layers.MaxPooling2D((2,2)),
    
    layers.Flatten(),          # convertir a vector 1D
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')  # 10 clases
])

cnn.compile(optimizer='adam', loss='sparse_categorical_crossentropy', 
            metrics=['accuracy'])

Arquitecturas famosas:

• LeNet-5 (1998): Primera CNN exitosa — reconocimiento de dígitos.
• AlexNet (2012): Ganó ImageNet con 15.3% de error. Inicio del deep learning moderno.
• ResNet (2015): 152 capas con conexiones residuales. Superó a humanos en ImageNet.
• EfficientNet (2019): Estado del arte en efficiency/accuracy.

Transfer learning:

# Usar ResNet50 preentrenada en ImageNet, reemplazar solo la capa de salida
base_model = keras.applications.ResNet50(
    weights='imagenet', include_top=False, input_shape=(224,224,3)
)
base_model.trainable = False  # congelar pesos preentrenados

x = base_model.output
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(256, activation='relu')(x)
salida = layers.Dense(5, activation='softmax')(x)  # 5 clases propias

modelo = keras.Model(inputs=base_model.input, outputs=salida)