Redes neuronales: de los perceptrones al deep learning

El 10 de marzo de 2016, en la segunda partida de una serie de cinco en Seúl, una máquina llamada AlphaGo colocó una piedra negra en la quinta línea del tablero. La jugada era tan extraña que los comentaristas humanos asumieron que era un error. Un profesional dijo en voz alta que a un principiante le regañarían por jugarla. Lee Sedol — campeón mundial 18 veces en el juego del Go — se levantó y salió de la sala para recomponerse.

No fue un error. Cincuenta movimientos más tarde, esa piedra — ya famosa como la «Jugada 37» — fue la bisagra sobre la que giró toda la partida. AlphaGo ganó. Lee Sedol, considerado uno de los mejores jugadores vivos, perdió la serie 4-1. Y aquí está la parte que importa: ningún humano le enseñó a AlphaGo esa jugada. No estaba en ningún libro de texto. La máquina la había descubierto por sí sola, jugando millones de partidas contra sí misma y ajustando miles de millones de pequeños números internos hasta que emergió un patrón que ninguna persona había visto nunca.

El Go tiene más posiciones posibles en el tablero que átomos hay en el universo observable. No se puede resolver por fuerza bruta. No se pueden escribir reglas para él. La única forma de jugarlo a un nivel sobrehumano es aprenderlo — y lo que estaba aprendiendo era una red neuronal: una pila de unidades matemáticas simples que, con suficientes datos y suficiente ajuste, puede encontrar estructura que ningún humano puede articular por completo.

Esa misma maquinaria — las mismas sumas ponderadas, el mismo bucle de entrenamiento, los mismos empujones de gradiente — es lo que impulsa el modelo de lenguaje con el que hablas, el sistema que detecta transacciones fraudulentas con tarjeta, y los modelos que los fondos cuantitativos ahora apuntan a los mercados financieros. Esta lección trata sobre lo que realmente ocurre dentro de esa caja.

Toda red neuronal — desde un simple filtro antispam hasta GPT o AlphaGo — desciende de una única idea: el perceptrón, inventado por Frank Rosenblatt en 1958. Es un modelo matemático vagamente inspirado en una neurona biológica. Una neurona real recibe señales eléctricas a través de sus dendritas, las acumula en el cuerpo de la célula, y dispara una señal por su axón solo si la entrada combinada supera un umbral. El perceptrón hace lo mismo, solo que con números en lugar de voltaje.

Un perceptrón toma un vector de entradas x, multiplica cada entrada por un peso aprendido w, suma los productos, añade un término de sesgo (bias) b que desplaza el umbral, y pasa el resultado a través de una función de activación. Si el resultado supera la barra, la neurona «se dispara»; si no, se mantiene callada. Todo se resume en una expresión compacta: salida = f(w·x + b).

Piensa en los pesos como reguladores de volumen. Cada entrada llega con cierta intensidad, y el peso decide cuánto importa esa entrada para esta neurona en particular. Una neurona que aprende a detectar una operación fraudulenta podría subir al máximo el peso de «tamaño de la transacción en relación con el historial de la cuenta» y bajar el peso de «hora del día». El aprendizaje, en su núcleo, no es nada más glamuroso que girar esos reguladores hasta los valores correctos.

Un solo perceptrón tiene un límite duro: solo puede separar datos con una línea recta (o, en dimensiones más altas, un hiperplano plano). Puede responder «¿este punto está por encima o por debajo de la línea?» pero no «¿está este punto dentro de la región curva?». El ejemplo histórico es el problema XOR — un patrón que un solo perceptrón demostrablemente no puede aprender, una limitación que ayudó a congelar la financiación de la IA durante años en la década de 1970. La escapatoria es casi absurdamente simple en retrospectiva: apilar muchos perceptrones en capas e insertar una activación no lineal entre ellas. Haz eso, y la red resultante puede doblar, plegar y esculpir el espacio en formas arbitrariamente complejas.

Una neurona es un regulador. Una red útil son miles de ellas, organizadas en capas que pasan información hacia delante como una cadena de cubos.

• Capa de entrada — donde entran tus características en bruto: los píxeles de una imagen, las palabras de una frase, o para un modelo de trading, cosas como el precio, el volumen, la volatilidad y el desequilibrio del libro de órdenes.
• Capas ocultas — las capas intermedias, donde ocurre el trabajo real. Cada capa toma las salidas de la anterior y las recombina en características nuevas, más abstractas.
• Capa de salida — la respuesta final: una probabilidad, una previsión de precio, una etiqueta de clase.

La palabra «profundo» (deep) en deep learning simplemente significa muchas capas ocultas. Y la profundidad compra algo específico: una jerarquía de características. En una red para imágenes, la primera capa detecta bordes, la siguiente ensambla bordes en formas, la siguiente ensambla formas en objetos. Nadie programó «detector de bordes» ni «detector de ojos» — esos conceptos emergen del entrenamiento. La red inventa su propio vocabulario intermedio.

Hay un resultado teórico precioso aquí, el teorema de aproximación universal: una red con incluso una sola capa oculta, dado suficientes neuronas, puede aproximar cualquier función continua con precisión arbitraria. Dicho de otro modo, la red adecuada puede en principio representar cualquier patrón que exista en tus datos. La trampa — y es grande — es que «en principio» hace mucho trabajo. El teorema promete que tal red existe; no dice nada sobre si puedes encontrarla, si tienes suficientes datos para fijarla, o si el patrón que persigues es siquiera real. En dominios de señal baja como las finanzas, esa brecha entre «representable» y «aprendible» es exactamente donde van a morir la mayoría de los modelos.

Aquí hay un hecho que sorprende a la gente: sin funciones de activación, la profundidad no vale nada. Si cada capa fuera una simple suma ponderada, entonces apilar diez capas sería matemáticamente idéntico a una sola capa — una cadena de operaciones lineales se colapsa en una sola operación lineal. Habrías gastado una fortuna en cómputo para construir una línea recta glorificada. Las funciones de activación son el quiebre no lineal insertado entre capas que permite que la red se doble, y doblarse es lo que la hace potente.

Las activaciones que todo practicante debería conocer:

• Sigmoide — σ(x) = 1/(1+e⁻ˣ). Comprime cualquier entrada en (0, 1), lo cual se lee de forma natural como una probabilidad. Genial para una salida binaria, pero una mala elección dentro de capas ocultas: para entradas muy positivas o muy negativas la curva se aplana, su gradiente cae casi a cero, y el aprendizaje se detiene — el problema del gradiente que se desvanece.
• Tanh — genera salidas en (−1, 1) y está centrada en cero, lo cual ayuda a la optimización. Sigue saturándose en los extremos, aunque menos drásticamente que la sigmoide.
• ReLU — f(x) = max(0, x). El valor por defecto moderno para las capas ocultas. Es ridículamente simple, barata de calcular, y mantiene un gradiente saludable para todas las entradas positivas. Su defecto es la «ReLU muriente»: una neurona que se ve empujada a generar siempre cero puede quedar permanentemente inerte.
• Leaky ReLU — f(x) = max(0,01x, x). Deja pasar un pequeño hilo de gradiente para los negativos, lo que evita que las neuronas mueran.
• GELU — una pariente suave y probabilística de la ReLU que es el estándar dentro de los transformers como BERT y GPT.

Hasta ahora tenemos una red llena de pesos. Pero, ¿de dónde salen los valores de peso correctos? Nadie los escribe a mano — hay millones. Se descubren mediante un bucle de retroalimentación que, en el fondo, es prueba y error organizado con el cálculo llevando la contabilidad.

El primer paso es la pasada hacia delante (forward pass): introduces un ejemplo, lo dejas fluir por las capas, y lees una predicción. El segundo paso es medir cuán equivocada estuvo esa predicción usando una función de pérdida. Para predecir un número (un precio), el error cuadrático medio promedia la brecha al cuadrado entre la predicción y la verdad. Para clasificación, la entropía cruzada mide qué tan lejos están las probabilidades predichas de la respuesta correcta. Una pérdida alta significa «muy equivocado»; el objetivo entero del entrenamiento es empujar ese número hacia abajo.

El tercer paso es la parte inteligente: la retropropagación (backpropagation). Usando la regla de la cadena del cálculo, el algoritmo trabaja hacia atrás desde la pérdida a través de cada capa y calcula, para cada peso individual, un gradiente — la respuesta a «si empujo este peso hacia arriba una pizca, ¿el error sube o baja, y cuánto?». Este es el truco que descongeló el «invierno de la IA». La retropropagación, popularizada en la década de 1980, hizo posible asignar la culpa entre millones de pesos de forma eficiente en lugar de adivinar.

El cuarto paso es el descenso de gradiente: empuja cada peso un pequeño paso en la dirección que reduce la pérdida, usando la regla w = w − α × ∂L/∂w. Imagina que estás en una ladera con niebla intentando llegar al fondo del valle; no puedes ver el fondo, pero puedes sentir bajo tus pies hacia dónde va cuesta abajo, así que dás un paso en esa dirección y repites. La tasa de aprendizaje α es la longitud de tu zancada, y es discutiblemente el dial más importante de todo el sistema. Demasiado grande y saltas más allá del valle y rebotas para siempre; demasiado pequeña y avanzas a paso de tortuga durante una eternidad o te quedas atascado a mitad de bajada.

Dos refinamientos con los que te toparás de inmediato. Los mini-lotes (mini-batches): en lugar de actualizar después de cada ejemplo individual (ruidoso) o solo después de todo el conjunto de datos (lento), actualizas después de un lote pequeño — típicamente entre 32 y 256 ejemplos — que es estable, amigable con la GPU, y el punto óptimo en la práctica. Y Adam: un optimizador más inteligente que le da a cada peso su propia zancada adaptativa y añade momentum para suavizar gradientes ruidosos. Adam es el punto de partida razonable para casi cualquier proyecto — aunque en finanzas, con su baja relación señal-ruido, seguirás necesitando ajustar a mano la tasa de aprendizaje, el weight decay y el punto de parada.

Aquí está el modo de fallo que destruye más modelos financieros que cualquier otro. Una red neuronal es un ajustador de funciones tan flexible que, si se le da la oportunidad, memorizará tus datos de entrenamiento por completo — incluyendo todo el ruido aleatorio, las casualidades puntuales y las coincidencias que nunca se repetirán. Puntúa maravillosamente en los datos que ya ha visto y se desploma en el momento en que se encuentra con algo nuevo. Esto es el sobreajuste (overfitting), y en los mercados — donde la señal genuina es débil y el ruido es atronador — es el resultado por defecto, no la excepción. Las herramientas que lo combaten se llaman regularización.

El dropout es el más popular. Durante cada paso de entrenamiento, cada neurona tiene una probabilidad p (a menudo 0,2-0,5) de apagarse temporalmente. Forzada a funcionar incluso cuando compañeros aleatorios sigan desapareciendo, la red aprende a distribuir su conocimiento entre muchas neuronas en lugar de apostarlo todo a unas pocas frágiles — un efecto de conjunto (ensemble) integrado en un único modelo. En el momento de la predicción, todas las neuronas se vuelven a encender, escaladas apropiadamente.

Las penalizaciones L1 y L2 añaden un impuesto sobre los pesos grandes a la pérdida. La L2 (weight decay) desincentiva que cualquier peso individual se haga demasiado grande, distribuyendo la influencia de forma uniforme. La L1 es más afilada: activamente empuja los pesos inútiles hasta exactamente cero, realizando una selección automática de características. En un conjunto de datos financiero donde la mayoría de tus cien características son ruido, la L1 puede encontrar silenciosamente el puñado que realmente lleva señal.

La normalización por lotes (batch normalization) reescala las salidas de cada capa a una media y varianza estables, lo cual estabiliza el entrenamiento y permite usar tasas de aprendizaje más altas. La parada temprana (early stopping) es la salvaguarda más simple y fiable de todas: vigila el error en un conjunto de validación reservado, y en el instante en que empiece a subir mientras el error de entrenamiento sigue bajando, detente — ese cruce es el momento exacto en que la red cambia de aprender patrones a memorizar ruido.

Las redes feedforward simples tratan cada entrada como una bolsa desestructurada de números. Pero muchos datos reales tienen estructura — una imagen tiene disposición espacial, una serie de precios tiene orden temporal — y dos arquitecturas especializadas explotan esa estructura directamente.

Las redes neuronales convolucionales (CNN) se construyeron para imágenes. En lugar de conectar cada píxel a cada neurona, una CNN desliza pequeños filtros a través de la entrada, buscando patrones locales — un borde aquí, una textura allí — y reutilizando el mismo filtro en todas partes. Las primeras capas captan bordes; las capas más profundas los ensamblan en formas y objetos. En finanzas, los investigadores han apuntado las CNN a:

• Imágenes de gráficos de velas — replanteando la lectura de gráficos como una tarea visual de reconocimiento de patrones.
• Mapas de calor del libro de órdenes — detectando desequilibrios de oferta y demanda en fotografías de la profundidad del mercado.
• Convoluciones 1D sobre secuencias de precios en bruto — aprendiendo motivos temporales cortos de la misma forma que una CNN para imágenes aprende motivos espaciales.

Las redes neuronales recurrentes (RNN) se construyeron para secuencias. Procesan un paso temporal a la vez mientras llevan un estado oculto — una memoria en marcha — de cada paso al siguiente. En teoría esto las hace ideales para las series temporales. En la práctica, las RNN básicas están lisiadas por el problema del gradiente que se desvanece en secuencias largas: la señal de muchos pasos atrás se encoge hacia cero en el camino de vuelta, así que la red simplemente olvida el pasado lejano.

Las redes de memoria a corto-largo plazo (LSTM) arreglan esto con un pequeño conjunto de puertas aprendibles — olvido, entrada y salida — que decide en cada paso qué borrar de la memoria, qué escribir, y qué leer. Ese sistema de puertas permite que una LSTM retenga información relevante a lo largo de cientos de pasos, por lo que se convirtió en un caballo de batalla para modelar series temporales financieras donde un evento de ayer todavía mueve el precio de hoy.

import torch.nn as nn

class PricePredictor(nn.Module):
    def __init__(self, input_dim, hidden_dim, num_layers):
        super().__init__()
        self.lstm = nn.LSTM(input_dim, hidden_dim,
                            num_layers, batch_first=True,
                            dropout=0.2)
        self.fc = nn.Linear(hidden_dim, 1)

    def forward(self, x):
        out, _ = self.lstm(x)
        return self.fc(out[:, -1, :])

En una plataforma como GaiaEx, donde los feeds por WebSocket transmiten datos continuos de precio y del libro de órdenes, una LSTM puede ingerir esa secuencia de forma natural. Dicho esto, el campo se ha movido en gran medida: los transformers — la arquitectura detrás de los modelos de lenguaje modernos — ahora igualan o superan a las LSTM en muchas tareas de secuencia al usar la «atención» para mirar todos los pasos temporales a la vez en lugar de recorrerlos uno a uno.

Las redes neuronales son buscadoras de patrones espectaculares. Pero una educación honesta implica nombrar dónde se rompen — y en el trading, se rompen de formas caras.

• Encuentran patrones incluso cuando no existen. Dale ruido a una red profunda y lo ajustará con confianza. Los mercados son en gran parte ruido, así que la carga de la prueba está en ti para demostrar que un patrón es real y persistente — no solo presente en los datos del año pasado.
• Son cajas negras. Un modelo puede ser preciso y aun así no poder decirte por qué. Cuando de repente pierde dinero, a menudo no hay una explicación clara ni una solución obvia. Para capital que asume riesgo, «no sé por qué hizo eso» es un pasivo serio.
• Son hambrientas y frágiles. El deep learning brilla con millones de ejemplos limpios. La historia financiera es corta, no estacionaria y ruidosa — el régimen que entrenó tu modelo puede simplemente dejar de existir, un problema llamado cambio de distribución (distribution shift).
• No superan a modelos más simples gratis. En los datos tabulares y basados en características habituales en finanzas, los árboles de gradient boosting como XGBoost con frecuencia superan a las redes neuronales mientras son más rápidos de entrenar y más fáciles de interpretar. La complejidad es un coste, no una virtud.
• Se pueden atacar. Perturbaciones pequeñas y deliberadas en una entrada pueden dar la vuelta a la salida de una red — un ejemplo adversario — lo cual importa en cualquier sitio donde un adversario pueda dar forma a lo que ve tu modelo.

Entrenar redes neuronales es intensivo en aritmética — abrumadoramente multiplicaciones de matrices — y el hardware sobre el que lo ejecutas cambia tu velocidad de iteración de «de la noche a la mañana» a «mientras tomas un café».

Las GPU son el estándar. Sus miles de núcleos ejecutan todos la misma operación sobre datos distintos a la vez, que es exactamente la forma de las matemáticas de las redes neuronales. Un modelo que se arrastra durante 8 horas en una CPU puede terminar en 15 minutos en una GPU moderna. NVIDIA domina: las tarjetas de consumo (una GPU de clase RTX) valen para aprender, mientras que las tarjetas de centro de datos (A100, H100) y las instancias en la nube gestionan el entrenamiento a escala de producción. Las TPU, los chips personalizados de Google para matemáticas de tensores, brillan en modelos muy grandes a través de Google Cloud, pero las GPU siguen siendo la opción por defecto práctica para la mayoría de los profesionales gracias a un soporte de software más amplio.

No necesitas comprar nada para empezar. Google Colab reparte tiempo gratuito de GPU que es más que suficiente para aprender y prototipar; alquila GPU en la nube a demanda a medida que crezcan tus modelos; compra hardware dedicado solo una vez que entrenes a diario y la factura de la nube lo justifique.

Un camino de aprendizaje sensato desde aquí:

• Empieza con una red feedforward simple sobre unas cuantas características diseñadas — rápida de entrenar, fácil de depurar, y un baseline honesto.
• Prueba una CNN 1D sobre secuencias de precios en bruto y compárala cara a cara con ese baseline.
• Construye una LSTM que consuma secuencias de datos de velas desde la API de GaiaEx.
• Estudia la atención y los transformers — cada vez más la arquitectura de elección para secuencias.
• Por encima de todo, enfrenta siempre tu modelo profundo contra un baseline de gradient boosting como XGBoost. Si la red neuronal no puede superar al modelo más simple fuera de muestra en tus datos financieros tabulares, despliega el modelo más simple y sigue adelante.

El mismo bucle que encontró la Jugada 37 — predecir, medir el error, empujar los pesos, repetir — es el bucle que corre dentro de cada sistema de esta lista. Entiende ese bucle y entiendes el deep learning; el resto es arquitectura e ingeniería encima de él.