Acceptance Is Not Speed (arXiv:2610.23818): Ilusi Akselerasi Lossy Speculative Decoding, Mengapa Relaxed Sampling Memperpanjang Reasoning Trace 1.54x, dan Solusi Length-Corrected Verification

Dalam rekayasa sistem inferensi Large Language Model (LLM), Speculative Decoding selama ini dianggap sebagai "cawan suci" optimasi latensi: dengan menggunakan model draft yang ringan untuk memprediksi token masa depan dan memverifikasinya secara paralel pada model target, sistem mampu meningkatkan throughput tanpa mengubah bobot model dasar. Namun, ketika industri beralih dari decoding tanpa rugi (lossless/strict) ke varian lossy (relaxed) speculative decoding demi mendongkrak angka penerimaan token, sebuah ilusi metrik yang berbahaya muncul ke permukaan: Acceptance Is Not Speed.

Gambar 1: Visualisasi Konseptual Length Inflation — Kelonggaran batas verifikasi menerima token-token subordinat dari model draft, yang membelokkan lintasan penalaran internal model target sehingga memperpanjang rantai pemikiran (thinking trace) hingga 1.54x lipat.

1. Ilusi Metrik Spekulatif: Mengapa Accepted Tokens Menipu Pengembang

Pada paradigma spekulatif klasik yang dirumuskan oleh Google Research (Leviathan et al., 2023), proses verifikasi bersifat lossless. Distribusi probabilitas token akhir dijamin 100% identik dengan model target autoregresif ($p$). Karena distribusi tidak berubah, panjang teks yang dihasilkan ($ar{L}$) konstan, dan percepatan waktu eksekusi (wall-clock speedup) berbanding lurus dengan rata-rata token draft yang diterima ($ar{\ell}$):

Untuk mendongkrak $\bar{\ell}$, berbagai riset mutakhir memperkenalkan Relaxed (Lossy) Speculative Decoding. Alih-alih menolak token jika probabilitas drafter $q(x) > p(x)$, metode ini mengizinkan toleransi berbasis divergensi informasi (seperti batas Reverse-KL pada CACTUS, Forward-KL pada Mentored Decoding, atau divergensi Jensen-Shannon pada Fuzzy Decoding).

Secara kasat mata pada metrik lokal, metode-metode ini tampak luar biasa: rasio penerimaan token melompat tajam. Namun para peneliti di University of Waterloo membuktikan bahwa persamaan kecepatan di atas tidak lagi berlaku jika distribusi generasi berubah. Rumus akselerasi yang sebenarnya harus dikoreksi dengan faktor rasio inflasi panjang ($lambda$):

Jumlah putaran verifikasi target model ($R$) memenuhi estimasi $R \approx L / (\bar{\ell} + 1)$. Sehingga perbandingan putaran verifikasi metode relaksasi terhadap lossless adalah:

Artinya, keuntungan bersih (net-win) hanya akan terjadi jika rasio peningkatan acceptance melebihi faktor pembengkakan panjang generasi ($rac{\bar{\ell}_{\mathrm{relax}} + 1}{\bar{\ell}_{\mathrm{strict}} + 1} > \lambda$). Jika tidak, model justru menghabiskan lebih banyak forward-pass GPU untuk memvalidasi teks yang membual tanpa henti.

2. Taksonomi 5 Aturan Lossy Speculative Decoding Bebas-Pelatihan (Training-Free)

Riset arXiv:2610.23818 membedah dan mengimplementasikan lima aturan verifikasi training-free populer ke dalam rejection sampler serving engine vLLM. Seluruh metode ini dapat diklasifikasikan ke dalam matriks formal distribusi target riil $\pi^{\mathrm{rej}}$, residu penolakan $\pi^{\mathrm{res}}$, dan token bonus $\pi^{\mathrm{bonus}}$:

3. Evaluasi Empiris Komprehensif: 360 Sel Pengujian Lintas 12 Pasangan Model

Eksperimen masif dilakukan pada dua kluster GPU (NVIDIA H100 SXM5 dan A100-80GB) mencakup 6 dataset standar: GSM8K (penalaran dasar), AIME24 (olimpiade matematika tingkat tinggi), HumanEval & LiveCodeBench (sintesis kode), MT-Bench (instruksi dialog multi-turn), dan LongBench-v2 (konteks panjang hingga ribuan token).

A. Perilaku Panjang Generasi (Length Ratio $lambda$)

Tabel di bawah menyajikan rasio panjang teks $\lambda = \bar{L}_{\mathrm{relax}} / \bar{L}_{\mathrm{strict}}$ pada pasangan utama GPT-OSS-20B dan Qwen3-8B yang dipasangkan dengan EAGLE-3 (angka dalam kurung menunjukkan akurasi tugas / skor MT-Bench):

Perhatikan data pada tugas AIME24 di atas: pada GPT-OSS-20B, aturan Casc-Opt dan r-Fuzzy memicu inflasi hingga $2.48\times$ dan $2.13\times$ panjang teks normal, sementara akurasi runtuh dari 0.70 menjadi 0.37 dan 0.50! Bahkan pada LiveCodeBench untuk Qwen3-8B dengan r-Fuzzy, akurasi hancur hingga hanya 0.02 (2%) akibat kegagalan sintaksis dan loop logika yang tak berujung.

4. Bedah Anatomi: Mengapa Model Berpikir Lebih Panjang?

Pertanyaan mendasar bagi para arsitek AI: Di mana token-token ekstra tersebut berada, dan apa isinya? Tim University of Waterloo melakukan tracking per-token dan menemukan fakta mengejutkan:

• > 90% Token Tambahan Adalah "Thinking Trace" (<think>): Pada model reasoning (seperti DeepSeek-R1, Qwen-Thinking, dan GPT-OSS), panjang jawaban akhir yang diberikan kepada pengguna hampir tidak berubah sama sekali. Seluruh inflasi panjang terserap di dalam blok monolog internal.
• Injeksi Token Probabilitas Rendah (Low-Probability Token Injection): Dalam decoding lossless, token spekulatif yang diterima memiliki probabilitas target rata-rata $p(x) \approx 0.78 \sim 0.93$ dengan peringkat target median $1$ (argmax). Namun, relaksasi meloloskan token subordinat di mana target model sebenarnya hanya memberikan probabilitas $0.01 \sim 0.09$ dengan peringkat vocab mencapai rank 37 hingga rank 234!
• Penyimpangan Trajektori Kognitif (Cognitive Derailment): Ketika sebuah token yang "tidak lazim" lolos ke dalam context window melalui relaksasi sampling, model reasoning terpaksa merasionalisasi token tersebut pada langkah berikutnya. Model mulai meragukan hipotesis sebelumnya, membatalkan kalkulasi yang sudah benar, dan berputar-putar dalam loop self-correction yang sia-sia.

Perbedaan Fundamental: GSM8K vs AIME24

Penelitian ini juga mengidentifikasi lokasi kemunculan token ekstra:

• Pada Masalah Mudah (GSM8K): $50\%$ hingga $82\%$ token ekstra muncul SETELAH model menuliskan jawaban yang benar. Model terus memvalidasi ulang dan mengulang penjelasan secara bertele-tele karena tidak mampu memutuskan kapan harus berhenti (EOS delay).
• Pada Masalah Sulit (AIME24): Token ekstra muncul SEBELUM jawaban tercapai (median token pembuktian bergeser dari token ke-1.721 menjadi token ke-3.865). Akibatnya fatal: model menyentuh batas kuota generation token budget (misal 4.096 token) sebelum sempat menghasilkan kesimpulan akhir (budget truncation failure).

5. Solusi Rekayasa: Reasoning Trace Budget Forcing

Untuk membuktikan bahwa token ekstra tersebut murni pemborosan (bukan proses berpikir produktif yang bernilai), para peneliti menerapkan teknik Budget Forcing (terinspirasi dari Muennighoff et al., 2025 - s1): ketika proses generasi mendekati batas kuota token (threshold 85%), sistem secara paksa menginjeksikan token penutup blok penalaran (</think>) dan memaksa model mengeluarkan jawaban saat itu juga.

Hasilnya sangat telak: dari 1.132 eksekusi yang hampir gagal karena kehabisan budget, intervensi forced trace termination berhasil menyelamatkan 335 eksekusi menjadi jawaban yang benar (lonjakan dari 126 jawaban benar menjadi 439 jawaban benar), dengan hanya 22 kasus regresi. Ini mengonfirmasi bahwa model penalaran sejatinya sudah mengetahui jawaban yang benar jauh sebelum batas kuota habis, namun terjebak dalam monolog akibat polusi token spekulatif yang longgar.

6. Implementasi Referensi: Length-Corrected Speculative Harness di TypeScript

Bagi pengembang yang mengoperasikan model serving (seperti vLLM, SGLang, atau custom inference gateways), berikut adalah modul harness referensi yang mengintegrasikan filter low-support elimination, deteksi inflasi panjang secara online, dan reasoning trace budget forcing:

// Production Implementation: Length-Corrected Speculative Decoding Harness
// Berdasarkan formulasi formal paper arXiv:2610.23818 (University of Waterloo)
// Mengimplementasikan:
// 1. Dual-Distribution Verification (Strict vs Relaxed Sampler)
// 2. Online Length Inflation Detection (lambda = L_current / L_baseline)
// 3. Dynamic Net-Win Guard: (l_accept + 1) / (l_strict + 1) > lambda
// 4. Token-Entropy & Target-Probability Support Filter (Eliminasi off-support low-prob tokens)
// 5. Reasoning Trace Budget Forcing (Auto-injection penutup trace saat mendekati limit budget)

export interface SpeculativeSampleContext {
  promptTokenCount: number;
  maxGenerationBudget: number;
  currentGeneratedTokens: number[];
  inThinkingBlock: boolean;
  thinkingTokenCount: number;
  totalVerifierRounds: number;
  accumulatedAcceptedTokens: number;
}

export interface DraftTokenCandidate {
  tokenId: number;
  drafterProb: number;     // q(x)
  targetProb: number;      // p(x)
  targetRank: number;      // Peringkat token pada distribusi target p
}

export interface SpeculativeHarnessConfig {
  draftBlockSize: number;           // N_draft = 6
  divergenceAlpha: number;          // Parameter kelonggaran relaksasi
  strictMinTargetProb: number;       // Ambang minimum p(x) agar tidak merusak trajectory (misal 0.15)
  maxTargetRankSupport: number;     // Max rank target yang diizinkan (misal top-10)
  traceBudgetThresholdRatio: number;// 0.85 (85% dari max budget memicu trace closure forcing)
  endOfThinkingTokenId: number;     // Token ID untuk 
}

export class LengthCorrectedSpeculativeEngine {
  private config: SpeculativeHarnessConfig;
  private runningInflationFactor: number = 1.0;
  private strictBaselineLength: number = 512; // Profil baseline model lossless

  constructor(config: SpeculativeHarnessConfig) {
    this.config = config;
  }

  /**
   * 1. Evaluasi Kelonggaran Verifikasi Berdasarkan Divergence Budget (CACTUS / Mentored Rule)
   * Menghitung probabilitas penerimaan relajasi pi_rej(x) dengan perlindungan support.
   */
  public evaluateRelaxedAcceptance(candidate: DraftTokenCandidate): {
    accepted: boolean;
    reason: 'STRICT_MATCH' | 'RELAXED_BUDGET' | 'REJECTED_LOW_SUPPORT' | 'REJECTED_COIN';
  } {
    const { drafterProb, targetProb, targetRank } = candidate;

    // RULE 1: Eliminasi token anomali (Low-Support Guard)
    // Paper membuktikan token rank 37-234 dengan probabilitas < 0.05 memicu halusinasi penalaran
    if (targetRank > this.config.maxTargetRankSupport || targetProb < this.config.strictMinTargetProb) {
      return { accepted: false, reason: 'REJECTED_LOW_SUPPORT' };
    }

    // RULE 2: Strict Acceptance Standard (Leviathan et al.)
    if (drafterProb <= targetProb) {
      return { accepted: true, reason: 'STRICT_MATCH' };
    }

    // RULE 3: Relaxed Acceptance with Taylor-Expanded Reverse-KL (CACTUS)
    // gamma_x = min(p(x) + sqrt(2 * alpha * p(x) * (1 - p(x))), 1.0)
    const variance = targetProb * (1 - targetProb);
    const boost = Math.sqrt(2 * this.config.divergenceAlpha * variance);
    const gammaRelaxed = Math.min(targetProb + boost, 1.0);

    const acceptanceProb = gammaRelaxed / drafterProb;
    const randomCoin = Math.random();

    if (randomCoin <= acceptanceProb) {
      return { accepted: true, reason: 'RELAXED_BUDGET' };
    }

    return { accepted: false, reason: 'REJECTED_COIN' };
  }

  /**
   * 2. Dynamic Net-Win Verification Guard (Eq. 5 dari arXiv:2610.23818)
   * Menghitung apakah percepatan drafting mengimbangi inflasi panjang token:
   * Net Win tercapai jika: (l_accept_relax + 1) / (l_accept_strict + 1) > lambda
   */
  public isNetWinSpeedup(
    currentAcceptedAvg: number,
    strictAcceptedAvg: number,
    currentLength: number
  ): boolean {
    this.runningInflationFactor = currentLength / this.strictBaselineLength;
    const acceptanceGain = (currentAcceptedAvg + 1) / (strictAcceptedAvg + 1);

    // Jika rasio panjang lebih besar dari rasio penambahan token, relaksasi adalah FALSE ECONOMY
    return acceptanceGain > this.runningInflationFactor;
  }

  /**
   * 3. Reasoning Trace Budget Forcing (Section 4 & Table 4)
   * Saat agen berpikir terlalu panjang akibat token drift, paksa trace closure
   * sebelum kuota konteks habis terbuang sia-sia.
   */
  public inspectAndEnforceBudget(context: SpeculativeSampleContext): {
    shouldForceTraceClosure: boolean;
    forcedTokenId?: number;
  } {
    const totalTokens = context.currentGeneratedTokens.length;
    const budgetLimit = context.maxGenerationBudget;

    // Jika model masih berada dalam blok  dan sudah melewati threshold budget
    if (
      context.inThinkingBlock &&
      totalTokens >= budgetLimit * this.config.traceBudgetThresholdRatio
    ) {
      return {
        shouldForceTraceClosure: true,
        forcedTokenId: this.config.endOfThinkingTokenId
      };
    }

    return { shouldForceTraceClosure: false };
  }
}

7. Rekomendasi Arsitektural untuk Tim AI Engineering di 2026

Berdasarkan temuan definitif dari paper arXiv:2610.23818, kami merumuskan 4 panduan mutlak bagi tim infrastruktur AI yang mengonfigurasi speculative decoding di lingkungan produksi:

1. Ukur Wall-Clock Speedup, Bukan Accepted Token Length: Jangan pernah mengevaluasi drafter spekulatif hanya dari metrik $ar{\ell}$ atau token/second mentah. Selalu ukur Time-to-Last-Token (TTLT) total per kueri pada tugas penalaran nyata (AIME/SWE-bench) untuk mendeteksi keberadaan Length Inflation.
2. Gunakan Drafter Mandiri (Standalone Model) Ketimbang Dedicated Head untuk Relaksasi: Data empiris membuktikan bahwa drafter berbasis head tambahan (seperti EAGLE-3) mengalami inflasi paling parah ($lambda = 3.30\times$), sedangkan model drafter mandiri (seperti target Llama-3.1-70B dengan drafter Llama-3.1-8B) mempertahankan rasio panjang yang stabil ($lambda = 0.90 \sim 1.06$).
3. Pasang Support Filter Ketat: Jika tetap menggunakan relaksasi divergensi (CACTUS atau Mentored), pasang filter probabilitas: tolak secara absolut setiap token spekulatif yang memiliki target probabilitas $p(x) < 0.10$ atau berada di luar $k=10$ besar, terlepas dari berapa pun nilai $\alpha$ yang ditetapkan.
4. Terapkan Adaptive Trace Cutoff pada Agen Otonom: Pada beban kerja agen (seperti coding agents yang menghasilkan ratusan langkah pemikiran), aktifkan trace budget forcing ketika konsumsi token mencapai 80-85% dari batas konteks untuk mencegah kegagalan fatal akibat context overflow.