Knowledge Distillation: Compressing Trading Models for Low-Latency Deployment

التوتر بين الدقة وزمن الاستجابة في التداول المدفوع بالتعلم الآلي لديه بالفعل إجابة منشورة في هذه المدونة. يوصي نمذجة الفارق السعري بالتعلم الآلي بتقسيم من مرحلتين: يتولى نموذج سريع لتعزيز التدرج عملية التسعير الفورية الحرجة زمنياً، بينما يعمل نموذج عميق بشكل غير متزامن ويغذيه بإشارة ثانوية أو يضبط معلماته. نموذجان، وساعتان، ونظام واحد.

التقطير المعرفي هو إجابة مختلفة للتوتر نفسه. بدلاً من تشغيل النموذج البطيء إلى جانب السريع، تستخدمه مرة واحدة خارجياً لتدريب السريع — يتعلم الطالب توزيع المعلم الاحتمالي الكامل على النتائج، لا التسميات الصلبة فقط، ثم يغادر المعلم المسار الحرج تماماً. نموذج واحد وقت الاستدلال، بلا اقتران غير متزامن، وبلا نافذة تقادم.

أي الإجابتين تفوز مسألة تجريبية، وهذا المقال لا يجيب عنها بعد. ما يلي هو الآلية، إضافة إلى تصريح صريح بالقياسات التي ستحسمها. لا يوجد هنا أي ناتج معياري؛ وحيثما يوضع رقم عادةً، توجد علامة توضح ما يجب تشغيله.

تصحيح تمهيدي للإطار، مستمد من DeepLOB والتعلم العميق على دفتر الأوامر: لا تتحول دقة التصنيف العالية تلقائياً إلى ربح — يجب أن تتجاوز الحركة المتوقعة الفارق بين العرض والطلب. لذلك فإن تحسين "الحفاظ على الدقة الاتجاهية للمعلم" ليس الهدف الصحيح الذي ينبغي أن يقاس عليه إعداد التقطير.

إطار المعلم والطالب

الصياغة الأصلية لهينتون وفينيالس ودين (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$ هي دالة softmax، و$T$ هو معامل درجة الحرارة، و$\alpha$ يتحكم في التوازن بين مكوّني الخسارة.

لماذا تهم الأهداف اللينة في التداول

إن صياغة السعر الوسطي ذات الفئات الثلاث: صعود/ثبات/هبوط، ووضع عتبة $\pm\alpha$، وسبب كون الاختلال الناتج يعني الإبلاغ عن F1 موزون بدلاً من الدقة، كلها معدة في DeepLOB — فافترض نظام التسميات هذا هنا. النقطة الخاصة بالتقطير هي ما يصدره المعلم قبل argmax: تحمل كلمة "صعود" الصلبة بتاً واحداً، بينما تقول 0.72/0.21/0.07 أيضاً إن الحركة قد تتوقف وإنها لن تنعكس على الأرجح. هذا البناء عبر الفئات هو إشارة التدريب الإضافية، ولهذا يمكن لطالب ذي أهداف لينة أن يعمم أفضل من الطالب نفسه المدرب على التسميات وحدها.

تحذير بشأن ما لا تعنيه هذه الثقة. مخرجات softmax ليست عدم يقين معايراً، والتعامل مع 0.55 مقابل 0.85 كمدخل لحجم المركز هو الاختصار الذي ترفضه التنبؤات المطابقة للتداول — فهي تستمد الحجم من عرض الفاصل ونسبة الحافة ومرشح عدم التداول عندما يعبر الفاصل الصفر، ولا يمنحك أي منها softmax خاماً. ولكي تستحق دعوى تحديد الحجم هنا، يجب قياس معايرة الطالب مقابل معايرة المعلم (مخطط الموثوقية وECE) وإظهار أن التقطير يحافظ عليها. هذه النتيجة ليست في المقال بعد.

درجة الحرارة والأهداف اللينة

يتحكم معامل درجة الحرارة $T$ في "نعومة" توزيع الاحتمالات. مع إعطاء لوغاريتمات $z_i$، يكون softmax بدرجة الحرارة:

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

عندما تكون $T = 1$ (softmax القياسي)، يكون التوزيع حاداً — تحصل الفئة المهيمنة على معظم كتلة الاحتمال. ومع زيادة $T$ يصبح التوزيع أكثر تسطحاً، فتظهر المقادير النسبية للوغاريتمات بوضوح أكبر.

هناك حجة معقولة مفادها أن نماذج التداول تريد درجة حرارة معتدلة: فالتنبؤات المالية أقل ثقة بكثير من تصنيف الصور، لذلك قد يخرج المعلم 0.55/0.30/0.15 بدلاً من 0.99/0.005/0.005، تاركاً حدة أقل لتليينها قبل أن تتلاشى الإشارة. هذه حجة وليست نتيجة — يجب أن يأتي النطاق من مسح على بيانات حقيقية، مع تسجيل F1 موزون، وقد يختلف حسب النظام.

يعوّض عامل $T^2$ في حد تباعد KL انخفاض مقادير التدرج عند درجات الحرارة الأعلى. وبدونه تصبح خسارة التقطير صغيرة إلى حد الإهمال مع زيادة $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 على الصفقات الأخيرة، ومحوّل على نوافذ متعددة الأطر الزمنية، ونموذج خطي على العوامل الكلية. يكون المتوسط أكثر استقراراً من أي عضو منفرد، وتشغيل النماذج الأربعة يضاعف زمن الاستجابة والتكلفة — وهي الحالة التي يعالجها التقسيم ذو المرحلتين من نمذجة الفارق السعري بالتعلم الآلي عبر نقل الأعضاء البطيئة إلى قناة جانبية غير متزامنة. أما التقطير فيدمج النماذج الأربعة كلها في طالب واحد داخل المسار الحرج.

يكون خرج معلم التجميع هو متوسط مخرجات softmax لأعضائه:

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

إن عدم التماثل في عدد المعلمات هو جوهر الفكرة: فشبكة MLP ذات طبقتين و64 وحدة مخفية تضم نحو 8,000 معلمة لمهمة من 60 سمة و3 فئات، مقابل تجميع يصل عدده الكلي إلى الملايين.

ما الذي يحتفظ به الطالب وما الذي يفقده

هذا هو السؤال التجريبي الحاسم، والمقال لا يجيب عنه. الحدس هو أن الطالب يتتبع التجميع داخل التوزيع ويسقط أداؤه في الأنظمة المجهدة، حيث يقوم تنوع التجميع بالعمل — لكن رقم الاحتفاظ لا يعني شيئاً إلا إذا قيس على بيانات دفتر أوامر حقيقية، وقُسم حسب النظام، وأُبلغ عنه كـ F1 موزون. الطالب الذي يصمد في الأيام الهادئة وينهار أثناء سلسلة تصفية هو منتج مختلف عن طالب يتدهور تدريجياً، ولا يستطيع رقم إجمالي التمييز بينهما.

ثلاثة تخفيفات تستحق الاختبار مقابل ذلك القياس بدلاً من تأكيدها مسبقاً:

1. إدراج الفترات المجهدة في مجموعة التقطير، حتى يرى الطالب الأنظمة التي يُتوقع أن تتسع فيها الفجوة.
2. التقطير القائم على السمات — مطابقة التمثيلات الوسيطة، لا المخرجات النهائية فقط.
3. رأس نظام مساعد على الطالب، لإجبار السمات الواعية بالنظام على الدخول في الجذع المشترك.

التقطير الذاتي: عندما يصبح الطالب معلماً

التقطير الذاتي تقنية يقطر فيها النموذج المعرفة من نفسه.

الشبكات المولودة من جديد (BANs)

درّب طالباً بهندسة مطابقة للمعلم. وغالباً ما يتفوق الطالب "المولود من جديد" على الأصل، وتتكرر العملية:

$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

من أين تأتي ميزانية الاستدلال

لا يهم التقطير إلا إذا كان يجب أن يقع الاستدلال داخل ميزانية صارمة، وقد جرى عرض سلم tick-to-trade الكامل — من NIC إلى مساحة المستخدم، وتجاوز النواة، والإجمالي الأقل من 100 µs، وطبقة أقل من 10 µs التي تفرض FPGA والذاكرة المشتركة — في البيانات والاتصالات في التداول الخوارزمي. والصف الذي يتركه ذلك السلم مفتوحاً هو استدلال النموذج، وهو الصف الذي يحاول التقطير ملأه.

قاوم ملء الصفوف الأخرى بجدول زمن استجابة حسب فئة النموذج. فقد نشرت نمذجة الفارق السعري بالتعلم الآلي بالفعل مقارنة GBM مقابل التعلم العميق، إضافة إلى التحفظ الأهم من الأرقام: يعتمد زمن الاستجابة على التنفيذ، ويستغرق نموذج LightGBM نفسه عشرات الميكروثواني لكل صف من Python، لكنه يستغرق بضع ميكروثوانٍ من متنبئ مترجم. يجب أن يذكر أي ادعاء عن زمن الاستجابة هنا الإطار والنواة وحجم الدفعة، وإلا فهو ضوضاء.

وعلى وحدات GPU تحديداً: يجب استهلاك الحمل الثابت لكل إطلاق قبل أن يفيد الجهاز أصلاً، ويقع الاستدلال لصف واحد بعيداً إلى يسار حافة السقف حيث لا يصل إليها أبداً. يقيس متى تؤتي GPU ثمارها منحنى الاستهلاك ذلك بطريقة صحيحة عبر مسح للدفعات، بما في ذلك كيف تدفع بطاقة PCIe منفصلة الحافة أبعد إلى اليمين — اقرأ ذلك بدلاً من الوثوق بثابت محفوظ من الذاكرة.

التكميم بعد التقطير

يضغط الطالب المقطر أكثر: أوزان INT8 (نحو ضعفي السرعة على CPU مع AVX-512 VNNI)، وأوزان ثنائية/ثلاثية تحول عمليات الضرب إلى جمع، وتقليص لتخطي الحساب القريب من الصفر.

الادعاء المغري هو أن التقطير ثم التكميم يحافظ على دقة أكبر من التكميم وحده، لأن الطالب تعلم بالفعل تمثيلاً مدمجاً. لا تنشره بناءً على ذلك. فخ دقة GPU هو موقف المدونة الثابت من الدقة العددية المنخفضة: فقد أعاد بهدوء بيانات تبدو معقولة لكنها قمامة، وما جعل المسار السريع قابلاً للنشر هو بوابة تكافؤ كمية — تحولات التنفيذ وفارق PnL بنقاط الأساس — لا مجرد ادعاء. طالب 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: مسار التقطير إلى ملف البتات

إن FPGAs هي طبقة أقل من 10 µs في سلم زمن الاستجابة، وتغطي مراجعة Tbricks/Broadridge استخدامها في الإنتاج إلى جانب بطاقات NIC التي تتجاوز النواة — زمن استجابة حتمي، بلا اهتزاز من نظام التشغيل، ومتموضعة مع مكدس الشبكة. وما لا تغطيه هذه المدونة في أي موضع هو كيفية نقل نموذج مقطر إلى إحداها.

تسرد ملاحظات 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

القيد الملزم هو أن النموذج يجب أن يلائم عناصر المنطق في الجهاز — LUTs وشرائح DSP وذاكرة RAM الكتلية. وبميزانية تقريبية لا كقياس: تضم شبكة MLP ذات طبقتين و64 وحدة مخفية وأوزان INT8 نحو 8,000 عملية ضرب-وتجميع لكل استدلال ونحو 16 KB من الأوزان، وهي حصة صغيرة من قطعة متوسطة المدى. هنا يكسب التقطير قيمته — فمعلم التجميع لا يلائم أي ميزانية؛ أما الطالب فبعيد جداً عن الحد.

تشمل الأدوات التي تؤتمت تحويل 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. والاقتباس من جدول توليف "نموذجي" دون تشغيله مجرد تخمين.

اعتبارات عملية

الحساب المسبق للوغاريتمات المعلمة

يحتاج التقطير إلى تنبؤات المعلم على مجموعة التدريب كاملة — تكلفة خارجية تُدفع مرة واحدة عن قصد: شغّل التجميع مرة، واحفظ اللوغاريتمات، ودرّب الطلاب على الذاكرة المؤقتة. بعد ذلك لا تكلف عمليات مسح درجة الحرارة والبحث عن الهندسة شيئاً إضافياً من التمريرات الأمامية للمعلم، وهو ما يجعل عمليات المسح أعلاه عملية أصلاً.

المراقب الوحيد الخاص بالتقطير

نظافة خط السمات، والتطبيع المتدحرج لأن معلمات z-score تنجرف، ومراقبة تحول توزيع المدخلات، وإعادة التدريب المحفزة بالنظام، كلها مغطاة في قسم الإنتاج في DeepLOB وتنطبق هنا بلا تغيير.

المراقب الخاص بالتقطير هو تباعد KL بين المعلم والطالب على البيانات الحية. لا يزال المعلم موجوداً خارجياً؛ شغّله على عينة من المدخلات الحية وقارن التوزيعات. يعني ارتفاع KL أن تقريب الطالب يتدهور في أنظمة لم يقطر عليها — ويطلق الإنذار قبل الدقة، لأنه لا ينتظر التسميات. ويجب معايرة عتبة إعادة التدريب مقابل KL المرصود في فترات معلومة الجودة وأخرى معلومة التدهور؛ أما اختيارها مسبقاً فهو اعتباطي.

متى لا ينبغي التقطير

• المعلم صغير بالفعل (نموذج خطي أو GBM سطحي): يضيف التقطير مرحلة في المسار بلا ضغط.
• زمن الاستجابة ليس قيداً (إعادة موازنة يومية، وإشارات نهاية اليوم): انشر المعلم.
• قابلية التفسير أهم من السرعة: يصعب شرح شبكة مقطرة أكثر من تجميع الأشجار الذي استبدلته.
• التقسيم ذو المرحلتين يعمل بالفعل: إذا كان النموذج البطيء غير المتزامن في هندسة نمذجة الفارق السعري يحقق المطلوب، فعلى التقطير أن يتفوق عليه في مقارنة مقاسة قبل أن يبرر استبدال نظام عامل.

الخلاصة

التقطير بديل متماسك للتقسيم السريع/البطيء ذي المرحلتين: درّب أفضل معلم تستطيع تحمل تكلفته خارجياً، وانقل بنيته ذات الأهداف اللينة إلى طالب صغير بما يكفي للمسار الحرج، ثم كمّم وانشره على CPU أو FPGA. ويذهب البديل حسب العمق أبعد من ذلك، إذ يجعل زمن الاستجابة خياراً وقت التشغيل بدلاً من كونه خيار وقت التدريب.

ما لا يدعيه هذا المقال عمداً هو أن أياً من ذلك يتفوق على ما تنشره المدونة بالفعل. يتطلب الحكم ثلاث قياسات على بيانات دفتر أوامر حقيقية: منحنى احتفاظ F1 الموزون للطالب مقابل التجميع مقسوماً حسب النظام، ومسح درجة الحرارة، وبوابة تكافؤ INT8 على أسلوب فخ دقة GPU. وإلى أن توجد هذه النتائج، فهذا وصف لتقنية، لا توصية بنشرها.

المراجع

1. هينتون، G.، فينيالس، O.، ودين، J. (2015). تقطير المعرفة في شبكة عصبية. arXiv:1503.02531

2. فورلانيلو، T.، ليبتون، Z. C.، تشانن، M.، إيتي، L.، وأناندكومار، A. (2018). الشبكات العصبية المولودة من جديد. ICML. arXiv:1805.04770

3. تشانغ، L.، سونغ، J.، غاو، A.، تشن، J.، باو، C.، وما، K. (2019). كن معلم نفسك: تحسين أداء الشبكات العصبية الالتفافية عبر التقطير الذاتي. ICCV. arXiv:1905.08094

4. روميرو، A.، بالاس، N.، كاهو، S. E.، تشاسانغ، A.، غاتا، C.، وبنجيو، Y. (2015). FitNets: تلميحات لشبكات عميقة رفيعة. ICLR. arXiv:1412.6550

5. غو، J.، يو، B.، ماي بنك، S. J.، وتاو، D. (2021). تقطير المعرفة: مسح. International Journal of Computer Vision، 129، 1789-1819. arXiv:2006.05525

6. دوارتي، J.، وآخرون. (2018). استدلال سريع للشبكات العصبية العميقة في FPGAs لفيزياء الجسيمات (hls4ml). Journal of Instrumentation، 13، P07027. arXiv:1804.06913

7. أوموروغلو، Y.، وآخرون. (2017). FINN: إطار لاستدلال سريع وقابل للتوسع لشبكات عصبية ثنائية. FPGA '17. arXiv:1612.07119

8. تشانغ، Z.، زورن، S.، وروبرتس، S. (2019). DeepLOB: شبكات عصبية التفافية عميقة لدفاتر أوامر الحد. IEEE Transactions on Signal Processing، 67(11)، 3001-3012. arXiv:1808.03668