Loop Scaling Laws 2026: Arsitektur Looped Mixture-of-Experts (LoopMoE), Sparsity-Conditional Recurrence Mapping, dan Penskalaan Efisiensi Parameter Skala Triliun Token

Dalam kurun waktu lima tahun terakhir, penskalaan model bahasa besar (LLM) bertumpu pada formula klasik Chinchilla scaling laws: perbesar jumlah parameter model ($N$) dan perbanyak jumlah token pelatihan ($D$). Namun, di era model frontier 2026, strategi penambahan brute-force parameter fisik telah menabrak dua dinding batas yang sangat nyata: memory footprint wall pada memori HBM GPU dan compute saturation pada cluster komputasi terdistribusi.

1. Mengapa Hukum Penskalaan Klasik Gagal pada Arsitektur Looped MoE?

Hukum penskalaan standar mengasumsikan model feed-forward statis di mana setiap token melewati setiap parameter tepat satu kali. Ketika peneliti mencoba memodelkan Looped Transformers sebelumnya (seperti Parcae), mereka menggunakan pemetaan linear sederhana:

Model linear ini mengasumsikan bahwa setiap kali model mengulang blok tengah (middle-block loop), keuntungan kapasitas parameter bertambah secara linier tanpa batas. Pada kenyataannya, pengujian empiris membuktikan terjadinya diminishing returns yang tajam: memutar bobot yang sama berulang-ulang akan mengalami saturasi karena representasi fitur token konvergen ke ruang representasi yang sempit.

Di sisi lain, hukum penskalaan MoE konvensional hanya memodelkan pembagian expert pada arsitektur non-looped. Ketika Looped Transformer dikombinasikan dengan MoE, terjadi dinamika yang sepenuhnya baru: Expert-Path Diversity ($Psi$). Karena mekanisme sparse routing memilih top-$k$ expert yang berbeda pada setiap pass rekursif $r$, token dapat melintasi kombinasi jalur parameter yang eksponensial meskipun bobot fisik model tetap identik!

2. Anatomi Matematika: Sparsity-Conditional Recurrence Mapping

Kunci keberhasilan Loop Scaling Laws terletak pada pengikatan rasio sparsity $m = N_{act} / N_{total}$ ke dalam koefisien saturasi rekursif:

Dalam formulasi ini, eksponen penskalaan sparsity $ heta = 0.3286$ bertindak sebagai tuas pengungkit. Ketika sparsity meningkat (nilai $m$ mengecil, yang berarti jumlah expert $E$ bertambah), nilai $m^{- heta}$ membesar. Efek geometrisnya sangat elegan:

• Pengangkatan Asimtotik ($kappa_1(m)$): Menaikkan batas atas kapasitas parameter efektif maksimum yang dapat dicapai oleh model saat $R o infty$. Token tidak lagi 'terkunci' dalam siklus representasi yang monoton karena pada setiap loop ia diproses oleh expert yang berbeda.
• Perlambatan Saturasi ($kappa_2(m)$): Memperpanjang rentang recurrensi yang efektif sebelum model menyentuh plateau hukum hasil yang berkurang (diminishing returns).
• Pemulihan Hukum Klasik (Boundary Properties): Saat $R = 1$, rumus secara tepat kembali ke parameter aktif non-looped ($N_{eff}(1, m) = N_{act}$). Saat $m = 1$ (model dense tanpa MoE), rumus secara otomatis memulihkan Dense Bounded Loop Scaling Law.

3. Koefisien Parametrik dan Optimasi Sumber Daya (Compute & Memory Optimal)

Melalui sweep empiris berskala masif melibatkan lebih dari 1.000 observasi training loss melintasi parameter aktif $N_{act} in {0.3B, 0.6B, 1.0B}$, token $D in [100B, 500B]$, expert $E in [1, 16]$, dan recurrensi $R in [1, 8]$, Meta AI berhasil mengestimasi parameter global dengan tingkat presisi tinggi (RMSE = 0.0037):

Dengan persamaan ini, arsitek sistem AI dapat memecahkan dua masalah optimasi krusial di bawah kendala komputasi dan memori:

1. Compute-Optimal Recurrence ($R^star$): Pada anggaran FLOPs tetap ($ar{F}_{train}$), apakah lebih baik melatih model dengan sedikit pass pada token yang banyak, atau dengan $R > 1$ pada token yang lebih sedikit? Analisis membuktikan bahwa untuk model dengan active parameter kecil, nilai $R^star = 2$ hingga $4$ memberikan loss yang jauh lebih rendah daripada model non-looped pada FLOPs yang sama.
2. Memory-Optimal Sparsity ($E^star$): Pada batas memori VRAM GPU tetap ($mathcal{M}_{weight} le M_{budget}$), meningkatkan sparsity via expert count meningkatkan kapasitas tanpa menambah komputasi aktif.

4. Evaluasi Triliun Token: Looped MoE Menaklukkan Model 2x Lebih Besar

Uji pembuktian paling spektakuler dari riset ini dilakukan pada skala triliun token. Peneliti membandingkan model baseline A0.6B-2.9B MoE (0.6B active / 2.9B total, 8 expert, dilatih pada ~6T token) melawan model yang dirancang berdasarkan hukum penskalaan: A0.3B-1.3B LoopMoE (0.3B active / 1.3B total, recurrensi $R=4$).

Kedua model dilatih dengan total compute FLOPs yang persis sama ($approx 1.5 imes 10^{22}$ FLOPs). Berikut adalah hasil evaluasi pada 14 tolok ukur standar downstream:

Hasil ini mengungkapkan fakta fundamental: meskipun ukuran parameter aktif dan totalnya 2x lebih kecil, model A0.3B-1.3B LoopMoE mampu mengejar performa penalaran matematis (GSM8K: 41.2% vs 42.9%) dan bahkan melampaui baseline non-looped pada Big-Bench Hard (BBH: 31.8% vs 29.8%). Selain itu, arsitektur looped memberikan keunggulan fleksibilitas inferensi: pengguna dapat menjalankan inferensi cepat pada $R=1$ (hanya 0.8x komputasi) untuk tugas ringan, atau menaikkan $R$ saat menghadapi masalah penalaran sulit tanpa mengubah satu pun bobot checkpoint.

5. Implementasi Referensi TypeScript: LoopMoE Scaling Law Engine

Untuk membantu tim riset dan machine learning engineering menghitung konfigurasi arsitektur optimal, berikut adalah implementasi TypeScript yang memetakan seluruh formulasi matematis Loop Scaling Laws:

// Production Implementation: LoopMoE Scaling Law Evaluator & Resource Optimizer
// Berdasarkan Arsitektur Meta AI (arXiv:2609.40316 - September/Oktober 2026)
//
// Karakteristik Desain:
// 1. Sparsity-Conditional Recurrence Mapping: N_eff(R, m) = N_act + κ_1(m) * N_loop * (1 - exp(-(R-1)/κ_2(m)))
// 2. Dual-Axis Parametric Loss: L(N_act, D, R, E, m) menggabungkan expert expansion E_hat dan N_eff
// 3. Compute- & Memory-Optimal Solver: Menghitung R* dan E* optimal di bawah batas FLOPs dan VRAM

export interface MoELoopLawCoefficients {
  A: number;        // Base parameter scaling constant (0.8085)
  alpha: number;    // Model scaling exponent (-0.1951)
  B: number;        // Base data scaling constant (3.4291)
  beta: number;     // Data scaling exponent (-0.7548)
  c: number;        // Irreducible loss entropy (1.3555)
  delta: number;    // MoE expert scaling coefficient (-0.1935)
  gamma: number;    // MoE parameter interaction exponent (-0.0137)
  omega: number;    // MoE data scaling coefficient (-0.2056)
  zeta: number;     // MoE data interaction exponent (0.0881)
  E_start: number;  // Expert start saturation point (1.3174)
  E_max: number;    // Maximum effective expert capacity (57.1201)
  kappa1: number;   // Recurrence scale multiplier (0.3682)
  kappa2: number;   // Recurrence decay base (1.4037)
  theta: number;    // Sparsity modulation exponent (0.3286)
}

export const META_FITTED_COEFFS: MoELoopLawCoefficients = {
  A: 0.8085,
  alpha: -0.1951,
  B: 3.4291,
  beta: -0.7548,
  c: 1.3555,
  delta: -0.1935,
  gamma: -0.0137,
  omega: -0.2056,
  zeta: 0.0881,
  E_start: 1.3174,
  E_max: 57.1201,
  kappa1: 0.3682,
  kappa2: 1.4037,
  theta: 0.3286,
};

export interface ArchitectureConfig {
  activeParamsB: number;   // N_act dalam Miliar (misal: 0.3B)
  totalParamsB: number;    // N_total dalam Miliar (misal: 1.3B)
  loopParamsB: number;     // N_loop dalam Miliar (middle block parameter)
  expertCount: number;     // E (jumlah routed expert)
  recurrence: number;      // R (jumlah pass middle block)
  trainingTokensB: number; // D dalam Miliar token
}

export class LoopMoEScalingEngine {
  constructor(private coeffs: MoELoopLawCoefficients = META_FITTED_COEFFS) {}

  /**
   * Menghitung Sparsity Ratio m = N_act / N_total
   */
  public computeSparsityRatio(N_act: number, N_total: number): number {
    return Math.min(1.0, Math.max(0.001, N_act / N_total));
  }

  /**
   * Menghitung Effective Expert Expansion E_hat (Clark et al., 2022)
   */
  public computeEffectiveExpertExpansion(E: number): number {
    const { E_start, E_max } = this.coeffs;
    if (E <= 1) return 1.0;
    const invTerm = Math.pow(E - 1 + Math.pow(1 / E_start - 1 / E_max, -1), -1);
    return Math.pow(invTerm + 1 / E_max, -1);
  }

  /**
   * Menghitung Effective Parameters N_eff(R, m) dengan Sparsity-Conditional Bounded Mapping
   * Persamaan (7) Meta AI arXiv:2609.40316
   */
  public computeEffectiveParameters(
    N_act: number,
    N_loop: number,
    R: number,
    m: number
  ): number {
    if (R <= 1) return N_act;
    const kappa1_m = this.coeffs.kappa1 * Math.pow(m, -this.coeffs.theta);
    const kappa2_m = this.coeffs.kappa2 * Math.pow(m, -this.coeffs.theta);
    const gainFactor = 1.0 - Math.exp(-(R - 1) / kappa2_m);
    return N_act + kappa1_m * N_loop * gainFactor;
  }

  /**
   * Prediksi Cross-Entropy Loss L(N_act, D, R, E, m)
   * Persamaan (9) Meta AI arXiv:2609.40316
   */
  public predictLoss(config: ArchitectureConfig): number {
    const { activeParamsB: N_act, totalParamsB: N_total, loopParamsB: N_loop, expertCount: E, recurrence: R, trainingTokensB: D } = config;
    const m = this.computeSparsityRatio(N_act, N_total);
    const E_hat = this.computeEffectiveExpertExpansion(E);
    const N_eff = this.computeEffectiveParameters(N_act, N_loop, R, m);

    const logE = Math.log(Math.max(1.0, E_hat));
    const paramExponent = this.coeffs.alpha + this.coeffs.gamma * logE;
    const dataExponent = this.coeffs.beta + this.coeffs.zeta * logE;

    const paramTerm = this.coeffs.A * Math.pow(E_hat, this.coeffs.delta) * Math.pow(N_eff, paramExponent);
    const dataTerm = this.coeffs.B * Math.pow(E_hat, this.coeffs.omega) * Math.pow(D, dataExponent);

    return paramTerm + dataTerm + this.coeffs.c;
  }

  /**
   * Menghitung Total Training FLOPs: F_train = 6 * N_unroll(R) * D
   */
  public computeTrainingFlops(config: ArchitectureConfig): number {
    const N_unroll = config.activeParamsB + (config.recurrence - 1) * config.loopParamsB;
    return 6.0 * N_unroll * 1e9 * (config.trainingTokensB * 1e9);
  }

  /**
   * Optimasi Compute-Optimal Recurrence (R*) pada Anggaran FLOPs Tetap (Persamaan 11)
   */
  public findComputeOptimalRecurrence(
    N_act: number,
    N_total: number,
    N_loop: number,
    E: number,
    targetFlops: number,
    candidateRecurrences: number[] = [1, 2, 3, 4, 6, 8]
  ): { optimalR: number; minLoss: number; tokenBudgetB: number } {
    let bestR = 1;
    let minLoss = Infinity;
    let optimalTokensB = 0;

    for (const R of candidateRecurrences) {
      const N_unroll = N_act + (R - 1) * N_loop;
      // 6 * N_unroll * 1e9 * D_tokens = targetFlops
      const tokens = targetFlops / (6.0 * N_unroll * 1e9);
      const tokensB = tokens / 1e9;

      const loss = this.predictLoss({
        activeParamsB: N_act,
        totalParamsB: N_total,
        loopParamsB: N_loop,
        expertCount: E,
        recurrence: R,
        trainingTokensB: tokensB,
      });

      if (loss < minLoss) {
        minLoss = loss;
        bestR = R;
        optimalTokensB = tokensB;
      }
    }

    return { optimalR: bestR, minLoss, tokenBudgetB: optimalTokensB };
  }
}

6. Implikasi Arsitektural bagi Generasi Foundation Models Mendatang

Penemuan Loop Scaling Laws mendefinisikan ulang peta jalan desain arsitektur foundation model di industri. Ke depan, pengembang model tidak lagi harus memilih antara model raksasa yang boros VRAM atau model kecil yang dangkal penalarannya.

Dengan memadukan Mixture-of-Experts dan Looped Depth:

• Efisiensi VRAM Edge & Consumer Hardware: Model dengan parameter fisik kecil (misal 1B hingga 3B) dapat ditampung sepenuhnya dalam cache on-chip atau VRAM kartu grafis kelas konsumen, namun memiliki kedalaman komputasi penalaran setara model 7B atau 14B.
• Native Test-Time Compute Scaling: Berbeda dengan model feed-forward biasa yang membutuhkan prompting Chain-of-Thought (CoT) panjang untuk memperpanjang waktu pikir, arsitektur Looped MoE dapat meningkatkan komputasi internal per token secara langsung di level arsitektur jaringan (latent reasoning recurrence).
• Optimalisasi Alokasi Biaya Pelatihan: Formulasi parametrik Meta AI memungkinkan tim ML untuk memprediksi secara akurat apakah budget tambahan $100.000 lebih efektif dialokasikan untuk menambah expert MoE, menambah token pre-training, atau menambah siklus perulangan rekursif.