Transformers Stop Thinking Too Early 2026: Arsitektur Tiny Rank-8 LoRA pada Single Layer, Relay Mechanism di Lapisan Tengah, dan Penskalaan Rantai Penalaran hingga 160 Baris

Gambar 1: Jangkauan Komputasi Penelusuran Referensi (arXiv:2609.36585 Fig. 1)—(a) 13 model dasar standar terhenti pada kedalaman 1.4–3.6 baris (garis putus-putus merah). (b) Tiny rank-8 LoRA pada satu lapisan awal mendongkrak akurasi Qwen3-8B dari 15.5% ke 99.0% pada 24 baris. (c) Pada model berulang Ouro-1.4B, LoRA memungkinkan penskalaan hingga 60 baris (4 loop) dan 160 baris (8 loop). arXiv:2609.36585

1. Mengapa Model Bahasa Modern Berhenti Berpikir Terlalu Dini?

Secara teoretis, arsitektur self-attention pada Transformer memiliki kapasitas komputasi untuk mensimulasikan sirkuit pengikatan variabel (variable binding) dan pelacakan pointer dalam kedalaman tak terbatas (Sanford et al., 2024; Saunshi et al., 2025). Secara praktis, para praktisi berasumsi bahwa model dengan parameter miliaran (7B, 14B, 32B, bahkan 292B MoE) secara otomatis memanfaatkan kedalaman layernya untuk memproses referensi kontekstual yang rumit.

Namun, temuan eksperimental Jin et al. membantah asumsi tersebut. Melalui pengujian ketat pada benchmark rantai referensi (reference chains), para peneliti menemukan fakta mengejutkan di seluruh model dasar terpopuler:

Bahkan pada model dengan puluhan lapis (32 hingga 40 layer), komputasi penyelesaian rantai hanya aktif pada beberapa lapis pertama. Lapisan-lapisan sisanya tidak melanjutkan proses resolusi pointer, melainkan hanya menyalin (copy) representasi statis yang sudah terhenti.

2. Arsitektur Intervensi: Tiny Rank-8 LoRA pada Lapisan Tunggal

Alih-alih melakukan full fine-tuning yang merusak distribusi representasi dasar atau menghabiskan biaya komputasi besar, riset ini merumuskan intervensi minimalis:

• Rank-8 Low-Rank Adaptation (LoRA): Hanya menambahkan matriks adaptasi A ∈ ℝ^{r × d} dan B ∈ ℝ^{d × r} dengan r = 8.
• Injeksi pada Satu Lapisan Awal (Single Layer): Sebagai contoh, pada Qwen3-8B (36 lapisan), LoRA disematkan secara spesifik di Layer 14.
• 100% Frozen Backbone: Seluruh bobot asli model dibekukan sepenuhnya. Hanya 65.537 parameter yang dilatih (kurang dari 0.0008% dari total 8 miliar parameter model).
• Learned Rescaling Scalar: Transformasi hidden state diformulasikan sebagai:
  h ← M(h) = s · h + B · A · h
  di mana s adalah skalar terpelajari yang diinisialisasi mendekati 1.0 (nilai konvergensi pada Qwen3-8B: s = 1.0006).

Gambar 2: Skema Komputasi Representasi (arXiv:2609.36585 Fig. 2)—Kiri: Pada model beku default, penyelesaian pointer terhenti setelah 2 baris; lapisan-lapisan berikutnya hanya melakukan passthrough tanpa komputasi tambahan. Kanan: Intervensi Tiny LoRA pada lapisan awal menginisiasi gelombang estafet (relay front) di mana lapisan-lapisan beku berikutnya secara bertahap membaca pointer lebih tinggi hingga mencapai root variabel. Mekanika Relay Laten

3. Analisis Mekanistik: Bagaimana LoRA Memulai Efek Estafet (Relay) pada Lapisan Beku

Pertanyaan fundamental dalam sains mekanistik AI: Bagaimana mungkin penambahan 65 ribu parameter di satu layer dapat membuat miliaran bobot beku di atasnya melakukan komputasi penelusuran yang sebelumnya tidak pernah mereka lakukan?

Dengan melakukan pelacakan representasi laten (activation patching dan attention probing), Jin et al. mengungkap fenomena Relay Mechanism:

Gambar 3: Sirkuit Atensi Pembacaan Pointer (arXiv:2609.36585 Fig. 5)—Pola atensi diferensial dari pointer baris ke pointer sebelumnya dalam rantai yang sama. Tanpa LoRA, model hanya memperhatikan parent terdekat. Dengan LoRA, jangkauan atensi meluas secara eksponensial di setiap lapisan tengah. Attention Probing Analysis

4. Batas Penempatan Kritis (Sharp Placement Limit) & Rumus Prediksi Cutoff Layer

Salah satu temuan paling krusial bagi praktisi rekayasa AI adalah sensitivitas ekstrem posisi layer. Efek LoRA ini tidak bisa diletakkan di sembarang lapisan:

• Pada Qwen3-8B: Memindahkan LoRA dari Layer 20 ke Layer 21 menjatuhkan jangkauan komputasi secara instan dari 20.5 baris menjadi hanya 5.2 baris!
• Pada OLMo-3-7B: Batas transisi tajam terjadi di antara Layer 12 dan 15.
• Pada Llama-3.1-8B: Batas transisi tajam berada di Layer 13 hingga 15.

Gambar 4: Batas Penempatan Lapisan LoRA (arXiv:2609.36585 Fig. 6)—Kiri: Jangkauan (reach) sebagai fungsi dari penempatan layer LoRA pada 9 model. Terlihat drop vertikal tajam begitu layer melewati ambang batas tertentu. Kanan: Korelasi antara prediksi Cutoff Layer berbasis model beku terhadap batas eksperimental aktual. Sharp Transition Boundary

Para peneliti merumuskan metrik Frozen-Model Cutoff Layer untuk memprediksi batas ini secara apriori tanpa perlu melatih LoRA pada setiap layer:

Cutoff layer didefinisikan sebagai lapisan pertama di mana pemulihan token pointer mengembalikan kurang dari setengah efek aslinya (S(p, ℓ) < 0.5). Metrik ini terbukti berhasil memprediksi bracket penempatan layer pada model-model held-out seperti Llama-3.2-1B (bracket 7–8, prediksi 8.0), Qwen3-4B (bracket 20–22, prediksi 22.0), dan Gemma-3-12B (bracket 24–27, prediksi 23.0) dengan akurasi tinggi.

5. Pembuktian Empiris: Generalisasi ke Multi-Hop Reasoning & Benchmark MuSiQue

Apakah fenomena ini hanya terjadi pada kode sintetis variabel penugasan? Untuk membuktikannya, para peneliti menguji dua domain generalisasi:

6. Implementasi Arsitektur: RelayLoRAModule & Placement Gate

Di bawah ini adalah implementasi sistem modular TypeScript untuk runtime inferensi agen otonom dan serving model yang mengintegrasikan rank-8 LoRA pada lapisan terpilih dengan mekanisme verifikasi cutoff gate:

// Production Implementation: Single-Layer Early Relay LoRA Injector
// Berdasarkan Arsitektur arXiv:2609.36585 (Zehao Jin, Ruixuan Deng, Junran Wang)
//
// Karakteristik Inti:
// 1. Single-Layer Intervention: rank-8 LoRA diinjeksikan HANYA pada satu lapisan awal terpilih
// 2. 100% Frozen Backbone: Seluruh bobot transformer W_base dibekukan sepenuhnya
// 3. Learned Scalar Scaling: h <- s * h + B * A * h dengan s diinisialisasi mendekati 1.0
// 4. Cutoff Layer Placement Gate: Menghitung S(p, l) untuk memverifikasi lapisan sebelum threshold limit

export interface LoRALayerConfig {
  layerIndex: number;
  hiddenDim: number;
  rank: number; // default r = 8
  alpha: number; // default alpha = 16
  initScale?: number; // learned scalar s, default ~1.0006
}

export interface RelayInterventionGate {
  modelName: string;
  totalLayers: number;
  predictedCutoffLayer: number;
  recommendedLoRALayer: number;
}

export class RelayLoRAModule {
  public readonly layerIndex: number;
  public readonly hiddenDim: number;
  public readonly rank: number;
  private scale: number;
  private matrixA: Float32Array; // [rank, hiddenDim]
  private matrixB: Float32Array; // [hiddenDim, rank]

  constructor(config: LoRALayerConfig) {
    this.layerIndex = config.layerIndex;
    this.hiddenDim = config.hiddenDim;
    this.rank = config.rank || 8;
    this.scale = config.initScale ?? 1.0006;

    // Inisialisasi Kaiming-uniform untuk A, dan zero initialization untuk B (standar LoRA)
    this.matrixA = new Float32Array(this.rank * this.hiddenDim);
    this.matrixB = new Float32Array(this.hiddenDim * this.rank);
    this.initMatrices();
  }

  private initMatrices(): void {
    const stdDev = 1.0 / Math.sqrt(this.hiddenDim);
    for (let i = 0; i < this.matrixA.length; i++) {
      this.matrixA[i] = (Math.random() * 2 - 1) * stdDev;
    }
    // Matrix B diinisialisasi dengan 0 agar saat inisialisasi awal Delta-W = 0
    this.matrixB.fill(0);
  }

  /**
   * Forward pass residu: h <- s * h + B * A * h
   * Mengaktivasi relay mechanism tanpa merusak representasi bahasa umum
   */
  public forward(hiddenState: Float32Array): Float32Array {
    const out = new Float32Array(this.hiddenDim);

    // 1. Hitung low-rank bottleneck: z = A * h  [rank]
    const z = new Float32Array(this.rank);
    for (let r = 0; r < this.rank; r++) {
      let sum = 0;
      const offsetA = r * this.hiddenDim;
      for (let d = 0; d < this.hiddenDim; d++) {
        sum += this.matrixA[offsetA + d] * hiddenState[d];
      }
      z[r] = sum;
    }

    // 2. Proyeksikan kembali ke dimensi tersembunyi: delta = B * z [hiddenDim]
    // dan tambahkan ke representasi terskala s * h
    for (let d = 0; d < this.hiddenDim; d++) {
      let delta = 0;
      const offsetB = d * this.rank;
      for (let r = 0; r < this.rank; r++) {
        delta += this.matrixB[offsetB + r] * z[r];
      }
      out[d] = this.scale * hiddenState[d] + delta;
    }

    return out;
  }
}

/**
 * Gate evaluator untuk memverifikasi apakah layer yang dipilih memenuhi cutoff threshold
 */
export function evaluateLayerPlacement(
  model: string,
  targetLayer: number,
  cutoffTable: Record
): { isValid: boolean; message: string } {
  const meta = cutoffTable[model];
  if (!meta) {
    return { isValid: true, message: `Model ${model} tidak memiliki profil cutoff terdaftar. Melanjutkan dengan observasi default.` };
  }

  if (targetLayer >= meta.predictedCutoffLayer) {
    return {
      isValid: false,
      message: `[WARNING] Penempatan layer ${targetLayer} melebihi cutoff (${meta.predictedCutoffLayer}) untuk ${model}. Relay tidak akan teraktivasi (drop reach drastis)!`,
    };
  }

  return {
    isValid: true,
    message: `[OPTIMAL] Layer ${targetLayer} berada di zona aman sebelum cutoff ${meta.predictedCutoffLayer}. Relay diperkirakan aktif sempurna.`,
  };
}

7. Implikasi Arsitektural untuk Komputasi AI Generasi Mendatang

Hasil penelitian dari arXiv:2609.36585 membawa implikasi besar bagi perancangan model masa depan, arsitektur agen otonom, dan optimalisasi inferensi:

1. Kapasitas Komputasi yang "Tertidur": Model transformer pretrained default selama ini secara masif under-utilized. Model memiliki bobot dan sirkuit atensi yang mampu melakukan reasoning sangat dalam, namun gagal memicu relay tersebut tanpa sedikit dorongan koordinat representasi di lapisan awal.
2. Alternatif Hemat Biaya untuk Looped Transformers: Model berulang (looped architectures seperti Ouro dan Huginn) yang dirancang untuk menghemat memori GPU sering kali dikritik karena penambahan loop tidak meningkatkan akurasi secara linier. Dengan adanya Tiny LoRA, model 1.4B mampu mengeksekusi hingga 160 baris penalaran (setara komputasi model ratusan lapis).
3. Surgical Adaptation Tanpa Bencana Lupa (Catastrophic Forgetting): Karena hanya satu layer awal yang dimodifikasi dengan matriks rank-8 (66K parameter), nilai Text KL-divergence tetap mendekati nol (KL = 0.005), menjaga 100% kelancaran sintaksis dan pengetahuan umum model.