Knowledge Distillation: Compressing Trading Models for Low-Latency Deployment

ML менен башкарылган соодадагы тактык менен кечигүү ортосундагы карама-каршылыктын бул блогдо жарыяланган жообу бар. Машина үйрөнүүсү менен спредди моделдөө эки баскычтуу бөлүүнү сунуштайт: тез gradient boosting модели кечигүүгө сезгич реалдуу убакыттагы котировканы аткарат, ал эми терең модель асинхрондуу иштеп, ага кошумча сигнал берет же параметрлерин өзгөртөт. Эки модель, эки саат, бир система.

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тен башка продукт, ал эми жалпы сан экөөнү айырмалай албайт.

Бул өлчөөгө каршы алдын ала ырастоонун ордуна текшерүүгө арзый турган үч чара бар:

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 кылынган модель алардын бирине кантип жеткирилери.

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