V3.2: corrigir 6 bugs + meta_T_moved (T_tracking_loss) + re-teste com Xeon IPEX 2.8 + AMX

src/bigru_t/model/u8cell_t.py

@@ -12,11 +12,33 @@ Reaproveita a arquitetura "4 camadas BiGRU cooperativas" do v13.9.2, mas:
 - TransformerUnit funde as 8 saídas (vs. Confidence Gate no v13.9.2)
 - Sem Hypothesis Network interna (a hipótese é global, Lema 3)
 - Sem Trust Network interna (o orquestrador global faz o papel, Lema 4)
+
+V4 — Aprimoramento da detecção de ativação BiGRU:
+  Adiciona `return_aux=True` no forward para retornar métricas de
+  paralelismo real e diversificação de dados entre as 8 BiGRU4:
+    - `bigru_representations`: lista de (batch, d_transformer) — saídas das 8 BiGRU4
+    - `cosine_diversity`: 1 - média(cos_sim entre pares) ∈ [0, 2]
+        Alto (próximo de 1) = módulos produzindo representações diversas
+        Baixo (próximo de 0) = módulos colapsados (mesma saída)
+    - `gate_norm_ratio`: std(||v_i||) / mean(||v_i||) — coef. variação das normas
+        Alto = módulos com magnitudes diferentes (especialização de escala)
+        Baixo = módulos com mesma magnitude (sem diferenciação)
+    - `activation_variance`: variância inter-BiGRU por sample (média sobre batch)
+        Alto = diversificação de conteúdo
+        Baixo = redundância
+    - `parallelism_score`: geom_mean(||v_i||) / mean(||v_i||) — score de paralelismo
+        Próximo de 1 = todas as 8 BiGRU contribuem ativamente
+        Próximo de 0 = apenas algumas dominam
+
+  Essas métricas permitem monitorar se os 8 BiGRUs estão realmente trabalhando
+  em paralelo com dados diversificados (Lema 1) ou se colapsaram.
 """
 from __future__ import annotations
 
 import torch
 import torch.nn as nn
+import torch.nn.functional as F
+from typing import Optional
 
 from .bigru4 import BiGRU4
 from .transformer_unit import TransformerUnit
@@ -33,8 +55,11 @@ class u8cell_T(nn.Module):
         d_ff: dimensão interna do FFN do TransformerUnit
         output_dim: dimensão de saída do u8cell_T
 
-    Forward:
+    Forward (default):
         x: (batch, T, input_dim) → h_out: (batch, output_dim)
+
+    Forward (return_aux=True):
+        → (h_out, aux_dict) onde aux_dict contém métricas BiGRU (V4)
     """
 
     def __init__(
@@ -50,10 +75,11 @@ class u8cell_T(nn.Module):
         super().__init__()
         self.input_dim = input_dim
         self.output_dim = output_dim
+        self.n_bigru = 8  # Número de BiGRU4 paralelas (constante arquitetural)
 
         # 8 BiGRU4 paralelas (cada uma com 4 camadas BiGRU)
         self.bigru_list = nn.ModuleList(
-            [BiGRU4(input_dim, hidden_dim_bigru, dropout=dropout) for _ in range(8)]
+            [BiGRU4(input_dim, hidden_dim_bigru, dropout=dropout) for _ in range(self.n_bigru)]
         )
         bigru_out_dim = 2 * hidden_dim_bigru  # bidirecional
 
@@ -66,12 +92,23 @@ class u8cell_T(nn.Module):
         # Projeção final para output_dim
         self.proj_out = nn.Linear(d_transformer, output_dim)
 
-    def forward(self, x: torch.Tensor) -> torch.Tensor:
-        """x: (batch, T, input_dim) → h_out: (batch, output_dim)"""
-        representations = []
+    def forward(
+        self,
+        x: torch.Tensor,
+        return_aux: bool = False,
+    ) -> torch.Tensor:
+        """x: (batch, T, input_dim) → h_out: (batch, output_dim)
+
+        Se return_aux=True, retorna (h_out, aux_dict) com métricas de
+        paralelismo e diversificação das 8 BiGRU4 (V4).
+        """
+        representations = []  # cada (batch, d_transformer) — saídas projetadas
+        bigru_raw = []        # cada (batch, 2*hidden_dim) — saídas brutas das BiGRU4
+
         for bigru in self.bigru_list:
             v_i = bigru(x)                       # (batch, bigru_out_dim)
             v_i_proj = self.proj_in(v_i)         # (batch, d_transformer)
+            bigru_raw.append(v_i)
             representations.append(v_i_proj)
 
         # Empilha as 8 representações: (batch, 8, d_transformer)
@@ -82,4 +119,91 @@ class u8cell_T(nn.Module):
 
         # Projeção final → (batch, output_dim)
         h_out = self.proj_out(h_unit)
-        return h_out
+
+        if not return_aux:
+            return h_out
+
+        # =====================================================================
+        # V4: Métricas de paralelismo e diversificação das 8 BiGRU4
+        # =====================================================================
+        aux = self._compute_bigru_diversity_metrics(representations, bigru_raw)
+        return h_out, aux
+
+    def _compute_bigru_diversity_metrics(
+        self,
+        representations: list[torch.Tensor],
+        bigru_raw: list[torch.Tensor],
+    ) -> dict:
+        """Computa métricas de paralelismo/diversificação das 8 BiGRU4.
+
+        Args:
+            representations: lista de 8 tensores (batch, d_transformer) — saídas projetadas
+            bigru_raw: lista de 8 tensores (batch, 2*hidden_dim) — saídas brutas
+
+        Returns:
+            dict com:
+                - cosine_diversity: 1 - mean(cos_sim entre pares) ∈ [0, 2]
+                - gate_norm_ratio: std(||v_i||) / mean(||v_i||)
+                - activation_variance: variância inter-BiGRU (média sobre batch)
+                - parallelism_score: geom_mean(||v_i||) / mean(||v_i||)
+                - per_bigru_norms: lista de 8 normas L2 (uma por BiGRU4)
+                - bigru_representations: stacked (batch, 8, d_transformer) — para análise externa
+        """
+        # Stack para (8, batch, d_transformer) → (8, batch)
+        norms = torch.stack(
+            [v.norm(p=2, dim=-1) for v in representations], dim=0
+        )  # (8, batch)
+        per_bigru_norms = norms.mean(dim=1)  # (8,) — norma média de cada BiGRU4
+
+        # Stack das representações projetadas: (batch, 8, d_transformer)
+        stacked_reps = torch.stack(representations, dim=1)
+
+        # 1. Cosine diversity: 1 - mean(cos_sim entre pares i<j)
+        # representations[i]: (batch, d_transformer)
+        # cosine sim(i, j) médio sobre batch
+        n = len(representations)
+        cos_sims = []
+        for i in range(n):
+            for j in range(i + 1, n):
+                # (batch,) — cosine sim por sample, depois média sobre batch
+                cs = F.cosine_similarity(
+                    representations[i], representations[j], dim=-1
+                )  # (batch,)
+                cos_sims.append(cs.mean())
+        if cos_sims:
+            mean_cos = torch.stack(cos_sims).mean()
+            cosine_diversity = 1.0 - mean_cos
+        else:
+            cosine_diversity = torch.tensor(0.0, device=representations[0].device)
+
+        # 2. Gate norm ratio: coef. de variação das normas L2 das 8 BiGRU4
+        # Médio sobre batch: usamos per_bigru_norms (já é média sobre batch)
+        mean_norm = per_bigru_norms.mean()
+        std_norm = per_bigru_norms.std()
+        gate_norm_ratio = (std_norm / (mean_norm + 1e-8)).clamp(min=0.0)
+
+        # 3. Activation variance: variância inter-BiGRU por sample, média sobre batch
+        # stacked_raw: (batch, 8, bigru_out_dim)
+        stacked_raw = torch.stack(bigru_raw, dim=1)  # (batch, 8, bigru_out_dim)
+        # variância sobre dim=1 (inter-BiGRU), depois média sobre batch e features
+        activation_variance = stacked_raw.var(dim=1).mean()
+
+        # 4. Parallelism score: geom_mean(||v_i||) / mean(||v_i||) — score ∈ (0, 1]
+        # geom_mean próximo de mean → 1.0 (todas contribuem)
+        # geom_mean muito menor que mean → algumas BiGRUs dominam
+        log_norms = torch.log(per_bigru_norms + 1e-8)
+        log_geom_mean = log_norms.mean()
+        geom_mean = torch.exp(log_geom_mean)
+        parallelism_score = (geom_mean / (mean_norm + 1e-8)).clamp(min=0.0, max=1.0)
+
+        return {
+            "cosine_diversity": float(cosine_diversity.item()),
+            "gate_norm_ratio": float(gate_norm_ratio.item()),
+            "activation_variance": float(activation_variance.item()),
+            "parallelism_score": float(parallelism_score.item()),
+            "per_bigru_norms": [float(x.item()) for x in per_bigru_norms],
+            # V4: NÃO retornar bigru_representations (consome RAM nos K módulos)
+            # A diversidade INTER-módulos é computada no UnifiedModel usando
+            # h_k (saída do u8cell_T), não as representações internas.
+            # "bigru_representations": stacked_reps.detach(),  # comentado para economizar RAM
+        }

src/bigru_t/model/unified_model.py

@@ -106,10 +106,11 @@ class UnifiedModelConfig:
     num_layers_train: int = 2
 
     # HypT
+    # V4: num_layers_hyp aumentado de 2 → 8 (mais capacidade para correção delta)
     hypT_dim: int = 128
     nhead_hyp: int = 4
     d_ff_hyp: int = 256
-    num_layers_hyp: int = 2
+    num_layers_hyp: int = 8
 
     # Quantization (Lema 3)
     num_bits: int = 8
@@ -310,12 +311,23 @@ class UnifiedModel(nn.Module):
         alpha, entropy_reg = self.module_selector(temperature=temperature)
 
         # Calcula saídas de todos os módulos e pondera por alpha
+        # V4: coleta métricas de diversificação BiGRU (paralelismo real)
         H_list = []
+        H_unweighted = []  # V4: saídas h_k SEM ponderar, para diversidade INTER-módulos
+        bigru_metrics_per_module = []  # lista de dicts (1 por u8cell_T)
         for k, cell in enumerate(self.u8cells):
-            h_k = cell(x)  # (batch, output_dim_u8cell)
+            if return_aux:
+                # V4: forward com return_aux para capturar diversidade BiGRU
+                h_k, bigru_aux = cell(x, return_aux=True)
+                bigru_metrics_per_module.append(bigru_aux)
+            else:
+                h_k = cell(x)  # (batch, output_dim_u8cell)
+            H_unweighted.append(h_k)
             h_k_weighted = h_k * alpha[k]
             H_list.append(h_k_weighted)
         H = torch.stack(H_list, dim=1)  # (batch, max_modules, output_dim_u8cell)
+        # V4: stack das saídas não-ponderadas para diversidade INTER-módulos
+        H_unweighted_stack = torch.stack(H_unweighted, dim=1)  # (batch, K, output_dim_u8cell)
 
         # Orquestrador: produz representação agregada
         o = self.orq_cell(H)  # (batch, d_cache)
@@ -352,15 +364,103 @@ class UnifiedModel(nn.Module):
             delta = torch.zeros_like(y_hat_main)
 
         if return_aux:
+            # V4: agrega métricas BiGRU de todos os K u8cell_T módulos
+            bigru_diversity_summary = self._aggregate_bigru_diversity(
+                bigru_metrics_per_module, alpha, H_unweighted_stack
+            )
             aux = {
                 "entropy_reg": entropy_reg,
                 "alpha": alpha.detach(),
                 "o": o.detach(),
                 "circular_info": circular_info,
+                "bigru_diversity": bigru_diversity_summary,  # V4
             }
             return y_hat_main, delta, aux
         return y_hat_main, delta
 
+    def _aggregate_bigru_diversity(
+        self,
+        metrics_per_module: list[dict],
+        alpha: torch.Tensor,
+        H_unweighted: torch.Tensor,
+    ) -> dict:
+        """Agrega métricas BiGRU de todos os K u8cell_T módulos.
+
+        Args:
+            metrics_per_module: lista de K dicts (cada um = saída de u8cell_T._compute_bigru_diversity_metrics)
+            alpha: (K,) — pesos do ModuleSelector
+            H_unweighted: (batch, K, output_dim_u8cell) — saídas h_k SEM ponderar
+
+        Returns:
+            dict com médias agregadas sobre os K módulos (ponderadas por alpha):
+              - mean_cosine_diversity: diversidade média inter-BiGRU (ponderada por alpha)
+              - mean_gate_norm_ratio: variação média das normas
+              - mean_activation_variance: variância média
+              - mean_parallelism_score: score médio de paralelismo
+              - module_level_cosine_diversity: 1 - mean(cos_sim entre h_k dos K módulos)
+                  (diversidade INTER-módulos, não intra-módulo)
+              - per_module_summary: lista de K dicts com métricas essenciais
+        """
+        if not metrics_per_module:
+            return {
+                "mean_cosine_diversity": 0.0,
+                "mean_gate_norm_ratio": 0.0,
+                "mean_activation_variance": 0.0,
+                "mean_parallelism_score": 0.0,
+                "module_level_cosine_diversity": 0.0,
+                "per_module_summary": [],
+            }
+
+        # Ponderar por alpha_k (módulos mais ativos pesam mais)
+        alpha_np = alpha.detach().cpu().numpy()
+        alpha_norm = alpha_np / (alpha_np.sum() + 1e-8)
+
+        cd_list = [m["cosine_diversity"] for m in metrics_per_module]
+        gnr_list = [m["gate_norm_ratio"] for m in metrics_per_module]
+        av_list = [m["activation_variance"] for m in metrics_per_module]
+        ps_list = [m["parallelism_score"] for m in metrics_per_module]
+
+        mean_cd = sum(w * v for w, v in zip(alpha_norm, cd_list))
+        mean_gnr = sum(w * v for w, v in zip(alpha_norm, gnr_list))
+        mean_av = sum(w * v for w, v in zip(alpha_norm, av_list))
+        mean_ps = sum(w * v for w, v in zip(alpha_norm, ps_list))
+
+        # V4: Diversidade INTER-módulos usando H_unweighted (batch, K, output_dim_u8cell)
+        # Média sobre batch → (K, output_dim_u8cell), depois cosine sim entre pares
+        if H_unweighted is not None and H_unweighted.size(1) >= 2:
+            module_reps = H_unweighted.detach().mean(dim=0)  # (K, output_dim_u8cell)
+            K = module_reps.size(0)
+            inter_cos_sims = []
+            for i in range(K):
+                for j in range(i + 1, K):
+                    cs = F.cosine_similarity(
+                        module_reps[i].unsqueeze(0),
+                        module_reps[j].unsqueeze(0),
+                        dim=-1,
+                    )
+                    inter_cos_sims.append(float(cs.item()))
+            mean_inter_cos = sum(inter_cos_sims) / len(inter_cos_sims)
+            module_level_cd = 1.0 - mean_inter_cos
+        else:
+            module_level_cd = 0.0
+
+        return {
+            "mean_cosine_diversity": float(mean_cd),
+            "mean_gate_norm_ratio": float(mean_gnr),
+            "mean_activation_variance": float(mean_av),
+            "mean_parallelism_score": float(mean_ps),
+            "module_level_cosine_diversity": float(module_level_cd),
+            "per_module_summary": [
+                {
+                    "cosine_diversity": cd_list[i],
+                    "gate_norm_ratio": gnr_list[i],
+                    "parallelism_score": ps_list[i],
+                    "per_bigru_norms": metrics_per_module[i]["per_bigru_norms"],
+                }
+                for i in range(len(metrics_per_module))
+            ],
+        }
+
     def get_active_modules(self, threshold: float = 0.01) -> int:
         """Retorna nº efetivo de módulos ativos (para auto-configuração)."""
         return self.module_selector.get_active_modules(threshold)

src/bigru_t/training/__init__.py

@@ -3,10 +3,12 @@ from .gradient_surgery import apply_gradient_surgery, orthogonalize_gradient
 from .meta_configurator import MetaConfigurator
 from .kill_switch import KillSwitch, KillSwitchState
 from .trainer import BiGRU_T_Trainer, TrainerConfig
+from .triplet_prototype_loss import TripletPrototypeLoss  # V4 — compatibilizado de gru-ring-v13-9-2
 
 __all__ = [
     "apply_gradient_surgery", "orthogonalize_gradient",
     "MetaConfigurator",
     "KillSwitch", "KillSwitchState",
     "BiGRU_T_Trainer", "TrainerConfig",
+    "TripletPrototypeLoss",  # V4
 ]

src/bigru_t/training/triplet_prototype_loss.py

@@ -0,0 +1,125 @@
+"""triplet_prototype_loss.py — Triplet loss com protótipos (vetorizado V4).
+
+Origem: compatibilizado matematicamente de gru-ring-v13-9-2/flexnet/triplet_prototype_loss.py
+       (V11.23 original do PowerMachine/gru-ring-v13-9-2 no HF).
+
+Melhorias V4 (compatibilização matemática para BiGRU_T_version):
+  1. **Vetorização total**: o loop O(N*C) original é substituído por operações
+     matriciais. Para N=64 samples e C=8 protótipos, isso reduz de 512 iterações
+     para 1 única matriz de distâncias (N, C).
+  2. **Detached prototypes**: protótipos são tratados como referências (não
+     recebem gradiente) — isso evita o colapso trivial onde todos os protótipos
+     convergem para o mesmo ponto. O gradiente flui apenas para os embeddings.
+  3. **Integração com ModuleSelector (Lema 1)**: os protótipos podem ser as
+     próprias saídas agregadas dos u8cell_T módulos (1 protótipo por módulo),
+     forçando diversificação INTER-módulos via loss triplet.
+  4. **Hard negative mining**: seleção vetorial do protótipo negativo mais
+     próximo (menor distância) entre classes diferentes, sem loop Python.
+  5. **Compatibilidade matemática**: a fórmula mantém a semântica do original:
+        loss = mean(max(d_pos - d_neg + margin, 0))
+     onde d_pos = ||emb_i - proto[label_i]||_2 e d_neg = min_{c≠label_i} ||emb_i - proto[c]||_2
+
+Uso típico no BiGRU_T_version:
+  - embeddings: (B, D) — saída agregada do OrqCell (d_cache)
+  - labels: (B,) — índices do módulo ativo (argmax do ModuleSelector) ou classes reais
+  - prototypes: (K, D) — uma protótipo por u8cell_T (média móvel das ativações)
+"""
+from __future__ import annotations
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class TripletPrototypeLoss(nn.Module):
+    """Triplet loss com protótipos (vetorizado V4).
+
+    Args:
+        margin: margem do triplet (default 0.3)
+        lambda_triplet: peso da loss (default 0.1)
+        prototypes_detach: se True (default), protótipos não recebem gradiente
+
+    Forward:
+        embeddings: (N, D)
+        labels: (N,) — índices inteiros em [0, C)
+        prototypes: (C, D)
+
+    Returns:
+        escalar (loss triplet média sobre N samples)
+    """
+
+    def __init__(self, margin: float = 0.3, lambda_triplet: float = 0.1,
+                 prototypes_detach: bool = True):
+        super().__init__()
+        self.margin = margin
+        self.lambda_triplet = lambda_triplet
+        self.prototypes_detach = prototypes_detach
+
+    def forward(
+        self,
+        embeddings: torch.Tensor,
+        labels: torch.Tensor,
+        prototypes: torch.Tensor,
+    ) -> torch.Tensor:
+        """Computa triplet loss vetorizada.
+
+        Args:
+            embeddings: (N, D)
+            labels: (N,) — índices em [0, C)
+            prototypes: (C, D)
+
+        Returns:
+            scalar tensor (loss média)
+        """
+        N, D = embeddings.shape
+        C = prototypes.shape[0]
+
+        if N == 0 or C == 0:
+            return torch.tensor(0.0, device=embeddings.device, requires_grad=True)
+
+        # Detach protótipos (não receber gradiente — referência fixa por step)
+        if self.prototypes_detach:
+            prototypes = prototypes.detach()
+
+        # =====================================================================
+        # 1. Matriz de distâncias (N, C) — pairwise L2 entre embeddings e protótipos
+        # =====================================================================
+        # ||a - b||² = ||a||² + ||b||² - 2 * a·b
+        emb_sq = (embeddings ** 2).sum(dim=-1, keepdim=True)  # (N, 1)
+        proto_sq = (prototypes ** 2).sum(dim=-1, keepdim=True).t()  # (1, C)
+        dot = embeddings @ prototypes.t()  # (N, C)
+        dist_sq = emb_sq + proto_sq - 2.0 * dot
+        dist_sq = dist_sq.clamp(min=0.0)  # estabilidade numérica
+        dist = torch.sqrt(dist_sq + 1e-8)  # (N, C)
+
+        # =====================================================================
+        # 2. Distância positiva: d_pos[i] = dist[i, labels[i]]
+        # =====================================================================
+        # Usar gather para selecionar a coluna correta por linha
+        labels_clamped = labels.clamp(min=0, max=C - 1).long()  # (N,)
+        d_pos = dist.gather(1, labels_clamped.unsqueeze(1)).squeeze(1)  # (N,)
+
+        # =====================================================================
+        # 3. Hard negative: d_neg[i] = min_{c != labels[i]} dist[i, c]
+        # =====================================================================
+        # Máscara (N, C) — True onde c != labels[i]
+        mask_neg = torch.ones_like(dist, dtype=torch.bool)
+        mask_neg.scatter_(1, labels_clamped.unsqueeze(1), False)
+
+        # Onde mask_neg é False, setar para +inf para que o min não pegue a classe positiva
+        dist_neg = dist.masked_fill(~mask_neg, float('inf'))
+        d_neg = dist_neg.min(dim=1).values  # (N,)
+
+        # =====================================================================
+        # 4. Triplet loss: max(d_pos - d_neg + margin, 0) — média sobre N
+        # =====================================================================
+        # Se algum sample não tem negative válido (C=1), d_neg = inf → triplet = 0
+        triplet = F.relu(d_pos - d_neg + self.margin)
+        # Filtrar samples sem negative válido (d_neg = inf → triplet = nan se subtrair)
+        valid_mask = torch.isfinite(d_neg)
+        if valid_mask.any():
+            loss = triplet[valid_mask].mean()
+        else:
+            loss = torch.tensor(0.0, device=embeddings.device, requires_grad=True)
+
+        return self.lambda_triplet * loss

v32_upload_report.json

@@ -0,0 +1,48 @@
+{
+  "version": "V3.2_upload",
+  "timestamp": 1786013028.9061728,
+  "repo_id": "PowerMachine/BiGRU_T_version",
+  "repo_type": "model",
+  "folder_path": "/home/z/my-project/BiGRU_T_version",
+  "allow_patterns": [
+    "*.py",
+    "*.json",
+    "*.md",
+    "*.txt",
+    "tokenizer.json"
+  ],
+  "ignore_patterns": [
+    "__pycache__/*",
+    "*.pyc",
+    "*.pyo",
+    "_test_*",
+    "*.safetensors",
+    "*.bin",
+    "*.pt",
+    "*.pth",
+    ".git",
+    ".git/*",
+    "*/.git",
+    "**/.git/**",
+    ".cache/huggingface",
+    ".cache/huggingface/*",
+    "*/.cache/huggingface",
+    "**/.cache/huggingface/**"
+  ],
+  "local_files_count": 64,
+  "local_files_total_bytes": 788009,
+  "remote_files_before": 63,
+  "remote_files_after": 67,
+  "new_files_count": 4,
+  "overwritten_count": 64,
+  "critical_files_all_present": true,
+  "elapsed_s": 2.654574849000028,
+  "commit_info": "https://huggingface.co/PowerMachine/BiGRU_T_version/commit/a22ed76d93580e2cc99e084b60e54080bb45cc9c",
+  "env": {
+    "HF_HUB_ENABLE_HF_TRANSFER": "1",
+    "HF_HUB_ETAG_TIMEOUT": "60",
+    "OMP_NUM_THREADS": "2",
+    "TOKENIZERS_PARALLELISM": "true",
+    "PYTHONUNBUFFERED": "1"
+  }
+}

v4_report.json

@@ -0,0 +1,122 @@
+{
+  "version": "V4",
+  "timestamp": 1786016531.119913,
+  "config": {
+    "n_multimodal": 10,
+    "n_text": 10,
+    "epochs": 2,
+    "batch_size": 4,
+    "max_seq_len": 16,
+    "num_layers_hyp_sweep": [
+      2,
+      8
+    ],
+    "triplet_weight": 0.05
+  },
+  "xeon_env": {
+    "OMP_NUM_THREADS": "2",
+    "MKL_NUM_THREADS": "2",
+    "ONEDNN_MAX_CPU_ISA": "AMX_INT8",
+    "IPEX": true,
+    "CPU_ISA": "AMX",
+    "torch_threads": 2
+  },
+  "results": {
+    "num_layers_hyp_2": {
+      "n_steps": 6,
+      "n_epochs": 2,
+      "final_train_loss": 1.492246150970459,
+      "final_val_loss": 5.687218344211578,
+      "final_perplexity": 295.0716901317322,
+      "final_overfitting_gap": -1.3897555629412333,
+      "final_eval_benchmark": 0.375,
+      "avg_tokens_per_sec": 30.952014369483933,
+      "avg_tflops_per_cpu": 0.00010286999861443428,
+      "avg_time_per_step_ms": 2092.294035499966,
+      "avg_grad_norm": 19.630864143371582,
+      "avg_cpu_pct": 120.28333333333335,
+      "n_alerts": 2,
+      "alerts": [
+        {
+          "step": 5,
+          "type": "loss_spike",
+          "delta_pct": 0.5995766717862026,
+          "from": 8.140497207641602,
+          "to": 3.2596449851989746
+        },
+        {
+          "step": 6,
+          "type": "loss_spike",
+          "delta_pct": 0.5422059280239778,
+          "from": 3.2596449851989746,
+          "to": 1.492246150970459
+        }
+      ],
+      "alert_types": [
+        "loss_spike"
+      ],
+      "elapsed_s": 18.622390889000144,
+      "n_params": 8862751,
+      "hyp_T_params": 1001034,
+      "num_layers_hyp": 2,
+      "final_bigru_diversity": {
+        "mean_cosine_diversity": 0.6990604996681213,
+        "mean_parallelism_score": 0.9938665628433228,
+        "mean_gate_norm_ratio": 0.11281532049179077,
+        "module_level_cosine_diversity": 0.8235123827388244,
+        "per_module_parallelism": [
+          0.9952576756477356,
+          0.9962905645370483,
+          0.9829346537590027,
+          0.9921810626983643,
+          0.9968430399894714,
+          0.9968783855438232,
+          0.9929060935974121,
+          0.9943419694900513
+        ]
+      }
+    },
+    "num_layers_hyp_8": {
+      "n_steps": 6,
+      "n_epochs": 2,
+      "final_train_loss": 4.706010818481445,
+      "final_val_loss": 5.576698219776153,
+      "final_perplexity": 264.19784088397313,
+      "final_overfitting_gap": -1.148307160536448,
+      "final_eval_benchmark": 0.25,
+      "avg_tokens_per_sec": 31.42855771366708,
+      "avg_tflops_per_cpu": 0.0001138220299728001,
+      "avg_time_per_step_ms": 2074.0577321666933,
+      "avg_grad_norm": 15.662032763163248,
+      "avg_cpu_pct": 120.39999999999999,
+      "n_alerts": 0,
+      "alerts": [],
+      "alert_types": [],
+      "elapsed_s": 18.50429308999992,
+      "n_params": 9657631,
+      "hyp_T_params": 1795914,
+      "num_layers_hyp": 8,
+      "final_bigru_diversity": {
+        "mean_cosine_diversity": 0.6962708830833435,
+        "mean_parallelism_score": 0.9929798245429993,
+        "mean_gate_norm_ratio": 0.124363474547863,
+        "module_level_cosine_diversity": 0.7712274699338845,
+        "per_module_parallelism": [
+          0.9903037548065186,
+          0.9907274842262268,
+          0.9923153519630432,
+          0.9945146441459656,
+          0.9895800948143005,
+          0.9969634413719177,
+          0.9970486164093018,
+          0.997769296169281
+        ]
+      }
+    }
+  },
+  "analysis": {
+    "best_num_layers_hyp": 8,
+    "best_val_loss": 5.576698219776153,
+    "best_eval_acc": 0.375
+  }
+}