Knowledge Distillation: Compressing Trading Models for Low-Latency Deployment

Căng thẳng giữa độ chính xác và độ trễ trong giao dịch do ML điều khiển đã có câu trả lời được đăng trên blog này. Mô hình hóa spread bằng machine learning đề xuất phân tách hai giai đoạn: một mô hình gradient boosting nhanh thực hiện việc báo giá thời gian thực nhạy cảm với độ trễ, trong khi một mô hình sâu chạy bất đồng bộ và cung cấp tín hiệu phụ hoặc điều chỉnh các tham số của nó. Hai mô hình, hai nhịp đồng hồ, một hệ thống.

Chưng cất tri thức là một câu trả lời khác cho cùng một sự căng thẳng. Thay vì chạy mô hình chậm song song với mô hình nhanh, bạn dùng mô hình chậm một lần, ngoại tuyến, để huấn luyện mô hình nhanh — student học toàn bộ phân phối xác suất của teacher trên các kết quả, không chỉ các nhãn cứng, rồi teacher rời khỏi đường chạy nóng hoàn toàn. Một mô hình tại thời điểm suy luận, không ghép nối bất đồng bộ, không có cửa sổ lỗi thời.

Câu trả lời nào thắng là vấn đề thực nghiệm, và bài viết này chưa trả lời điều đó. Phần tiếp theo là cơ chế, cùng với tuyên bố rõ ràng về các phép đo sẽ quyết định kết quả. Không có gì ở đây là kết quả benchmark; ở nơi thường cần một con số, có một dấu đánh dấu cho biết cần chạy gì.

Trước hết cần chỉnh lại một cách đóng khung, dựa trên DeepLOB và deep learning trên sổ lệnh: độ chính xác phân loại cao không tự động chuyển thành lợi nhuận — chuyển động được dự đoán phải vượt qua bid-ask spread. Vì vậy, "giữ nguyên độ chính xác hướng của teacher" là mục tiêu sai cho một thiết lập chưng cất.

Khung Teacher-Student

Công thức ban đầu của Hinton, Vinyals và Dean (2015) rất đơn giản. Bạn có một mô hình teacher $T$ (lớn, chậm, chính xác) và một mô hình student $S$ (nhỏ, nhanh, cần huấn luyện). Student học từ hai tín hiệu đồng thời:

1. Mục tiêu cứng: các nhãn thực tế $y$ (ví dụ giá tăng hay giảm)
2. Mục tiêu mềm: phân phối xác suất đầu ra $q_T$ của teacher trên tất cả các lớp

Hàm mất mát của student kết hợp cả hai:

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

trong đó $z_T$ và $z_S$ là các logit của teacher và student, $\sigma$ là hàm softmax, $T$ là tham số nhiệt độ và $\alpha$ điều khiển sự cân bằng giữa hai thành phần mất mát.

Vì sao mục tiêu mềm quan trọng trong giao dịch

Cách xây dựng bài toán ba lớp tăng/đi ngang/giảm của giá giữa, ngưỡng $\pm\alpha$ và lý do mất cân bằng tạo ra khiến bạn báo cáo F1 có trọng số thay vì độ chính xác đều đã được thiết lập trong DeepLOB — hãy giả định lược đồ nhãn đó ở đây. Điểm riêng của chưng cất là những gì teacher phát ra trước argmax: một nhãn cứng "tăng" chỉ mang một bit, còn 0.72/0.21/0.07 cũng nói rằng chuyển động có thể chững lại và gần như chắc chắn không đảo chiều. Cấu trúc giữa các lớp đó là tín hiệu huấn luyện bổ sung, và đó là lý do student dùng mục tiêu mềm có thể khái quát tốt hơn cùng student được huấn luyện chỉ bằng nhãn.

Cần cảnh báo về điều mà mức tự tin đó không phải. Đầu ra softmax không phải độ bất định đã hiệu chỉnh, và coi 0.55 so với 0.85 là đầu vào để định cỡ vị thế là lối tắt mà dự đoán conformal cho giao dịch chủ động từ chối — nó suy ra kích thước từ độ rộng khoảng, tỷ lệ lợi thế và bộ lọc không giao dịch khi khoảng chứa số 0, không điều nào trong số đó có trong softmax thô. Để biện minh cho tuyên bố về định cỡ ở đây, phải đo mức hiệu chỉnh của student so với teacher (biểu đồ độ tin cậy, ECE) và cho thấy chưng cất giữ được nó. Kết quả đó chưa có trong bài viết này.

Nhiệt độ và mục tiêu mềm

Tham số nhiệt độ $T$ điều khiển "độ mềm" của phân phối xác suất. Với các logit $z_i$, softmax có nhiệt độ là:

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

Khi $T = 1$ (softmax tiêu chuẩn), phân phối nhọn — lớp chiếm ưu thế nhận phần lớn khối lượng xác suất. Khi $T$ tăng, phân phối phẳng hơn, làm lộ rõ hơn độ lớn tương đối của các logit.

Có một lập luận hợp lý rằng các mô hình giao dịch muốn nhiệt độ vừa phải: dự đoán tài chính kém tự tin hơn nhiều so với phân loại ảnh, vì vậy teacher có thể xuất 0.55/0.30/0.15 thay vì 0.99/0.005/0.005, để lại ít độ nhọn hơn cần làm mềm trước khi tín hiệu bị rửa trôi. Đó là một lập luận, không phải phát hiện — khoảng giá trị phải đến từ một phép quét trên dữ liệu thực, được chấm bằng F1 có trọng số, và có thể khác theo chế độ.

Thừa số $T^2$ trong thành phần phân kỳ KL bù cho độ lớn gradient giảm ở nhiệt độ cao hơn. Nếu không có nó, mất mát chưng cất sẽ trở nên nhỏ đến mức không đáng kể khi $T$ tăng.

Chọn nhiệt độ bằng tìm kiếm lưới

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

Chưng cất ensemble thành một mô hình duy nhất

Một ensemble định lượng trộn các thiên kiến quy nạp: cây gradient-boosted trên đặc trưng sổ lệnh, 1D-CNN trên các tick gần đây, transformer trên các cửa sổ đa khung thời gian, và mô hình tuyến tính trên các yếu tố vĩ mô. Việc lấy trung bình ổn định hơn bất kỳ thành viên nào, còn chạy cả bốn làm tăng nhiều lần độ trễ và chi phí — tình huống mà phân tách hai giai đoạn từ mô hình hóa spread bằng machine learning xử lý bằng cách đẩy các thành viên chậm xuống một kênh phụ bất đồng bộ. Chưng cất thay vào đó thu gọn cả bốn vào một student trên đường chạy nóng.

Đầu ra của teacher ensemble là trung bình đầu ra softmax của các thành viên:

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

trong đó $K$ là số thành viên ensemble. Student được huấn luyện theo phân phối trung bình này.

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)

Sự bất đối xứng về số lượng tham số là toàn bộ mục đích: một MLP hai lớp với 64 đơn vị ẩn có khoảng 8.000 tham số cho tác vụ 60 đặc trưng, 3 lớp, so với số lượng kết hợp của ensemble lên đến hàng triệu.

Student giữ lại gì và mất đi gì

Đây là câu hỏi thực nghiệm then chốt và bài viết chưa trả lời. Trực giác là student bám theo ensemble trong phân phối và suy giảm ở các chế độ căng thẳng, nơi tính đa dạng của ensemble đang tạo ra khác biệt — nhưng một con số duy trì chỉ có ý nghĩa nếu được đo trên dữ liệu sổ lệnh thực, chia theo chế độ và báo cáo dưới dạng F1 có trọng số. Một student hoạt động tốt trong những ngày yên ả và sụp đổ trong một đợt thanh lý là một sản phẩm khác với student suy giảm từ từ, và một con số tổng hợp không thể phân biệt chúng.

Ba biện pháp đáng thử theo phép đo đó thay vì khẳng định trước:

1. Đưa các giai đoạn căng thẳng vào tập chưng cất, để student thấy những chế độ nơi khoảng cách dự kiến mở ra.
2. Chưng cất dựa trên đặc trưng — khớp các biểu diễn trung gian, không chỉ đầu ra cuối cùng.
3. Đầu dự báo chế độ phụ trên student, buộc các đặc trưng nhận biết chế độ đi vào trunk dùng chung.

Tự chưng cất: Khi student trở thành teacher

Tự chưng cất là kỹ thuật trong đó một mô hình chưng cất tri thức từ chính nó.

Mạng tái sinh (BAN)

Huấn luyện một student có kiến trúc giống hệt teacher. Student "tái sinh" thường vượt qua mô hình gốc, và quá trình lặp lại:

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

Mỗi thế hệ được huấn luyện trên các mục tiêu mềm từ thế hệ trước, với mức tăng thường bão hòa sau vài thế hệ. Đối với mô hình giao dịch, điều này không tốn chi phí về kiến trúc — không có đặc trưng mới, dữ liệu mới, chỉ là một quy trình huấn luyện khác — đồng nghĩa rất rẻ để thử và không có lý do gì báo cáo nó mà chưa kiểm thử.

Tự chưng cất theo độ sâu

Gắn các bộ phân loại phụ ở các lớp trung gian. Nhánh thoát sâu nhất đóng vai trò teacher cho các nhánh nông hơn. Khi suy luận, bạn chọn một nhánh thoát: nông cho độ trễ thấp hơn, sâu cho độ chính xác tối đa.

Đây là ý tưởng phù hợp nhất với một hệ thống giao dịch, vì độ sâu nhánh thoát trở thành núm điều khiển độ trễ lúc chạy: một mạng được huấn luyện bao phủ một loạt ngân sách thay vì cam kết vào một kiến trúc duy nhất tại thời điểm huấn luyện. Khi sổ lệnh chuyển động nhanh, bạn chọn nhánh thoát nông và chấp nhận posterior kém hơn; khi yên ắng, bạn trả chi phí cho toàn bộ độ sâu. Cả các đường cong độ chính xác theo nhánh thoát và độ trễ theo nhánh thoát đều đo được, và giao điểm của chúng quyết định liệu chiếc núm này có đáng có hay không.

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

Ngân sách suy luận đến từ đâu

Chưng cất chỉ có ý nghĩa nếu suy luận phải nằm trong một ngân sách cứng, và toàn bộ bậc thang từ tick đến giao dịch — NIC đến userspace, bỏ qua kernel, tổng dưới 100 µs và tầng dưới 10 µs buộc phải dùng FPGA cùng bộ nhớ chia sẻ — đã được trình bày trong dữ liệu và giao tiếp trong giao dịch thuật toán. Hàng mà bậc thang đó để ngỏ là suy luận mô hình, và đó là hàng mà chưng cất đang cố lấp đầy.

Đừng cố lấp các hàng khác bằng một bảng độ trễ theo loại mô hình. Mô hình hóa spread bằng machine learning đã công bố so sánh GBM với deep learning cùng lưu ý quan trọng hơn các con số: độ trễ phụ thuộc vào triển khai, và cùng một mô hình LightGBM mất hàng chục micro giây mỗi dòng từ Python nhưng chỉ vài micro giây từ predictor đã biên dịch. Bất kỳ tuyên bố độ trễ nào ở đây cũng phải nêu framework, lõi CPU và kích thước batch, nếu không nó chỉ là nhiễu.

Riêng với GPU: overhead cố định mỗi lần khởi chạy phải được phân bổ đủ trước khi thiết bị có ích, còn suy luận một dòng nằm rất xa về bên trái của đỉnh roofline, nơi điều đó không bao giờ xảy ra. Khi nào GPU có lợi đo đúng đường cong phân bổ đó bằng phép quét batch, bao gồm cách một card PCIe rời đẩy đỉnh sang phải hơn — hãy đọc bài đó thay vì tin một hằng số được trích từ trí nhớ.

Lượng tử hóa sau chưng cất

Student đã chưng cất có thể nén thêm: trọng số INT8 (xấp xỉ nhanh gấp 2 trên CPU với AVX-512 VNNI), trọng số nhị phân/tam phân biến phép nhân thành phép cộng và pruning để bỏ qua tính toán gần bằng 0.

Tuyên bố hấp dẫn là chưng cất rồi lượng tử hóa giữ được nhiều độ chính xác hơn lượng tử hóa đơn thuần, vì student đã học một biểu diễn gọn. Đừng triển khai chỉ dựa trên đó. Cạm bẫy độ chính xác GPU là lập trường thường trực của blog về độ chính xác số giảm: nó âm thầm trả về rác trông có vẻ hợp lý, và điều khiến đường chạy nhanh có thể triển khai là một cổng tương đương được định lượng — các lệnh khớp bị dịch chuyển, chênh lệch PnL theo bps — chứ không phải một lời khẳng định. Student INT8 là một mô hình khác cho đến khi cổng đó được đo so với student 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

Triển khai FPGA: Quy trình từ chưng cất đến bitstream

FPGA là tầng dưới 10 µs trong bậc thang độ trễ, và bài đánh giá Tbricks/Broadridge đề cập đến chúng trong sản xuất cùng NIC bỏ qua kernel — độ trễ xác định, không có jitter của hệ điều hành, đồng vị trí với ngăn xếp mạng. Điều chưa được đề cập ở đâu trên blog này là cách đưa một mô hình đã chưng cất lên đó.

Ghi chú sản xuất của DeepLOB liệt kê ONNX/TensorRT, lượng tử hóa INT8 và triển khai FPGA như ba lựa chọn rồi dừng lại. Đây là cách mở rộng lựa chọn thứ ba:

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

Ràng buộc quyết định là mô hình phải vừa trong các phần tử logic của thiết bị — LUT, lát DSP và RAM khối. Như một ngân sách bậc độ lớn chứ không phải phép đo: MLP hai lớp với 64 đơn vị ẩn và trọng số INT8 cần khoảng 8.000 phép nhân-tích lũy cho mỗi lần suy luận và khoảng 16 KB trọng số, một phần nhỏ của chip tầm trung. Đây là nơi chưng cất phát huy giá trị — teacher ensemble không vừa với bất kỳ ngân sách nào; student còn rất xa giới hạn.

Các công cụ tự động hóa việc chuyển PyTorch/ONNX thành phần cứng có thể tổng hợp gồm AMD/Xilinx Vitis AI, hls4ml (từ CERN) và FINN (từ Xilinx Research).

Ví dụ: Chuyển đổi bằng 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() là nguồn đáng tin cậy duy nhất về các con số tài nguyên và độ trễ cho một mô hình, bo mạch, độ chính xác và hệ số tái sử dụng cụ thể — các con số thay đổi đáng kể chỉ với default_reuse_factor. Trích dẫn một bảng tổng hợp "điển hình" mà chưa chạy nó chỉ là đoán.

Các cân nhắc thực tế

Tính trước logit của teacher

Chưng cất cần dự đoán của teacher trên toàn bộ tập huấn luyện — một chi phí ngoại tuyến một lần đáng trả có chủ ý: chạy ensemble một lần, lưu logit lại, huấn luyện student theo cache. Khi đó phép quét nhiệt độ và tìm kiếm kiến trúc không tốn thêm lượt forward của teacher, chính điều này khiến các phép quét ở trên thực tế khả thi.

Một monitor riêng cho chưng cất

Vệ sinh pipeline đặc trưng, chuẩn hóa cuộn vì các tham số z-score trôi dạt, giám sát dịch chuyển phân phối đầu vào và huấn luyện lại kích hoạt theo chế độ đều đã được đề cập trong phần sản xuất của DeepLOB và áp dụng nguyên vẹn ở đây.

Monitor riêng của chưng cất là phân kỳ KL giữa teacher và student trên dữ liệu trực tiếp. Teacher vẫn tồn tại ngoại tuyến; hãy chạy nó trên một mẫu đầu vào trực tiếp và so sánh các phân phối. KL tăng nghĩa là phép xấp xỉ của student đang suy giảm trong những chế độ mà nó chưa được chưng cất — và nó phát hiện trước độ chính xác, vì không chờ nhãn. Ngưỡng huấn luyện lại phải được hiệu chỉnh dựa trên KL quan sát được trong các giai đoạn tốt và suy giảm đã biết; nếu chọn trước thì nó là tùy ý.

Khi nào không nên chưng cất

• Teacher vốn đã nhỏ (mô hình tuyến tính, GBM nông): chưng cất thêm một tầng pipeline mà không nén được gì.
• Độ trễ không bị ràng buộc (tái cân bằng hằng ngày, tín hiệu cuối ngày): triển khai teacher.
• Khả năng giải thích quan trọng hơn tốc độ: mạng đã chưng cất khó giải thích hơn ensemble cây mà nó thay thế.
• Phân tách hai giai đoạn đã hoạt động: nếu mô hình chậm bất đồng bộ trong kiến trúc mô hình hóa spread đang mang lại kết quả, chưng cất phải thắng trong một so sánh được đo lường trước khi biện minh cho việc thay thế một hệ thống đang hoạt động.

Tóm tắt

Chưng cất là một lựa chọn thay thế nhất quán cho phân tách nhanh/chậm hai giai đoạn: huấn luyện teacher tốt nhất mà bạn có thể chi trả ngoại tuyến, chuyển cấu trúc mục tiêu mềm của nó vào một student đủ nhỏ cho đường chạy nóng, lượng tử hóa, triển khai trên CPU hoặc FPGA. Biến thể theo độ sâu còn tiến thêm và biến độ trễ thành lựa chọn lúc chạy thay vì lúc huấn luyện.

Điều bài viết này cố ý không tuyên bố là bất kỳ phần nào trong đó vượt qua những gì blog đã công bố. Kết luận cần ba phép đo trên dữ liệu sổ lệnh thực: đường cong duy trì F1 có trọng số của student so với ensemble, chia theo chế độ; phép quét nhiệt độ; và cổng tương đương INT8 theo phong cách cạm bẫy độ chính xác GPU. Cho đến khi có các phép đo đó, đây là mô tả về một kỹ thuật, không phải khuyến nghị triển khai.

Tài liệu tham khảo

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