Knowledge Distillation: Compressing Trading Models for Low-Latency Deployment

Makine öğrenimi odaklı ticarette doğruluk ve gecikme arasındaki gerilimin bu blogda zaten yayınlanmış bir yanıtı var. Makine öğrenimi ile yayılmış modelleme iki aşamalı bir bölünme önerir: hızlı bir degrade artırma modeli, gecikme açısından kritik olan gerçek zamanlı alıntılamayı gerçekleştirirken, derin bir model eşzamansız olarak çalışır ve ona ikincil bir sinyal besler veya parametrelerini ayarlar. İki model, iki saat, bir sistem.

Bilginin damıtılması aynı gerilime verilen farklı bir yanıttır. Yavaş modeli hızlı modelin yanında çalıştırmak yerine, hızlı olanı eğitmek için onu bir kez, çevrimdışı olarak kullanırsınız; öğrenci, yalnızca kesin etiketleri değil, öğretmenin sonuçlar üzerindeki tam olasılık dağılımını öğrenir ve öğretmen daha sonra sıcak yolu tamamen terk eder. Çıkarım anında tek model, asenkron bağlantı yok, eskime penceresi yok.

Hangi cevabın kazanacağı ampiriktir ve bu makale henüz bu soruya cevap vermemektedir. Aşağıda makine ve buna karar verecek ölçümlerin açık bir ifadesi yer almaktadır. Burada hiçbir şey bir kıyaslama sonucu değildir; normalde bir sayının gideceği yerde, neyin çalıştırılması gerektiğini söyleyen bir işaret vardır.

DeepLOB ve sipariş defterindeki derin öğrenme'tan çerçeveleme düzeltmesi: yüksek sınıflandırma doğruluğu otomatik olarak kâra dönüşmez; tahmin edilen hareketin teklif-ask farkını temizlemesi gerekir. Bu nedenle "Öğretmenin yön doğruluğunu korumak" bir damıtma kurulumunu optimize etmek için yanlış bir şeydir.

Öğretmen-Öğrenci Çerçevesi

Hinton, Vinyals ve Dean (2015) tarafından hazırlanan orijinal formülasyon basittir. Bir öğretmen modeliniz var $T$ (büyük, yavaş, doğru) ve bir öğrenci modeli $S$ (küçük, hızlı, eğitilmesi gereken). Öğrenci aynı anda iki sinyalden öğrenir:

1. Zor hedefler: kesin doğruluk etiketleri $y$ (örneğin, fiyat arttı veya düştü)
2. Hafif hedefler: öğretmenin çıktı olasılık dağılımı $q_T$ tüm sınıflarda

Öğrencinin kayıp fonksiyonu her ikisini de birleştirir:

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

Neresi $z_T$ Ve $z_S$ öğretmen ve öğrenci logitleri, $\sigma$ softmax fonksiyonudur, $T$ sıcaklık parametresidir ve $\alpha$ iki kayıp bileşeni arasındaki dengeyi kontrol eder.

Ticaret İçin Yumuşak Hedefler Neden Önemlidir

Üç sınıflı yukarı/sabit/aşağı orta fiyat formülasyonu, $\pm\alpha$ eşikleme ve ortaya çıkan dengesizliğin neden doğruluk yerine ağırlıklı F1 rapor ettiğiniz anlamına geldiği tamamen DeepLOB içinde ayarlanmıştır - buradaki etiket şemasını varsayalım. Damıtmaya özgü nokta, öğretmenin argmax'tan önce yaydığı şeydir: sert bir "yukarı" bir bit taşırken, 0,72/0,21/0,07 ayrıca hareketin durabileceğini ve neredeyse kesinlikle geri dönmeyeceğini belirtir. Sınıflar arasındaki bu yapı, ekstra eğitim sinyalidir ve yumuşak hedefli bir öğrencinin, yalnızca etiketler konusunda eğitim almış aynı öğrenciden daha iyi genelleme yapabilmesinin nedeni budur.

Bu güvenin ne olmadığına dair bir uyarı. Softmax çıktısı kalibre edilmiş belirsizlik değildir ve 0,55'e karşı 0,85'i konum boyutlandırma girdisi olarak ele almak, ticaret için uyumlu tahminin reddetmek için var olduğu kısayoldur - boyutlandırmayı aralık genişliğinden, bir kenar oranından ve aralık sıfırın iki yanında olduğunda bir ticaret dışı filtreden türetir; ham softmax bunların hiçbirini size vermez. Burada boyutlandırma iddiasını kazanmak, öğrencinin kalibrasyonunu öğretmeninkine göre ölçmek (güvenilirlik diyagramı, ECE) ve damıtmanın onu koruduğunu göstermek anlamına gelir. Bu sonuç henüz bu makalede yer almıyor.

Sıcaklık ve Yumuşak Hedefler

Sıcaklık parametresi $T$ olasılık dağılımının "yumuşaklığını" kontrol eder. Verilen logitler $z_i$, sıcaklıkla birlikte softmax:

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

Ne zaman $T = 1$ (standart softmax), dağılım zirvedir; olasılık kütlesinin çoğunu baskın sınıf alır. Gibi $T$ arttıkça dağılım düzleşir ve logitlerin göreceli büyüklükleri daha net ortaya çıkar.

Ticaret modellerinin ılımlı bir sıcaklık istediğine dair makul bir argüman var: finansal tahminler görüntü sınıflandırmasından çok daha az güvenilir, bu nedenle bir öğretmen 0,99/0,005/0,005 yerine 0,55/0,30/0,15 çıktısı verebilir ve sinyal silinmeden önce yumuşayacak daha az zirve bırakabilir. Bu bir bulgu değil, bir argümandır; aralığın, ağırlıklı F1 tarafından puanlanan gerçek verilerden elde edilmesi gerekir ve rejime göre farklılık gösterebilir.

The $T^2$ KL diverjans terimindeki faktör, daha yüksek sıcaklıklarda azalan gradyan büyüklüklerini telafi eder. Bu olmasaydı, damıtma kaybı ihmal edilebilecek kadar küçük olurdu $T$ artar.

Izgara Arama Yoluyla Sıcaklığın Seçilmesi

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

Toplulukları Tek Bir Modele Dönüştürmek

Niceliksel bir topluluk, endüktif önyargıları karıştırır: sipariş defteri özelliklerinde gradyanla güçlendirilmiş bir ağaç, son tıklamalar üzerinde bir 1D-CNN, çok zaman dilimli pencereler üzerinde bir transformatör, makro faktörler üzerinde doğrusal bir model. Ortalama alma, tek başına herhangi bir üyeden daha kararlıdır ve dördünün birden çalıştırılması gecikmeyi ve maliyeti artırır; bu durum, makine öğrenimi ile yayılma modellemesinden ayrılan iki aşamalı durum, yavaş üyeleri eşzamansız bir yan kanala indirgeyerek ele alınır. Damıtma bunun yerine dördünü de sıcak yoldaki tek bir öğrenciye indirir.

Topluluk öğretmeninin çıktısı, üyelerinin softmax çıktılarının ortalamasıdır:

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

Neresi $K$ topluluk üyelerinin sayısıdır. Öğrenci bu ortalama dağılıma göre eğitilir.

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)

Bütün mesele parametre sayısı asimetrisidir: 64 gizli üniteye sahip iki katmanlı bir MLP, 60 özellikli, 3 sınıflı bir görev için toplam sayısı milyonları bulan bir topluluğa karşı 8.000 parametre düzeyindedir.

Öğrencinin Neleri Tutar ve Neleri Kaybeder

Bu yük taşıyan ampirik sorudur ve makale buna cevap vermiyor. Sezgi, öğrencinin topluluğu dağıtımda takip etmesi ve topluluğun çeşitliliğinin işi yaptığı stresli rejimlere düşmesidir - ancak elde tutma rakamı yalnızca gerçek sipariş defteri verileriyle ölçülen, rejime göre bölünmüş ve ağırlıklı F1 olarak rapor edilen bir şey anlamına gelir. Sakin günleri atlatan ve bir tasfiye süreci sırasında çöken bir öğrenci, incelikle bozulan bir öğrenciden farklı bir üründür ve toplam sayı onları birbirinden ayıramaz.

Önceden iddia etmek yerine, bu ölçüme göre test etmeye değer üç azaltım vardır:

1. Damıtma setine gerilmeli dönemleri dahil edin, böylece öğrenci, boşluğun açılmasının beklendiği rejimleri görebilir.
2. Özelliğe dayalı damıtma — yalnızca nihai çıktıları değil, ara temsilleri de eşleştirin.
3. Yardımcı rejim kafası öğrenciye yöneliktir ve rejime duyarlı özellikleri paylaşılan bagaja zorlar.

Kendini Damıtma: Öğrenci Öğretmen Olduğunda

Kendi kendine damıtma, bir modelin bilgiyi kendisinden damıttığı bir tekniktir.

Yeniden Doğmuş Ağlar (BAN'lar)

Bir öğrenciyi öğretmenle aynı mimariye sahip olarak eğitin. "Yeniden doğan" öğrenci çoğu zaman orijinalinden daha iyi performans gösterir ve süreç yinelenir:

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

Her nesil bir öncekinin yumuşak hedefleri üzerinde eğitim alır ve kazanımlar genellikle birkaç nesil sonra doyuma ulaşır. Ticaret modelleri için bunun mimari olarak hiçbir maliyeti yoktur - yeni özellik yok, yeni veri yok, sadece farklı bir eğitim prosedürü - bu aynı zamanda test etmenin ucuz olduğu ve test edilmediğini bildirmenin hiçbir mazereti olmadığı anlamına da geliyor.

Derinlik Bilge Kendi Kendini Damıtma

Yardımcı sınıflandırıcıları ara katmanlara ekleyin. En derin çıkış, sığ olanlara öğretmen görevi görür. Çıkarımda bir çıkış seçersiniz: daha düşük gecikme için sığ, maksimum doğruluk için derin.

Burada bir ticaret sistemine en uygun fikir budur, çünkü çıkış derinliği bir çalışma zamanı gecikme düğmesi haline gelir: eğitim zamanında tek bir mimariye bağlı kalmak yerine eğitimli bir ağ, çeşitli bütçeleri kapsar. Kitap hızla ilerlediğinde sığ çıkışa yönelir ve daha kötü bir sonuncuyu kabul edersiniz; sessiz olduğunda tam derinlik için ödeme yaparsınız. Hem çıkış başına doğruluk hem de çıkış başına gecikme eğrileri ölçülebilir ve bunların geçişleri, düğmenin sahip olmaya değer olup olmadığına karar verir.

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

Çıkarım Bütçesinin Nereden Geldiği

Damıtma, yalnızca çıkarımın zor bir bütçe dahilinde olması gerekiyorsa önemlidir ve işlem için onay merdiveninin tamamı - NIC'den kullanıcı alanına, çekirdek bypass'tan, 100 µs'nin altındaki toplam ve FPGA'yı ve paylaşılan belleği zorlayan 10 µs'nin altındaki katman - algoritmik ticarette veri ve iletişim bölümünde zaten ortaya konmuştur. Merdivenin açık bıraktığı satır model çıkarımıdır ve bu da damıtmanın doldurmaya çalıştığı satırdır.

Diğer satırları model sınıfı bir gecikme tablosuyla doldurmaya direnin. Makine öğrenimiyle yayılmış modelleme halihazırda GBM-derin öğrenme karşılaştırmasını ve sayılardan daha önemli olan uyarıyı yayınlıyor: gecikme uygulamaya bağlıdır ve aynı LightGBM modeli Python'dan satır başına onlarca mikrosaniye alır, ancak derlenmiş bir tahminciden birkaç mikrosaniye alır. Buradaki herhangi bir gecikme iddiasında çerçeve, çekirdek ve toplu iş boyutunun belirtilmesi gerekir, aksi takdirde gürültü olur.

Özellikle GPU'larda: bir cihazın herhangi bir şekilde yardımcı olabilmesi için başlatma başına sabit ek yükün amortismana tabi tutulması gerekir ve tek sıralı çıkarım, tavan çizgisi sırtının hiç olmadığı kadar solunda durur. When GPU amorti ettiğinde, ayrı bir PCIe kartının sırtı nasıl daha sağa ittiği de dahil olmak üzere, toplu tarama ile amortisman eğrisini düzgün bir şekilde ölçer - bellekten alınan sabit bir alıntıya güvenmek yerine bunu okuyun.

Damıtma Sonrası Niceleme

Damıtılmış bir öğrenci daha da sıkıştırır: INT8 ağırlıkları (AVX-512 VNNI ile CPU'da kabaca 2 kat), çarpmaları toplamalara dönüştüren ikili/üçlü ağırlıklar ve sıfıra yakın hesaplamayı atlamak için budama.

Cazip iddia, öğrenci zaten kompakt bir gösterimi öğrendiğinden, damıtma ve ardından nicelemenin tek başına nicelemeden daha fazla doğruluğu koruduğudur. Üzerinde nakliye yapmayın. GPU hassas tuzağı, blogun azaltılmış sayısal hassasiyet konusundaki duruşudur: sessizce makul görünen çöpler döndürdü ve hızlı yolu gönderilebilir kılan şey, niceliksel bir eşdeğerlik kapısıydı - dolgular kaydırıldı, bps cinsinden PnL deltası - bir iddia değil. Bir INT8 öğrencisi, bu kapı FP32 öğrencisiyle ölçülene kadar farklı bir modeldir.

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 Dağıtımı: Damıtmadan Bit Akışına Boru Hattı

FPGA'ler, gecikme merdiveninde 10 µs'nin altındaki katmandır ve Tbricks/Broadridge incelemesi bunları üretimde çekirdek bypass NIC'leriyle birlikte kapsar — deterministik gecikme, işletim sistemi titreşimi yok, ağ yığınıyla aynı yerde bulunur. Bu blogun hiçbir yerinde ele alınmayan şey, damıtılmış bir modelin nasıl bir araya geldiğidir.

DeepLOB'un üretim notları ONNX/TensorRT, INT8 nicemleme ve FPGA dağıtımını üç seçenek olarak listeliyor ve burada bitiyor. Üçüncüsü şu şekilde genişliyor:

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

Bağlama kısıtlaması, modelin cihazın mantık öğelerine (LUT'lar, DSP dilimleri, blok RAM) uyması gerektiğidir. Bir ölçümden ziyade büyüklük sırası bütçesi olarak: 64 gizli birim ve INT8 ağırlıklarına sahip 2 katmanlı bir MLP, çıkarım başına 8.000 çarpma-birikim ve ~16 KB ağırlık düzeyindedir; bu, orta aralıktaki bir parçanın küçük bir kısmıdır. Damıtmanın geçimini sağladığı yer burasıdır; topluluk öğretmeni hiçbir bütçeye uymaz; öğrenci sınıra yakın değil.

PyTorch/ONNX'i sentezlenebilir donanıma otomatikleştiren araçlar arasında AMD/Xilinx Vitis AI, hls4ml (CERN'den) ve FINN (Xilinx Research'ten) yer alır.

Örnek: hls4ml Dönüşümü

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() belirli bir model, anakart, hassasiyet ve yeniden kullanım faktörü için kaynak ve gecikme sayılarına ilişkin tek güvenilir kaynaktır; rakamlar, default_reuse_factor yalnız. "Tipik" bir sentez tablosunu çalıştırmadan alıntı yapmak tahmin etmektir.

Pratik Hususlar

Öğretmen Logitlerinin Ön Hesaplanması

Damıtma, tüm eğitim seti boyunca öğretmen tahminlerine ihtiyaç duyar - kasıtlı olarak ödemeye değer tek seferlik bir çevrimdışı maliyet: topluluğu bir kez çalıştırın, logitleri sürdürün, öğrencileri önbelleğe karşı eğitin. Sıcaklık taramaları ve mimari aramaları öğretmenlerin ileri geçişlerinde ekstra hiçbir maliyet gerektirmez, bu da yukarıdaki taramaları pratik hale getirir.

Damıtmaya Özel Tek Monitör

Özellik akışı hijyeni, z-puanı parametrelerinin kayması nedeniyle yuvarlanan normalleştirme, girdi dağılımı değişimi izleme ve rejim tarafından tetiklenen yeniden eğitimin tamamı DeepLOB'un üretim bölümünde ele alınmıştır ve burada değiştirilmeden uygulanır.

Damıtmaya özgü monitör canlı verilerdeki öğretmen-öğrenci KL farklılığıdır. Öğretmen hâlâ çevrimdışıdır; canlı girdilerden oluşan bir örnek üzerinde çalıştırın ve dağılımları karşılaştırın. Yükselen KL, öğrencinin yaklaşımının, üzerinde durulmadığı rejimlerde bozulduğu anlamına gelir ve etiketleri beklemediği için doğruluktan önce ateşlenir. Yeniden eğitim eşiğinin, bilinen-iyi ve bilinen-bozulmuş dönemlerde gözlemlenen KL'ye göre kalibre edilmesi gerekir; a priori seçilmiştir, bu keyfidir.

Ne Zaman Damıtmamalı

• Öğretmen zaten küçüktür (doğrusal bir model, sığ bir GBM): damıtma, sıkıştırma olmaması için bir boru hattı aşaması ekler.
• Gecikme bir kısıtlama değildir (günlük yeniden dengeleme, gün sonu sinyalleri): öğretmeni görevlendirin.
• Yorumlanabilirlik hızı geride bırakır: damıtılmış bir ağı açıklamak, yerini aldığı ağaç topluluğunu açıklamaktan daha zordur.
• İki aşamalı bölünme zaten işe yarıyor: yayılmış modelleme mimarisindeki eşzamansız yavaş model başarılıysa, damıtmanın, çalışan bir sistemi değiştirmeyi haklı çıkarmadan önce, ölçülen bir karşılaştırmada onu geçmesi gerekir.

Özet

Damıtma, iki aşamalı hızlı/yavaş ayrımına tutarlı bir alternatiftir: karşılayabileceğiniz en iyi öğretmeni çevrimdışı olarak eğitin, yumuşak hedef yapısını sıcak yol için yeterince küçük bir öğrenciye aktarın, nicemleyin, CPU veya FPGA üzerinde konuşlandırın. Derinlik odaklı varyant daha da ileri giderek gecikmeyi eğitim zamanı yerine çalışma zamanı tercihi haline getiriyor.

Bu makalenin kasıtlı olarak iddia etmediği şey, herhangi birinin blogun zaten yayınladığı şeyleri geride bıraktığıdır. Bu karar için gerçek sipariş defteri verileri üzerinde üç ölçüm yapılması gerekiyor: Rejime göre bölünmüş öğrenci-topluluk ağırlıklı F1 tutma eğrisi, sıcaklık taraması ve GPU hassas tuzağı tarzında bir INT8 eşlik kapısı. Bunlar mevcut olana kadar bu, bir tekniğin açıklamasıdır, onun uygulanmasına yönelik bir tavsiye değildir.

Referanslar

1. Hinton, G., Vinyals, O. ve Dean, J. (2015). Bilginin Sinir Ağında Damıtılması. arXiv:1503.02531

2. Furlanello, T., Lipton, Z.C., Tschannen, M., Itti, L. ve Anandkumar, A. (2018). Yeniden Doğmuş Sinir Ağları. ICML. arXiv:1805.04770

3. Zhang, L., Song, J., Gao, A., Chen, J., Bao, C. ve Ma, K. (2019). Kendi Öğretmeniniz Olun: Kendi Kendini Damıtma Yoluyla Evrişimli Sinir Ağlarının Performansını Artırın. ICCV. arXiv:1905.08094

4. Romero, A., Ballas, N., Kahou, S.E., Chassang, A., Gatta, C. ve Bengio, Y. (2015). FitNets: İnce Derin Ağlar İçin İpuçları. ICLR. arXiv:1412.6550

5. Gou, J., Yu, B., Maybank, S.J. ve Tao, D. (2021). Bilgi Damıtma: Bir Araştırma. Uluslararası Bilgisayarlı Görme Dergisi, 129, 1789-1819. arXiv:2006.05525

6. Duarte, J., ve diğerleri. (2018). Parçacık Fiziği için FPGA'lerde Derin Sinir Ağlarının Hızlı Çıkarımı (hls4ml). Enstrümantasyon Dergisi, 13, P07027. arXiv:1804.06913

7. Umuroğlu, Y., vd. (2017). FINN: Hızlı, Ölçeklenebilir İkili Sinir Ağı Çıkarımına Yönelik Bir Çerçeve. FPGA'17. arXiv:1612.07119

8.Zhang, Z., Zohren, S. ve Roberts, S. (2019). DeepLOB: Limitli Emir Defterleri için Derin Evrişimli Sinir Ağları. Sinyal İşleme ile ilgili IEEE İşlemleri, 67(11), 3001-3012. arXiv:1808.03668