Knowledge Distillation: Compressing Trading Models for Low-Latency Deployment

ML арқылы басқарылатын саудадағы дәлдік пен кідіріс арасындағы қайшылықтың осы блогта жарияланған жауабы бар. Машиналық оқыту арқылы спредті модельдеу екі кезеңді бөлуді ұсынады: жылдам градиенттік бустинг моделі кідіріске сезімтал нақты уақыттағы котировкалауды орындайды, ал терең модель асинхронды жұмыс істеп, оған қосымша сигнал береді немесе параметрлерін өзгертеді. Екі модель, екі сағат, бір жүйе.

Knowledge distillation — сол қайшылыққа берілетін басқа жауап. Баяу модельді жылдам модельмен қатар іске қосудың орнына, оны офлайн режимде бір рет қолданып, жылдам модельді үйретесіз: student тек қатаң белгілерді емес, teacher-дің нәтижелер бойынша толық ықтималдық үлестірімін үйренеді, содан кейін teacher жедел жолдан мүлде шығады. Инференс кезінде бір модель, асинхронды байланыс жоқ, ескіру терезесі жоқ.

Қай жауаптың жеңетіні эмпирикалық түрде анықталады, ал бұл мақала оған әлі жауап бермейді. Төменде механизм және шешім қабылдайтын өлшемдер нақты көрсетілген. Мұнда бенчмарк нәтижесі жоқ; әдетте сан тұратын жерде қандай өлшеу жүргізілуі керегі белгіленген.

Алдымен DeepLOB және ордер кітабындағы deep learning жұмысынан маңызды түзету: жіктеу дәлдігінің жоғарылығы автоматты түрде пайдаға айналмайды — болжанған қозғалыс bid-ask спредінен асуы керек. Сондықтан "teacher-дің бағыттық дәлдігін сақтау" distillation жүйесін оңтайландырудың дұрыс мақсаты емес.

Teacher-Student құрылымы

Hinton, Vinyals және Dean (2015) ұсынған бастапқы тұжырым қарапайым. Сізде teacher моделі $T$ (үлкен, баяу, дәл) және student моделі $S$ (кіші, жылдам, үйретілетін) бар. Student бір уақытта екі сигналдан үйренеді:

1. Қатаң мақсаттар: шынайы белгілер $y$ (мысалы, баға өсті немесе төмендеді)
2. Жұмсақ мақсаттар: teacher-дің барлық кластар бойынша шығаратын ықтималдық үлестірімі $q_T$

Student-тің loss функциясы екеуін біріктіреді:

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

мұндағы $z_T$ және $z_S$ — teacher мен student логиттері, $\sigma$ — softmax функциясы, $T$ — температура параметрі, ал $\alpha$ екі loss компонентінің арасындағы тепе-теңдікті басқарады.

Саудада жұмсақ мақсаттар неге маңызды

Үш класты up/stationary/down орташа баға формулировкасы, $\pm\alpha$ шегін қолдану және осыдан туындайтын теңгерімсіздік accuracy орнына weighted F1 есептеуді талап ететіні DeepLOB материалында берілген — мұнда сол белгілеу схемасын қабылдаңыз. Distillation-ге тән мәселе — teacher argmax-қа дейін не шығарады: қатаң "up" бір бит береді, ал 0.72/0.21/0.07 қозғалыстың тоқтап қалуы мүмкін екенін және кері айналмайтынын да көрсетеді. Кластар арасындағы осы құрылым қосымша үйрету сигналын береді, сондықтан жұмсақ мақсатпен үйретілген student тек белгілермен үйретілген дәл сол student-ке қарағанда жақсырақ жалпылай алады.

Бұл сенімділіктің не емес екеніне назар аударыңыз. Softmax шығысы калибрленген белгісіздік емес, ал 0.55 пен 0.85-ті позиция көлемінің кірісі ретінде қолдану — саудаға арналған conformal prediction бас тартатын қысқа жол: ол көлемді интервал еніне, edge қатынасына және интервал нөлді қамтығанда сауда жасамау сүзгісіне негіздейді, ал шикі softmax бұлардың ешқайсысын бермейді. Мұндағы көлем туралы тұжырымды негіздеу үшін student калибрлеуін teacher калибрлеуімен (сенімділік диаграммасы, ECE) өлшеп, distillation оның сақталатынын көрсету керек. Бұл нәтиже әзірге мақалада жоқ.

Температура және жұмсақ мақсаттар

Температура параметрі $T$ ықтималдық үлестірімінің "жұмсақтығын" басқарады. $z_i$ логиттері берілсе, температурасы бар softmax:

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

$T = 1$ болғанда (стандартты softmax) үлестірім шыңды болады — басым класс ықтималдық массасының көбін алады. $T$ артқан сайын үлестірім тегістеліп, логиттердің салыстырмалы шамаларын анығырақ көрсетеді.

Сауда модельдеріне орташа температура қажет деген негізді уәж бар: қаржылық болжамдар кескін жіктеуіне қарағанда әлдеқайда сенімсіз, сондықтан teacher 0.99/0.005/0.005 орнына 0.55/0.30/0.15 беруі мүмкін; сигнал жоғалмай тұрып жұмсартылатын шыңдылық та аз болады. Бірақ бұл — аргумент, нәтиже емес: диапазон нақты деректегі sweep арқылы, weighted F1-пен бағаланып алынуы керек және режимге қарай өзгеруі мүмкін.

KL divergence мүшесіндегі $T^2$ көбейткіші жоғары температуралардағы градиент шамасының азаюын өтейді. Онсыз $T$ артқанда distillation loss мәні елеусіз кішкентай болып қалады.

Температураны grid search арқылы таңдау

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

Ensemble модельдерін бір модельге distill ету

Quant ensemble әртүрлі индуктивтік бейімділіктерді біріктіреді: ордер кітабы белгілеріндегі gradient-boosted tree, соңғы tick-тердегі 1D-CNN, көп уақыт масштабы терезелеріндегі transformer және макрофакторлардағы сызықтық модель. Орташа мән жеке модельдердің кез келгенінен тұрақтырақ, ал төртеуін қатар іске қосу кідіріс пен шығынды көбейтеді — машиналық оқыту арқылы спредті модельдеу мақаласындағы екі кезеңді бөлу баяу модельдерді асинхронды қосалқы арнаға ығыстыру арқылы шешетін жағдай. Distillation оның орнына төртеуін де жедел жолдағы бір student-ке біріктіреді.

Ensemble teacher-дің шығысы оның мүшелерінің softmax шығыстарының орташа мәні:

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

мұндағы $K$ — ensemble мүшелерінің саны. Student осы ортақ үлестірімге қарап үйретіледі.

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)

Параметрлер санының асимметриясы — негізгі мән: 64 жасырын бірлігі бар екі қабатты MLP 60 белгісі және 3 класы бар міндет үшін шамамен 8 000 параметрден тұрады, ал ensemble жиынтықта миллиондаған параметрге жетеді.

Student нені сақтайды және нені жоғалтады

Бұл — мақаланың жауап бермейтін негізгі эмпирикалық сұрағы. Интуиция бойынша student деректер үлестірімі ішінде ensemble-ді қадағалайды да, ensemble әртүрлілігі жұмыс істейтін күйзеліс режимдерінде әлсірейді. Бірақ сақтау көрсеткіші нақты ордер кітабы деректерінде режимдерге бөлініп, weighted F1 ретінде өлшенгенде ғана мәнді. Тыныш күндері шыдап, жою каскады кезінде құлайтын student біртіндеп нашарлайтын student-тен басқа өнім, ал жиынтық сан бұл айырмашылықты көрсетпейді.

Бұл өлшемге қарсы алдын ала тұжырым жасамай, тексеруге тұрарлық үш mitigation бар:

1. Күйзеліс кезеңдерін distillation жиынына қосу, сонда student алшақтық ашылатын режимдерді көреді.
2. Белгіге негізделген distillation — тек соңғы шығыстарды емес, аралық көріністерді де сәйкестендіру.
3. Student-ке қосалқы режим басын қосу, ортақ trunk ішіне режимді ескеретін белгілерді енгізуге мәжбүрлеу.

Self-distillation: student teacher болған кезде

Self-distillation — модель білімді өзінен distill ететін тәсіл.

Born-Again желілері (BANs)

Teacher архитектурасымен бірдей student үйретіңіз. "Born-again" student жиі бастапқы модельден асып түседі және процесс қайталанады:

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

Әр буын алдыңғы буынның жұмсақ мақсаттарында үйретіледі, ал өсім әдетте бірнеше буыннан кейін қанығады. Сауда модельдері үшін архитектуралық құны жоқ — жаңа белгілер де, жаңа дерек те керек емес, тек басқа үйрету процедурасы қажет. Бұл оны тексеруді арзан етеді және тексермей есеп беруге еш сылтау қалдырмайды.

Тереңдік бойынша self-distillation

Аралық қабаттарға қосалқы жіктеуіштер жалғаңыз. Ең терең exit таяз exit-терге teacher болады. Инференсте exit таңдаңыз: кідіріс аз болсын десеңіз таяз, ең жоғары дәлдік керек болса терең.

Бұл сауда жүйесіне ең үйлесетін идея, өйткені exit тереңдігі орындау кезіндегі кідіріс реттегішіне айналады: үйрету кезінде бір архитектураға бекінбей, бір желі бюджеттердің ауқымын қамтиды. Ордер кітабы жылдам қозғалғанда таяз exit-ті таңдап, нашар posterior-ды қабылдайсыз; тыныш кезде толық тереңдікке төлейсіз. Әр exit үшін дәлдік пен кідіріс қисықтарын өлшеуге болады, ал олардың қиылысуы бұл реттегіштің қажет екенін анықтайды.

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

Инференс бюджеті қайдан пайда болады

Distillation инференс қатаң бюджетке сыйуы керек болғанда ғана маңызды, ал tick-тен trade-ке дейінгі толық баспалдақ — NIC-тен userspace-ке дейін, kernel bypass, 100 µs-тан аз жалпы уақыт және FPGA мен ортақ жадты талап ететін 10 µs-тан аз деңгей — алгоритмдік саудадағы деректер және коммуникация материалында бұрыннан берілген. Сол баспалдақ ашық қалдырған жол — модель инференсі, distillation толтыруға тырысатын жол да осы.

Басқа жолдарды модель класының кідіріс кестесімен толтыруға асықпаңыз. Машиналық оқыту арқылы спредті модельдеу GBM мен deep learning салыстыруын және сандардан маңызды ескертуді жариялаған: кідіріс іске асыруға тәуелді, бір LightGBM моделі Python-нан бір жолға ондаған микросекунд жұмсаса, компиляцияланған predictor-дан бірнеше микросекунд қана алады. Мұндағы кез келген кідіріс тұжырымы framework, ядро және batch size атауы көрсетілгенде ғана мәнді; әйтпесе бұл шу.

GPU туралы нақты айтсақ: құрылғы көмектесе бастамас бұрын іске қосудың тұрақты үстеме шығыны өтелуі керек, ал бір жолдық инференс roofline ridge-інің сол жағында тым алыс орналасқандықтан, ол жерде GPU ешқашан тиімді болмайды. GPU қашан ақталады batch sweep арқылы осы өтеу қисығын дұрыс өлшейді, соның ішінде дискретті PCIe картасы ridge-ті одан әрі оңға жылжытатынын көрсетеді — жадтан алынған тұрақты санға сенбей, соны оқыңыз.

Distillation-нен кейінгі quantization

Distill етілген student одан әрі сығылады: INT8 салмақтары (AVX-512 VNNI бар CPU-де шамамен 2 есе), көбейтулерді қосуларға айналдыратын binary/ternary салмақтар және нөлге жақын есептеуді өткізіп жіберетін pruning.

Distillation-then-quantization quantization-ның өзінен көбірек дәлдікті сақтайды деген тартымды тұжырым бар, себебі student ықшам көріністі алдын ала үйренген. Оған сүйеніп production-ға шығармаңыз. GPU дәлдігі тұзағы — блогтың қысқартылған сандық дәлдікке қатысты тұрақты ұстанымы: ол көзге нанымды, бірақ қате нәтижені үнсіз қайтарды, ал жылдам жолды іске жарамды еткен нәрсе тұжырым емес, санмен өлшенген эквиваленттік шегі болды — ығысқан толтырулар, bps-тағы PnL айырмасы. INT8 student FP32 student-пен салыстырылған бұл шек өлшенбейінше басқа модель болып саналады.

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-ға орналастыру: distill-to-bitstream конвейері

FPGA — кідіріс баспалдағындағы 10 µs-тан төмен деңгей, ал Tbricks/Broadridge шолуы оларды kernel-bypass NIC-пен қатар production-да қарастырады — детерминирленген кідіріс, OS jitter жоқ, желілік стекпен бірге орналастыру. Бұл блогта әлі қамтылмаған нәрсе — distill етілген модельді FPGA-ға қалай жеткізу.

DeepLOB-тың production жазбаларында ONNX/TensorRT, INT8 quantization және FPGA-ға орналастыру үш нұсқа ретінде аталып, сол жерде тоқтайды. Үшіншісі мына жолға тарқатылады:

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

Негізгі шектеу — модель құрылғының логикалық элементтеріне: LUT, DSP slice және block RAM-ға сыйуы керек. Өлшеу емес, шамамен бюджет ретінде: 64 жасырын бірлігі бар және INT8 салмақтары бар 2 қабатты MLP бір инференске шамамен 8 000 multiply-accumulate және ~16 KB салмақ жұмсайды, бұл орта деңгейлі чиптің шағын бөлігі. Distillation осы жерде тиімділігін көрсетеді — ensemble teacher кез келген бюджетке сыймайды, ал student шекке жақындамайды.

PyTorch/ONNX моделін синтезделетін аппаратураға автоматты түрлендіретін құралдарға AMD/Xilinx Vitis AI, hls4ml (CERN-нен) және FINN (Xilinx Research-тен) жатады.

Мысал: 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() — берілген модель, плата, дәлдік және reuse factor үшін ресурс пен кідіріс сандарының жалғыз сенімді көзі; мәндер тек default_reuse_factor параметрінің өзінен-ақ айтарлықтай өзгереді. Іске қоспай "әдеттегі" синтез кестесін келтіру — болжау ғана.

Практикалық мәселелер

Teacher логиттерін алдын ала есептеу

Distillation бүкіл үйрету жиыны бойынша teacher болжамдарын қажет етеді — әдейі төлеуге тұрарлық бір реттік офлайн шығын: ensemble-ді бір рет іске қосып, логиттерді сақтап, student-терді кэшке қарсы үйретіңіз. Температура sweep-тері мен архитектура іздеулері teacher-дің алға өтулеріне қосымша шығын қоспайды, сондықтан жоғарыдағы sweep-терді іс жүзінде жүргізуге болады.

Distillation-ге тән жалғыз монитор

Feature pipeline тазалығы, z-score параметрлері ығысатындықтан жылжымалы нормализация, кіріс үлестірімінің ауысуын бақылау және режимге қарай қайта үйрету DeepLOB-тың production бөлімінде қамтылған және мұнда өзгеріссіз қолданылады.

Distillation-ге тән монитор — тірі деректердегі teacher-student KL divergence. Teacher офлайнда сақталады; тірі кірістердің бір бөлігінде оны іске қосып, үлестірімдерді салыстырыңыз. KL өсуі student аппроксимациясының distill етілмеген режимдерде нашарлап жатқанын білдіреді — әрі ол accuracy-ден бұрын іске қосылады, себебі белгілерді күтпейді. Қайта үйрету шегі жақсы және нашар кезеңдерде байқалған KL-ге қарсы калибрленуі керек; алдын ала таңдалса, ол еркін алынған сан.

Қай кезде distill жасамау керек

• Teacher онсыз да кіші (сызықтық модель, таяз GBM): distillation сығымдаусыз қосымша конвейер кезеңін қосады.
• Кідіріс шектеу емес (күнделікті қайта теңгеру, күн соңындағы сигналдар): teacher-ді орналастырыңыз.
• Түсіндірмелілік жылдамдықтан маңызды: distill етілген желіні ол алмастырған ағаш ensemble-іне қарағанда түсіндіру қиынырақ.
• Екі кезеңді бөлу онсыз да жұмыс істейді: егер спредті модельдеу архитектурасындағы асинхронды баяу модель нәтиже беріп тұрса, distillation жұмыс істеп тұрған жүйені алмастыруға негіз болу үшін өлшенген салыстыруда одан асып түсуі керек.

Қорытынды

Distillation — екі кезеңді fast/slow бөлуге үйлесімді балама: офлайн режимде мүмкіндігіңіз жететін ең жақсы teacher-ді үйретіңіз, оның жұмсақ мақсат құрылымын жедел жолға сыятындай кіші student-ке беріңіз, quantization жасаңыз, CPU немесе FPGA-ға орналастырыңыз. Тереңдік бойынша нұсқа бұдан әрі кетіп, кідірісті үйрету кезіндегі емес, орындау кезіндегі таңдау етеді.

Бұл мақаланың әдейі айтпайтыны — осының бәрі блогта бұрын жарияланған тәсілдерден асып түседі деген тұжырым. Мұны шешу үшін нақты ордер кітабы деректерінде үш өлшеу керек: режимдерге бөлінген student-ensemble weighted F1 сақтау қисығы, температура sweep-і және GPU дәлдігі тұзағы үлгісіндегі INT8 parity gate. Бұлар болмайынша, бұл орналастыруға арналған кеңес емес, техниканың сипаттамасы ғана.

Әдебиеттер

1. Hinton, G., Vinyals, O., & Dean, J. (2015). Distilling the Knowledge in a Neural Network. arXiv:1503.02531

2. Furlanello, T., Lipton, Z. C., Tschannen, M., Itti, L., & Anandkumar, A. (2018). Born-Again Neural Networks. ICML. arXiv:1805.04770

3. Zhang, L., Song, J., Gao, A., Chen, J., Bao, C., & Ma, K. (2019). Be Your Own Teacher: Improve the Performance of Convolutional Neural Networks via Self Distillation. ICCV. arXiv:1905.08094

4. Romero, A., Ballas, N., Kahou, S. E., Chassang, A., Gatta, C., & Bengio, Y. (2015). FitNets: Hints for Thin Deep Nets. ICLR. arXiv:1412.6550

5. Gou, J., Yu, B., Maybank, S. J., & Tao, D. (2021). Knowledge Distillation: A Survey. International Journal of Computer Vision, 129, 1789-1819. arXiv:2006.05525

6. Duarte, J., et al. (2018). Fast Inference of Deep Neural Networks in FPGAs for Particle Physics (hls4ml). Journal of Instrumentation, 13, P07027. arXiv:1804.06913

7. Umuroglu, Y., et al. (2017). FINN: A Framework for Fast, Scalable Binarized Neural Network Inference. FPGA '17. arXiv:1612.07119

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