kernel/modulator.py

"""
GLADIUS v2.0 — Language Modulator

Register Vector (4D): formal↔casual, technical↔simple, concise↔elaborate, warm↔detached
Intent Vector (4D): inform, persuade, comfort, challenge
Silence Gate: scalar 0-1, >threshold = suppress output entirely
Bias Layer: register + intent → vocab-sized logit adjustment
Temporal Gate: time engine modulates ALL outputs — silence, pixel, logit bias

argmax_token S(token | base_logits + register_bias + intent_bias, time)
The modulator reshapes the argmax landscape without replacing knowledge.
Time doesn't just color the input — it gates the output.
"""

import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Optional

from .config import KernelConfig


class Modulator(nn.Module):
    """
    Language modulation system with temporal output gating.

    Derives register and intent from cognitive state (not from prompt tokens).
    Applies as additive logit bias — same candidates, different weighting.

    When temporal embedding is provided, it modulates ALL output heads:
      - Silence gate: time decides when to speak
      - Pixel output: time shifts color
      - Logit bias scale: time controls how strongly register/intent reshape output
    
    The temporal inversion: time flows forward through the input path,
    then gates the output path — closing the loop.
    """

    def __init__(self, config: KernelConfig):
        super().__init__()
        self.config = config

        # Register vector: derived from hidden state
        self.register_head = nn.Sequential(
            nn.Linear(config.hidden_dim, config.hidden_dim // 4),
            nn.SiLU(),
            nn.Linear(config.hidden_dim // 4, config.register_dim),
            nn.Tanh(),  # [-1, 1] for each axis
        )

        # Intent vector: derived from hidden state
        self.intent_head = nn.Sequential(
            nn.Linear(config.hidden_dim, config.hidden_dim // 4),
            nn.SiLU(),
            nn.Linear(config.hidden_dim // 4, config.intent_dim),
            nn.Softmax(dim=-1),  # Distribution over intents
        )

        # Silence gate: scalar decision
        self.silence_head = nn.Sequential(
            nn.Linear(config.hidden_dim, config.hidden_dim // 4),
            nn.SiLU(),
            nn.Linear(config.hidden_dim // 4, 1),
            nn.Sigmoid(),
        )

        # Bias projection: register + intent → vocab logit adjustment
        self.bias_proj = nn.Linear(
            config.register_dim + config.intent_dim,
            config.vocab_size,
            bias=False
        )

        # Bias scale (learnable, starts small)
        self.bias_scale = nn.Parameter(torch.tensor(0.1))

        # Pixel head: RGB output
        self.pixel_head = nn.Sequential(
            nn.Linear(config.hidden_dim, config.hidden_dim // 4),
            nn.SiLU(),
            nn.Linear(config.hidden_dim // 4, 3), # RGB output
            nn.Sigmoid(), # Constrain to [0, 1]
        )

        # === Temporal Output Gate ===
        # Time modulates expression. Three learned projections from temporal embedding:
        #   silence_gate_mod: (hidden_dim → 1) — temporal modulation of silence
        #   pixel_mod: (hidden_dim → 3) — temporal color shift
        #   bias_scale_mod: (hidden_dim → 1) — temporal scaling of logit bias
        # All use Tanh: centered at 0 (no effect), can push positive or negative.
        # Additive on silence/pixel, multiplicative on bias scale.

        self.temporal_silence_mod = nn.Sequential(
            nn.Linear(config.hidden_dim, config.hidden_dim // 8),
            nn.SiLU(),
            nn.Linear(config.hidden_dim // 8, 1),
            nn.Tanh(),  # [-1, +1] — push silence up or down
        )

        self.temporal_pixel_mod = nn.Sequential(
            nn.Linear(config.hidden_dim, config.hidden_dim // 8),
            nn.SiLU(),
            nn.Linear(config.hidden_dim // 8, 3),
            nn.Tanh(),  # [-1, +1] per channel — shift RGB
        )

        self.temporal_bias_mod = nn.Sequential(
            nn.Linear(config.hidden_dim, config.hidden_dim // 8),
            nn.SiLU(),
            nn.Linear(config.hidden_dim // 8, 1),
            nn.Sigmoid(),  # [0, 2] after scaling — can amplify or suppress bias
        )

        # Initialize temporal gates near-zero so they don't disrupt existing checkpoints
        for mod in [self.temporal_silence_mod, self.temporal_pixel_mod, self.temporal_bias_mod]:
            nn.init.zeros_(mod[-2].weight)  # Linear before activation
            nn.init.zeros_(mod[-2].bias)

    def forward(
        self,
        hidden: torch.Tensor,
        output_head: nn.Linear,
        temporal_embedding: Optional[torch.Tensor] = None,
        modality_mask: Optional[torch.Tensor] = None,
    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
        """
        Args:
            hidden: (batch, seq_len, hidden_dim) — final layer output
            output_head: the shared embedding output projection
            temporal_embedding: (batch, hidden_dim) — from TimeEngine, or None
        Returns:
            logits: (batch, seq_len, vocab_size) — temporally modulated logits
            silence: (batch, 1) — temporally gated silence value
            pixel_output: (batch, 3) — temporally shifted RGB values [0, 1]
        """
        # Base logits from output head
        base_logits = output_head(hidden)  # (B, S, V)

        # Derive register and intent from pooled hidden state
        pooled = hidden.mean(dim=1)  # (B, D)
        register = self.register_head(pooled)  # (B, register_dim)
        intent = self.intent_head(pooled)      # (B, intent_dim)
        silence = self.silence_head(pooled)    # (B, 1)
        pixel_output = self.pixel_head(pooled) # (B, 3) - RGB output

        # Compute logit bias
        control = torch.cat([register, intent], dim=-1)  # (B, register_dim + intent_dim)
        bias = self.bias_proj(control)  # (B, V)

        # === Temporal output modulation ===
        if temporal_embedding is not None:
            # Time gates silence: additive shift before final clamp
            t_silence = self.temporal_silence_mod(temporal_embedding)  # (B, 1) in [-1, 1]
            silence = (silence + t_silence * 0.3).clamp(0, 1)  # Scaled, clamped to valid range

            # Time shifts pixel: additive color modulation
            t_pixel = self.temporal_pixel_mod(temporal_embedding)  # (B, 3) in [-1, 1]
            pixel_output = (pixel_output + t_pixel * 0.2).clamp(0, 1)  # Gentle shift, valid RGB

            # Time scales bias: multiplicative on bias strength
            t_bias = self.temporal_bias_mod(temporal_embedding) * 2.0  # (B, 1) in [0, 2]
            bias = bias * self.bias_scale * t_bias  # Time can amplify or suppress register/intent
        else:
            bias = bias * self.bias_scale

        # Apply bias (broadcast across sequence)
        modulated_logits = base_logits + bias.unsqueeze(1)

        return modulated_logits, silence, pixel_output