ActObs 2026: Arsitektur Observation Supervision, Dynamic Entropy Retention, dan Orthogonal Gradient Updates pada Post-Training RL Autonomous AI Agents

1. Paradoks SFT Konvensional: Mengapa Kita Menutup Mata Model dari Respon Lingkungan?

Dalam setiap trajektori agen otonom (seperti coding assistant, DevOps automation, atau browser agent), interaksi selalu terbentuk sebagai rangkaian pasangan aksi dan reaksi: agen menjalankan perintah shell (action a_t), sistem operasi membalas dengan luaran konsol atau galat (observation o_t), lalu agen menentukan langkah penalaran berikutnya.

Namun, seluruh pipeline pelatihan SFT mainstream—mulai dari AgentTuning (ACL 2024), Agent-FLAN, hingga tuning korpus sintetis 2026—mengadopsi asumsi bawaan: karena pada fase deployment agen hanya bertugas mengetikkan aksi dan tidak pernah memproduksi output terminal itu sendiri, maka token observasi harus diberi label mask -100 (diabaikan dari perhitungan loss).

Akibatnya, model SFT konvensional (ActionSFT) menjadi sangat kaku: ia mengalami overconfidence pada sintaks spesifik guru, kehilangan pemahaman mengenai apa yang akan terjadi jika sintaks tersebut sedikit dimodifikasi, dan menderita penurunan entropi yang tajam saat diteruskan ke fase reinforcement learning (RL).

2. Formulasi Matematika ActObs: Loss Masking Invarian Skala dengan Parameter Lambda

ActObs (Action & Observation Supervision) mendobrak dogma ini dengan mengaktifkan token observasi lingkungan yang sebetulnya sudah ada di dalam sequence pelatihan. Tidak ada rollouts baru yang perlu diambil, tidak ada forward pass ganda, dan tidak ada penambahan parameter adapter.

Misalkan sebuah lintasan interaksi direpresentasikan sebagai ( au = (x, a_1, o_1, a_2, o_2, dots, a_T, o_T)), di mana (x) adalah task prompt, (a_t) adalah token aksi buatan asisten, dan (o_t) adalah output lingkungan. Himpunan indeks token aksi dinyatakan sebagai (mathcal{A}), sedangkan token observasi dinyatakan sebagai (mathcal{O}). Fungsi objektif ActObs dirumuskan sebagai:

Karakteristik kunci formulasi ini meliputi:

• Invariansi Skala: Penyebut (|mathcal{A}| + lambda |mathcal{O}|) memastikan bahwa skala magnitudo gradien per-sample tetap stabil terlepas dari perubahan nilai hiperparameter (lambda).
• Kontrol Bobot (lambda): Pada (lambda = 0), objektif mereduksi kembali menjadi ActionSFT murni. Pada default (lambda = 1.0), setiap token aksi dan token observasi mendapatkan perlakuan bobot yang setara.
• World Modeling Bebas Biaya: Dengan memprediksi (o_t) terkondisikan pada (a_t) dan riwayat sebelumnya, LLM secara implisit dipaksa membangun internal transition dynamics model (world model teks) pada ruang representasi yang persis sama dengan yang digunakan untuk memilih aksi (a_{t+1}).

3. Geometri Gradien: Ortogonalitas Aliran Aksi vs Observasi dalam Ruang Parameter

Mengapa supervisi observasi menghasilkan dampak yang begitu berbeda dibandingkan hanya menambah lebih banyak demonstrasi aksi? Peneliti melakukan dekomposisi geometris terhadap vektor gradien aksi ((g_{ ext{act}})) dan gradien observasi ((g_{ ext{obs}})) pada 256 trajektori held-out:

Implikasinya krusial: Action-only training tidak pernah secara tidak langsung mengoptimalkan prediksi lingkungan. Lebih buruk lagi, ActionSFT menyebabkan performa cross-entropy prediksi observasi menurun drastis—bahkan berada di bawah performa base model aslinya. ActObs mencegah spesialisasi sepihak ini.

4. Retensi Entropi & Regularisasi Eksplorasi pada Reinforcement Learning (GRPO)

Keunggulan sejati ActObs tidak tampak secara kasat mata pada metrik akurasi SFT tunggal, melainkan meledak saat model dijadikan titik awal (initialization) untuk Reinforcement Learning dengan Group Relative Policy Optimization (GRPO):

• Retensi Entropi Tinggi pada Argumen Perintah: Analisis distribusi token-level mengungkap bahwa setelah GRPO, baik ActionSFT maupun ActObs memiliki ketajaman probabilitas yang sama pada token awal perintah shell (seperti grep, python, qemu). Namun, pada token argumen flags, nama path direktori, dan parameter eksekusi, ActObs mempertahankan entropi yang jauh lebih tinggi.
• Pergerakan Kebijakan Minimal (Smaller Policy Displacement): Uji KL Divergence (D_{ ext{KL}}(pi_{ ext{init}} parallel pi_{ ext{final}})) membuktikan bahwa model ActObs memerlukan pergeseran distribusi bobot yang jauh lebih sedikit dari inisialisasinya untuk mencapai konvergensi reward reward RL tertinggi dibanding model ActionSFT.
• Ketidakberdayaan Temperature Scaling: Eksperimen membuktikan bahwa menaikkan suhu inferensi (temperature (T = 0.64)) pada ActionSFT untuk menyamai angka entropi ActObs tidak membuahkan hasil (+0.0 additional tasks solved). Entropi yang dipertahankan oleh ActObs adalah ketidakpastian struktural yang bermakna kausal, bukan noise acak.

5. Evaluasi Empiris Menyeluruh: Terminal-Bench 2.0 & Cross-Domain Aider-Polyglot

Eksperimen dijalankan pada model Qwen3-4B dan Qwen3-8B menggunakan korpus 50.000 trajektori multi-turn (0.71 miliar token) dari sintesis Nemotron-Terminal-Corpus yang dieksekusi oleh DeepSeek-V3.2. Evaluasi menggunakan 16 attempts per task dengan estimator unbiased pass@k:

6. Implementasi Referensi Produksi: ActObs Loss Masker & Gradient Monitor (PyTorch)

Berikut adalah implementasi referensi industri yang mengonversi pipeline SFT standar menjadi ActObs-compliant training engine lengkap dengan normalisasi pembagi skala dan tracking sudut kosinus gradien ortogonal:

"""
ActObs Production Reference Engine & Loss Masking Implementation (PyTorch / HuggingFace Transformers / GRPO)
Berdasarkan Dokumen Riset Resmi arXiv:2609.20715 (AWS AI Labs & UMD, September 2026)

Komponen Inti:
1. Dynamic Trajectory Loss Mask Builder (Unmasking Environment Observations with Lambda Weighting)
2. Normalized Scale Denominator (|A| + lambda * |O|)
3. Orthogonal Gradient Angle Tracker (Tracking cosine similarity between action and observation gradients)
4. Entropy Retention & KL Divergence Monitor during GRPO Post-Training
"""

import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from dataclasses import dataclass
from typing import Dict, List, Optional, Tuple

@dataclass
class ActObsConfig:
    obs_loss_weight: float = 1.0  # lambda: 0.0 = ActionSFT murni, 1.0 = Default ActObs seimbang
    pad_token_id: int = 0
    action_token_id: int = 32001    # Tag boundary aksi <|action|>
    obs_token_id: int = 32002       # Tag boundary observasi <|obs|>
    prompt_token_id: int = 32000    # Tag boundary system / prompt
    temperature: float = 0.6

class ActObsLossMasker:
    """
    Mengonstruksi loss mask biner dan bobot normalisasi untuk sequence interaksi multi-turn.
    Standar ActionSFT membuang loss pada observasi lingkungan (o_t),
    sementara ActObs mengaktifkan observasi dengan pembobotan lambda terstandarisasi.
    """
    def __init__(self, config: ActObsConfig):
        self.config = config

    def build_loss_weights(
        self,
        token_ids: torch.Tensor,
        action_mask: torch.BoolTensor,
        observation_mask: torch.BoolTensor
    ) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        Menghitung loss weights per token dan skala pembagi normalisasi.
        
        Persamaan 1 arXiv:2609.20715:
        L_lambda(theta) = - [ sum_{i in A} log p(y_i) + lambda * sum_{i in O} log p(y_i) ] / (|A| + lambda * |O|)
        """
        batch_size, seq_len = token_ids.shape
        loss_weights = torch.zeros_like(token_ids, dtype=torch.float32)
        
        # Alokasikan bobot 1.0 untuk token aksi agen
        loss_weights[action_mask] = 1.0
        
        # Alokasikan bobot lambda untuk token respon lingkungan (stdout, traceback, tool return)
        loss_weights[observation_mask] = self.config.obs_loss_weight
        
        # Hitung denominator skala per batch sample untuk menjaga invariansi gradien
        num_action_tokens = action_mask.sum(dim=-1, keepdim=True).float()
        num_obs_tokens = observation_mask.sum(dim=-1, keepdim=True).float()
        denominator = num_action_tokens + self.config.obs_loss_weight * num_obs_tokens
        denominator = torch.clamp(denominator, min=1.0)
        
        normalized_weights = loss_weights / denominator
        return loss_weights, normalized_weights

class GradientOrthogonalityAnalyzer:
    """
    Menganalisis sudut geometri (cosine similarity) antara gradien aksi dan gradien observasi.
    Memverifikasi temuan riset: c = cos(g_obs, g_act) kolaps ke floor noise ortogonal (~0.05)
    dalam 10-20 step awal SFT, membenarkan kebutuhan supervisi simultan.
    """
    @staticmethod
    def compute_gradient_cosine(
        model: nn.Module,
        loss_action: torch.Tensor,
        loss_observation: torch.Tensor
    ) -> Dict[str, float]:
        # Hitung gradien parsial g_act
        model.zero_grad()
        loss_action.backward(retain_graph=True)
        g_act = [p.grad.clone().detach().flatten() for p in model.parameters() if p.grad is not None]
        g_act_flat = torch.cat(g_act)
        
        # Hitung gradien parsial g_obs
        model.zero_grad()
        loss_observation.backward()
        g_obs = [p.grad.clone().detach().flatten() for p in model.parameters() if p.grad is not None]
        g_obs_flat = torch.cat(g_obs)
        
        # Hitung norma dan cosine similarity
        norm_act = torch.norm(g_act_flat)
        norm_obs = torch.norm(g_obs_flat)
        
        if norm_act == 0 or norm_obs == 0:
            return {"cosine_similarity": 0.0, "norm_ratio": 0.0}
            
        cos_sim = torch.dot(g_act_flat, g_obs_flat) / (norm_act * norm_obs)
        norm_ratio = norm_obs / norm_act
        
        return {
            "cosine_similarity": float(cos_sim.item()),
            "norm_ratio": float(norm_ratio.item())
        }

class ActObsTrainerEngine:
    """
    Training pipeline terpadu yang memadukan ActObs SFT dengan evaluasi rollouts GRPO.
    """
    def __init__(self, model: nn.Module, config: ActObsConfig):
        self.model = model
        self.config = config
        self.masker = ActObsLossMasker(config)

    def forward_sft_step(
        self,
        input_ids: torch.Tensor,
        action_mask: torch.BoolTensor,
        observation_mask: torch.BoolTensor
    ) -> Tuple[torch.Tensor, Dict[str, float]]:
        # Target token di-shift 1 ke kanan
        logits = self.model(input_ids[:, :-1]).logits
        targets = input_ids[:, 1:]
        
        # Shift mask agar sejajar dengan posisi target
        act_mask_shifted = action_mask[:, 1:]
        obs_mask_shifted = observation_mask[:, 1:]
        
        loss_weights, norm_weights = self.masker.build_loss_weights(
            targets, act_mask_shifted, obs_mask_shifted
        )
        
        # Cross entropy loss token demi token
        log_probs = F.log_softmax(logits, dim=-1)
        token_losses = -log_probs.gather(dim=-1, index=targets.unsqueeze(-1)).squeeze(-1)
        
        # Weighted reduction
        weighted_loss = (token_losses * norm_weights).sum()
        
        # Logging metrik per-aliran
        action_loss_scalar = (token_losses * act_mask_shifted).sum() / torch.clamp(act_mask_shifted.sum(), min=1.0)
        obs_loss_scalar = (token_losses * obs_mask_shifted).sum() / torch.clamp(obs_mask_shifted.sum(), min=1.0)
        
        metrics = {
            "total_loss": float(weighted_loss.item()),
            "action_loss": float(action_loss_scalar.item()),
            "observation_loss": float(obs_loss_scalar.item()),
            "active_action_tokens": int(act_mask_shifted.sum().item()),
            "active_obs_tokens": int(obs_mask_shifted.sum().item()),
        }
        
        return weighted_loss, metrics

7. Rekomendasi Rekayasa Post-Training AI Agent 2026

Bagi tim AI engineering, lab riset LLM, dan arsitek autonomous agents yang sedang merancang siklus pelatihan model foundation untuk agen terminal dan coding:

• Hapus Masking pada Respon Lingkungan: Jangan lagi menetapkan ignore_index = -100 pada token keluaran terminal, traceback eksekusi kode, atau data kembalian API perkakas. Berikan loss penuh ((lambda = 1.0)) untuk mempertahankan world-modeling laten.
• Jaga Normalisasi Skala Denominator: Jangan menggunakan rata-rata token standar yang mengaburkan bobot rasio token aksi terhadap observasi. Gunakan pembagi terkalibrasi ((|mathcal{A}| + lambda |mathcal{O}|)) agar gradien tetap invarian terhadap panjang respons terminal.
• Gunakan ActObs Sebagai Inisialisasi Terbaik Menuju RL: Model yang dilatih dengan ActObs merupakan kandidat paling prima untuk algoritma RL seperti GRPO, PPO, dan ECHO karena mempertahankan spektrum variasi tindakan yang jauh lebih kaya tanpa mengalami kolaps mode.
• Uji Transferabilitas Lintas Domain: Evaluasi agen Anda pada tolok ukur di luar habitat latihannya (seperti membuktikan transfer dari terminal CLI ke benchmark polyglot code editing) untuk memastikan ketahanan generalisasi agen dalam skenario nyata.