Knowledge Distillation: Compressing Trading Models for Low-Latency Deployment

ML 기반 거래의 정확성 대 지연 시간 긴장에 대한 답변은 이미 이 블로그에 게시되어 있습니다. 기계 학습을 사용한 확산 모델링에서는 2단계 분할을 권장합니다. 빠른 경사 부스팅 모델은 지연 시간이 중요한 실시간 인용을 수행하는 반면 심층 모델은 비동기식으로 실행되어 보조 신호를 공급하거나 매개변수를 조정합니다. 두 가지 모델, 두 개의 시계, 하나의 시스템.

지식 증류는 동일한 긴장에 대한 다른 대답입니다. 빠른 모델과 함께 느린 모델을 실행하는 대신 오프라인에서 한 번 사용하여 빠른 모델을 훈련합니다. 학생은 하드 라벨뿐만 아니라 결과에 대한 교사의 전체 확률 분포를 배우고 교사는 핫 경로를 완전히 떠납니다. 추론 시 하나의 모델, 비동기식 결합 없음, 부실 기간 없음.

어떤 답변이 승리하는지는 경험적이며 이 기사에서는 아직 이에 대한 답변을 제공하지 않습니다. 다음은 기계와 이를 결정하는 측정에 대한 명시적인 설명입니다. 여기에는 벤치마크 결과가 없습니다. 일반적으로 숫자가 가는 곳에 무엇을 실행해야 하는지 알려주는 마커가 있습니다.

DeepLOB 및 주문서의 딥 러닝에서 한 가지 프레이밍 수정: 높은 분류 정확도는 자동으로 이익으로 변환되지 않습니다. 예측된 움직임은 매수-매도 스프레드를 지워야 합니다. 따라서 "교사의 방향 정확도 유지"는 증류 설정을 최적화하는 데 잘못된 것입니다.

교사-학생 프레임워크

Hinton, Vinyals 및 Dean(2015)의 원래 공식은 간단합니다. 교사 모델 $T$(크고 느리며 정확함)와 학생 모델 $S$(작고 빠르며 훈련 가능)가 있습니다. 학생은 두 가지 신호를 동시에 학습합니다.

1. 하드 타겟: 실제 라벨 $y$(예: 가격 상승 또는 하락)
2. 소프트 타겟: 모든 수업에 대한 교사의 출력 확률 분포 $q_T$

학생의 손실 함수는 다음 두 가지를 모두 결합합니다.

$\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$는 교사 및 학생 로짓이고, $\sigma$는 소프트맥스 함수이고, $T$는 온도 매개변수이고, $\alpha$는 두 손실 구성요소 간의 균형을 제어합니다.

소프트 타겟이 트레이딩에 중요한 이유

3등급 상승/고정/하향 중간 가격 공식인 $\pm\alpha$ 임계값과 그에 따른 불균형으로 인해 정확도가 아닌 가중치 F1을 보고하는 이유는 모두 DeepLOB — 여기에서 해당 라벨 구성표를 가정합니다. 증류 관련 요점은 교사가 argmax 전에 내보내는 것입니다. 하드 "위로"는 1비트를 전달하는 반면, 0.72/0.21/0.07은 또한 이동이 멈출 수 있고 거의 확실히 반전되지 않을 것이라고 말합니다. 클래스 전반에 걸친 이러한 구조는 추가 훈련 신호이며 소프트 타겟 학생이 레이블만 훈련한 동일한 학생보다 더 잘 일반화할 수 있는 이유입니다.

그 자신감이 무엇인지에 대한 경고입니다. Softmax 출력은 보정된 불확실성이 아니며 0.55 대 0.85를 위치 크기 조정 입력으로 처리하는 것은 거래에 대한 등각 예측가 거부하기 위해 존재하는 지름길입니다. 이는 간격 너비, 가장자리 비율 및 간격이 0에 걸칠 때 거래 없음 필터에서 크기를 파생하며 원시 소프트맥스에서는 제공하지 않습니다. 여기서 사이징 청구를 획득한다는 것은 교사의 교정(신뢰성 다이어그램, ECE)에 대해 학생의 교정을 측정하고 증류를 통해 이를 보존한다는 것을 의미합니다. 그 결과는 아직 이 글에 없습니다.

온도 및 소프트 타겟

온도 매개변수 $T$는 확률 분포의 "부드러움"을 제어합니다. 로지트 $z_i$가 주어지면 온도에 따른 소프트맥스는 다음과 같습니다.

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

$T = 1$(표준 소프트맥스)인 경우 분포는 뾰족합니다. 즉 지배적인 클래스가 대부분의 확률 질량을 얻습니다. $T$가 증가하면 분포가 평탄해지며 로짓의 상대적 크기가 더 명확하게 드러납니다.

거래 모델이 적당한 온도를 원한다는 그럴듯한 주장이 있습니다. 재무 예측은 이미지 분류보다 훨씬 덜 확실하므로 교사는 0.99/0.005/0.005가 아닌 0.55/0.30/0.15를 출력하여 신호가 사라지기 전에 부드러워지는 피크를 덜 남길 수 있습니다. 이는 주장이지 결론이 아닙니다. 범위는 F1 가중치를 적용하여 점수를 매긴 실제 데이터에 대한 조사에서 나와야 하며 체제에 따라 다를 수 있습니다.

KL 발산 항의 $T^2$ 인자는 더 높은 온도에서 감소된 기울기 크기를 보상합니다. 이것이 없으면 $T$가 증가함에 따라 증류 손실은 무시할 수 있을 정도로 작아집니다.

그리드 검색을 통한 온도 선택

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

앙상블을 단일 모델로 추출

퀀트 앙상블은 주문장 기능에 대한 그래디언트 부스팅 트리, 최근 틱에 대한 1D-CNN, 다중 기간 창에 대한 변환기, 매크로 요인에 대한 선형 모델 등 귀납적 편향을 혼합합니다. 평균화는 어떤 멤버보다 안정적이며 4개를 모두 실행하면 대기 시간과 비용이 증가합니다. 기계 학습을 사용한 확산 모델링의 2단계 분할이 느린 멤버를 비동기식 사이드 채널로 강등하여 처리하는 상황입니다. 대신 증류는 네 가지 모두를 핫 경로의 한 학생으로 축소합니다.

앙상블 교사의 출력은 구성원의 소프트맥스 출력의 평균입니다.

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

여기서 $K$는 앙상블 멤버 수입니다. 학생은 이 평균 분포에 대해 훈련을 받습니다.

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개의 숨겨진 단위가 있는 2계층 MLP는 결합된 수가 수백만에 달하는 앙상블에 비해 60개 기능, 3클래스 작업에 대해 8,000개의 매개변수 정도입니다.

학생이 얻는 것과 잃는 것

이것은 부담이 큰 경험적 질문이며 기사에서는 이에 대한 답변을 제공하지 않습니다. 직관은 학생이 앙상블 내분포를 추적하고 앙상블의 다양성이 작업을 수행하는 스트레스가 있는 체제에서 떨어진다는 것입니다. 그러나 유지 수치는 실제 주문장 데이터에서 측정되고 체제별로 분할되어 가중치 F1로 보고되는 것을 의미할 뿐입니다. 평온한 날을 견디다가 청산 폭포 중에 쓰러지는 학생은 우아하게 타락하는 학생과 다른 제품이며 총 숫자로는 구별할 수 없습니다.

세 가지 완화 방법은 미리 주장하는 것보다 해당 측정값에 대해 테스트해 볼 가치가 있습니다.

1. 학생이 격차가 벌어질 것으로 예상되는 체제를 볼 수 있도록 증류 세트에 스트레스 기간을 포함합니다.
2. 특성 기반 증류 — 최종 출력뿐만 아니라 중간 표현도 일치시킵니다.
3. 학생의 보조 정권 헤드, 정권 인식 기능을 공유 트렁크에 강제 적용합니다.

자기 증류: 학생이 교사가 될 때

자가 증류는 모델이 그 자체로부터 지식을 증류하는 기술입니다.

Born-Again Networks (BAN)

교사와 동일한 아키텍처로 학생을 훈련합니다. "다시 태어난" 학생은 원래의 학생보다 더 나은 성과를 내는 경우가 많으며 그 과정은 다음과 같이 반복됩니다.

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

각 세대는 이전 세대의 소프트 타겟을 대상으로 훈련하며, 일반적으로 몇 세대가 지나면 성과가 포화됩니다. 거래 모델의 경우 이는 구조적으로 비용이 전혀 들지 않습니다. 새로운 기능, 새로운 데이터, 교육 절차만 다를 뿐이므로 테스트 비용이 저렴하고 테스트되지 않은 상태로 보고할 이유가 없습니다.

깊이에 따른 자가 증류

중간 레이어에 보조 분류기를 연결합니다. 가장 깊은 출구는 더 얕은 출구의 교사 역할을 합니다. 추론 시에는 종료를 선택합니다. 대기 시간을 낮추려면 얕게, 정확도를 높이려면 깊습니다.

종료 깊이가 런타임 대기 시간 손잡이가 되기 때문에 이는 거래 시스템에 가장 적합한 아이디어입니다. 훈련된 하나의 네트워크는 훈련 시간에 단일 아키텍처에 전념하는 대신 다양한 예산을 포괄합니다. 책이 빠르게 움직일 때 당신은 얕은 출구를 선택하고 더 나쁜 뒷부분을 받아들입니다. 조용할 때는 전체 깊이에 대한 비용을 지불합니다. 출구당 정확도와 출구당 대기 시간 곡선은 모두 측정 가능하며, 이들의 교차에 따라 손잡이의 가치가 결정됩니다.

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

추론 예산의 출처

추론이 엄격한 예산 내에 있어야 하고 전체 틱-투-트레이드 사다리(NIC-사용자 공간, 커널 바이패스, 총 100μs 미만, FPGA 및 공유 메모리를 강제하는 10μs 미만 계층)가 이미 알고리즘 거래의 데이터 및 통신]에 배치되어 있는 경우에만 증류가 중요합니다. 사다리가 열려 있는 행은 모델 추론이며, 이것이 행 증류가 채우려고 하는 행입니다.

다른 행을 모델 수준의 지연 시간 테이블로 채우지 마세요. 기계 학습을 사용한 확산 모델링는 이미 GBM 대 딥 러닝 비교와 숫자보다 더 중요한 주의 사항을 게시했습니다. 대기 시간은 구현에 따라 다르며 동일한 LightGBM 모델은 Python에서 행당 수십 마이크로초가 걸리지만 컴파일된 예측기에서는 몇 마이크로초가 걸립니다. 여기에서 지연 시간 주장은 프레임워크, 코어 및 배치 크기의 이름을 지정해야 하며 그렇지 않으면 노이즈입니다.

특히 GPU의 경우 고정된 실행당 오버헤드는 장치가 전혀 도움이 되기 전에 상각되어야 하며 단일 행 추론은 결코 도움이 되지 않는 지붕선 능선의 왼쪽에 멀리 위치합니다. GPU가 성과를 거둘 때는 개별 PCIe 카드가 능선을 더 오른쪽으로 밀어내는 방법을 포함하여 배치 스윕을 통해 상각 곡선을 적절하게 측정합니다. 메모리에서 인용된 상수를 신뢰하는 대신 읽어보세요.

증류 후 양자화

증류된 학생은 INT8 가중치(AVX-512 VNNI를 사용하는 CPU에서 약 2배), 곱셈을 덧셈으로 바꾸는 이진/삼항 가중치, 0에 가까운 계산을 건너뛰기 위한 가지치기 등을 추가로 압축합니다.

유혹적인 주장은 학생이 이미 간결한 표현을 배웠기 때문에 증류 후 양자화가 양자화만 사용하는 것보다 더 많은 정확도를 유지한다는 것입니다. 그것에 발송하지 마십시오. GPU 정밀도 트랩는 숫자 정밀도 감소에 대한 블로그의 입장입니다. 그럴듯해 보이는 쓰레기를 자동으로 반환했으며 빠른 경로를 출시 가능하게 만든 것은 어설션이 아닌 정량화된 등가 게이트(채우기 이동, PnL 델타(bps))였습니다. INT8 학생은 해당 게이트가 FP32 학생에 대해 측정될 때까지 다른 모델입니다.

import torch.quantization as quant

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

    student_prepared = quant.prepare(student)

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

    student_quantized = quant.convert(student_prepared)
    return student_quantized

FPGA 배포: 증류-비트스트림 파이프라인

FPGA는 지연 시간 사다리]에서 10μs 미만 계층이며 Tbricks/Broadridge 리뷰에서는 이를 커널 우회 NIC와 함께 프로덕션에서 다룹니다. 결정적 대기 시간, OS 지터 없음, 네트워크 스택과 함께 배치됩니다. 이 블로그의 어디에서도 다루지 않은 것은 증류된 모델이 어떻게 완성되는지에 대한 것입니다.

DeepLOB의 프로덕션 노트에는 ONNX/TensorRT, INT8 양자화 및 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 슬라이스, 블록 RAM)에 맞아야 한다는 것입니다. 측정이 아닌 크기 순서 예산: 64개의 숨겨진 단위와 INT8 가중치가 있는 2계층 MLP는 추론당 약 8,000개의 곱셈 누적과 중간 범위 부분의 작은 부분인 ~16KB의 가중치를 갖습니다. 이것이 증류가 계속되는 곳입니다. 앙상블 교사는 예산에 맞지 않습니다. 학생은 한계 근처에도 없습니다.

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()는 특정 모델, 보드, 정밀도 및 재사용 요소에 대한 리소스 및 대기 시간 수치에 대한 신뢰할 수 있는 유일한 소스입니다. default_reuse_factor만으로도 수치가 크게 이동합니다. "전형적인" 합성 테이블을 실행하지 않고 인용하는 것은 추측입니다.

실제 고려 사항

교사 로지트 사전 계산

Distillation에는 전체 훈련 세트에 대한 교사의 예측이 필요합니다. 이는 의도적으로 지불할 가치가 있는 일회성 오프라인 비용입니다. 즉, 앙상블을 한 번 실행하고 로짓을 유지하며 학생들을 캐시에 대해 훈련시킵니다. 온도 스윕 및 아키텍처 검색은 교사 전달 패스에서 추가 비용이 들지 않으며, 이는 위의 스윕을 전혀 실용적으로 만듭니다.

증류 전용 모니터 하나

기능 파이프라인 위생, z-점수 매개변수 드리프트로 인한 롤링 정규화, 입력 분포 이동 모니터링 및 체제 트리거 재훈련은 모두 DeepLOB의 프로덕션 섹션에서 다루며 여기에서는 변경되지 않고 적용됩니다.

증류 관련 모니터는 실시간 데이터의 교사-학생 KL 발산입니다. 교사는 여전히 오프라인으로 존재합니다. 실시간 입력 샘플에서 실행하고 분포를 비교합니다. KL 상승은 스튜던트의 근사치가 증류되지 않은 체제에서 저하되고 있음을 의미하며 레이블을 기다리지 않기 때문에 정확도가 떨어지기 전에 실행됩니다. 재교육 임계값은 알려진 양호한 기간과 알려진 저하된 기간에 관찰된 KL에 대해 보정되어야 합니다. 선험적으로 선택한 것은 임의적입니다.

증류하지 말아야 할 경우

• 교사는 이미 작습니다(선형 모델, 얕은 GBM): 증류는 압축이 없는 파이프라인 단계를 추가합니다.
• 지연은 제약이 아닙니다(일일 재조정, 일과 종료 신호): 교사를 배치합니다.
• 해석성이 속도보다 중요: 증류된 네트워크는 대체된 트리 앙상블보다 설명하기가 더 어렵습니다.
• 2단계 분할은 이미 작동합니다: 확산 모델링 아키텍처의 비동기식 저속 모델이 제공되는 경우 증류는 작업 시스템 교체를 정당화하기 전에 측정된 비교에서 이를 능가해야 합니다.

요약

증류는 2단계 빠른/느린 분할에 대한 일관된 대안입니다. 오프라인에서 감당할 수 있는 최고의 교사를 교육하고, 소프트 타겟 구조를 핫 경로에 적합한 작은 학생에게 전송하고, 양자화하고, CPU 또는 FPGA에 배포합니다. 깊이별 변형은 더 나아가 대기 시간을 훈련 시간이 아닌 런타임 선택으로 만듭니다.

이 기사가 고의적으로 주장하지 않는 것은 그 중 어느 것도 블로그가 이미 게시한 것보다 낫다는 것입니다. 해당 평결에는 실제 주문장 데이터에 대한 세 가지 측정이 필요합니다. 즉, 정권별로 분할된 학생 대 앙상블 가중 F1 유지 곡선, 온도 스윕 및 GPU 정밀 트랩] 스타일의 INT8 패리티 게이트입니다. 이러한 기술이 존재할 때까지 이는 기술에 대한 설명일 뿐 배포 권장 사항은 아닙니다.

참고자료

1. Hinton, G., Vinyals, O., & Dean, J. (2015). 신경망에서 지식 추출. arXiv:1503.02531

2. Furlanello, T., Lipton, Z. C., Tschannen, M., Itti, L., & Anandkumar, A. (2018). 다시 태어나는 신경망. ICML. arXiv:1805.04770

3. Zhang, L., Song, J., Gao, A., Chen, J., Bao, C., & Ma, K. (2019). 스스로 가르치는 사람이 되어 보세요: 자가 증류를 통해 컨볼루셔널 신경망의 성능을 향상시키세요. ICCV. arXiv:1905.08094

4. Romero, A., Ballas, N., Kahou, S. E., Chassang, A., Gatta, C., & Bengio, Y. (2015). FitNets: Thin Deep Nets에 대한 힌트. ICLR. arXiv:1412.6550

5. Gou, J., Yu, B., Maybank, S. J., & Tao, D. (2021). 지식 증류: 설문조사. 컴퓨터 비전 국제 저널, 129, 1789-1819. arXiv:2006.05525

6. Duarte, J., 외. (2018). 입자 물리학을 위한 FPGA의 심층 신경망에 대한 빠른 추론(hls4ml). 계측 저널, 13, P07027. arXiv:1804.06913

7. Umuroglu, Y., 외. (2017). FINN: 빠르고 확장 가능한 이진 신경망 추론을 위한 프레임워크. FPGA '17. arXiv:1612.07119

8. Zhang, Z., Zohren, S., & Roberts, S. (2019). DeepLOB: 지정가 주문장을 위한 심층 합성곱 신경망. 신호 처리에 관한 IEEE 거래, 67(11), 3001-3012. arXiv:1808.03668