MISVO 2026: Arsitektur Minimally Invasive Steering Vector Optimization, Fisher Information Geometry pada Pre-Logit Hidden States, dan Eliminasi Degradasi Koherensi Test-Time Alignment Tanpa Update Bobot LLM

Dalam evolusi rekayasa model bahasa terdepan (frontier LLM), kebutuhan untuk menyelaraskan model terhadap preferensi pengguna yang dinamis, batasan kebijakan domain spesifik, dan sinyal evaluasi waktu nyata (real-time evaluators) telah mendorong pergeseran besar dari training-time alignment statis menuju test-time alignment. Selama bertahun-tahun, paradigma dominan bergantung pada pembaruan bobot permanen melalui RLHF, PPO, atau DPO. Namun, ketika model telah dideploy di lingkungan produksi berskala masif, memperbarui miliaran hingga triliunan parameter untuk setiap variasi konteks pengguna adalah kemustahilan komputasi.

Pendekatan alternatif yang sangat menjanjikan adalah representation steering (atau activation steering), di mana representasi laten model dimodifikasi secara dinamis saat inferensi dengan menambahkan vektor intervensi $u_t$ pada status tersembunyi pre-logit $h_t$ sebelum memasuki lapisan unembedding: $z_t = W(h_t + u_t) + b$. Pendekatan ini memungkinkan modifikasi perilaku generasi model secara instan tanpa menyentuh satupun bobot model dasar.

Terobosan fundamental hadir melalui publikasi riset teranyar dari tim peneliti Johns Hopkins University (arXiv:2609.30218, 24 September 2026) berjudul "Minimally Invasive Steering of Language Models". Riset ini memperkenalkan kerangka MISVO (Minimally Invasive Steering Vector Optimization). Alih-alih menggunakan jarak Euclidean yang buta terhadap distribusi output, MISVO meregularisasi intervensi pre-logit menggunakan geometri kelengkungan lokal yang ditentukan oleh Fisher Information Matrix (FIM).

1. Geometri Riemannian KL Divergence & Kegagalan Penalti Isotropik

Secara formal, pertimbangkan model bahasa acuan beku $\pi_{\text{ref}}$ dengan matriks bobot proyeksi unembedding $W \in \mathbb{R}^{V \times d}$ dan bias $b \in \mathbb{R}^V$, di mana $V$ adalah ukuran kosakata dan $d$ adalah dimensi status tersembunyi. Untuk prompt $x$ dan respons sekuensial $y = (y_1, \dots, y_T)$, distribusi token referensi pada posisi $t$ didefinisikan sebagai:

Ketika kita menyuntikkan vektor intervensi posisi $u_t \in \mathbb{R}^d$, distribusi token yang terinduksi menjadi:

Tujuan dari KL-regularized test-time alignment adalah menyelesaikan optimasi:

Mengapa mengganti penalti KL dengan penalti Euclidean $\frac{1}{2} \sum_t \|u_t\|_2^2$ berakibat fatal? Karena metrik Euclidean mengasumsikan ruang laten berjarak seragam. Dalam kenyataannya, manifold probabilitas adalah ruang Riemannian di mana metrik fundamentalnya ditentukan oleh Fisher Information Metric.

Berdasarkan ekspansi Taylor orde kedua dari fungsi partisi logaritmik $A(z) = \log \sum_{i=1}^V e^{z_i}$, divergensi KL level-token di sekitar $u_t = 0$ memenuhi relasi asimtotik:

di mana matriks simetris semidefinit positif $F_t(u_t) \in \mathbb{R}^{d \times d}$ adalah Fisher Information Matrix terhadap vektor intervensi $u_t$:

Matriks kovariansi kovariat $C_{\pi} := \text{diag}(\pi) - \pi \pi^\top$ secara langsung mencerminkan sensitivitas distribusi probabilitas terhadap perturbasi logit. Penalti berbasis bentuk kuadratik Fisher $\frac{1}{2} u_t^\top F_t u_t$ secara presisi menghukum pergeseran pada arah laten yang paling sensitif terhadap probabilitas token kosakata, sekaligus memberikan kebebasan eksplorasi penuh pada arah-arah laten yang invarian.

2. Landasan Teori: Teorema Dekomposisi Gradien KL Level-Sekuens (Theorem 1)

Tantangan teoretis terbesar dalam menerapkan penalti kuadratik per-token pada sekuens autoregresif adalah bahwa prefix $y_{<t}$ itu sendiri dihasilkan oleh kebijakan yang telah terperturbasi $\pi_u$. Apakah mengabaikan ketergantungan sekuensial ini akan merusak gradien regulasi?

Peneliti MISVO membuktikan teorema dekomposisi fundamental yang membongkar anatomi gradien KL level-sekuens:

Dekomposisi ini mengungkapkan fakta matematis yang sangat elegan: suku pertama ($g_t^{\text{an}}$) adalah kontribusi lokal deterministik yang dapat dihitung secara eksak tanpa variansi Monte-Carlo. Sementara suku kedua ($g_t^{\text{suffix}}$) adalah efek kovariansi terhadap generasi masa depan.

Lebih lanjut, dalam Proposition 2 makalah tersebut, penulis membuktikan bahwa untuk horizon tetap $T$, suku sufiks memenuhi batas:

Artinya, di sekitar titik awal inferensi ($u = 0$), suku sufiks yang berisik tersebut adalah suku berorde kedua! Dengan demikian, surigat Fisher berbasis model acuan beku $\bar{F}_t := \mathbb{E}_{y_{<t} \sim \pi_{\text{ref}}}[F_t(0)]$ mencocokkan gradien divergensi KL penuh hingga ekspansi Taylor orde pertama:

Temuan ini memberikan justifikasi teoretis yang sangat kokoh: kita dapat membuang suku sufiks yang menyebabkan variansi Monte-Carlo meledak, dan menggantikannya dengan gradien regulasi kuadratik deterministik yang stabil secara numerik.

3. Arsitektur Matrix-Free Fisher-Vector Products: Zero Memory Overhead

Hambatan praktis terbesar dari Information Geometry pada model bahasa modern adalah skala matriks Fisher. Pada model seperti Llama-3-8B atau Phi-4 (14B), dimensi status tersembunyi $d$ bernilai antara $4096$ hingga $5120$, dan ukuran kosakata $V$ mencapai $128.000$ hingga $256.000$.

Membuat dan menyimpan matriks Fisher eksplisit berukuran $d \times d$ membutuhkan memori:

Untuk sekuens sepanjang $T = 256$ token, alokasi memori akan membengkak hingga lebih dari $17.1 \text{ GB}$ hanya untuk menyimpan matriks regulasi! Selain itu, menghitung $F_t = W^\top C W$ secara naif membutuhkan $\mathcal{O}(d^2 V)$ perkalian floating-point, yang akan melumpuhkan kecepatan inferensi.

MISVO memecahkan kendala ini secara brilian dengan merumuskan Matrix-Free Fisher Products. Karena algoritma optimasi berbasis gradien hanya memerlukan hasil kali matriks-vektor $F_t u_t$, produk ini dapat dihitung tanpa pernah mengkonstruksi matriks $d \times d$ ataupun $V \times V$:

Dengan formulasi matrix-free ini, evaluasi penalti Fisher hanya memerlukan dua operasi perkalian matriks-vektor dengan bobot unembedding yang sudah berada di VRAM GPU. Overhead komputasi regulasi menurun drastis menjadi kurang dari 4% dari total waktu forward pass model.

4. Algoritma Optimasi MISVO: Stochastic Ascent Berpemandu Fisher

Pipeline eksekusi MISVO beroperasi dalam siklus iteratif yang ringkas selama inferensi. Untuk setiap prompt masukan $x$:

1. Inisialisasi Vektor Intervensi: Tetapkan $u_t^{(0)} = 0$ untuk setiap posisi $t \in \{1, \dots, T\}$. Hitung distribusi probabilitas token referensi beku $\pi_{\text{ref}}(\cdot \mid x, y_{<t})$.
2. Rollout Sampling: Pada iterasi ke-$m$, generate $K$ respons independen $y^{(1)}, \dots, y^{(K)} \sim \pi_{u^{(m)}}$.
3. Evaluasi Reward: Hitung reward skalar $R_k = R(x, y^{(k)})$ menggunakan reward model eksternal, verifikator unit test, atau heuristik domain.
4. Estimasi Gradien Reward: Hitung gradien arah kebijakan:
   $$g_t^R = \frac{1}{K} \sum_{k=1}^K (R_k - \bar{R}) \, W^\top (e_{y_t^{(k)}} - p_t^{(k)})$$
5. Pembaruan Geometris Fisher: Perbarui vektor intervensi menggunakan gradien gabungan:
   $$u_t^{(m+1)} = u_t^{(m)} + \eta \left( g_t^R - \lambda \, \bar{F}_t u_t^{(m)} \right)$$
   di mana $\bar{F}_t u_t^{(m)}$ dievaluasi menggunakan mesin matrix-free tanpa alokasi matriks.

5. Evaluasi Kinerja Empiris: Benchmark SHP & MBPP+ pada 4 Keluarga Model

Peneliti mengevaluasi MISVO pada empat model instruction-tuned dengan skala arsitektur berbeda: LFM2.5-1.2B-Instruct, Gemma3-4B-IT, Llama-3-8B-Instruct, dan Phi-4 (14B) pada dua domain tugas kritis: Stanford Human Preferences (SHP) dan sintesis kode program Python (MBPP+).

Hasil empiris di atas menegaskan tiga keunggulan kunci arsitektur MISVO:

• Reward Tertinggi Tanpa Perplexity Degradation: MISVO mengungguli Best-of-N dan Euclidean steering di 6 dari 7 pengujian model, sambil mempertahankan perplexity pada rasio 1.04x (nyaris identik dengan model acuan murni).
• Penyelamatan Sintaksis pada Code Generation: Pada benchmark MBPP+, penalti Euclidean menyebabkan penurunan akurasi (dari 54.2% menjadi 48.1%) akibat rusaknya token indentasi dan sintaksis bahasa Python. Sebaliknya, MISVO meningkatkan akurasi hingga 68.1% karena Fisher Information Matrix secara otomatis memproteksi token-token struktural yang kritis.
• Efisiensi Test-Time Compute: Dibandingkan Best-of-N yang mengharuskan sampling 16x sekuens penuh dari nol, MISVO mencapai konvergensi hanya dalam beberapa iterasi gradien kecil, menghemat lebih dari 75% FLOPs total inferensi.

6. Jebakan Arsitektur (Pitfalls) & Kesalahan Fatal pada Test-Time Representation Steering

Bagi tim AI Platform yang mengintegrasikan layer steering pada LLM serving cluster, terdapat 3 jebakan fatal yang wajib dihindari:

• Mencoba Mematerialisasi Matriks Fisher $d \times d$ di VRAM: Mengalokasikan matriks kovariansi penuh untuk model 8B/14B pada panjang konteks 4096 token akan langsung memicu CUDA Out-of-Memory (OOM). Selalu gunakan formulasi matrix-free dua langkah ($W u_t \to m \to W^\top m$) yang hanya membutuhkan memori vektor seukuran kosakata $V$.
• Menghitung Ulang Matriks Fisher Dinamis pada Setiap Iterasi: Mengevaluasi $F_t(u_t^{(m)})$ pada setiap pembaruan gradien menambah overhead komputasi tanpa memberikan perbaikan reward yang berarti. Berdasarkan Theorem 2, surigat model referensi beku $\bar{F}_t = F_t(0)$ sudah akurat hingga orde pertama $\mathcal{O}(\|u\|^2)$ dan cukup dihitung satu kali di awal.
• Mengabaikan Skala Koefisien Regulerisasi $\lambda$: Menetapkan $\lambda$ terlalu kecil ($< 0.01$) akan menyebabkan vektor intervensi meledak dan mengorbankan koherensi semantik. Sebaliknya, $\lambda$ yang terlalu besar ($> 1.0$) mematikan efek steering sama sekali. Nilai optimal berada pada rentang $\lambda \in [0.05, 0.2]$ dengan pembaruan momentum Adam.

7. Spesifikasi Teknis: Implementasi TypeScript MISVO Matrix-Free Steering Engine

Berikut adalah implementasi referensi tingkat produksi dalam TypeScript modern yang menyediakan modul penghitung perkalian Fisher bebas matriks dan pengoptimal vektor intervensi untuk framework runtime agentic:

// MISVO Production Harness: Matrix-Free Fisher Steering & Online Activation Interventions
// Berdasarkan Arsitektur Riset arXiv:2609.30218 (Entesari, Zhang, Khashabi, Fazlyab - September 2026)
//
// Komponen Utama:
// 1. MatrixFreeFisherProduct: Menghitung F_t(0) * u_t dalam O(d * V) FLOPs tanpa materialisasi matriks d x d
// 2. TokenLogitPerturbation: Mengaplikasikan vektor steering u_t pada pre-logit hidden state h_t
// 3. FrozenFisherSurrogateEstimator: Mengestimasi matriks biaya Fisher referensi ekspektasi E_{y delta in R^V
   */
  public static projectToLogits(W: number[][], u: number[]): number[] {
    const vocabSize = W.length;
    const hiddenDim = u.length;
    const delta = new Array(vocabSize).fill(0);

    for (let i = 0; i < vocabSize; i++) {
      let sum = 0;
      const row = W[i];
      for (let j = 0; j < hiddenDim; j++) {
        sum += row[j] * u[j];
      }
      delta[i] = sum;
    }
    return delta;
  }

  /**
   * Menghitung W^T * vector -> out in R^d
   */
  public static projectToHidden(W: number[][], v: number[]): number[] {
    const vocabSize = W.length;
    const hiddenDim = W[0].length;
    const result = new Array(hiddenDim).fill(0);

    for (let i = 0; i < vocabSize; i++) {
      const v_i = v[i];
      if (Math.abs(v_i) < 1e-9) continue;
      const row = W[i];
      for (let j = 0; j < hiddenDim; j++) {
        result[j] += row[j] * v_i;
      }
    }
    return result;
  }

  /**
   * Menghitung F_t * u secara matrix-free:
   * 1. delta = W * u
   * 2. alpha = sum_i (p_i * delta_i) = p^T * delta
   * 3. m_i = p_i * delta_i - alpha * p_i
   * 4. output = W^T * m
   */
  public static computeFisherVectorProduct(W: number[][], p: number[], u: number[]): number[] {
    const delta = this.projectToLogits(W, u);
    let alpha = 0;
    const vocabSize = p.length;

    for (let i = 0; i < vocabSize; i++) {
      alpha += p[i] * delta[i];
    }

    const m = new Array(vocabSize);
    for (let i = 0; i < vocabSize; i++) {
      m[i] = p[i] * delta[i] - alpha * p[i];
    }

    return this.projectToHidden(W, m);
  }
}

/**
 * 2. MISVO Optimizer Core
 * Mengoptimalkan vektor intervensi posisi u_1:T menggunakan stochastic gradient ascent
 */
export class MISVOOptimizer {
  private hiddenDim: number;
  private horizonT: number;
  private params: OptimizationHyperparameters;
  private W: number[][]; // Head proyeksi LM (V x d)

  constructor(hiddenDim: number, horizonT: number, W: number[][], params: OptimizationHyperparameters) {
    this.hiddenDim = hiddenDim;
    this.horizonT = horizonT;
    this.W = W;
    this.params = params;
  }

  /**
   * Menghitung estimasi gradien reward Monte-Carlo g_t^R
   * g_t^R = (1/K) * sum_{k=1}^K (R_k - R_bar) * W^T (e_{y_t^(k)} - p_t^(k))
   */
  public computeRewardGradient(
    rolloutTokens: number[][], // K x T token index
    rolloutProbabilities: number[][][], // K x T x V probabilitas token
    rewards: number[] // K reward empiris
  ): number[][] {
    const K = rewards.length;
    const meanReward = rewards.reduce((a, b) => a + b, 0) / K;
    const gradR: number[][] = Array.from({ length: this.horizonT }, () => new Array(this.hiddenDim).fill(0));

    for (let t = 0; t < this.horizonT; t++) {
      const accumV = new Array(this.W.length).fill(0);

      for (let k = 0; k < K; k++) {
        const advantage = rewards[k] - meanReward;
        const chosenToken = rolloutTokens[k][t];
        const p_t = rolloutProbabilities[k][t];

        for (let i = 0; i < this.W.length; i++) {
          const indicator = i === chosenToken ? 1.0 : 0.0;
          accumV[i] += advantage * (indicator - p_t[i]);
        }
      }

      for (let i = 0; i < this.W.length; i++) {
        accumV[i] /= K;
      }

      gradR[t] = MatrixFreeFisherEngine.projectToHidden(this.W, accumV);
    }

    return gradR;
  }

  /**
   * Langkah Pembaruan Vektor Intervensi MISVO:
   * u_t^(iter+1) = u_t^(iter) + eta * ( g_t^R - lambda * F_bar_t * u_t^(iter) )
   */
  public step(
    currentU: number[][], // T x d
    referenceP: number[][], // T x V distribusi probabilitas referensi beku
    gradR: number[][] // T x d gradien reward
  ): number[][] {
    const nextU: number[][] = Array.from({ length: this.horizonT }, () => new Array(this.hiddenDim).fill(0));

    for (let t = 0; t < this.horizonT; t++) {
      const u_t = currentU[t];
      const p_ref_t = referenceP[t];

      // Hitung penalti geometris Fisher Information secara matrix-free
      const fisherGrad = MatrixFreeFisherEngine.computeFisherVectorProduct(this.W, p_ref_t, u_t);

      for (let j = 0; j < this.hiddenDim; j++) {
        const netGrad = gradR[t][j] - this.params.klLambda * fisherGrad[j];
        nextU[t][j] = u_t[j] + this.params.learningRate * netGrad;
      }
    }

    return nextU;
  }
}

8. Rekomendasi Strategis bagi Engineering & AI Platform Architects

Publikasi MISVO menandai babak baru dalam rekayasa sistem AI enterprise. Bagi organisasi yang membangun infrastruktur AI agentik, asisten koding privat, atau sistem kepatuhan real-time:

1. Gantikan Adapter Fine-Tuning Ringan (LoRA) Statis dengan Test-Time Steering: Untuk kebutuhan adaptasi gaya bicara, persona, atau kebijakan kepatuhan per-penyewa (multi-tenant compliance), steering laten test-time jauh lebih fleksibel dan tidak memerlukan manajemen ratusan checkpoint LoRA di storage cluster.
2. Terapkan Information Geometry sebagai Standar Keamanan Alignment: Setiap intervensi representasi internal—baik melalui activation patching, refusal steering, maupun circuit breaking—wajib diukur menggunakan metrik Fisher Information guna memastikan representasi inti model tidak terkorupsi.
3. Manfaatkan Matrix-Free Kernels pada Inference Engine: Implementasikan operator kustom Triton atau CUDA untuk fusi kernel $W u_t \to m \to W^\top m$ langsung pada lapisan terakhir transformer sebelum Softmax untuk mencapai latensi sub-milidetik.