Les modèles de diffusion contre l'anarchie des cryptomonnaies : pourquoi DDPM prédit les crashs de Bitcoin mieux que votre astrologue

En guise de préface : quand le machine learning classique jette l'éponge

Les marchés des cryptomonnaies sont l'endroit où les méthodes de prévision traditionnelles vont mourir. Les modèles LSTM deviennent nerveux face à la volatilité du Bitcoin, les modèles ARIMA font des crises de nerfs devant les sauts brutaux d'Ethereum, et les réseaux de neurones classiques abandonnent purement et simplement à la vue du graphique du Dogecoin. Et c'est là que les modèles de diffusion entrent en scène — une technologie qui, à l'origine, apprenait aux ordinateurs à dessiner des chats, et qui tente aujourd'hui de prédire quand le Bitcoin décidera de nous offrir un nouveau "lundi noir".

Curieusement, l'architecture qui a donné naissance à Stable Diffusion et DALL-E est désormais activement appliquée à l'analyse des séries temporelles financières. Et vous savez quoi ? Ça fonctionne plutôt bien. Surtout quand les approches classiques se mettent à halluciner face à la volatilité extrême des cryptomonnaies.

Du chaos à la clarté : comment les modèles de diffusion extraient des signaux structurés de l'environnement très bruité des marchés de cryptomonnaies

Pourquoi les modèles de diffusion fonctionnent-ils avec les séries temporelles ?

Les modèles de diffusion sont une classe de modèles génératifs qui apprennent à restaurer les données originales à partir du bruit, via un processus séquentiel de "débruitage". L'idée de base est simple : on prend des données réelles, on leur ajoute progressivement du bruit gaussien jusqu'à obtenir du bruit pur, puis on entraîne un réseau de neurones à inverser ce processus.

Dans le contexte des séries temporelles financières, cela signifie que le modèle apprend à séparer le signal du bruit au sens littéral du terme. Les marchés de cryptomonnaies sont connus pour leur bruit extrême — tweets aléatoires d'Elon Musk, ventes paniques, achats FOMO. Un modèle de diffusion peut apprendre à "voir" des motifs structurels à travers tout ce chaos.

Mathématiquement, le processus se présente ainsi :

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

où $\beta_t$ est le calendrier de bruit, et $\theta$ sont les paramètres du réseau de neurones.

Débruitage séquentiel : le processus direct (ajout de bruit) et le processus inverse (débruitage) pour reconstruire des séries temporelles financières

Bibliothèques concrètes et solutions prêtes à l'emploi

1. Diffusion-TS : le soldat universel des séries temporelles

GitHub : Y-debug-sys/Diffusion-TS

C'est la bibliothèque phare pour travailler avec des modèles de diffusion sur des séries temporelles, publiée à ICLR 2024. Son principal atout est qu'elle fonctionne à la fois de manière conditionnelle (prévision) et inconditionnelle (génération).

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)

Le modèle utilise un transformeur encodeur-décodeur avec des représentations temporelles séparées, où la décomposition aide à capturer le sens sémantique de la série temporelle.

2. TSDiff : l'approche d'Amazon face au chaos des cryptomonnaies

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

Amazon Research a proposé TSDiff — un modèle de diffusion inconditionnel capable de faire de la prévision grâce à un mécanisme d'auto-guidage. La particularité est que le modèle ne nécessite pas de réseaux supplémentaires pour le conditionnement.

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 : les données financières tabulaires rencontrent la diffusion

Article : FinDiff est spécifiquement conçu pour générer des données financières tabulaires synthétiques. Il convient pour créer des scénarios de marché variés.

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. Implémentation rapide avec pytorch-forecasting

Pour ceux qui veulent essayer rapidement les modèles de diffusion en combinaison avec des architectures éprouvées :

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))

Résultats pratiques : diffusion contre méthodes classiques

Les recherches montrent des résultats curieux. Dans l'article "Prediction of Cryptocurrency Prices through a Path Dependent Monte Carlo Simulation", les auteurs utilisent le modèle de diffusion à sauts de Merton — un hybride de processus stochastiques et de machine learning. Le résultat ? Le modèle a réussi à capturer à la fois les variations de prix progressives et les sauts brutaux caractéristiques des marchés de cryptomonnaies.

Une autre étude a montré que ADE-TFT (Advanced Deep Learning-Enhanced Temporal Fusion Transformer) avec des composants de diffusion surpasse nettement les approches classiques sur les métriques MAPE, MSE et RMSE. Les résultats sur la configuration à 8 couches cachées sont particulièrement impressionnants.

Prévision probabiliste : utilisation des modèles de diffusion pour générer des trajectoires de prix futures avec des intervalles de confiance associés

Le côté obscur des modèles de diffusion en finance

Mais soyons honnêtes. Les modèles de diffusion ne sont pas une solution miracle. Ils présentent des problèmes sérieux :

1. Gourmandise computationnelle

Entraîner un modèle de diffusion sur des données de cryptomonnaies exige des ressources de calcul considérables. Si votre modèle effectue 1000 étapes de diffusion, il faut alors 1000 passages dans le réseau de neurones pour obtenir une seule prévision. Ce n'est guère adapté au trading à haute fréquence.

2. Le problème du cygne noir

Les marchés de cryptomonnaies sont connus pour leurs événements extrêmes — un crash de 50 % en une journée, une interdiction des cryptomonnaies en Chine, le piratage d'une grande plateforme d'échange. Les modèles de diffusion entraînés sur des données historiques prédisent mal ce type d'événements.

3. Dépendance au régime de marché

Les marchés de cryptomonnaies présentent différents régimes comportementaux — marché haussier, marché baissier, mouvement latéral. Un modèle de diffusion peut fonctionner remarquablement bien dans un régime et échouer complètement dans un autre.

Optimisation et accélération : comment ne pas se ruiner en GPU

Token Merging pour la diffusion

GitHub : dbolya/tomesd

La bibliothèque Token Merging permet d'accélérer les modèles de diffusion de 1,24x sans perte de qualité, en fusionnant les tokens redondants :

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 combine optimisation spatiale et temporelle, ce qui est particulièrement important pour les séries temporelles :

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
)

Exemple pratique : pipeline complet pour le Bitcoin

Voici un exemple réaliste d'utilisation des modèles de diffusion pour la prévision du 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}")

Quand devriez-vous utiliser les modèles de diffusion ?

Cela vaut la peine si :

• Vous disposez de beaucoup de données historiques (au moins un an de données horaires)
• Vous pouvez vous permettre un entraînement long (des jours, voire des semaines sur GPU)
• Vous avez besoin de générer des scénarios synthétiques pour le backtesting
• Vous travaillez avec des séries temporelles multivariées
• L'estimation de l'incertitude des prévisions est importante

Cela ne vaut pas la peine si :

• Vous avez besoin de prévisions rapides en temps réel
• Vous travaillez avec des séries temporelles courtes
• Vos ressources de calcul sont limitées
• L'interprétabilité du modèle est critique

L'avenir des modèles de diffusion dans l'analyse des cryptomonnaies

Les modèles de diffusion en finance sont un peu comme les cryptomonnaies en 2010. La technologie est encore brute, gourmande en ressources, mais le potentiel est immense. On observe déjà des approches hybrides : DDPM + Transformer, diffusion + apprentissage par renforcement, diffusion conditionnelle pour les régimes de marché.

La prochaine avancée majeure est attendue du côté de la diffusion multimodale — des modèles qui prendront en compte non seulement les prix, mais aussi les actualités, les signaux sociaux, les métriques on-chain. Imaginez un modèle de diffusion capable de "voir" la corrélation entre un tweet d'Elon Musk et le mouvement du Dogecoin.

Conclusion : la diffusion comme évolution, pas comme révolution

Les modèles de diffusion ne remplaceront pas les approches classiques de prévision des cryptomonnaies. Ils viendront les compléter. LSTM restera utile pour les prévisions rapides, ARIMA pour les sections stationnaires, et la diffusion prendra en charge la génération de scénarios et le travail avec la volatilité extrême.

La leçon principale : dans le monde des cryptomonnaies, il n'existe pas de solution miracle. Il n'y a qu'une combinaison intelligente d'outils, une compréhension approfondie du marché et un scepticisme sain envers toute solution "révolutionnaire". Les modèles de diffusion sont un outil puissant, mais souvenez-vous : ils ne font qu'essayer de trouver des motifs dans le chaos. Et le chaos, comme chacun sait, n'aime guère être prédit.

P.-S. : Si votre modèle de diffusion affiche une précision de 95 % sur la prévision du Bitcoin — vérifiez le code deux fois. Il y a fort à parier qu'il y a une fuite de données quelque part 😉