Modelos de difusión vs anarquía de las criptomonedas: por qué DDPM predice los desplomes de Bitcoin mejor que tu astrólogo

En lugar de un prólogo: cuando el aprendizaje automático clásico se rinde

Los mercados de criptomonedas son el lugar donde los métodos tradicionales de previsión van a morir. Los modelos LSTM empiezan a ponerse nerviosos con la volatilidad de Bitcoin, los modelos ARIMA sufren ataques de histeria con los saltos bruscos de Ethereum y las redes neuronales clásicas simplemente se rinden al ver el gráfico de Dogecoin. Y entonces entran en escena los modelos de difusión: una tecnología que originalmente enseñó a las computadoras a dibujar gatos y que ahora intenta predecir cuándo Bitcoin decidirá protagonizar otro "lunes negro".

Resulta curioso que la arquitectura que dio origen a Stable Diffusion y DALL-E se aplique ahora activamente al análisis de series temporales financieras. ¿Y sabes qué? Funciona bastante bien. Sobre todo cuando los enfoques clásicos empiezan a alucinar por la volatilidad extrema de las criptomonedas.

Del caos a la claridad: cómo los modelos de difusión extraen señales estructuradas del entorno de alto ruido de los mercados de criptomonedas

¿Por qué funcionan los modelos de difusión con series temporales?

Los modelos de difusión son una clase de modelos generativos que aprenden a restaurar los datos originales a partir del ruido mediante un proceso de "eliminación de ruido" secuencial. La idea básica es simple: tomamos datos reales, les añadimos gradualmente ruido gaussiano hasta obtener ruido puro y luego enseñamos a una red neuronal a invertir este proceso.

En el contexto de las series temporales financieras, esto significa que el modelo aprende a separar la señal del ruido en el sentido literal. Los mercados de criptomonedas son conocidos por su extrema cantidad de ruido: tuits aleatorios de Elon Musk, ventas por pánico, compras por FOMO. Un modelo de difusión puede aprender a "ver" patrones estructurales a través de todo este caos.

Matemáticamente, el proceso se ve así:

• Proceso directo: $q(x_t | x_{t-1}) = \mathcal{N}(x_t; \sqrt{1-\beta_t}x_{t-1}, \beta_t I)$
• Proceso inverso: $p_\theta(x_{t-1} | x_t) = \mathcal{N}(x_{t-1}; \mu_\theta(x_t, t), \Sigma_\theta(x_t, t))$

donde $\beta_t$ es el calendario de ruido y $\theta$ son los parámetros de la red neuronal.

Eliminación de ruido secuencial: el proceso directo (añadir ruido) y el proceso inverso (eliminar ruido) para reconstruir series temporales financieras

Bibliotecas concretas y soluciones listas para usar

1. Diffusion-TS: el soldado universal para series temporales

GitHub: Y-debug-sys/Diffusion-TS

Esta es la biblioteca insignia para trabajar con modelos de difusión aplicados a series temporales, publicada en ICLR 2024. Su principal ventaja es que funciona tanto de forma condicional (previsión) como incondicional (generación).

import torch
from diffusion_ts import DiffusionTS
import pandas as pd

btc_data = pd.read_csv('btc_prices.csv')
prices = torch.tensor(btc_data['close'].values).float()

model = DiffusionTS(
    input_dim=1,
    hidden_dim=64,
    num_layers=4,
    max_sequence_length=100,
    num_diffusion_steps=1000
)

model.fit(prices, epochs=100)

forecast = model.predict(prices[-100:], forecast_horizon=24)

El modelo utiliza un transformer codificador-decodificador con representaciones temporales separadas, donde la descomposición ayuda a capturar el significado semántico de las series temporales.

2. TSDiff: el enfoque de Amazon frente al caos de las criptomonedas

GitHub: amazon-science/unconditional-time-series-diffusion

Amazon Research propuso TSDiff, un modelo de difusión incondicional que puede trabajar con previsiones mediante un mecanismo de autoguiado. Su particularidad es que el modelo no requiere redes adicionales para el condicionamiento.

from tsdiff import TSDiff
import numpy as np

crypto_data = load_cryptocurrency_data(['BTC', 'ETH', 'LTC'])

tsdiff = TSDiff(
    input_size=crypto_data.shape[-1],
    hidden_size=128,
    num_layers=6,
    diffusion_steps=1000,
    beta_schedule='cosine'
)

tsdiff.train(crypto_data, num_epochs=200)

synthetic_crypto = tsdiff.sample(num_samples=1000, length=365)

forecast = tsdiff.forecast_with_guidance(
    context=crypto_data[-30:],  # last 30 days
    forecast_length=7,          # week forecast
    guidance_scale=2.0
)

3. FinDiff: los datos financieros tabulares se encuentran con la difusión

Paper: FinDiff está diseñado específicamente para generar datos financieros tabulares sintéticos. Es adecuado para crear escenarios de mercado diversos.

import torch
from findiff import FinancialDiffusion

market_data = pd.read_csv('crypto_market_features.csv')

financial_features = [
    'price', 'volume', 'market_cap', 'volatility',
    'rsi', 'macd', 'bollinger_bands'
]

findiff = FinancialDiffusion(
    categorical_columns=['exchange', 'crypto_type'],
    numerical_columns=financial_features,
    embedding_dim=32,
    hidden_dim=256
)

findiff.fit(market_data[financial_features])

synthetic_scenarios = findiff.generate(n_samples=10000)

stress_test_data = findiff.generate_conditional(
    conditions={'volatility': '>0.8'}  # high volatility
)

4. Implementación rápida con pytorch-forecasting

Para quienes quieran probar rápidamente los modelos de difusión combinados con arquitecturas ya probadas:

import lightning.pytorch as pl
from pytorch_forecasting import TimeSeriesDataSet, TemporalFusionTransformer
from diffusion_wrapper import DiffusionTFT  # hypothetical wrapper

crypto_df = pd.read_csv('hourly_crypto_data.csv')

training = TimeSeriesDataSet(
    crypto_df,
    time_idx="hour",
    target="btc_price",
    group_ids=["crypto_pair"],
    max_encoder_length=168,  # week back
    max_prediction_length=24,  # day forward
    time_varying_unknown_reals=["price", "volume", "volatility"],
    time_varying_known_reals=["hour_of_day", "day_of_week"],
)

diffusion_tft = DiffusionTFT.from_dataset(
    training,
    hidden_size=64,
    attention_head_size=4,
    diffusion_steps=100,
    noise_schedule='linear'
)

trainer = pl.Trainer(max_epochs=50, accelerator="gpu")
trainer.fit(diffusion_tft, train_dataloaders=training.to_dataloader(train=True))

Resultados prácticos: difusión vs clásicos

La investigación arroja resultados curiosos. En el artículo "Prediction of Cryptocurrency Prices through a Path Dependent Monte Carlo Simulation", los autores utilizan el modelo de difusión con saltos de Merton, un híbrido de procesos estocásticos y aprendizaje automático. ¿El resultado? El modelo fue capaz de captar tanto los cambios graduales de precio como los saltos bruscos característicos de los mercados de criptomonedas.

Otro estudio demostró que ADE-TFT (Advanced Deep Learning-Enhanced Temporal Fusion Transformer) con componentes de difusión supera de forma significativa a los enfoques clásicos en las métricas MAPE, MSE y RMSE. Los resultados de la configuración con 8 capas ocultas son especialmente impresionantes.

Previsión probabilística: uso de modelos de difusión para generar trayectorias de precios futuros con sus intervalos de confianza asociados

El lado oscuro de los modelos de difusión en las finanzas

Pero seamos honestos. Los modelos de difusión no son una bala de plata. Tienen problemas serios:

1. Voracidad computacional

Entrenar un modelo de difusión con datos de criptomonedas requiere recursos computacionales serios. Si tu modelo realiza 1000 pasos de difusión, para obtener una sola previsión necesitas 1000 pasadas por la red neuronal. Esto no es muy adecuado para el trading de alta frecuencia.

2. El problema del cisne negro

Los mercados de criptomonedas son conocidos por sus eventos extremos: un desplome del 50 % en un día, la prohibición de una criptomoneda en China, el hackeo de un gran exchange. Los modelos de difusión entrenados con datos históricos predicen mal este tipo de eventos.

3. Dependencia del régimen

Los mercados de criptomonedas tienen distintos regímenes de comportamiento: mercado alcista, mercado bajista, movimiento lateral. Un modelo de difusión puede funcionar de maravilla en un régimen y fracasar por completo en otro.

Optimización y aceleración: cómo no arruinarse en la GPU

Token Merging para difusión

GitHub: dbolya/tomesd

La biblioteca Token Merging permite acelerar los modelos de difusión en 1,24x sin pérdida de calidad, fusionando tokens redundantes:

import tomesd
from diffusion_model import CryptoDiffusion

model = CryptoDiffusion(...)

tomesd.apply_patch(model, ratio=0.7)  # remove 30% of tokens

forecast = model.predict(btc_data)

Cached Adaptive Token Merging

GitHub: omidiu/ca_tome

CA-ToMe combina la optimización espacial y temporal, lo que es especialmente importante para las series temporales:

from ca_tome import apply_ca_tome

apply_ca_tome(
    model, 
    threshold=0.7,
    caching_steps=[0, 10, 20, 30, 40]  # cache every 10 steps
)

Ejemplo práctico: pipeline completo para Bitcoin

Aquí tienes un ejemplo realista de cómo usar modelos de difusión para la previsión de Bitcoin:

import torch
import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from diffusion_ts import DiffusionTS

class CryptoDiffusionPipeline:
    def __init__(self, sequence_length=100, forecast_horizon=24):
        self.sequence_length = sequence_length
        self.forecast_horizon = forecast_horizon
        self.scaler = MinMaxScaler()
        self.model = None
        
    def prepare_data(self, crypto_data):
        """Data preparation considering cryptocurrency features"""
        crypto_data['returns'] = crypto_data['close'].pct_change()
        crypto_data['volatility'] = crypto_data['returns'].rolling(24).std()
        crypto_data['rsi'] = self.compute_rsi(crypto_data['close'])
        
        features = ['close', 'volume', 'volatility', 'rsi']
        scaled_data = self.scaler.fit_transform(crypto_data[features])
        
        return scaled_data
    
    def train_model(self, data):
        """Training diffusion model"""
        self.model = DiffusionTS(
            input_dim=data.shape[1],
            hidden_dim=128,
            num_layers=6,
            diffusion_steps=1000,
            noise_schedule='cosine',
            loss_type='l2'
        )
        
        X, y = self.create_sequences(data)
        
        self.model.fit(
            X, y,
            epochs=200,
            batch_size=32,
            learning_rate=1e-4,
            validation_split=0.2
        )
    
    def forecast(self, recent_data):
        """Forecasting with confidence intervals"""
        predictions = []
        
        for _ in range(100):  # Monte Carlo sampling
            pred = self.model.sample_forecast(
                context=recent_data[-self.sequence_length:],
                horizon=self.forecast_horizon
            )
            predictions.append(pred)
        
        predictions = np.array(predictions)
        
        mean_pred = np.mean(predictions, axis=0)
        std_pred = np.std(predictions, axis=0)
        
        return {
            'forecast': mean_pred,
            'confidence_95': mean_pred + 1.96 * std_pred,
            'confidence_5': mean_pred - 1.96 * std_pred
        }

pipeline = CryptoDiffusionPipeline()
btc_data = pd.read_csv('btc_hourly.csv')

prepared_data = pipeline.prepare_data(btc_data)
pipeline.train_model(prepared_data)

forecast_result = pipeline.forecast(prepared_data)
print(f"Bitcoin forecast for next 24h: {forecast_result['forecast'][-1]:.2f}")

¿Cuándo deberías usar modelos de difusión?

Vale la pena usarlos si:

• Dispones de muchos datos históricos (mínimo un año de datos horarios)
• Puedes permitirte un entrenamiento largo (días o semanas en GPU)
• Necesitas generar escenarios sintéticos para backtesting
• Trabajas con series temporales multivariantes
• Es importante la estimación de la incertidumbre de las previsiones

No vale la pena usarlos si:

• Necesitas previsiones rápidas en tiempo real
• Trabajas con series temporales cortas
• Tienes recursos computacionales limitados
• La interpretabilidad del modelo es crítica

El futuro de los modelos de difusión en la analítica cripto

Los modelos de difusión en las finanzas son como las criptomonedas en 2010. La tecnología es inmadura y consume muchos recursos, pero el potencial es enorme. Ya vemos enfoques híbridos: DDPM + Transformer, difusión + aprendizaje por refuerzo, difusión condicional para regímenes de mercado.

Se espera que el próximo gran avance llegue con la difusión multimodal: modelos que tendrán en cuenta no solo los precios, sino también las noticias, las señales sociales y las métricas on-chain. Imagina un modelo de difusión que "vea" la correlación entre un tuit de Elon Musk y el movimiento de Dogecoin.

Conclusión: la difusión como evolución, no como revolución

Los modelos de difusión no reemplazarán a los enfoques clásicos de previsión de criptomonedas. Los complementarán. LSTM se mantendrá para las previsiones rápidas, ARIMA para los tramos estacionarios y la difusión se encargará de la generación de escenarios y del trabajo con la volatilidad extrema.

La lección principal: en el mundo de las criptomonedas no hay balas de plata. Solo existe una combinación inteligente de herramientas, una comprensión profunda del mercado y un escepticismo sano frente a cualquier solución "revolucionaria". Los modelos de difusión son una herramienta poderosa, pero recuerda: solo intentan encontrar patrones en el caos. Y el caos, como sabemos, no es muy amigo de que lo predigan.

P.D.: si tu modelo de difusión muestra un 95 % de precisión en la previsión de Bitcoin, revisa el código dos veces. Lo más probable es que haya una fuga de datos en algún lugar 😉