run_structured.py

import os
import argparse
import random
from dataclasses import dataclass
from typing import Dict, Tuple, List

import yaml
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt


# ============================================================
# Reproducibility
# ============================================================

def set_seed(seed: int = 42):
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)


# ============================================================
# Config
# ============================================================

@dataclass
class Config:
    seed: int = 42
    device: str = "cpu"

    # data
    input_dim: int = 2
    output_dim: int = 1
    overlap_std: float = 0.9

    # regime centers
    center_A: Tuple[float, float] = (2.5, 2.5)
    center_B: Tuple[float, float] = (-2.5, -2.5)
    center_C: Tuple[float, float] = (2.5, -2.5)

    # model
    hidden_dim: int = 64
    num_experts: int = 3
    gate_hidden_dim: int = 64

    # routing softness
    temperature: float = 0.60

    # training
    epochs: int = 220
    lr: float = 2e-3
    weight_decay: float = 1e-5

    # phase-sequence setting
    phase_batch_size: int = 64
    phase_train_cycles: int = 40
    phase_test_cycles: int = 12
    transition_steps: int = 8

    # hybrid delta
    ema_decay: float = 0.80
    err_baseline_momentum: float = 0.85
    w_env: float = 1.0
    w_err: float = 2.0

    # loss weights
    alpha_dogma: float = 0.04
    beta_nomad: float = 0.05
    gamma_diversity: float = 0.08
    lambda_sep: float = 0.08
    lambda_cons: float = 0.03

    # output
    save_dir: str = "outputs_transition"


# ============================================================
# YAML helpers
# ============================================================

def load_yaml_config(path: str) -> dict:
    with open(path, "r", encoding="utf-8") as f:
        data = yaml.safe_load(f)
    return data if data is not None else {}


def build_config_from_yaml(yaml_dict: dict) -> Config:
    runtime = yaml_dict.get("runtime", {})
    training = yaml_dict.get("training", {})
    model = yaml_dict.get("model", {})
    data = yaml_dict.get("data", {})
    loss = yaml_dict.get("loss", {})
    delta = yaml_dict.get("delta", {})

    device_value = runtime.get("device", "auto")
    if device_value == "auto":
        device_value = "cuda" if torch.cuda.is_available() else "cpu"

    cfg = Config(
        seed=runtime.get("seed", 42),
        save_dir=runtime.get("save_dir", "outputs_transition"),
        device=device_value,

        epochs=training.get("epochs", 220),
        lr=training.get("lr", 2e-3),
        weight_decay=training.get("weight_decay", 1e-5),

        hidden_dim=model.get("hidden_dim", 64),
        num_experts=model.get("num_experts", 3),
        gate_hidden_dim=model.get("gate_hidden_dim", 64),
        temperature=model.get("temperature", 0.60),

        overlap_std=data.get("overlap_std", 0.9),
        phase_batch_size=data.get("phase_batch_size", 64),
        phase_train_cycles=data.get("phase_train_cycles", 40),
        phase_test_cycles=data.get("phase_test_cycles", 12),
        transition_steps=data.get("transition_steps", 8),

        alpha_dogma=loss.get("alpha_dogma", 0.04),
        beta_nomad=loss.get("beta_nomad", 0.05),
        gamma_diversity=loss.get("gamma_diversity", 0.08),
        lambda_sep=loss.get("lambda_sep", 0.08),
        lambda_cons=loss.get("lambda_cons", 0.03),

        ema_decay=delta.get("ema_decay", 0.80),
        err_baseline_momentum=delta.get("err_baseline_momentum", 0.85),
        w_env=delta.get("w_env", 1.0),
        w_err=delta.get("w_err", 2.0),
    )
    return cfg


# ============================================================
# Data generation
# ============================================================

REGIME_TO_ID = {"A": 0, "B": 1, "C": 2}
ID_TO_REGIME = {0: "A", 1: "B", 2: "C"}
REGIME_ORDER = ["A", "B", "C"]


def sample_regime_x(regime: str, n: int, std: float, device: str = "cpu") -> torch.Tensor:
    noise = std * torch.randn(n, 2, device=device)

    if regime == "A":
        center = torch.tensor([2.5, 2.5], device=device)
    elif regime == "B":
        center = torch.tensor([-2.5, -2.5], device=device)
    elif regime == "C":
        center = torch.tensor([2.5, -2.5], device=device)
    else:
        raise ValueError(f"Unknown regime: {regime}")

    return noise + center


def regime_function(x: torch.Tensor, regime: str) -> torch.Tensor:
    x1 = x[:, 0]
    x2 = x[:, 1]

    if regime == "A":
        y = x1 + x2
    elif regime == "B":
        y = x1 - x2
    elif regime == "C":
        y = -x1 + 0.5 * x2
    else:
        raise ValueError(f"Unknown regime: {regime}")

    return y.unsqueeze(-1)


def generate_phase_sequence(cfg: Config, cycles: int, device: str = "cpu"):
    """
    Creates a time-ordered sequence:
      stable A -> transition A->B -> stable B -> transition B->C -> stable C -> transition C->A -> ...
    Returns:
      X, Y, R, phase_tags
    """
    xs, ys, rs = [], [], []
    phase_tags: List[str] = []

    for _ in range(cycles):
        for i in range(len(REGIME_ORDER)):
            curr_r = REGIME_ORDER[i]
            next_r = REGIME_ORDER[(i + 1) % len(REGIME_ORDER)]

            # stable block
            x_stable = sample_regime_x(curr_r, cfg.phase_batch_size, std=cfg.overlap_std, device=device)
            y_stable = regime_function(x_stable, curr_r)
            r_stable = torch.full((cfg.phase_batch_size,), REGIME_TO_ID[curr_r], dtype=torch.long, device=device)

            xs.append(x_stable)
            ys.append(y_stable)
            rs.append(r_stable)
            phase_tags.extend([f"stable_{curr_r}"] * cfg.phase_batch_size)

            # transition block
            for step in range(cfg.transition_steps):
                alpha = (step + 1) / cfg.transition_steps

                x_a = sample_regime_x(curr_r, cfg.phase_batch_size, std=cfg.overlap_std, device=device)
                x_b = sample_regime_x(next_r, cfg.phase_batch_size, std=cfg.overlap_std, device=device)
                x_mix = (1.0 - alpha) * x_a + alpha * x_b

                y_a = regime_function(x_mix, curr_r)
                y_b = regime_function(x_mix, next_r)
                y_mix = (1.0 - alpha) * y_a + alpha * y_b

                dominant = curr_r if alpha < 0.5 else next_r
                r_mix = torch.full((cfg.phase_batch_size,), REGIME_TO_ID[dominant], dtype=torch.long, device=device)

                xs.append(x_mix)
                ys.append(y_mix)
                rs.append(r_mix)
                phase_tags.extend([f"transition_{curr_r}_to_{next_r}"] * cfg.phase_batch_size)

    X = torch.cat(xs, dim=0)
    Y = torch.cat(ys, dim=0)
    R = torch.cat(rs, dim=0)

    return X, Y, R, phase_tags


def iterate_sequence_minibatches(X: torch.Tensor, Y: torch.Tensor, R: torch.Tensor, batch_size: int):
    """
    No shuffling. Preserves phase order.
    """
    n = X.size(0)
    for start in range(0, n, batch_size):
        end = min(start + batch_size, n)
        yield X[start:end], Y[start:end], R[start:end]


# ============================================================
# Models
# ============================================================

class MLPRegressor(nn.Module):
    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, output_dim),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.net(x)


class Expert(nn.Module):
    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, output_dim),
        )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.net(x)


class GateNet(nn.Module):
    def __init__(self, input_dim: int, gate_hidden_dim: int, num_experts: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim + 1, gate_hidden_dim),  # x + delta_hybrid
            nn.ReLU(),
            nn.Linear(gate_hidden_dim, gate_hidden_dim),
            nn.ReLU(),
            nn.Linear(gate_hidden_dim, num_experts),
        )

    def forward(self, x: torch.Tensor, delta_hybrid: torch.Tensor, temperature: float):
        gate_input = torch.cat([x, delta_hybrid], dim=-1)
        logits = self.net(gate_input)
        probs = F.softmax(logits / temperature, dim=-1)
        return probs, logits


class NomadicMoE(nn.Module):
    def __init__(self, input_dim: int, hidden_dim: int, output_dim: int, num_experts: int, gate_hidden_dim: int):
        super().__init__()
        self.num_experts = num_experts
        self.experts = nn.ModuleList([
            Expert(input_dim, hidden_dim, output_dim) for _ in range(num_experts)
        ])
        self.gate = GateNet(input_dim, gate_hidden_dim, num_experts)

    def forward(self, x: torch.Tensor, delta_hybrid: torch.Tensor, temperature: float):
        gate_probs, gate_logits = self.gate(x, delta_hybrid, temperature)
        expert_outputs = torch.stack([expert(x) for expert in self.experts], dim=1)  # [B, E, 1]
        y_hat = (gate_probs.unsqueeze(-1) * expert_outputs).sum(dim=1)               # [B, 1]
        return y_hat, gate_probs, gate_logits, expert_outputs


# ============================================================
# Hybrid Delta utilities
# ============================================================

class HybridDeltaTracker:
    """
    Upgraded hybrid delta:
      delta_env = input mean shift
      delta_err = relu(err_ema - err_baseline)
      raw_hybrid = w_env * delta_env + w_err * delta_err
      delta_hybrid = tanh(raw_hybrid)
    """
    def __init__(
        self,
        ema_decay: float = 0.8,
        err_baseline_momentum: float = 0.85,
        w_env: float = 1.0,
        w_err: float = 2.0,
        device: str = "cpu",
    ):
        self.ema_decay = ema_decay
        self.err_baseline_momentum = err_baseline_momentum
        self.w_env = w_env
        self.w_err = w_err
        self.device = device

        self.prev_x_mean = None
        self.err_ema = None
        self.err_baseline = None

        self.delta_env_history = []
        self.delta_err_history = []
        self.delta_hybrid_raw_history = []
        self.delta_hybrid_history = []

    def reset(self):
        self.prev_x_mean = None
        self.err_ema = None
        self.err_baseline = None

    def compute(self, x: torch.Tensor, current_batch_mse: torch.Tensor):
        x_mean = x.mean(dim=0, keepdim=True)

        if self.prev_x_mean is None:
            delta_env_scalar = torch.tensor(0.0, device=self.device)
        else:
            delta_env_scalar = torch.norm(x_mean - self.prev_x_mean, p=2)

        batch_err = current_batch_mse.detach()

        if self.err_ema is None:
            self.err_ema = batch_err
            self.err_baseline = batch_err
            delta_err_scalar = torch.tensor(0.0, device=self.device)
        else:
            self.err_ema = self.ema_decay * self.err_ema + (1.0 - self.ema_decay) * batch_err
            self.err_baseline = (
                self.err_baseline_momentum * self.err_baseline
                + (1.0 - self.err_baseline_momentum) * self.err_ema
            )
            delta_err_scalar = torch.relu(self.err_ema - self.err_baseline)

        raw_hybrid = self.w_env * delta_env_scalar + self.w_err * delta_err_scalar
        delta_hybrid_scalar = torch.tanh(raw_hybrid)

        self.prev_x_mean = x_mean.detach()

        self.delta_env_history.append(float(delta_env_scalar.item()))
        self.delta_err_history.append(float(delta_err_scalar.item()))
        self.delta_hybrid_raw_history.append(float(raw_hybrid.item()))
        self.delta_hybrid_history.append(float(delta_hybrid_scalar.item()))

        delta_hybrid = torch.full((x.size(0), 1), float(delta_hybrid_scalar.item()), device=self.device)
        return (
            delta_hybrid,
            float(delta_env_scalar.item()),
            float(delta_err_scalar.item()),
            float(delta_hybrid_scalar.item()),
        )


# ============================================================
# Regularizers / metrics
# ============================================================

def compute_diversity_loss(expert_outputs: torch.Tensor) -> torch.Tensor:
    num_experts = expert_outputs.size(1)
    if num_experts < 2:
        return torch.tensor(0.0, device=expert_outputs.device)

    loss = 0.0
    count = 0
    for i in range(num_experts):
        for j in range(i + 1, num_experts):
            sim = F.cosine_similarity(
                expert_outputs[:, i, :],
                expert_outputs[:, j, :],
                dim=-1
            ).mean()
            loss = loss + sim
            count += 1
    return loss / count


def compute_dogma_penalty(gate_probs: torch.Tensor) -> torch.Tensor:
    mean_usage = gate_probs.mean(dim=0)
    concentration = torch.sum(mean_usage ** 2)
    uniform_floor = 1.0 / gate_probs.size(1)
    penalty = concentration - uniform_floor
    return penalty


def compute_nomad_bonus(gate_probs: torch.Tensor) -> torch.Tensor:
    eps = 1e-8
    entropy = -(gate_probs * (gate_probs + eps).log()).sum(dim=-1).mean()
    return entropy


def gate_entropy(gate_probs: torch.Tensor) -> torch.Tensor:
    eps = 1e-8
    return -(gate_probs * (gate_probs + eps).log()).sum(dim=-1)


def regimewise_usage(gate_probs: torch.Tensor, regime_ids: torch.Tensor, num_experts: int) -> Dict[str, np.ndarray]:
    usage = {}
    top1 = gate_probs.argmax(dim=-1)

    for rid in range(3):
        mask = regime_ids == rid
        regime_name = ID_TO_REGIME[rid]
        if mask.sum() == 0:
            usage[regime_name] = np.zeros(num_experts, dtype=np.float32)
            continue

        counts = torch.bincount(top1[mask], minlength=num_experts).float()
        counts = counts / counts.sum().clamp_min(1.0)
        usage[regime_name] = counts.detach().cpu().numpy()

    return usage


def compute_regime_gate_stats(
    gate_probs: torch.Tensor,
    regime_ids: torch.Tensor,
    num_regimes: int = 3,
):
    device = gate_probs.device
    regime_means = {}
    valid_means = []
    valid_names = []

    l_cons = torch.tensor(0.0, device=device)
    valid_regime_count = 0

    for rid in range(num_regimes):
        mask = regime_ids == rid
        regime_name = ID_TO_REGIME[rid]

        if mask.sum() == 0:
            continue

        g_r = gate_probs[mask]
        u_r = g_r.mean(dim=0)
        regime_means[regime_name] = u_r
        valid_means.append(u_r)
        valid_names.append(regime_name)

        l_cons = l_cons + ((g_r - u_r.unsqueeze(0)) ** 2).sum(dim=-1).mean()
        valid_regime_count += 1

    if valid_regime_count > 0:
        l_cons = l_cons / valid_regime_count

    if len(valid_means) < 2:
        l_sep = torch.tensor(0.0, device=device)
        mean_gate_distance = 0.0
        pairwise_distances = {}
        return regime_means, l_sep, l_cons, mean_gate_distance, pairwise_distances

    pairwise = []
    pairwise_distances = {}

    for i in range(len(valid_means)):
        for j in range(i + 1, len(valid_means)):
            dist = torch.norm(valid_means[i] - valid_means[j], p=2)
            pairwise.append(dist)
            pairwise_distances[f"{valid_names[i]}-{valid_names[j]}"] = float(dist.detach().cpu().item())

    pairwise_tensor = torch.stack(pairwise)
    mean_gate_distance = float(pairwise_tensor.mean().detach().cpu().item())
    l_sep = -pairwise_tensor.mean()

    return regime_means, l_sep, l_cons, mean_gate_distance, pairwise_distances


def mse_by_regime(y_true: torch.Tensor, y_pred: torch.Tensor, regime_ids: torch.Tensor) -> Dict[str, float]:
    result = {}
    for rid in range(3):
        mask = regime_ids == rid
        regime_name = ID_TO_REGIME[rid]
        if mask.sum() == 0:
            result[regime_name] = float("nan")
        else:
            result[regime_name] = F.mse_loss(y_pred[mask], y_true[mask]).item()
    return result


def infer_regime_to_expert(usage: Dict[str, np.ndarray]) -> Dict[str, int]:
    mapping = {}
    for regime in ["A", "B", "C"]:
        mapping[regime] = int(np.argmax(usage[regime]))
    return mapping


def compute_dwell_times(top1_sequence: np.ndarray) -> List[int]:
    if len(top1_sequence) == 0:
        return []

    dwells = []
    current = top1_sequence[0]
    run_len = 1

    for t in range(1, len(top1_sequence)):
        if top1_sequence[t] == current:
            run_len += 1
        else:
            dwells.append(run_len)
            current = top1_sequence[t]
            run_len = 1
    dwells.append(run_len)
    return dwells


def compute_switch_latency(regime_seq: List[str], top1_seq: np.ndarray, regime_to_expert: Dict[str, int]) -> List[int]:
    latencies = []
    prev_regime = regime_seq[0] if len(regime_seq) > 0 else None

    for t in range(1, len(regime_seq)):
        curr_regime = regime_seq[t]
        if curr_regime != prev_regime:
            target_expert = regime_to_expert.get(curr_regime, None)
            if target_expert is None:
                prev_regime = curr_regime
                continue

            latency = None
            for k in range(t, len(top1_seq)):
                if int(top1_seq[k]) == int(target_expert):
                    latency = k - t
                    break

            if latency is not None:
                latencies.append(latency)

        prev_regime = curr_regime

    return latencies


# ============================================================
# Training / Evaluation
# ============================================================

def evaluate_fixed(model: nn.Module, X: torch.Tensor, Y: torch.Tensor, R: torch.Tensor):
    model.eval()
    with torch.no_grad():
        y_pred = model(X)
        total_mse = F.mse_loss(y_pred, Y).item()
        per_regime = mse_by_regime(Y, y_pred, R)
    return total_mse, per_regime


def evaluate_nomadic_static_full(model: NomadicMoE, X: torch.Tensor, Y: torch.Tensor, R: torch.Tensor, cfg: Config):
    """
    Static evaluation:
    - delta_hybrid fixed to zero
    - ignores sequential phase dynamics
    Useful for checking static separability only.
    """
    model.eval()
    with torch.no_grad():
        delta_hybrid = torch.zeros((X.size(0), 1), device=X.device)
        y_pred, gate_probs, _, _ = model(X, delta_hybrid, cfg.temperature)

        total_mse = F.mse_loss(y_pred, Y).item()
        per_regime = mse_by_regime(Y, y_pred, R)
        usage = regimewise_usage(gate_probs, R, cfg.num_experts)

        _, _, _, mean_gate_distance, pairwise_distances = compute_regime_gate_stats(
            gate_probs=gate_probs,
            regime_ids=R,
            num_regimes=3,
        )

        ent = gate_entropy(gate_probs).mean().item()
        top1 = gate_probs.argmax(dim=-1).detach().cpu().numpy()
        dwell_times = compute_dwell_times(top1)

    return total_mse, per_regime, usage, mean_gate_distance, pairwise_distances, ent, dwell_times, y_pred, gate_probs


def evaluate_nomadic_sequence_dynamics(model: NomadicMoE, X: torch.Tensor, Y: torch.Tensor, R: torch.Tensor, phase_tags: List[str], cfg: Config):
    """
    Sequential evaluation with live hybrid delta.
    Measures:
      - phase-level entropy
      - switch latency
      - dwell times
      - stepwise expert trajectory
    """
    model.eval()
    tracker = HybridDeltaTracker(
        ema_decay=cfg.ema_decay,
        err_baseline_momentum=cfg.err_baseline_momentum,
        w_env=cfg.w_env,
        w_err=cfg.w_err,
        device=cfg.device,
    )
    tracker.reset()

    all_y = []
    all_gate_probs = []
    batch_regimes = []
    batch_phase_tags = []
    batch_entropies = []
    batch_top1 = []

    with torch.no_grad():
        for batch_idx, (xb, yb, rb) in enumerate(iterate_sequence_minibatches(X, Y, R, cfg.phase_batch_size)):
            zero_delta = torch.zeros((xb.size(0), 1), device=cfg.device)
            warm_y, _, _, _ = model(xb, zero_delta, cfg.temperature)
            warm_mse = F.mse_loss(warm_y, yb)

            delta_hybrid, _, _, _ = tracker.compute(xb, warm_mse)
            y_hat, gate_probs, _, _ = model(xb, delta_hybrid, cfg.temperature)

            all_y.append(y_hat)
            all_gate_probs.append(gate_probs)

            dominant_regime = ID_TO_REGIME[int(rb[0].item())]
            batch_regimes.append(dominant_regime)

            phase_tag = phase_tags[batch_idx * cfg.phase_batch_size]
            batch_phase_tags.append(phase_tag)

            ent = gate_entropy(gate_probs).mean().item()
            batch_entropies.append(ent)

            top1 = gate_probs.argmax(dim=-1)
            binc = torch.bincount(top1, minlength=cfg.num_experts).float()
            batch_top1.append(int(torch.argmax(binc).item()))

    Y_hat = torch.cat(all_y, dim=0)
    G = torch.cat(all_gate_probs, dim=0)

    total_mse = F.mse_loss(Y_hat, Y).item()
    usage = regimewise_usage(G, R, cfg.num_experts)
    regime_to_expert = infer_regime_to_expert(usage)

    latencies = compute_switch_latency(batch_regimes, np.array(batch_top1), regime_to_expert)
    dwell_times = compute_dwell_times(np.array(batch_top1))

    stable_entropy = []
    transition_entropy = []
    for tag, ent in zip(batch_phase_tags, batch_entropies):
        if tag.startswith("stable_"):
            stable_entropy.append(ent)
        elif tag.startswith("transition_"):
            transition_entropy.append(ent)

    dynamics = {
        "batch_regimes": batch_regimes,
        "batch_phase_tags": batch_phase_tags,
        "batch_entropies": batch_entropies,
        "batch_top1": batch_top1,
        "switch_latencies": latencies,
        "dwell_times": dwell_times,
        "mean_switch_latency": float(np.mean(latencies)) if len(latencies) > 0 else float("nan"),
        "mean_dwell_time": float(np.mean(dwell_times)) if len(dwell_times) > 0 else float("nan"),
        "stable_entropy_mean": float(np.mean(stable_entropy)) if len(stable_entropy) > 0 else float("nan"),
        "transition_entropy_mean": float(np.mean(transition_entropy)) if len(transition_entropy) > 0 else float("nan"),
        "regime_to_expert": regime_to_expert,
    }

    return total_mse, usage, dynamics, Y_hat, G


def train_fixed(cfg: Config, X_train, Y_train, R_train, X_test, Y_test, R_test):
    model = MLPRegressor(cfg.input_dim, cfg.hidden_dim, cfg.output_dim).to(cfg.device)
    optimizer = torch.optim.Adam(model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)

    train_losses = []
    test_losses = []

    for epoch in range(cfg.epochs):
        model.train()
        epoch_loss = 0.0
        n_batches = 0

        for xb, yb, _ in iterate_sequence_minibatches(X_train, Y_train, R_train, cfg.phase_batch_size):
            optimizer.zero_grad()
            y_hat = model(xb)
            loss = F.mse_loss(y_hat, yb)
            loss.backward()
            optimizer.step()

            epoch_loss += loss.item()
            n_batches += 1

        train_losses.append(epoch_loss / max(n_batches, 1))
        test_mse, _ = evaluate_fixed(model, X_test, Y_test, R_test)
        test_losses.append(test_mse)

        if (epoch + 1) % 25 == 0 or epoch == 0:
            print(f"[Fixed] Epoch {epoch+1:03d}/{cfg.epochs} | Train MSE: {train_losses[-1]:.4f} | Test MSE: {test_mse:.4f}")

    return model, {"train_losses": train_losses, "test_losses": test_losses}


def train_nomadic(cfg: Config, X_train, Y_train, R_train, X_test, Y_test, R_test, phase_tags_test):
    model = NomadicMoE(
        input_dim=cfg.input_dim,
        hidden_dim=cfg.hidden_dim,
        output_dim=cfg.output_dim,
        num_experts=cfg.num_experts,
        gate_hidden_dim=cfg.gate_hidden_dim,
    ).to(cfg.device)

    optimizer = torch.optim.Adam(model.parameters(), lr=cfg.lr, weight_decay=cfg.weight_decay)

    logs = {
        "train_total_losses": [],
        "train_mse_losses": [],
        "train_dogma_losses": [],
        "train_nomad_bonus": [],
        "train_diversity_losses": [],
        "train_sep_losses": [],
        "train_cons_losses": [],
        "train_mean_gate_distance": [],
        "train_entropy": [],
        "test_mse_static": [],
        "test_mse_sequence": [],
        "test_mean_gate_distance_static": [],
        "delta_env": [],
        "delta_err": [],
        "delta_hybrid_raw": [],
        "delta_hybrid": [],
        "test_switch_latency": [],
        "test_transition_entropy": [],
        "test_stable_entropy": [],
    }

    for epoch in range(cfg.epochs):
        model.train()

        tracker = HybridDeltaTracker(
            ema_decay=cfg.ema_decay,
            err_baseline_momentum=cfg.err_baseline_momentum,
            w_env=cfg.w_env,
            w_err=cfg.w_err,
            device=cfg.device,
        )
        tracker.reset()

        epoch_total = 0.0
        epoch_mse = 0.0
        epoch_dogma = 0.0
        epoch_nomad = 0.0
        epoch_diversity = 0.0
        epoch_sep = 0.0
        epoch_cons = 0.0
        epoch_entropy = 0.0
        n_batches = 0

        for xb, yb, rb in iterate_sequence_minibatches(X_train, Y_train, R_train, cfg.phase_batch_size):
            optimizer.zero_grad()

            with torch.no_grad():
                zero_delta = torch.zeros((xb.size(0), 1), device=cfg.device)
                warm_y, _, _, _ = model(xb, zero_delta, cfg.temperature)
                warm_mse = F.mse_loss(warm_y, yb)

            delta_hybrid, de, derr, dh = tracker.compute(xb, warm_mse)
            y_hat, gate_probs, _, expert_outputs = model(xb, delta_hybrid, cfg.temperature)

            mse_loss = F.mse_loss(y_hat, yb)
            dogma_pen = compute_dogma_penalty(gate_probs)
            nomad_bonus = compute_nomad_bonus(gate_probs)
            diversity_loss = compute_diversity_loss(expert_outputs)

            _, sep_loss, cons_loss, _, _ = compute_regime_gate_stats(
                gate_probs=gate_probs,
                regime_ids=rb,
                num_regimes=3,
            )

            entropy_val = gate_entropy(gate_probs).mean()

            total_loss = (
                mse_loss
                + cfg.alpha_dogma * dogma_pen
                - cfg.beta_nomad * nomad_bonus
                + cfg.gamma_diversity * diversity_loss
                + cfg.lambda_sep * sep_loss
                + cfg.lambda_cons * cons_loss
            )

            total_loss.backward()
            optimizer.step()

            epoch_total += total_loss.item()
            epoch_mse += mse_loss.item()
            epoch_dogma += dogma_pen.item()
            epoch_nomad += nomad_bonus.item()
            epoch_diversity += diversity_loss.item()
            epoch_sep += sep_loss.item()
            epoch_cons += cons_loss.item()
            epoch_entropy += entropy_val.item()
            n_batches += 1

            logs["delta_env"].append(de)
            logs["delta_err"].append(derr)
            logs["delta_hybrid"].append(dh)
            logs["delta_hybrid_raw"].append(tracker.delta_hybrid_raw_history[-1])

        logs["train_total_losses"].append(epoch_total / max(n_batches, 1))
        logs["train_mse_losses"].append(epoch_mse / max(n_batches, 1))
        logs["train_dogma_losses"].append(epoch_dogma / max(n_batches, 1))
        logs["train_nomad_bonus"].append(epoch_nomad / max(n_batches, 1))
        logs["train_diversity_losses"].append(epoch_diversity / max(n_batches, 1))
        logs["train_sep_losses"].append(epoch_sep / max(n_batches, 1))
        logs["train_cons_losses"].append(epoch_cons / max(n_batches, 1))
        logs["train_entropy"].append(epoch_entropy / max(n_batches, 1))

        _, _, _, train_gate_dist_full, _, _, _, _, _ = evaluate_nomadic_static_full(
            model, X_train, Y_train, R_train, cfg
        )
        logs["train_mean_gate_distance"].append(train_gate_dist_full)

        test_mse_static, _, _, test_gate_dist_static, _, _, _, _, _ = evaluate_nomadic_static_full(
            model, X_test, Y_test, R_test, cfg
        )
        logs["test_mse_static"].append(test_mse_static)
        logs["test_mean_gate_distance_static"].append(test_gate_dist_static)

        test_mse_sequence, _, dynamics_eval, _, _ = evaluate_nomadic_sequence_dynamics(
            model, X_test, Y_test, R_test, phase_tags_test, cfg
        )
        logs["test_mse_sequence"].append(test_mse_sequence)
        logs["test_switch_latency"].append(dynamics_eval["mean_switch_latency"])
        logs["test_transition_entropy"].append(dynamics_eval["transition_entropy_mean"])
        logs["test_stable_entropy"].append(dynamics_eval["stable_entropy_mean"])

        if (epoch + 1) % 25 == 0 or epoch == 0:
            print(
                f"[Nomadic] Epoch {epoch+1:03d}/{cfg.epochs} | "
                f"Train Total: {logs['train_total_losses'][-1]:.4f} | "
                f"Train MSE: {logs['train_mse_losses'][-1]:.4f} | "
                f"Train GateDist(full): {logs['train_mean_gate_distance'][-1]:.4f} | "
                f"Train Entropy: {logs['train_entropy'][-1]:.4f} | "
                f"Test Static MSE: {test_mse_static:.4f} | "
                f"Test Seq MSE: {test_mse_sequence:.4f} | "
                f"Test Static GateDist: {test_gate_dist_static:.4f} | "
                f"Switch Latency: {dynamics_eval['mean_switch_latency']:.4f}"
            )

    return model, logs


# ============================================================
# Plotting
# ============================================================

def ensure_dir(path: str):
    os.makedirs(path, exist_ok=True)


def plot_dataset(X: torch.Tensor, R: torch.Tensor, save_path: str):
    x = X.detach().cpu().numpy()
    r = R.detach().cpu().numpy()

    plt.figure(figsize=(7, 6))
    for rid, name in ID_TO_REGIME.items():
        mask = r == rid
        plt.scatter(x[mask, 0], x[mask, 1], s=10, alpha=0.45, label=f"Regime {name}")

    plt.title("Phase Dataset in Input Space")
    plt.xlabel("x1")
    plt.ylabel("x2")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_training_curves(fixed_logs: dict, nomadic_logs: dict, save_path: str):
    epochs = np.arange(1, len(fixed_logs["train_losses"]) + 1)

    plt.figure(figsize=(8, 5))
    plt.plot(epochs, fixed_logs["test_losses"], label="Fixed Test MSE")
    plt.plot(epochs, nomadic_logs["test_mse_static"], label="Nomadic Static Test MSE")
    plt.plot(epochs, nomadic_logs["test_mse_sequence"], label="Nomadic Sequence Test MSE")
    plt.xlabel("Epoch")
    plt.ylabel("MSE")
    plt.title("Fixed vs Nomadic Test MSE (Static vs Sequence)")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_nomadic_losses(nomadic_logs: dict, save_path: str):
    epochs = np.arange(1, len(nomadic_logs["train_total_losses"]) + 1)

    plt.figure(figsize=(8, 5))
    plt.plot(epochs, nomadic_logs["train_mse_losses"], label="MSE")
    plt.plot(epochs, nomadic_logs["train_dogma_losses"], label="Dogma")
    plt.plot(epochs, nomadic_logs["train_nomad_bonus"], label="Nomad Bonus")
    plt.plot(epochs, nomadic_logs["train_diversity_losses"], label="Diversity")
    plt.plot(epochs, nomadic_logs["train_sep_losses"], label="Regime Sep")
    plt.plot(epochs, nomadic_logs["train_cons_losses"], label="Regime Cons")
    plt.xlabel("Epoch")
    plt.ylabel("Value")
    plt.title("Nomadic Loss Components")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_delta_trace(nomadic_logs: dict, save_path: str):
    steps = np.arange(1, len(nomadic_logs["delta_env"]) + 1)

    plt.figure(figsize=(8, 5))
    plt.plot(steps, nomadic_logs["delta_env"], label="delta_env")
    plt.plot(steps, nomadic_logs["delta_err"], label="delta_err")
    plt.plot(steps, nomadic_logs["delta_hybrid_raw"], label="delta_hybrid_raw")
    plt.plot(steps, nomadic_logs["delta_hybrid"], label="delta_hybrid_tanh")
    plt.xlabel("Batch Step")
    plt.ylabel("Magnitude")
    plt.title("Hybrid Delta Trace")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_usage_bars(usage: Dict[str, np.ndarray], save_path: str, title: str):
    regimes = ["A", "B", "C"]
    num_experts = len(next(iter(usage.values())))
    x = np.arange(len(regimes))
    width = 0.22

    plt.figure(figsize=(8, 5))
    for e in range(num_experts):
        vals = [usage[r][e] for r in regimes]
        plt.bar(x + e * width - width, vals, width=width, label=f"Expert {e}")

    plt.xticks(x, [f"Regime {r}" for r in regimes])
    plt.ylabel("Top-1 Selection Ratio")
    plt.title(title)
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_gate_heatmap(usage: Dict[str, np.ndarray], save_path: str):
    regimes = ["A", "B", "C"]
    mat = np.stack([usage[r] for r in regimes], axis=0)

    plt.figure(figsize=(6, 4))
    plt.imshow(mat, aspect="auto")
    plt.colorbar(label="Top-1 Selection Ratio")
    plt.yticks(range(len(regimes)), [f"Regime {r}" for r in regimes])
    plt.xticks(range(mat.shape[1]), [f"Expert {i}" for i in range(mat.shape[1])])
    plt.title("Regime-Expert Usage Heatmap")
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_gate_distance_curve(nomadic_logs: dict, save_path: str):
    epochs = np.arange(1, len(nomadic_logs["train_mean_gate_distance"]) + 1)

    plt.figure(figsize=(8, 5))
    plt.plot(epochs, nomadic_logs["train_mean_gate_distance"], label="Train Mean Gate Distance (full)")
    plt.plot(epochs, nomadic_logs["test_mean_gate_distance_static"], label="Test Mean Gate Distance (static)")
    plt.xlabel("Epoch")
    plt.ylabel("Distance")
    plt.title("Regime Mean Gate Distance")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_phase_entropy(dynamics: dict, save_path: str):
    ent = np.array(dynamics["batch_entropies"])
    x = np.arange(len(ent))

    plt.figure(figsize=(10, 4))
    plt.plot(x, ent, label="Batch Gate Entropy")
    plt.xlabel("Batch Index")
    plt.ylabel("Entropy")
    plt.title("Gate Entropy across Phase Sequence")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_expert_trajectory(dynamics: dict, save_path: str):
    top1 = np.array(dynamics["batch_top1"])
    x = np.arange(len(top1))

    plt.figure(figsize=(10, 4))
    plt.plot(x, top1)
    plt.xlabel("Batch Index")
    plt.ylabel("Dominant Expert")
    plt.title("Dominant Expert Trajectory across Phase Sequence")
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_dwell_histogram(dwell_times: List[int], save_path: str):
    plt.figure(figsize=(7, 5))
    bins = min(20, max(5, len(set(dwell_times)) if len(dwell_times) > 0 else 5))
    plt.hist(dwell_times, bins=bins)
    plt.xlabel("Dwell Time")
    plt.ylabel("Count")
    plt.title("Dwell Time Distribution")
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_switch_latency_histogram(latencies: List[int], save_path: str):
    plt.figure(figsize=(7, 5))
    if len(latencies) > 0:
        bins = min(15, max(3, len(set(latencies))))
        plt.hist(latencies, bins=bins)
    plt.xlabel("Switch Latency")
    plt.ylabel("Count")
    plt.title("Switch Latency Distribution")
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_entropy_comparison(nomadic_logs: dict, save_path: str):
    epochs = np.arange(1, len(nomadic_logs["test_transition_entropy"]) + 1)

    plt.figure(figsize=(8, 5))
    plt.plot(epochs, nomadic_logs["test_stable_entropy"], label="Stable Entropy")
    plt.plot(epochs, nomadic_logs["test_transition_entropy"], label="Transition Entropy")
    plt.xlabel("Epoch")
    plt.ylabel("Entropy")
    plt.title("Stable vs Transition Gate Entropy")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_switch_latency_curve(nomadic_logs: dict, save_path: str):
    epochs = np.arange(1, len(nomadic_logs["test_switch_latency"]) + 1)

    plt.figure(figsize=(8, 5))
    plt.plot(epochs, nomadic_logs["test_switch_latency"], label="Mean Switch Latency")
    plt.xlabel("Epoch")
    plt.ylabel("Latency")
    plt.title("Epoch-wise Mean Switch Latency")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


def plot_regime_expert_alignment(dynamics: dict, save_path: str):
    regime_map = {"A": 0, "B": 1, "C": 2}
    regime_vals = np.array([regime_map[r] for r in dynamics["batch_regimes"]])
    expert_vals = np.array(dynamics["batch_top1"])
    x = np.arange(len(regime_vals))

    plt.figure(figsize=(10, 5))
    plt.plot(x, regime_vals, label="Dominant Regime")
    plt.plot(x, expert_vals, label="Dominant Expert")
    plt.xlabel("Batch Index")
    plt.ylabel("Index")
    plt.title("Regime vs Expert Alignment across Phase Sequence")
    plt.legend()
    plt.tight_layout()
    plt.savefig(save_path)
    plt.close()


# ============================================================
# Reporting
# ============================================================

def print_report(
    fixed_total_mse: float,
    fixed_per_regime: Dict[str, float],
    nomadic_static_total_mse: float,
    nomadic_per_regime: Dict[str, float],
    nomadic_usage: Dict[str, np.ndarray],
    nomadic_mean_gate_distance: float,
    nomadic_pairwise_gate_distances: Dict[str, float],
    seq_total_mse: float,
    dynamics: dict,
):
    print("\n" + "=" * 72)
    print("FINAL REPORT")
    print("=" * 72)

    print("\n[Fixed Model]")
    print(f"Total Test MSE: {fixed_total_mse:.6f}")
    for k, v in fixed_per_regime.items():
        print(f"  Regime {k} MSE: {v:.6f}")

    print("\n[Nomadic Model | Static Eval]")
    print(f"Static Total Test MSE: {nomadic_static_total_mse:.6f}")
    for k, v in nomadic_per_regime.items():
        print(f"  Regime {k} MSE: {v:.6f}")

    print("\n[Nomadic Model | Sequence Eval]")
    print(f"Sequence Total Test MSE: {seq_total_mse:.6f}")

    print("\n[Nomadic Regime-wise Expert Usage | Top-1 Ratio]")
    for regime in ["A", "B", "C"]:
        arr = nomadic_usage[regime]
        arr_str = ", ".join([f"E{i}: {p:.3f}" for i, p in enumerate(arr)])
        print(f"  Regime {regime} -> {arr_str}")

    print("\n[Nomadic Mean Gate Distance | Static Full]")
    print(f"Mean pairwise gate-centroid distance: {nomadic_mean_gate_distance:.6f}")
    if len(nomadic_pairwise_gate_distances) > 0:
        print("[Pairwise Gate Distances]")
        for k, v in nomadic_pairwise_gate_distances.items():
            print(f"  {k}: {v:.6f}")

    print("\n[Transition Dynamics]")
    print(f"Regime -> Expert mapping: {dynamics['regime_to_expert']}")
    print(f"Mean switch latency: {dynamics['mean_switch_latency']:.4f}")
    print(f"Mean dwell time: {dynamics['mean_dwell_time']:.4f}")
    print(f"Stable-phase mean entropy: {dynamics['stable_entropy_mean']:.4f}")
    print(f"Transition-phase mean entropy: {dynamics['transition_entropy_mean']:.4f}")

    print("\nInterpretation hint:")
    print("- Sequence Test MSE is the main performance metric in phase-transition settings.")
    print("- Static Test MSE is only a reference check, not the main success criterion.")
    print("- Transition entropy > stable entropy suggests gate uncertainty rises during phase shifts.")
    print("- Shorter switch latency suggests faster nomadic response.")
    print("- Moderate dwell time suggests neither rigid fixation nor chaotic wandering.")
    print("=" * 72 + "\n")


# ============================================================
# Main
# ============================================================

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", type=str, default="config.yaml")
    parser.add_argument("--save_dir", type=str, default=None)
    parser.add_argument("--device", type=str, default=None, choices=["cpu", "cuda", "auto"])
    parser.add_argument("--seed", type=int, default=None)
    args = parser.parse_args()

    yaml_cfg = load_yaml_config(args.config)
    cfg = build_config_from_yaml(yaml_cfg)

    if args.save_dir is not None:
        cfg.save_dir = args.save_dir

    if args.seed is not None:
        cfg.seed = args.seed

    if args.device is not None:
        cfg.device = "cuda" if (args.device == "auto" and torch.cuda.is_available()) else args.device

    ensure_dir(cfg.save_dir)
    set_seed(cfg.seed)

    print(f"Using device: {cfg.device}")
    print(f"Saving outputs to: {cfg.save_dir}")
    print(f"Loaded config from: {args.config}")

    X_train, Y_train, R_train, phase_tags_train = generate_phase_sequence(cfg, cfg.phase_train_cycles, cfg.device)
    X_test, Y_test, R_test, phase_tags_test = generate_phase_sequence(cfg, cfg.phase_test_cycles, cfg.device)

    plot_dataset(X_train, R_train, os.path.join(cfg.save_dir, "phase_dataset_input_space.png"))

    fixed_model, fixed_logs = train_fixed(cfg, X_train, Y_train, R_train, X_test, Y_test, R_test)
    nomadic_model, nomadic_logs = train_nomadic(
        cfg, X_train, Y_train, R_train, X_test, Y_test, R_test, phase_tags_test
    )

    fixed_total_mse, fixed_per_regime = evaluate_fixed(fixed_model, X_test, Y_test, R_test)
    (
        nomadic_static_total_mse,
        nomadic_per_regime,
        nomadic_usage,
        nomadic_mean_gate_distance,
        nomadic_pairwise_gate_distances,
        _,
        _,
        _,
        _,
    ) = evaluate_nomadic_static_full(
        nomadic_model, X_test, Y_test, R_test, cfg
    )

    seq_total_mse, seq_usage, dynamics, _, _ = evaluate_nomadic_sequence_dynamics(
        nomadic_model, X_test, Y_test, R_test, phase_tags_test, cfg
    )

    plot_training_curves(
        fixed_logs,
        nomadic_logs,
        os.path.join(cfg.save_dir, "fixed_vs_nomadic_test_mse.png"),
    )
    plot_nomadic_losses(
        nomadic_logs,
        os.path.join(cfg.save_dir, "nomadic_loss_components.png"),
    )
    plot_delta_trace(
        nomadic_logs,
        os.path.join(cfg.save_dir, "hybrid_delta_trace.png"),
    )
    plot_usage_bars(
        nomadic_usage,
        os.path.join(cfg.save_dir, "regime_expert_usage_bars.png"),
        "Regime-wise Expert Usage (Top-1)",
    )
    plot_gate_heatmap(
        nomadic_usage,
        os.path.join(cfg.save_dir, "regime_expert_usage_heatmap.png"),
    )
    plot_gate_distance_curve(
        nomadic_logs,
        os.path.join(cfg.save_dir, "regime_mean_gate_distance.png"),
    )
    plot_phase_entropy(
        dynamics,
        os.path.join(cfg.save_dir, "phase_gate_entropy.png"),
    )
    plot_expert_trajectory(
        dynamics,
        os.path.join(cfg.save_dir, "expert_trajectory.png"),
    )
    plot_dwell_histogram(
        dynamics["dwell_times"],
        os.path.join(cfg.save_dir, "dwell_time_histogram.png"),
    )
    plot_switch_latency_histogram(
        dynamics["switch_latencies"],
        os.path.join(cfg.save_dir, "switch_latency_histogram.png"),
    )
    plot_entropy_comparison(
        nomadic_logs,
        os.path.join(cfg.save_dir, "stable_vs_transition_entropy.png"),
    )
    plot_switch_latency_curve(
        nomadic_logs,
        os.path.join(cfg.save_dir, "switch_latency_curve.png"),
    )
    plot_regime_expert_alignment(
        dynamics,
        os.path.join(cfg.save_dir, "regime_expert_alignment.png"),
    )

    print_report(
        fixed_total_mse,
        fixed_per_regime,
        nomadic_static_total_mse,
        nomadic_per_regime,
        nomadic_usage,
        nomadic_mean_gate_distance,
        nomadic_pairwise_gate_distances,
        seq_total_mse,
        dynamics,
    )

    print("Saved files:")
    for fname in [
        "phase_dataset_input_space.png",
        "fixed_vs_nomadic_test_mse.png",
        "nomadic_loss_components.png",
        "hybrid_delta_trace.png",
        "regime_expert_usage_bars.png",
        "regime_expert_usage_heatmap.png",
        "regime_mean_gate_distance.png",
        "phase_gate_entropy.png",
        "expert_trajectory.png",
        "dwell_time_histogram.png",
        "switch_latency_histogram.png",
        "stable_vs_transition_entropy.png",
        "switch_latency_curve.png",
        "regime_expert_alignment.png",
    ]:
        print(" -", os.path.join(cfg.save_dir, fname))


if __name__ == "__main__":
    main()