Knowledge Distillation: Compressing Trading Models for Low-Latency Deployment

Auf die Spannung zwischen Genauigkeit und Latenz beim ML-gesteuerten Handel gibt es in diesem Blog bereits eine veröffentlichte Antwort. Spread-Modellierung mit maschinellem Lernen empfiehlt eine zweistufige Aufteilung: Ein schnelles Gradienten-Boosting-Modell übernimmt die latenzkritische Echtzeit-Quotierung, während ein tiefes Modell asynchron läuft und ihm ein sekundäres Signal zuführt oder seine Parameter anpasst. Zwei Modelle, zwei Uhren, ein System.

Wissensdestillation ist eine andere Antwort auf die gleiche Spannung. Anstatt das langsame Modell neben dem schnellen Modell laufen zu lassen, verwenden Sie es einmal offline, um das schnelle Modell zu trainieren. Der Schüler lernt die vollständige Wahrscheinlichkeitsverteilung des Lehrers über die Ergebnisse, nicht nur die harten Bezeichnungen, und der Lehrer verlässt dann den heißen Pfad vollständig. Ein Modell zur Inferenzzeit, keine asynchrone Kopplung, kein Staleness-Fenster.

Welche Antwort gewinnt, ist empirisch und wird in diesem Artikel noch nicht beantwortet. Was folgt, ist die Maschinerie sowie eine explizite Angabe der Messungen, die darüber entscheiden würden. Nichts hier ist ein Benchmark-Ergebnis; An der Stelle, an der normalerweise eine Zahl steht, befindet sich eine Markierung, die angibt, was ausgeführt werden muss.

Eine Framing-Korrektur vorab, von DeepLOB und Deep Learning im Orderbuch: Eine hohe Klassifizierungsgenauigkeit führt nicht automatisch zu Gewinn – die vorhergesagte Bewegung muss die Geld-Brief-Spanne überwinden. „Die Richtungsgenauigkeit des Lehrers bewahren“ ist daher der falsche Weg, um einen Destillationsaufbau zu optimieren.

Das Lehrer-Schüler-Framework

Die ursprüngliche Formulierung von Hinton, Vinyals und Dean (2015) ist unkompliziert. Sie haben ein Lehrermodell $T$ (groß, langsam, genau) und ein Studentenmodell $S$ (klein, schnell, trainierbar). Der Schüler lernt aus zwei Signalen gleichzeitig:

1. Harte Ziele: die Ground-Truth-Etiketten $y$ (z. B. der Preis ist gestiegen oder gesunken)
2. Weiche Ziele: die Ausgabewahrscheinlichkeitsverteilung des Lehrers $q_T$ über alle Klassen hinweg

Die Verlustfunktion des Studenten kombiniert beides:

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

Wo $z_T$ Und $z_S$ sind die Lehrer- und Schülerlogs, $\sigma$ ist die Softmax-Funktion, $T$ ist der Temperaturparameter und $\alpha$ steuert das Gleichgewicht zwischen den beiden Verlustkomponenten.

Warum Soft Targets für den Handel wichtig sind

Die Drei-Klassen-Aufwärts-/Stationär-/Abwärts-Mittelpreisformulierung, die $\pm\alpha$ Schwellenwerte und warum das daraus resultierende Ungleichgewicht dazu führt, dass Sie gewichtetes F1 statt Genauigkeit melden, werden alle in DeepLOB eingerichtet – gehen Sie hier von diesem Beschriftungsschema aus. Der destillationsspezifische Punkt ist das, was der Lehrer vor dem Argmax ausgibt: Ein hartes „Up“ trägt ein Bit, während 0,72/0,21/0,07 auch besagt, dass die Bewegung ins Stocken geraten könnte und sich mit ziemlicher Sicherheit nicht umkehren wird. Diese klassenübergreifende Struktur ist das zusätzliche Trainingssignal, und deshalb kann ein Schüler mit weichem Ziel besser verallgemeinern als derselbe Schüler, der nur auf Etiketten trainiert wurde.

Eine Warnung, was dieses Vertrauen nicht ist. Bei der Softmax-Ausgabe handelt es sich nicht um eine kalibrierte Unsicherheit, und die Behandlung von 0,55 vs. 0,85 als Positionsgrößeneingabe ist die Abkürzung, die [konforme Vorhersage für den Handel] (/en/blog/post/conformal-prediction-trading) ablehnen kann – sie leitet die Größe aus der Intervallbreite, einem Kantenverhältnis und einem No-Trade-Filter ab, wenn das Intervall Null überspannt, was Ihnen ein roher Softmax nicht gibt. Um den Anspruch auf Größenbestimmung zu erhalten, muss man die Kalibrierung des Schülers mit der des Lehrers vergleichen (Zuverlässigkeitsdiagramm, ECE) und zeigen, dass die Destillation sie bewahrt. Dieses Ergebnis ist noch nicht in diesem Artikel enthalten.

Temperatur und weiche Ziele

Der Temperaturparameter $T$ steuert die „Weichheit“ der Wahrscheinlichkeitsverteilung. Gegebene Protokolle $z_i$, der Softmax mit der Temperatur ist:

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

Wann $T = 1$ (Standard-Softmax) ist die Verteilung spitzenmäßig – die dominante Klasse erhält den größten Teil der Wahrscheinlichkeitsmasse. Als $T$ Wenn sich der Wert erhöht, wird die Verteilung flacher, wodurch die relativen Größen der Logits deutlicher sichtbar werden.

Es gibt ein plausibles Argument dafür, dass Handelsmodelle eine gemäßigte Temperatur wünschen: Finanzprognosen sind weitaus weniger sicher als die Bildklassifizierung, sodass ein Lehrer möglicherweise 0,55/0,30/0,15 anstelle von 0,99/0,005/0,005 ausgibt, sodass weniger Spitzenwerte übrig bleiben, bevor das Signal ausgewaschen wird. Dabei handelt es sich um ein Argument, nicht um eine Feststellung – der Bereich muss aus einer Durchsuchung realer Daten stammen, anhand der Gewichtung F1 bewertet werden und kann je nach Regime unterschiedlich sein.

Der $T^2$ Der Faktor im KL-Divergenzterm kompensiert die verringerten Gradientengrößen bei höheren Temperaturen. Ohne sie würde der Destillationsverlust vernachlässigbar gering werden $T$ erhöht sich.

Temperatur über Rastersuche auswählen

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

Ensembles in ein einziges Modell destillieren

Ein quantitatives Ensemble mischt induktive Verzerrungen: einen Gradienten-verstärkten Baum für Orderbuchmerkmale, ein 1D-CNN für aktuelle Ticks, einen Transformator für Fenster mit mehreren Zeitrahmen und ein lineares Modell für Makrofaktoren. Die Mittelwertbildung ist stabiler als die eines Mitglieds allein, und die Ausführung aller vier vervielfacht Latenz und Kosten – die Situation, die die zweistufige Aufteilung von Spread-Modellierung mit maschinellem Lernen bewältigt, indem langsame Mitglieder auf einen asynchronen Seitenkanal herabgestuft werden. Stattdessen führt die Destillation alle vier zu einem Studenten im heißen Pfad zusammen.

Der Output des Ensemblelehrers ist der Durchschnitt der Softmax-Outputs seiner Mitglieder:

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

Wo $K$ ist die Anzahl der Ensemblemitglieder. Der Schüler wird anhand dieser gemittelten Verteilung trainiert.

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)

Die Parameter-Anzahl-Asymmetrie ist der springende Punkt: Ein zweischichtiges MLP mit 64 versteckten Einheiten liegt in der Größenordnung von 8.000 Parametern für eine 60-Feature-3-Klassen-Aufgabe im Vergleich zu einem Ensemble, dessen Gesamtzahl in die Millionen geht.

Was der Student behält und was er verliert

Dies ist die tragende empirische Frage und der Artikel beantwortet sie nicht. Die Intuition ist, dass der Student das Ensemble in der Verteilung verfolgt und in gestressten Regimen abfällt, in denen die Diversität des Ensembles die Arbeit macht – aber eine Retention-Zahl bedeutet nur etwas, das anhand realer Auftragsbuchdaten gemessen, nach Regime aufgeteilt und als gewichtetes F1 gemeldet wird. Ein Student, der an ruhigen Tagen durchhält und während einer Liquidationskaskade zusammenbricht, ist ein anderes Produkt als einer, der elegant degradiert, und eine aggregierte Zahl kann sie nicht voneinander unterscheiden.

Es lohnt sich, drei Abhilfemaßnahmen anhand dieser Messung zu testen, anstatt sie im Voraus zu behaupten:

1. Beziehen Sie betonte Perioden in den Destillationssatz ein, damit der Schüler die Regime sieht, in denen sich die Lücke voraussichtlich öffnen wird.
2. Feature-basierte Destillation – Passen Sie Zwischendarstellungen an, nicht nur Endausgaben.
3. Hilfsregime-Kopf auf dem Studenten, wodurch die Regime-bewussten Merkmale in den gemeinsamen Rumpf gezwungen werden.

Selbstdestillation: Wenn der Schüler zum Lehrer wird

Selbstdestillation ist eine Technik, bei der ein Modell Wissen aus sich selbst destilliert.

Born-Again-Netzwerke (BANs)

Bilden Sie einen Schüler mit einer Architektur aus, die mit der des Lehrers identisch ist. Der „wiedergeborene“ Schüler übertrifft oft den ursprünglichen Schüler und der Prozess wiederholt sich:

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

Jede Generation trainiert auf weichen Zielen der vorherigen Generation, wobei die Gewinne typischerweise nach einigen Generationen ihren Sättigungsgrad erreichen. Für Handelsmodelle kostet dies architektonisch nichts – keine neuen Funktionen, keine neuen Daten, nur ein anderes Trainingsverfahren – was auch bedeutet, dass es kostengünstig zu testen ist und es keine Entschuldigung dafür gibt, es als ungetestet zu melden.

Tiefenweise Selbstdestillation

An Zwischenlagen Hilfsklassierer anbringen. Der tiefste Ausgang dient als Lehrer für die flacheren. Bei der Inferenz wählen Sie einen Ausgang: flach für geringere Latenz, tief für maximale Genauigkeit.

Das ist hier die Idee, die am besten zu einem Handelssystem passt, denn die Ausstiegstiefe wird zum Drehknopf für die Laufzeitlatenz: Ein trainiertes Netzwerk deckt eine Reihe von Budgets ab, anstatt sich zur Trainingszeit auf eine einzige Architektur festzulegen. Wenn sich das Buch schnell bewegt, nehmen Sie den flachen Ausgang und akzeptieren einen schlechteren Seitenzahn; Wenn es ruhig ist, zahlt man für die volle Tiefe. Sowohl die Genauigkeits-pro-Exit- als auch die Latenz-pro-Exit-Kurve sind messbar, und ihr Schnittpunkt entscheidet darüber, ob sich der Knopf lohnt.

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

Woher das Inferenzbudget kommt

Die Destillation ist nur dann von Bedeutung, wenn die Inferenz in einem festen Budget verankert sein muss, und die gesamte Leiter vom Tick zum Handel – NIC-zu-Userspace, Kernel-Bypass, die Sub-100-µs-Gesamtzahl und die Sub-10-µs-Stufe, die FPGA und Shared Memory erzwingt – ist bereits in Daten und Kommunikation im algorithmischen Handel dargelegt. Die Zeile, die die Leiter offen lässt, ist die Modellinferenz, und das ist die Zeile, die die Destillation zu füllen versucht.

Vermeiden Sie es, die anderen Zeilen mit einer Latenztabelle der Modellklasse zu füllen. Spread-Modellierung mit maschinellem Lernen veröffentlicht bereits den Vergleich zwischen GBM und Deep-Learning sowie den Vorbehalt, der wichtiger ist als die Zahlen: Die Latenz hängt von der Implementierung ab, und das gleiche LightGBM-Modell benötigt bei Python mehrere zehn Mikrosekunden pro Zeile, bei einem kompilierten Prädiktor jedoch einige Mikrosekunden. Jeder Anspruch auf Latenz muss hier das Framework, den Kern und die Stapelgröße benennen, sonst handelt es sich um Rauschen.

Speziell bei GPUs: Der feste Mehraufwand pro Start muss amortisiert werden, bevor ein Gerät überhaupt hilft, und die Einzelzeileninferenz befindet sich weit links vom Dachkamm, wo sie nie ist. Wenn sich die GPU auszahlt misst diese Amortisationskurve ordnungsgemäß mit einem Batch-Sweep, einschließlich der Art und Weise, wie eine diskrete PCIe-Karte den Grat weiter nach rechts verschiebt – lesen Sie das, anstatt einer aus dem Speicher zitierten Konstante zu vertrauen.

Quantisierung nach der Destillation

Ein destillierter Student komprimiert weiter: INT8-Gewichte (ungefähr 2x auf der CPU mit AVX-512 VNNI), binäre/ternäre Gewichte, die Multiplikationen in Additionen umwandeln, und Bereinigung, um Berechnungen nahe Null zu überspringen.

Die verlockende Behauptung ist, dass die Destillation und dann die Quantisierung eine höhere Genauigkeit gewährleistet als die Quantisierung allein, da der Schüler bereits eine kompakte Darstellung gelernt hat. Versenden Sie nicht darauf. Die GPU-Präzisionsfalle ist die aktuelle Position des Blogs zur reduzierten numerischen Präzision: Sie gab stillschweigend plausibel aussehenden Müll zurück, und was den Fast Path auslieferbar machte, war ein quantifiziertes Äquivalenzgatter – verschobene Füllungen, PnL-Delta in bps – keine Behauptung. Ein INT8-Student ist ein anderes Modell, bis dieses Tor mit dem FP32-Studenten verglichen wird.

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

FPGA-Bereitstellung: Die Distill-to-Bitstream-Pipeline

FPGAs sind die Sub-10-µs-Stufe in der Latenzleiter und der Test von Tbricks/Broadridge deckt sie in der Produktion neben Kernel-Bypass-NICs ab – deterministische Latenz, kein Betriebssystem-Jitter, zusammen mit dem Netzwerk-Stack platziert. Was in diesem Blog nirgends behandelt wird, ist, wie ein destilliertes Modell auf ein solches gelangt.

DeepLOBs Produktionsnotizen führen ONNX/TensorRT, INT8-Quantisierung und FPGA-Bereitstellung als drei Optionen auf und hören hier auf. Dies ist, was der dritte erweitert:

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

Die Bindungsbeschränkung besteht darin, dass das Modell in die Logikelemente des Geräts passen muss – LUTs, DSP-Slices, Block-RAM. Als Größenordnungsbudget und nicht als Maß: Ein zweischichtiges MLP mit 64 versteckten Einheiten und INT8-Gewichten liegt in der Größenordnung von 8.000 Multiplikationsakkumulationen pro Inferenz und ~16 KB an Gewichten, ein kleiner Bruchteil eines Mittelbereichsteils. Hier verdient die Destillation ihren Lebensunterhalt – der Ensemble-Lehrer passt in kein Budget; Der Student ist noch lange nicht an der Grenze.

Zu den Tools, die PyTorch/ONNX auf synthetisierbare Hardware automatisieren, gehören AMD/Xilinx Vitis AI, hls4ml (von CERN) und FINN (von Xilinx Research).

Beispiel: hls4ml-Konvertierung

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() ist die einzige glaubwürdige Quelle für Ressourcen- und Latenzzahlen für ein bestimmtes Modell, ein bestimmtes Board, eine bestimmte Präzision und einen bestimmten Wiederverwendungsfaktor – die Zahlen ändern sich erheblich mit default_reuse_factor allein. Eine „typische“ Synthesetabelle zu zitieren, ohne sie auszuführen, ist eine Vermutung.

Praktische Überlegungen

Lehrerprotokolle vorab berechnen

Für die Destillation sind Lehrervorhersagen über den gesamten Trainingssatz erforderlich – ein einmaliger Offline-Kostenwert, der es wert ist, bewusst bezahlt zu werden: Führen Sie das Ensemble einmal aus, behalten Sie die Logits bei, trainieren Sie die Schüler anhand des Caches. Temperatur-Sweeps und Architektursuchen kosten dann in Lehrer-Vorwärtsdurchgängen nichts extra, was die oben genannten Sweeps überhaupt praktisch macht.

Der einzige destillationsspezifische Monitor

Feature-Pipeline-Hygiene, rollierende Normalisierung aufgrund einer Drift der Z-Score-Parameter, Überwachung der Eingabeverteilungsverschiebung und durch das Regime ausgelöste Umschulung werden alle im DeepLOB-Produktionsabschnitt behandelt und gelten hier unverändert.

Der für die Destillation spezifische Monitor ist Lehrer-Schüler-KL-Divergenz anhand von Live-Daten. Der Lehrer ist immer noch offline; Führen Sie es an einer Stichprobe von Live-Eingaben aus und vergleichen Sie die Verteilungen. Steigende KL bedeutet, dass sich die Approximation des Schülers in Regimen verschlechtert, auf die sie nicht destilliert wurde – und sie wird vor der Genauigkeit ausgelöst, weil sie nicht auf Labels wartet. Die Umschulungsschwelle muss anhand der beobachteten KL in bekanntermaßen guten und bekanntermaßen verschlechterten Zeiträumen kalibriert werden; a priori ausgewählt, ist es willkürlich.

Wann man nicht destilliert

• Der Lehrer ist bereits klein (ein lineares Modell, ein flaches GBM): Durch die Destillation wird eine Pipeline-Stufe ohne Komprimierung hinzugefügt.
• Latenz ist keine Einschränkung (täglicher Neuausgleich, Tagesendsignale): Setzen Sie den Lehrer ein.
• Interpretierbarkeit geht über Geschwindigkeit: Ein destilliertes Netzwerk ist schwerer zu erklären als das Baumensemble, das es ersetzt hat.
• Die zweistufige Aufteilung funktioniert bereits: Wenn das asynchrone langsame Modell in der Spread-Modeling-Architektur liefert, muss die Destillation es bei einem gemessenen Vergleich schlagen, bevor es den Ersatz eines funktionierenden Systems rechtfertigt.

Zusammenfassung

Die Destillation ist eine kohärente Alternative zur zweistufigen Schnell-/Langsam-Aufteilung: Trainieren Sie den besten Lehrer, den Sie sich leisten können, offline, übertragen Sie seine Soft-Target-Struktur auf einen Schüler, der klein genug für den heißen Pfad ist, quantisieren Sie ihn und stellen Sie ihn auf der CPU oder dem FPGA bereit. Die Tiefenvariante geht noch weiter und macht die Latenz zu einer Laufzeitwahl und nicht zu einer Trainingszeitwahl.

Was dieser Artikel bewusst nicht behauptet, ist, dass irgendetwas davon besser ist als das, was der Blog bereits veröffentlicht. Für dieses Urteil sind drei Messungen an realen Auftragsbuchdaten erforderlich: die nach Regime aufgeteilte gewichtete F1-Retentionskurve zwischen Studenten und Ensembles, der Temperaturdurchlauf und ein INT8-Paritätsgatter im Stil der GPU-Präzisionsfalle. Bis diese vorhanden sind, handelt es sich hierbei um eine Beschreibung einer Technik und nicht um eine Empfehlung für deren Einsatz.

Referenzen

1. Hinton, G., Vinyals, O. & Dean, J. (2015). Das Wissen in einem neuronalen Netzwerk destillieren. arXiv:1503.02531

2. Furlanello, T., Lipton, Z. C., Tschannen, M., Itti, L. & Anandkumar, A. (2018). Wiedergeborene neuronale Netze. ICML. arXiv:1805.04770

3. Zhang, L., Song, J., Gao, A., Chen, J., Bao, C. & Ma, K. (2019). Seien Sie Ihr eigener Lehrer: Verbessern Sie die Leistung von Faltungs-Neuronalen Netzen durch Selbstdestillation. ICCV. arXiv:1905.08094

4. Romero, A., Ballas, N., Kahou, S. E., Chassang, A., Gatta, C. & Bengio, Y. (2015). FitNets: Hinweise für dünne, tiefe Netze. ICLR. arXiv:1412.6550

5. Gou, J., Yu, B., Maybank, S. J. und Tao, D. (2021). Wissensdestillation: Eine Umfrage. International Journal of Computer Vision, 129, 1789-1819. arXiv:2006.05525

6. Duarte, J., et al. (2018). Schnelle Inferenz tiefer neuronaler Netze in FPGAs für die Teilchenphysik (hls4ml). Journal of Instrumentation, 13, P07027. arXiv:1804.06913

7. Umuroglu, Y., et al. (2017). FINN: Ein Framework für schnelle, skalierbare binarisierte neuronale Netzwerkinferenz. FPGA '17. arXiv:1612.07119

8. Zhang, Z., Zohren, S. & Roberts, S. (2019). DeepLOB: Deep Convolutional Neural Networks für Limit-Order-Bücher. IEEE Transactions on Signal Processing, 67(11), 3001-3012. arXiv:1808.03668