Knowledge Distillation: Compressing Trading Models for Low-Latency Deployment

La tension entre précision et latence dans le trading basé sur le ML a déjà une réponse publiée sur ce blog. Modélisation de propagation avec apprentissage automatique recommande une séparation en deux étapes : un modèle à accélération rapide du gradient effectue la cotation en temps réel critique en termes de latence, tandis qu'un modèle approfondi s'exécute de manière asynchrone et lui fournit un signal secondaire ou ajuste ses paramètres. Deux modèles, deux horloges, un système.

La distillation des connaissances est une réponse différente à la même tension. Au lieu d'exécuter le modèle lent avec le modèle rapide, vous l'utilisez une fois, hors ligne, pour entraîner le modèle rapide : l'élève apprend la distribution de probabilité complète de l'enseignant sur les résultats, pas seulement les étiquettes strictes, et l'enseignant quitte alors complètement le chemin chaud. Un modèle au moment de l'inférence, pas de couplage asynchrone, pas de fenêtre d'obsolescence.

La réponse qui l’emporte est empirique, et cet article n’y répond pas encore. Ce qui suit est la machinerie, plus une déclaration explicite des mesures qui en décideraient. Rien ici n’est un résultat de référence ; là où devrait normalement aller un numéro, il y a un marqueur indiquant ce qui doit être exécuté.

Une correction de cadrage dès le départ, de DeepLOB et deep learning sur le carnet de commandes : une précision de classification élevée ne se traduit pas automatiquement en profit — le mouvement prévu doit effacer l'écart acheteur-vendeur. "Préserver la précision directionnelle de l'enseignant" n'est donc pas une bonne chose pour optimiser une configuration de distillation.

Le cadre enseignant-élève

La formulation originale de Hinton, Vinyals et Dean (2015) est simple. Vous avez un modèle d'enseignant $T$ (grand, lent, précis) et un modèle étudiant $S$ (petit, rapide, à entraîner). L’élève apprend simultanément à partir de deux signaux :

1. Cibles dures : les étiquettes de vérité terrain $y$ (par exemple, le prix a augmenté ou diminué)
2. Cibles souples : distribution de probabilité de production de l'enseignant $q_T$ sur toutes les classes

La fonction de perte de Student combine à la fois :

$\mathcal{L} = \alpha \cdot \mathcal{L}_{\text{CE}}(y, \sigma(z_S)) + (1 - \alpha) \cdot T^2 \cdot D_{\text{KL}}\left(\sigma\left(\frac{z_T}{T}\right) \| \sigma\left(\frac{z_S}{T}\right)\right)$

où $z_T$ et $z_S$ sont les logits de l'enseignant et de l'élève, $\sigma$ est la fonction softmax, $T$ est le paramètre de température, et $\alpha$ contrôle l’équilibre entre les deux composantes de la perte.

Pourquoi les cibles souples sont importantes pour le trading

La formulation à trois classes de prix moyen haut/stationnaire/bas, le $\pm\alpha$ le seuillage, et pourquoi le déséquilibre qui en résulte signifie que vous signalez la pondération F1 plutôt que la précision sont tous configurés dans DeepLOB - supposons ce schéma d'étiquette ici. Le point spécifique à la distillation est ce que l'enseignant émet avant l'argmax : un "haut" dur porte un bit, tandis que 0,72/0,21/0,07 indique également que le mouvement peut caler et ne s'inversera presque certainement pas. Cette structure entre les classes est le signal de formation supplémentaire, et c'est pourquoi un étudiant à cible souple peut mieux généraliser que le même étudiant formé uniquement sur des étiquettes.

Un avertissement sur ce que cette confiance n’est pas. La sortie Softmax n'est pas une incertitude calibrée, et traiter 0,55 contre 0,85 comme une entrée de dimensionnement de position est le raccourci que prédiction conforme pour le trading existe pour refuser - il dérive le dimensionnement de la largeur de l'intervalle, d'un rapport de bord et d'un filtre de non-échange lorsque l'intervalle chevauche zéro, ce qu'un softmax brut ne vous donne pas. Obtenir la réclamation de dimensionnement ici signifie mesurer l'étalonnage de l'élève par rapport à celui de l'enseignant (diagramme de fiabilité, ECE) et montrer que la distillation le préserve. Ce résultat n'est pas encore dans cet article.

Température et cibles souples

Le paramètre de température $T$ contrôle la « douceur » de la distribution de probabilité. Logits donnés $z_i$, le softmax avec la température est :

$\sigma(z_i; T) = \frac{\exp(z_i / T)}{\sum_j \exp(z_j / T)}$

Quand $T = 1$ (softmax standard), la distribution est maximale — la classe dominante obtient l'essentiel de la masse de probabilité. Comme $T$ augmente, la distribution s'aplatit, révélant plus clairement les ampleurs relatives des logits.

Il existe un argument plausible selon lequel les modèles commerciaux souhaitent une température modérée : les prévisions financières sont beaucoup moins fiables que la classification d'images, de sorte qu'un enseignant peut produire 0,55/0,30/0,15 plutôt que 0,99/0,005/0,005, laissant moins de pointe s'atténuer avant que le signal ne disparaisse. Il s’agit d’un argument, pas d’une conclusion : la fourchette doit provenir d’un balayage de données réelles, notées par F1 pondérée, et peut différer selon le régime.

Le $T^2$ Le facteur dans le terme de divergence KL compense les amplitudes réduites du gradient à des températures plus élevées. Sans cela, la perte de distillation deviendrait négligeable à mesure que $T$ augmente.

Choisir la température via la recherche par grille

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from sklearn.metrics import f1_score

def distillation_loss(
    student_logits: torch.Tensor,
    teacher_logits: torch.Tensor,
    labels: torch.Tensor,
    temperature: float,
    alpha: float,
) -> torch.Tensor:
    """Combined hard-target + soft-target distillation loss."""
    hard_loss = F.cross_entropy(student_logits, labels)

    soft_teacher = F.log_softmax(teacher_logits / temperature, dim=-1)
    soft_student = F.log_softmax(student_logits / temperature, dim=-1)

    soft_loss = F.kl_div(
        soft_student,
        soft_teacher,
        log_target=True,
        reduction="batchmean",
    )

    return alpha * hard_loss + (1.0 - alpha) * (temperature ** 2) * soft_loss


def search_temperature(
    teacher: nn.Module,
    student_factory,       # callable returning a fresh student
    train_loader: DataLoader,
    val_loader: DataLoader,
    temperatures: list[float] = [1, 2, 3, 5, 8, 12],
    alpha: float = 0.3,
    epochs: int = 30,
    lr: float = 1e-3,
    device: str = "cuda",
):
    """Grid search over temperature, scored by weighted F1 (not accuracy:
    the up/flat/down label scheme is heavily imbalanced toward flat)."""
    best_f1, best_T, best_student = 0.0, 1.0, None

    for T in temperatures:
        student = student_factory().to(device)
        optimizer = torch.optim.AdamW(student.parameters(), lr=lr)

        for epoch in range(epochs):
            student.train()
            for X, y in train_loader:
                X, y = X.to(device), y.to(device)
                with torch.no_grad():
                    teacher_logits = teacher(X)
                student_logits = student(X)

                loss = distillation_loss(
                    student_logits, teacher_logits, y, T, alpha
                )
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()

        student.eval()
        preds, targets = [], []
        with torch.no_grad():
            for X, y in val_loader:
                preds.append(student(X.to(device)).argmax(dim=-1).cpu())
                targets.append(y)

        f1 = f1_score(
            torch.cat(targets), torch.cat(preds), average="weighted"
        )
        print(f"T={T:>4.1f}  val_weighted_f1={f1:.4f}")
        if f1 > best_f1:
            best_f1, best_T, best_student = f1, T, student

    print(f"\nBest temperature: T={best_T}, val_weighted_f1={best_f1:.4f}")
    return best_T, best_student

Distiller les ensembles en un seul modèle

Un ensemble quantitatif mélange des biais inductifs : un arbre boosté par gradient sur les caractéristiques du carnet de commandes, un 1D-CNN sur les ticks récents, un transformateur sur des fenêtres multi-temporelles, un modèle linéaire sur des facteurs macro. La moyenne est plus stable que n'importe quel membre seul, et l'exécution des quatre multiplie la latence et le coût – la situation que la séparation en deux étapes de modélisation étendue avec apprentissage automatique gère en rétrogradant les membres lents vers un canal secondaire asynchrone. Au lieu de cela, la distillation réduit les quatre en un seul élève dans le chemin chaud.

Le rendement du professeur d'ensemble est la moyenne des rendements softmax de ses membres :

$q_{\text{ensemble}}(x) = \frac{1}{K} \sum_{k=1}^{K} \sigma(z_k(x) / T)$

où $K$ est le nombre de membres de l’ensemble. L'étudiant est formé par rapport à cette distribution moyenne.

class EnsembleTeacher(nn.Module):
    """Wraps K models, returns averaged logits for distillation."""

    def __init__(self, models: list[nn.Module]):
        super().__init__()
        self.models = nn.ModuleList(models)

    @torch.no_grad()
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        logits = torch.stack([m(x) for m in self.models], dim=0)
        return logits.mean(dim=0)   # average logits, not softmax


class TradingStudent(nn.Module):
    """Lightweight MLP for sub-millisecond inference."""

    def __init__(self, input_dim: int, hidden: int = 64, n_classes: int = 3):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden),
            nn.ReLU(),
            nn.BatchNorm1d(hidden),
            nn.Linear(hidden, hidden),
            nn.ReLU(),
            nn.BatchNorm1d(hidden),
            nn.Linear(hidden, n_classes),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.net(x)

L'asymétrie du nombre de paramètres est tout l'intérêt : un MLP à deux couches avec 64 unités cachées est de l'ordre de 8 000 paramètres pour une tâche de 60 fonctionnalités et 3 classes, contre un ensemble dont le nombre combiné se chiffre en millions.

Ce que l'étudiant retient et ce qu'il perd

C’est la question empirique porteuse de poids et l’article n’y répond pas. L'intuition est que l'étudiant suit l'ensemble dans la distribution et diminue dans les régimes stressés, où la diversité de l'ensemble fait le travail - mais un chiffre de rétention signifie seulement quelque chose mesuré sur les données du carnet de commandes réel, divisé par régime, et rapporté comme pondéré F1. Un étudiant qui résiste les jours calmes et s’effondre lors d’une cascade de liquidation est un produit différent de celui qui se dégrade gracieusement, et un nombre global ne peut pas les distinguer.

Trois mesures d’atténuation méritent d’être testées par rapport à cette mesure plutôt que d’être affirmées à l’avance :

1. Incluez les périodes de stress dans l'ensemble de distillation, afin que l'étudiant voie les régimes dans lesquels l'écart devrait s'ouvrir.
2. Distillation basée sur les caractéristiques — faites correspondre les représentations intermédiaires, pas seulement les résultats finaux.
3. Tête de régime auxiliaire sur l'étudiant, forçant les fonctionnalités sensibles au régime dans le tronc partagé.

Autodistillation : Quand l’élève devient professeur

L'autodistillation est une technique par laquelle un modèle distille des connaissances à partir de lui-même.

Réseaux Born-Again (BAN)

Former un étudiant avec une architecture identique à celle du professeur. L'élève « né de nouveau » surpasse souvent l'original, et le processus se répète :

$M_0 \xrightarrow{\text{distill}} M_1 \xrightarrow{\text{distill}} M_2 \xrightarrow{\text{distill}} \cdots$

Chaque génération s’entraîne sur des cibles faciles de la précédente, les gains saturant généralement après quelques générations. Pour les modèles commerciaux, cela ne coûte rien du point de vue architectural – pas de nouvelles fonctionnalités, pas de nouvelles données, juste une procédure de formation différente – ce qui signifie également que le test est peu coûteux et qu'il n'y a aucune excuse pour le signaler non testé.

Autodistillation en profondeur

Fixez des classificateurs auxiliaires aux couches intermédiaires. La sortie la plus profonde sert de professeur aux sorties les moins profondes. Lors de l'inférence, vous choisissez une sortie : peu profonde pour une latence plus faible, profonde pour une précision maximale.

C'est l'idée ici la mieux adaptée à un système commercial, car la profondeur de sortie devient un bouton de latence d'exécution : un réseau formé couvre une gamme de budgets au lieu de s'engager sur une seule architecture au moment de la formation. Lorsque le livre avance rapidement, vous prenez la sortie peu profonde et acceptez un pire postérieur ; quand c'est calme, vous payez pour toute la profondeur. Les courbes de précision par sortie et de latence par sortie sont mesurables, et leur croisement décide si le bouton vaut la peine d'être utilisé.

class SelfDistillingNet(nn.Module):
    """Network with early-exit classifiers for variable-latency inference."""

    def __init__(self, input_dim: int, n_classes: int = 3):
        super().__init__()
        self.block1 = nn.Sequential(
            nn.Linear(input_dim, 128), nn.ReLU(), nn.BatchNorm1d(128)
        )
        self.block2 = nn.Sequential(
            nn.Linear(128, 64), nn.ReLU(), nn.BatchNorm1d(64)
        )
        self.block3 = nn.Sequential(
            nn.Linear(64, 32), nn.ReLU(), nn.BatchNorm1d(32)
        )

        self.exit1 = nn.Linear(128, n_classes)
        self.exit2 = nn.Linear(64, n_classes)
        self.exit3 = nn.Linear(32, n_classes)  # final exit

    def forward(
        self, x: torch.Tensor, exit_layer: int = 3
    ) -> torch.Tensor:
        h1 = self.block1(x)
        if exit_layer == 1:
            return self.exit1(h1)

        h2 = self.block2(h1)
        if exit_layer == 2:
            return self.exit2(h2)

        h3 = self.block3(h2)
        return self.exit3(h3)

    def forward_all_exits(self, x: torch.Tensor):
        """Return logits from all exits (for self-distillation training)."""
        h1 = self.block1(x)
        h2 = self.block2(h1)
        h3 = self.block3(h2)
        return self.exit1(h1), self.exit2(h2), self.exit3(h3)


def self_distillation_step(
    model: SelfDistillingNet,
    x: torch.Tensor,
    y: torch.Tensor,
    temperature: float = 4.0,
    alpha: float = 0.5,
) -> torch.Tensor:
    """One training step with self-distillation from deepest exit."""
    logits_1, logits_2, logits_3 = model.forward_all_exits(x)

    loss_hard = F.cross_entropy(logits_3, y)

    loss_distill_1 = distillation_loss(
        logits_1, logits_3.detach(), y, temperature, alpha
    )
    loss_distill_2 = distillation_loss(
        logits_2, logits_3.detach(), y, temperature, alpha
    )

    return loss_hard + 0.5 * loss_distill_1 + 0.5 * loss_distill_2

D'où vient le budget d'inférence

La distillation n'a d'importance que si l'inférence doit s'inscrire dans un budget strict, et que l'échelle complète du tick-to-trade - de la carte réseau à l'espace utilisateur, le contournement du noyau, le total inférieur à 100 µs et le niveau inférieur à 10 µs qui force le FPGA et la mémoire partagée - est déjà présentée dans [données et communication dans le trading algorithmique] (/en/blog/post/data-communication-algotrading). La ligne que l’échelle laisse ouverte est l’inférence du modèle, et c’est la ligne que la distillation essaie de remplir.

Résistez à remplir les autres lignes avec un tableau de latence de classe modèle. Spread modeling with machine learning publie déjà la comparaison GBM-deep-learning avec une mise en garde qui compte plus que les chiffres : la latence dépend de l'implémentation, et le même modèle LightGBM prend des dizaines de microsecondes par ligne à partir de Python mais quelques microsecondes à partir d'un prédicteur compilé. Toute revendication de latence ici doit nommer le framework, le cœur et la taille du lot, sinon il s'agit de bruit.

Sur les GPU en particulier : les frais généraux fixes par lancement doivent être amortis avant qu'un appareil ne soit utile, et l'inférence à une seule ligne se trouve bien à gauche de la crête de la ligne de toit, là où elle ne se trouve jamais. Quand le GPU paie mesure correctement cette courbe d'amortissement avec un balayage par lots, y compris la façon dont une carte PCIe discrète pousse la crête plus à droite - lisez cela plutôt que de vous fier à une constante citée de mémoire.

Quantification après distillation

Un étudiant distillé compresse davantage : les poids INT8 (environ 2x sur CPU avec AVX-512 VNNI), les poids binaires/ternaires qui transforment les multiplications en ajouts et l'élagage pour éviter les calculs proches de zéro.

L’affirmation tentante est que la distillation puis la quantification préservent plus de précision que la quantification seule, puisque l’étudiant a déjà appris une représentation compacte. N'expédiez pas dessus. Le piège de précision GPU est la position du blog sur une précision numérique réduite : il renvoyait silencieusement des déchets d'apparence plausible, et ce qui rendait le chemin rapide livrable était une porte d'équivalence quantifiée - remplissages décalés, delta PnL en bps - pas une assertion. Un étudiant INT8 est un modèle différent jusqu'à ce que cette porte soit mesurée par rapport à l'étudiant FP32.

import torch.quantization as quant

def quantize_student(student: nn.Module, calibration_loader: DataLoader):
    """Post-training static quantization for CPU deployment."""
    student.cpu()
    student.eval()
    student.qconfig = quant.get_default_qconfig("x86")

    student_prepared = quant.prepare(student)

    with torch.no_grad():
        for X, _ in calibration_loader:
            student_prepared(X)

    student_quantized = quant.convert(student_prepared)
    return student_quantized

Déploiement FPGA : le pipeline Distill-to-Bitstream

Les FPGA constituent le niveau inférieur à 10 µs dans l'échelle de latence et la revue Tbricks/Broadridge les couvre en production aux côtés des cartes réseau de contournement du noyau - latence déterministe, pas de gigue du système d'exploitation, colocalisée avec la pile réseau. Ce qui n’est abordé nulle part sur ce blog, c’est la façon dont un modèle distillé y parvient.

Notes de production de DeepLOB répertorient ONNX/TensorRT, la quantification INT8 et le déploiement de FPGA comme trois options et s'arrêtent là. Voici ce que développe le troisième :

1. Train ensemble teacher (offline, GPU cluster, hours/days)
       |
2. Distill to small MLP student (offline, single GPU, minutes)
       |
3. Quantize student to INT8 / fixed-point (offline, CPU)
       |
4. Convert to HLS (High-Level Synthesis) or RTL
       |
5. Synthesize FPGA bitstream (offline, hours)
       |
6. Deploy to FPGA card in production server
       |
7. Inference: market data -> FPGA -> trading signal

La contrainte contraignante est que le modèle doit s'adapter aux éléments logiques du périphérique : LUT, tranches DSP, bloc RAM. En tant qu'ordre de grandeur du budget plutôt qu'en tant que mesure : un MLP à 2 couches avec 64 unités cachées et des poids INT8 est de l'ordre de 8 000 accumulations multipliées par inférence et environ 16 Ko de poids, soit une petite fraction d'une partie de milieu de gamme. C'est là que la distillation gagne sa place : le professeur d'ensemble ne rentre dans aucun budget ; l'étudiant est loin de la limite.

Les outils qui automatisent PyTorch/ONNX en matériel synthétisable incluent AMD/Xilinx Vitis AI, hls4ml (du CERN) et FINN (de Xilinx Research).

Exemple : conversion hls4ml

import hls4ml
import onnx

dummy_input = torch.randn(1, 60)  # 60 input features
torch.onnx.export(student, dummy_input, "student.onnx", opset_version=13)

hls_config = hls4ml.utils.config_from_onnx_model(
    onnx.load("student.onnx"),
    granularity="name",
    default_precision="ap_fixed<16,8>",
    default_reuse_factor=1,          # full parallelism
)

hls_model = hls4ml.converters.convert_from_onnx_model(
    "student.onnx",
    hls_config=hls_config,
    output_dir="hls_student",
    backend="VivadoAccelerator",
    board="alveo-u250",
)

hls_model.compile()
hls_model.build(csim=True, synth=True)

hls_model.report()

hls_model.report() est la seule source crédible de chiffres de ressources et de latence pour un modèle, une carte, une précision et un facteur de réutilisation donnés - les chiffres évoluent considérablement avec default_reuse_factor seul. Citer une table de synthèse "typique" sans l'exécuter, c'est deviner.

Considérations pratiques

Logits des enseignants de précalcul

La distillation nécessite des prédictions des enseignants sur l'ensemble de la formation - un coût unique hors ligne qui mérite d'être payé délibérément : exécuter l'ensemble une fois, conserver les logits, former les étudiants avec le cache. Les balayages de température et les recherches d'architecture ne coûtent alors rien de plus en laissez-passer d'enseignant, ce qui rend les balayages ci-dessus pratiques du tout.

Le moniteur spécifique à la distillation

L'hygiène du pipeline de fonctionnalités, la normalisation continue en raison de la dérive des paramètres du score z, la surveillance des changements de distribution des entrées et le recyclage déclenché par le régime sont tous traités dans la [section de production de DeepLOB] (/en/blog/post/deeplob-deep-learning-order-book) et s'appliquent inchangés ici.

Le moniteur spécifique à la distillation est divergence KL enseignant-élève sur données live. L'enseignant existe toujours hors ligne ; exécutez-le sur un échantillon d’entrées en direct et comparez les distributions. L'augmentation du KL signifie que l'approximation de l'étudiant se dégrade dans des régimes sur lesquels elle n'a pas été distillée – et elle se déclenche avant la précision, car elle n'attend pas les étiquettes. Le seuil de reconversion doit être calibré par rapport au KL observé dans les périodes connues de bonne qualité et de dégradation connue ; choisi a priori, il est arbitraire.

Quand ne pas distiller

• Le professeur est déjà petit (un modèle linéaire, un GBM peu profond) : la distillation ajoute un étage pipeline pour aucune compression.
• La latence n'est pas une contrainte (rééquilibrage quotidien, signaux de fin de journée) : déployer le professeur.
• L'interprétabilité avant la vitesse : un réseau distillé est plus difficile à expliquer que l'ensemble d'arbres qu'il a remplacé.
• La division en deux étapes fonctionne déjà : si le modèle lent asynchrone dans l'architecture de modélisation par propagation fonctionne, la distillation doit le battre sur une comparaison mesurée avant de justifier le remplacement d'un système fonctionnel.

Résumé

La distillation est une alternative cohérente à la division rapide/lente en deux étapes : former le meilleur professeur que vous pouvez vous permettre hors ligne, transférer sa structure de cible souple chez un étudiant suffisamment petit pour le hot path, quantifier, déployer sur CPU ou FPGA. La variante en profondeur va plus loin et fait de la latence un choix d'exécution plutôt qu'un choix de temps de formation.

Ce que cet article ne prétend délibérément pas, c'est que tout cela surpasse ce que le blog publie déjà. Ce verdict nécessite trois mesures sur des données réelles du carnet de commandes : la courbe de rétention F1 pondérée par élève par rapport à l'ensemble divisée par régime, le balayage de température et une porte de parité INT8 dans le style du piège de précision GPU. Jusqu'à ce que ceux-ci existent, il s'agit d'une description d'une technique et non d'une recommandation pour la déployer.

Références

1. Hinton, G., Vinyals, O. et Dean, J. (2015). Distiller les connaissances dans un réseau neuronal. arXiv:1503.02531

2. Furlanello, T., Lipton, Z.C., Tschannen, M., Itti, L. et Anandkumar, A. (2018). Réseaux de neurones nés de nouveau. CIML. arXiv:1805.04770

3. Zhang, L., Song, J., Gao, A., Chen, J., Bao, C. et Ma, K. (2019). Soyez votre propre professeur : améliorez les performances des réseaux de neurones convolutifs via l'autodistillation. ICCV. arXiv:1905.08094

4. Romero, A., Ballas, N., Kahou, SE, Chassang, A., Gatta, C. et Bengio, Y. (2015). FitNets : conseils pour les filets fins et profonds. ICLR. arXiv:1412.6550

5. Gou, J., Yu, B., Maybank, SJ et Tao, D. (2021). Distillation des connaissances : une enquête. Journal international de vision par ordinateur, 129, 1789-1819. arXiv:2006.05525

6. Duarte, J. et coll. (2018). Inférence rapide de réseaux de neurones profonds dans les FPGA pour la physique des particules (hls4ml). Journal d'instrumentation, 13, P07027. arXiv:1804.06913

7. Umuroglu, Y., et al. (2017). FINN : un cadre pour une inférence de réseau neuronal binarisé rapide et évolutive. FPGA'17. arXiv:1612.07119

8. Zhang, Z., Zohren, S. et Roberts, S. (2019). DeepLOB : réseaux de neurones à convolution profonde pour les carnets d'ordres limités. Transactions IEEE sur le traitement du signal, 67(11), 3001-3012. arXiv:1808.03668