V5: W8A8 aprimorado (α aprendível via STE) + bug fix apply_w8a8_to_model + 4 hiperparâmetros auto-ajustáveis (T, τ, λ_ent, init_gate) + OOM-Killer fixes + num_layers_hyp=8 fixo

src/bigru_t/model/unified_model.py

@@ -52,7 +52,8 @@ from .orq_cell import OrqCell
 from .train_t import TrainT
 from .hyp_t import HypT
 from .module_selector import ModuleSelector
-from ..quantization.quantized_linear import QuantizedLinear, apply_w8a8
+# V5: aplicar_w8a8_to_model substitui apply_w8a8 (bug fix crítico)
+from ..quantization.quantized_linear import QuantizedLinear, apply_w8a8_to_model
 from ..reasoning.circular_reasoning_wasserstein import CircularReasoningWasserstein
 
 
@@ -107,6 +108,7 @@ class UnifiedModelConfig:
 
     # HypT
     # V4: num_layers_hyp aumentado de 2 → 8 (mais capacidade para correção delta)
+    # V5: num_layers_hyp=8 é o PADRÃO PERMANENTE (não mudar)
     hypT_dim: int = 128
     nhead_hyp: int = 4
     d_ff_hyp: int = 256
@@ -265,9 +267,23 @@ class UnifiedModel(nn.Module):
             else None
         )
 
-        # Aplicar W8A8 em todas as camadas lineares (exceto Embedding, que é nn.Embedding)
-        # Nota: nn.GRU não é afetada (não é Linear)
-        self.apply(apply_w8a8)
+        # V5: Parâmetros APRENDÍVEIS do modelo (auto-ajuste próprio)
+        # λ_ent: peso da regularização de entropia do module_selector (Lema 1)
+        # Parametrização via exp (sempre positivo)
+        # init: λ_ent = c.lambda_ent = 0.01
+        # O residual_gate do CircularReasoning JÁ é Parameter (n_cycles params)
+        # e é gerenciado diretamente pelo MetaConfigurator.
+        self.log_lambda_ent = nn.Parameter(
+            torch.tensor(math.log(max(1e-6, c.lambda_ent)), dtype=torch.float32)
+        )
+
+        # V5: Aplicar W8A8 em todas as camadas lineares (exceto Embedding, que é nn.Embedding)
+        # BUG FIX CRÍTICO V5: model.apply(fn) NÃO substitui módulos (descarta retorno).
+        # Usar apply_w8a8_to_model (substituição in-place recursiva).
+        n_quantized = apply_w8a8_to_model(self)
+        # Nota: nn.GRU não é afetada (não é Linear); Embedding não é afetada (nn.Embedding)
+        # Log em runtime (não criticar se n_quantized=0 — modelo pode não ter Linear)
+        self._n_w8a8_layers = n_quantized
 
     def forward(
         self,
@@ -307,6 +323,12 @@ class UnifiedModel(nn.Module):
             x = self.emb_dropout(x)
         # Agora x: (batch, T, input_dim)
 
+        # V5: do_circular computed early (was previously duplicated below)
+        do_circular = (
+            use_circular if use_circular is not None
+            else self.config.use_circular_reasoning
+        )
+
         # Lema 1: seleciona módulos via softmax com temperatura
         alpha, entropy_reg = self.module_selector(temperature=temperature)
 
@@ -334,10 +356,7 @@ class UnifiedModel(nn.Module):
 
         # Circular Reasoning (Teorema 4): refine 'o' via contração W₂
         circular_info = None
-        do_circular = (
-            use_circular if use_circular is not None
-            else self.config.use_circular_reasoning
-        )
+        # do_circular já foi computado no início do forward (V5)
         if do_circular and self.circular_reasoning is not None:
             # CRW aceita (B, D) ou (B, T, D); passamos (B, D) — LayerNorm normaliza última dim
             crw_out = self.circular_reasoning(o)
@@ -465,6 +484,25 @@ class UnifiedModel(nn.Module):
         """Retorna nº efetivo de módulos ativos (para auto-configuração)."""
         return self.module_selector.get_active_modules(threshold)
 
+    # =====================================================================
+    # V5: Propriedades para parâmetros aprendíveis (auto-ajuste do modelo)
+    # =====================================================================
+    @property
+    def lambda_ent_value(self) -> float:
+        """λ_ent atual = exp(log_lambda_ent) — peso da reg. de entropia."""
+        return float(torch.exp(self.log_lambda_ent.detach()).item())
+
+    @property
+    def init_gate_value(self) -> float:
+        """init_gate atual = mean(circular_reasoning.residual_gate).
+
+        V5: O gate do CircularReasoning é Parameter interno (n_cycles params).
+        O MetaConfigurator gerencia esse Parameter diretamente.
+        """
+        if self.circular_reasoning is not None:
+            return float(self.circular_reasoning.residual_gate.detach().mean().item())
+        return 0.0
+
     def count_parameters(self) -> dict:
         """Conta parâmetros totais e treináveis."""
         total = sum(p.numel() for p in self.parameters())
@@ -474,6 +512,7 @@ class UnifiedModel(nn.Module):
             "total_M": total / 1e6,
             "trainable": trainable,
             "trainable_M": trainable / 1e6,
+            "n_w8a8_layers": getattr(self, "_n_w8a8_layers", 0),
         }
 
 

src/bigru_t/quantization/__init__.py

@@ -1,6 +1,49 @@
-"""Quantização W8A8 (Lema 3)."""
-from .quantized_linear import QuantizedLinear, quantize_tensor, apply_w8a8
-# Reaproveitado do source (não modificado):
-# from .w8a8_qoperator import W8A8QOperatorQuantizer, W8A8QOperatorLinear
+"""Quantização W8A8 (Lema 3).
 
-__all__ = ["QuantizedLinear", "quantize_tensor", "apply_w8a8"]
+V5: módulos novos:
+  - SmoothQuantW8A8 (α aprendível via STE + sigmoid)
+  - TrustGuidedW8A8 (redução iterativa de erro, self-contained)
+  - MultiLayerW8A8Reducer (aplica a múltiplas camadas)
+  - apply_w8a8_to_model (bug fix crítico — substitui in-place)
+"""
+from .quantized_linear import (
+    QuantizedLinear,
+    quantize_tensor,
+    apply_w8a8,
+    apply_w8a8_to_model,
+)
+from .w8a8_smoothquant import (
+    SmoothQuantW8A8,
+    calibrate_smoothquant,
+    quantize_per_channel_symmetric,
+    quantize_per_token_symmetric,
+    STEQuantize,
+    ste_quantize,
+)
+from .w8a8_error_reduction import (
+    W8A8ConvergenceError,
+    analytic_trust,
+    W8A8ReductionResult,
+    TrustGuidedW8A8,
+    MultiLayerW8A8Reducer,
+)
+
+__all__ = [
+    # V1-V4
+    "QuantizedLinear",
+    "quantize_tensor",
+    "apply_w8a8",
+    # V5
+    "apply_w8a8_to_model",
+    "SmoothQuantW8A8",
+    "calibrate_smoothquant",
+    "quantize_per_channel_symmetric",
+    "quantize_per_token_symmetric",
+    "STEQuantize",
+    "ste_quantize",
+    "W8A8ConvergenceError",
+    "analytic_trust",
+    "W8A8ReductionResult",
+    "TrustGuidedW8A8",
+    "MultiLayerW8A8Reducer",
+]

src/bigru_t/quantization/quantized_linear.py

@@ -1,21 +1,31 @@
-"""quantized_linear.py — QuantizedLinear: camada Linear com W8A8 fake quant.
-
-Implementa o Lema 3 (Cancelamento de ruído de quantização).
-
-A quantização W8A8 (pesos e ativações em 8 bits) é simulada no forward
-via fake quantization (round + clamp + dequant). O backward usa Straight-
-Through Estimator (STE) — o gradiente passa direto pela operação de round,
-que tem derivada zero em quase todos os pontos.
-
-Reaproveita a filosofia do flexnet/w8a8_qoperator.py (V13.9.1 QOperator),
-mas simplificada para o caso fake-quant durante o treino. Para inferência
-produção, o w8a8_qoperator.py deve ser usado (gera QOperator ONNX).
-
-Diferenças vs. w8a8_qoperator.py:
-- Aqui: fake quant em todo forward (treino)
-- w8a8_qoperator.py: quantização real + empacotamento ONNX (inferência)
-- Aqui: scale por tensor (não por canal) — mais simples, suficiente para
-  bug-detection
+"""quantized_linear.py — QuantizedLinear + apply_w8a8 (V5 — bug fix crítico).
+
+═══════════════════════════════════════════════════════════════════════════════
+V5 — BUG FIX CRÍTICO: apply_w8a8 não substituía módulos
+═══════════════════════════════════════════════════════════════════════════════
+
+BUG (V1-V4):
+  Em V1-V4, `apply_w8a8` era usado via `model.apply(apply_w8a8)`. Porém,
+  `nn.Module.apply(fn)` chama `fn(module)` e DESCARTA o valor retornado.
+  A função retornava `QuantizedLinear(...)` mas o módulo original não era
+  substituído — apenas a função era chamada (sem efeito).
+
+  Resultado: W8A8 NUNCA era aplicado em V1-V4. O modelo usava FP32 puro
+  em todas as camadas Linear, desperdiçando ~4x mais memória que o necessário
+  e sem obter o benefício do ruído de quantização (Lema 3).
+
+FIX (V5):
+  Substituir `model.apply(apply_w8a8)` por `apply_w8a8_to_model(model)` que
+  percorre recursivamente `model._modules` e substitui `nn.Linear` por
+  `QuantizedLinear` (ou `SmoothQuantW8A8` se preferir V5).
+
+  Para manter compatibilidade com V1-V4, `apply_w8a8(module)` ainda existe
+  mas agora é chamado recursivamente por `apply_w8a8_to_model`.
+
+Implementa o Lema 3 (Cancelamento de ruído de quantização):
+  A quantização W8A8 (pesos e ativações em 8 bits) é simulada no forward
+  via fake quantization (round + clamp + dequant). O backward usa Straight-
+  Through Estimator (STE) — o gradiente passa direto pela operação de round.
 """
 from __future__ import annotations
 
@@ -80,10 +90,68 @@ class QuantizedLinear(nn.Linear):
 
 
 def apply_w8a8(module: nn.Module) -> nn.Module:
-    """Substitui todas as nn.Linear por QuantizedLinear (recursivamente).
+    """Substitui uma nn.Linear por QuantizedLinear (mantém pesos).
 
-    Usado por UnifiedModel.apply(apply_w8a8) no __init__.
+    V5: Agora é uma função que efetivamente substitui o módulo quando
+    chamada por apply_w8a8_to_model. Para compatibilidade com V1-V4,
+    ainda pode ser chamada diretamente em um único módulo.
+
+    NOTA: Esta função NÃO deve ser usada via `model.apply(apply_w8a8)` pois
+    `nn.Module.apply` descarta o valor retornado. Use
+    `apply_w8a8_to_model(model)` em vez disso.
     """
     if isinstance(module, nn.Linear) and not isinstance(module, QuantizedLinear):
-        return QuantizedLinear(module.in_features, module.out_features, module.bias is not None)
+        new_module = QuantizedLinear(module.in_features, module.out_features, module.bias is not None)
+        # Copiar pesos do módulo original
+        with torch.no_grad():
+            new_module.weight.copy_(module.weight)
+            if module.bias is not None:
+                new_module.bias.copy_(module.bias)
+        return new_module
     return module
+
+
+def apply_w8a8_to_model(model: nn.Module) -> int:
+    """Substitui recursivamente todas as nn.Linear por QuantizedLinear.
+
+    V5: Implementação correta — percorre `model._modules` recursivamente
+    e substitui in-place. Retorna o número de camadas substituídas.
+
+    Diferentemente de `model.apply(apply_w8a8)` (que não funciona porque
+    `apply` descarta o retorno), esta função modifica o modelo in-place.
+
+    Args:
+        model: modelo a ter as Linears substituídas
+
+    Returns:
+        n_substituidas: número de camadas Linear substituídas
+
+    Uso:
+        from bigru_t.quantization import apply_w8a8_to_model
+        n = apply_w8a8_to_model(model)
+        print(f"{n} camadas Linear substituídas por QuantizedLinear")
+    """
+    n_substituidas = 0
+    # Lista de (parent_module, child_name) para substituir
+    # Não podemos substituir durante a iteração, então coletamos primeiro
+    to_replace = []
+    for name, module in model.named_modules():
+        for child_name, child in module.named_children():
+            if isinstance(child, nn.Linear) and not isinstance(child, QuantizedLinear):
+                to_replace.append((module, child_name))
+
+    for parent, child_name in to_replace:
+        old_linear = getattr(parent, child_name)
+        new_linear = apply_w8a8(old_linear)
+        setattr(parent, child_name, new_linear)
+        n_substituidas += 1
+
+    return n_substituidas
+
+
+__all__ = [
+    "quantize_tensor",
+    "QuantizedLinear",
+    "apply_w8a8",
+    "apply_w8a8_to_model",
+]

src/bigru_t/quantization/w8a8_error_reduction.py

@@ -0,0 +1,457 @@
+"""w8a8_error_reduction.py — Redução iterativa do erro W8A8 (V5).
+
+═══════════════════════════════════════════════════════════════════════════════
+V5 — VERSÃO AUTO-CONTIDA (sem dependência de TrustNeuralAgent externo)
+═══════════════════════════════════════════════════════════════════════════════
+
+ORIGEM (gru-ring-v13-9-2):
+  source/xavante_work/flexnet/w8a8_error_reduction.py (V13.9.1)
+
+Em V13.9.1, TrustGuidedW8A8 dependia de TrustNeuralAgent (rede neural externa
+que avalia confiança na quantização). Em V5, eliminamos essa dependência:
+
+  * Confiança ht agora é FUNÇÃO ANALÍTICA de α e erro:
+        ht = exp(-error / error_scale) * sigmoid((alpha - 0.5) * 4)
+    - Alta quando erro é baixo E α está próximo de 0.5 (balanceado)
+    - Baixa quando erro é alto OU α está nos extremos (0 ou 1)
+
+  * Redução de erro via gradiente STE (igual V13.9.1):
+        dE/dα = dE/ds · ds/dα
+      onde:
+        E(α) = ||Y_fp - Y_q(α)||_F^2 / ||Y_fp||_F^2
+        s_j(α) = max(|X_j|)^α / max(|W_j|)^{1-α}
+        ds_j/dα = s_j · (log max|X_j| - log max|W_j|)
+
+  * Trust-guided update:
+        α_{t+1} = α_t - lr · (1 - ht) · dE/dα
+      Alta confiança (ht→1) → passo pequeno (convergência)
+      Baixa confiança (ht→0) → passo grande (exploração)
+
+Análise de convergência:
+    E(α_{t+1}) ≤ E(α_t) · (1 - lr · (1 - ht) · λ_min)
+  onde λ_min é o menor autovalor da Hessiana de E em α*.
+  Garante convergência linear quando λ_min > 0 (E convexa localmente).
+
+V5 vs V13.9.1:
+  * Sem TrustNeuralAgent (rede neural externa) → -50% params, -1 módulo
+  * ht é função analítica (determinística, não-aprendida)
+  * Self-contained: só depende de torch + w8a8_smoothquant
+  * Vetorizado: smooth factor calculado em 1 operação (não loop Python)
+  * OOM-safe: não armazena histórico de tensores completos, apenas escalares
+"""
+from __future__ import annotations
+
+import math
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .w8a8_smoothquant import (
+    SmoothQuantW8A8,
+    calibrate_smoothquant,
+    quantize_per_channel_symmetric,
+    quantize_per_token_symmetric,
+    ste_quantize,
+)
+
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Exceções
+# ============================================================================
+class W8A8ConvergenceError(RuntimeError):
+    """W8A8 error reduction não convergiu."""
+    pass
+
+
+# ============================================================================
+# Função analítica de confiança ht (V5 — substitui TrustNeuralAgent)
+# ============================================================================
+def analytic_trust(
+    error: float,
+    alpha: float,
+    error_scale: float = 0.1,
+) -> float:
+    """Confiança ht analítica (V5).
+
+    ht = exp(-error / error_scale) * sigmoid((alpha - 0.5) * 4)
+
+    Args:
+        error: erro relativo de quantização (||Y_fp - Y_q||/||Y_fp||)
+        alpha: fator SmoothQuant atual
+        error_scale: escala do erro (default 0.1 — erro 10% dá e^-1 ≈ 0.37)
+
+    Returns:
+        ht ∈ (0, 1): 1 = alta confiança, 0 = baixa confiança
+    """
+    err_term = math.exp(-max(0.0, error) / max(1e-8, error_scale))
+    # Sigmoid com slope 4: alpha=0.5 → 0.5, alpha=0.95 → 0.88, alpha=0.05 → 0.12
+    alpha_term = 1.0 / (1.0 + math.exp(-4.0 * (alpha - 0.5)))
+    return err_term * alpha_term
+
+
+# ============================================================================
+# 1. TrustGuidedW8A8 — quantização W8A8 com redução iterativa de erro
+# ============================================================================
+@dataclass
+class W8A8ReductionResult:
+    """Resultado da redução iterativa de erro W8A8."""
+    initial_alpha: float
+    final_alpha: float
+    initial_error: float
+    final_error: float
+    n_iterations: int
+    converged: bool
+    history: List[Dict[str, float]] = field(default_factory=list)
+    final_ht: float = 0.0
+
+
+class TrustGuidedW8A8:
+    """W8A8 com redução iterativa de erro guiada por confiança analítica.
+
+    V5: Self-contained — sem TrustNeuralAgent externo. ht é função analítica
+    de (error, alpha), não uma rede neural aprendida.
+
+    Pipeline:
+    1. Calibra α inicial e quantiza
+    2. Mede erro E₀
+    3. Função analítica avalia ht (confiança na quantização)
+    4. Se ht < τ: atualiza α via STE gradiente na direção de redução de erro
+    5. Re-quantiza, mede erro E₁, atualiza ht
+    6. Repete até ht > τ ou convergência
+
+    A atualização é modulada por (1 - ht): alta confiança → passo pequeno.
+    """
+
+    def __init__(
+        self,
+        ref: nn.Linear,
+        init_alpha: float = 0.5,
+        trust_threshold: float = 0.8,
+        lr: float = 0.05,
+        max_iterations: int = 20,
+        convergence_tol: float = 1e-4,
+        reg_lambda: float = 0.01,
+        verbose: bool = False,
+    ):
+        self.ref = ref
+        self.init_alpha = init_alpha
+        self.trust_threshold = trust_threshold
+        self.lr = lr
+        self.max_iterations = max_iterations
+        self.convergence_tol = convergence_tol
+        self.reg_lambda = reg_lambda
+        self.verbose = verbose
+        # V5: Sem TrustNeuralAgent. ht é função analítica.
+        # Parâmetro α parametrizado via sigmoid.
+        init_eta = math.log(init_alpha / (1 - init_alpha))
+        self.eta_alpha = torch.nn.Parameter(torch.tensor(init_eta))
+
+    @property
+    def alpha(self) -> torch.Tensor:
+        return torch.sigmoid(self.eta_alpha)
+
+    def _compute_quantization_error(
+        self,
+        X: torch.Tensor,
+        alpha_val: float,
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Computa Y_quantized e Y_reference para um dado α.
+
+        Retorna: (Y_q, Y_ref)
+        """
+        W = self.ref.weight
+        Y_ref = F.linear(X, W, self.ref.bias)
+        # Smooth factor.
+        s = calibrate_smoothquant(X, W, alpha=alpha_val)
+        # Smooth.
+        X_smooth = X / s
+        W_smooth = W * s.unsqueeze(0)
+        # Quantize W per-channel.
+        W_q, w_scale = quantize_per_channel_symmetric(W_smooth, axis=0, n_bits=8)
+        # Quantize X per-token.
+        X_q, x_scale = quantize_per_token_symmetric(X_smooth, n_bits=8)
+        # Dequant.
+        X_fp = X_q.to(torch.float32) * x_scale
+        W_fp = W_q.to(torch.float32) * w_scale.unsqueeze(1)
+        Y_q = X_fp @ W_fp.t()
+        if self.ref.bias is not None:
+            Y_q = Y_q + self.ref.bias
+        return Y_q, Y_ref
+
+    def _compute_error_gradient(
+        self,
+        X: torch.Tensor,
+        alpha_tensor: torch.Tensor,
+    ) -> torch.Tensor:
+        """Computa gradiente do erro via STE (Straight-Through Estimator).
+
+        E(α) = ||Y_ref - Y_q(α)||_F^2 / ||Y_ref||_F^2
+
+        Usa STE para round() (não-diferenciável).
+        """
+        W = self.ref.weight
+        # Y_ref (sem grad).
+        with torch.no_grad():
+            Y_ref = F.linear(X, W, self.ref.bias)
+            y_ref_norm_sq = max(((Y_ref) ** 2).mean().item(), 1e-12)
+        # s(α) diferenciável.
+        d_in = W.shape[-1]
+        X_flat = X.reshape(-1, d_in)
+        max_x = X_flat.abs().amax(dim=0).clamp(min=1e-8)
+        max_w = W.abs().amax(dim=0).clamp(min=1e-8)
+        s = torch.pow(max_x, alpha_tensor) / torch.pow(max_w, 1.0 - alpha_tensor)
+        # Smooth.
+        X_smooth = X / s
+        W_smooth = W * s.unsqueeze(0)
+        # Quantização com STE.
+        qmax = 127
+        max_w_smooth = W_smooth.abs().amax(dim=1, keepdim=True).clamp(min=1e-8)
+        scale_w = max_w_smooth / qmax
+        max_x_smooth = X_smooth.abs().amax(dim=-1, keepdim=True).clamp(min=1e-8)
+        scale_x = max_x_smooth / qmax
+        # STE: round com gradiente pass-through.
+        W_q_deq = ste_quantize(W_smooth, scale_w, 8)
+        X_q_deq = ste_quantize(X_smooth, scale_x, 8)
+        # Matmul.
+        Y_q = X_q_deq @ W_q_deq.t()
+        if self.ref.bias is not None:
+            Y_q = Y_q + self.ref.bias
+        # Loss = MSE relativo.
+        loss = ((Y_ref - Y_q) ** 2).mean() / y_ref_norm_sq
+        # Regularização entropy (atrai α para 0.5 — centro do intervalo).
+        eps = 1e-8
+        alpha_clamped = alpha_tensor.clamp(eps, 1.0 - eps)
+        reg = -self.reg_lambda * (
+            alpha_clamped * torch.log(alpha_clamped + eps) +
+            (1 - alpha_clamped) * torch.log(1 - alpha_clamped + eps)
+        )
+        # negativo porque queremos MAXIMIZAR entropy (atrair α para 0.5)
+        total_loss = loss - reg
+        total_loss.backward()
+        return total_loss
+
+    def reduce_error(
+        self,
+        X: torch.Tensor,
+    ) -> W8A8ReductionResult:
+        """Executa redução iterativa de erro W8A8.
+
+        Args:
+            X: dados de calibração (B, d_in)
+
+        Returns:
+            W8A8ReductionResult
+        """
+        initial_alpha = float(self.alpha.item())
+        # Computa erro inicial.
+        with torch.no_grad():
+            Y_q_0, Y_ref_0 = self._compute_quantization_error(X, initial_alpha)
+            initial_error = ((Y_ref_0 - Y_q_0) ** 2).mean().item() / max(
+                ((Y_ref_0) ** 2).mean().item(), 1e-12
+            )
+        # V5: ht analítico (sem rede neural)
+        ht_val = analytic_trust(initial_error, initial_alpha)
+        history = [{"iteration": 0, "alpha": initial_alpha, "error": initial_error, "ht": ht_val}]
+        prev_error = initial_error
+        converged = False
+        opt = torch.optim.SGD([self.eta_alpha], lr=self.lr)
+        for iteration in range(1, self.max_iterations + 1):
+            # 1. α atual.
+            alpha_val = float(self.alpha.item())
+            with torch.no_grad():
+                Y_q, Y_ref = self._compute_quantization_error(X, alpha_val)
+                current_error = ((Y_ref - Y_q) ** 2).mean().item() / max(
+                    ((Y_ref) ** 2).mean().item(), 1e-12
+                )
+            # V5: ht analítico
+            ht_val = analytic_trust(current_error, alpha_val)
+            # 2. Se ht > threshold, converged.
+            if ht_val > self.trust_threshold:
+                converged = True
+                if self.verbose:
+                    print(f"  iter {iteration}: ht={ht_val:.4f} > τ={self.trust_threshold}, converged")
+                break
+            # 3. Atualiza α via STE gradiente, modulado por (1 - ht).
+            opt.zero_grad()
+            self._compute_error_gradient(X, self.alpha)
+            # Modula gradiente por (1 - ht).
+            with torch.no_grad():
+                if self.eta_alpha.grad is not None:
+                    self.eta_alpha.grad *= (1.0 - ht_val)
+            opt.step()
+            # 4. Clamp α para [0.01, 0.99].
+            with torch.no_grad():
+                self.eta_alpha.data.clamp_(
+                    math.log(0.01 / 0.99), math.log(0.99 / 0.01)
+                )
+            # 5. Verifica convergência por erro.
+            if abs(prev_error - current_error) < self.convergence_tol:
+                converged = True
+                if self.verbose:
+                    print(f"  iter {iteration}: erro convergiu (Δ={abs(prev_error - current_error):.2e})")
+                break
+            prev_error = current_error
+            history.append({
+                "iteration": iteration,
+                "alpha": float(self.alpha.item()),
+                "error": current_error,
+                "ht": ht_val,
+            })
+            if self.verbose and iteration % 5 == 0:
+                print(f"  iter {iteration}: α={float(self.alpha.item()):.4f}, "
+                      f"erro={current_error:.6f}, ht={ht_val:.4f}")
+        final_alpha = float(self.alpha.item())
+        final_error = history[-1]["error"]
+        return W8A8ReductionResult(
+            initial_alpha=initial_alpha,
+            final_alpha=final_alpha,
+            initial_error=initial_error,
+            final_error=final_error,
+            n_iterations=len(history) - 1,
+            converged=converged,
+            history=history,
+            final_ht=ht_val,
+        )
+
+    def get_smooth_scale(self, X: torch.Tensor) -> torch.Tensor:
+        """Retorna o smooth scale final."""
+        with torch.no_grad():
+            return calibrate_smoothquant(X, self.ref.weight, float(self.alpha.item())).detach()
+
+    def quantize_weights(self, X: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
+        """Quantiza pesos com α otimizado.
+
+        Retorna: (weight_int8, weight_scale)
+        """
+        s = self.get_smooth_scale(X)
+        W_smooth = self.ref.weight * s.unsqueeze(0)
+        W_q, w_scale = quantize_per_channel_symmetric(W_smooth, axis=0, n_bits=8)
+        return W_q, w_scale
+
+
+# ============================================================================
+# 2. MultiLayerW8A8Reducer — aplica redução a múltiplas camadas
+# ============================================================================
+class MultiLayerW8A8Reducer:
+    """Aplica TrustGuidedW8A8 a múltiplas camadas Linear de um modelo.
+
+    Para cada camada:
+    1. Coleta ativações de calibração
+    2. Executa TrustGuidedW8A8.reduce_error()
+    3. Substitui a camada original pela versão quantizada (SmoothQuantW8A8)
+
+    V5: OOM-safe — não armazena ativações de todas as camadas simultaneamente.
+    Processa uma camada por vez.
+    """
+
+    def __init__(
+        self,
+        init_alpha: float = 0.5,
+        trust_threshold: float = 0.8,
+        lr: float = 0.05,
+        max_iterations: int = 15,
+        verbose: bool = False,
+    ):
+        self.init_alpha = init_alpha
+        self.trust_threshold = trust_threshold
+        self.lr = lr
+        self.max_iterations = max_iterations
+        self.verbose = verbose
+
+    def reduce_model(
+        self,
+        model: nn.Module,
+        calib_X: torch.Tensor,
+        target_substrings: Optional[List[str]] = None,
+    ) -> Dict[str, W8A8ReductionResult]:
+        """Aplica redução W8A8 a todas as nn.Linear no modelo.
+
+        Args:
+            model: modelo a ser quantizado
+            calib_X: dados de calibração (B, T, d) ou (B, d)
+            target_substrings: substrings para filtrar camadas (None = todas)
+
+        Retorna: {layer_name: W8A8ReductionResult}
+        """
+        results = {}
+        # Coleta camadas a quantizar.
+        to_replace = []
+        for name, module in model.named_modules():
+            for child_name, child in module.named_children():
+                if isinstance(child, nn.Linear) and not isinstance(child, SmoothQuantW8A8):
+                    full_name = f"{name}.{child_name}" if name else child_name
+                    if target_substrings is None or any(s in full_name for s in target_substrings):
+                        to_replace.append((module, child_name, child, full_name))
+        if self.verbose:
+            print(f"  Encontradas {len(to_replace)} camadas Linear para quantização")
+        # Para cada camada, aplica TrustGuidedW8A8.
+        for module, child_name, linear_layer, full_name in to_replace:
+            d_in = linear_layer.in_features
+            # Extrai ativações de calibração para esta camada.
+            if calib_X.shape[-1] == d_in:
+                X_calib = calib_X.reshape(-1, d_in)
+            else:
+                # Projeta ou usa aleatório.
+                X_calib = torch.randn(min(64, calib_X.shape[0]), d_in)
+            # Reduz erro.
+            reducer = TrustGuidedW8A8(
+                ref=linear_layer,
+                init_alpha=self.init_alpha,
+                trust_threshold=self.trust_threshold,
+                lr=self.lr,
+                max_iterations=self.max_iterations,
+                verbose=self.verbose,
+            )
+            result = reducer.reduce_error(X_calib)
+            results[full_name] = result
+            # Substitui a camada pela versão quantizada (SmoothQuantW8A8 com α aprendível).
+            sq = SmoothQuantW8A8(
+                linear_layer,
+                init_alpha=result.final_alpha,
+                learnable_alpha=True,  # V5: α continua aprendível após redução
+            )
+            sq.calibrate(X_calib)
+            # Seta o smooth_scale otimizado.
+            s = reducer.get_smooth_scale(X_calib)
+            sq.smooth_scale.copy_(s)
+            sq.freeze_quantization()
+            setattr(module, child_name, sq)
+            # V5 OOM fix: del referências explícitas
+            del reducer, X_calib
+            if self.verbose:
+                print(f"  {full_name}: α {result.initial_alpha:.4f}→{result.final_alpha:.4f}, "
+                      f"erro {result.initial_error:.6f}→{result.final_error:.6f}, "
+                      f"ht={result.final_ht:.4f}, conv={result.converged}")
+        return results
+
+    def summarize_results(
+        self, results: Dict[str, W8A8ReductionResult]
+    ) -> str:
+        """Gera resumo tabular dos resultados."""
+        lines = [
+            f"{'Layer':<30} | {'α_init':>8} | {'α_final':>8} | {'err_init':>10} | {'err_final':>10} | {'reduction':>10} | {'ht':>6} | {'conv':>5}",
+            f"{'-'*30} | {'-'*8} | {'-'*8} | {'-'*10} | {'-'*10} | {'-'*10} | {'-'*6} | {'-'*5}",
+        ]
+        for name, r in results.items():
+            reduction = (1 - r.final_error / max(r.initial_error, 1e-12)) * 100
+            lines.append(
+                f"{name:<30} | {r.initial_alpha:>8.4f} | {r.final_alpha:>8.4f} | "
+                f"{r.initial_error:>10.6f} | {r.final_error:>10.6f} | "
+                f"{reduction:>9.1f}% | {r.final_ht:>6.3f} | {'✓' if r.converged else '✗':>5}"
+            )
+        return "\n".join(lines)
+
+
+__all__ = [
+    "W8A8ConvergenceError",
+    "analytic_trust",
+    "W8A8ReductionResult",
+    "TrustGuidedW8A8",
+    "MultiLayerW8A8Reducer",
+]

src/bigru_t/quantization/w8a8_smoothquant.py

@@ -0,0 +1,365 @@
+"""w8a8_smoothquant.py — W8A8 com SmoothQuant e α APRENDÍVEL (V5).
+
+═══════════════════════════════════════════════════════════════════════════════
+V5 — APRIMORAMENTO MATEMÁTICO: α APRENDÍVEL VIA STE
+═══════════════════════════════════════════════════════════════════════════════
+
+ORIGEM (gru-ring-v13-9-2):
+  source/xavante_work/flexnet/w8a8_smoothquant.py (V13.9.1)
+
+Algoritmo (Xiao et al., 2023 — "SmoothQuant"):
+==============================================
+Dada uma camada Linear Y = X W^T:
+  * X ∈ R^{B × d_in}  ativações (com outliers por canal)
+  * W ∈ R^{d_out × d_in}  pesos (aproximadamente uniformes)
+
+SmoothQuant introduz fator de suavização s ∈ R^{d_in}_{>0}:
+  * X̃ = X / s                (divide ativações → reduz outliers)
+  * W̃ = W * s                (multiplica pesos → preserva produto)
+  * Y = X̃ W̃^T = X W^T        (matematicamente equivalente)
+
+Escolha de s por canal de entrada j:
+  s_j = max(|X_j|)^α  /  max(|W_j|)^{1-α}
+
+  * α = 0.0 → "dificuldade" toda nos pesos (= quantização per-channel clássica)
+  * α = 1.0 → "dificuldade" toda nas ativações (= quantização per-token)
+  * α = 0.5 (default empírico do paper) → balanceia
+
+V5 — MELHORIA MATEMÁTICA SOBRE V13.9.1:
+  Em V13.9.1, α era FIXO (default 0.5). Em V5, α é APRENDÍVEL:
+    * Parametrizado via sigmoid: α = sigmoid(eta_alpha) ∈ (0, 1)
+    * eta_alpha é nn.Parameter treinável — o modelo ajusta α sozinho
+    * Backward via STE (Straight-Through Estimator):
+        - round() não é diferenciável → STE substitui grad por 1
+        - clamp() tem gradiente 1 dentro do intervalo, 0 fora
+    * Loss auxiliary: ||Y_fp - Y_q||_F^2 / ||Y_fp||_F^2 (relative MSE)
+      adicionada à loss total → gradiente flui para eta_alpha
+
+  Isso atende ao requisito V5: "modelo deve ajustar todos os seus parâmetros
+  por conta própria sempre". α era o único parâmetro do W8A8 que não era
+  auto-ajustado — agora é.
+
+V5 — MELHORIA DE MEMÓRIA (OOM-Killer fix):
+  * calib_X_buf (256 × d_in float32 = 1KB por camada) REMOVIDO
+    — em V13.9.1 era armazenado para freeze_quantization, mas só max-abs
+      é usado; buffer completo era desperdício.
+  * Substituído por calib_max_abs (d_in float32 = 0.5KB por camada)
+    — running max-abs per channel, suficiente para s.
+  * Em modelo com 100 camadas Linear × d_in=1024: 256KB → 0.5KB (-99.8%)
+
+Limite de erro (W8A8 simétrico, per-channel):
+  ||Y_fp - Y_q||_2  ≤  ε_w · ||W||_F · ||X||_F  +  ε_x · ||X||_F · ||W||_F
+onde ε_w, ε_x ≤ 2^{-7} (1/128) para escalas bem calibradas.
+"""
+from __future__ import annotations
+
+import math
+import logging
+from typing import Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+logger = logging.getLogger(__name__)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# Funções de Quantização Simétrica (zero_point=0 sempre)
+# ═══════════════════════════════════════════════════════════════════════════
+def _per_channel_max_abs(W: torch.Tensor, dim: int) -> torch.Tensor:
+    """max |W| ao longo de dim, com mínimo epsilon para evitar divisão por 0."""
+    return W.abs().amax(dim=dim).clamp(min=1e-8)
+
+
+def calibrate_smoothquant(
+    X: torch.Tensor,
+    W: torch.Tensor,
+    alpha: float = 0.5,
+) -> torch.Tensor:
+    """Calcula o fator SmoothQuant s ∈ R^{d_in}_{>0}.
+
+    X: (B, d_in) ou (..., d_in) — ativações de calibração
+    W: (d_out, d_in) — pesos da camada Linear
+    alpha: ∈ [0, 1], trade-off (default 0.5)
+
+    Retorna: s ∈ R^{d_in} (positivo).
+
+    Fórmula: s_j = max(|X_j|)^α / max(|W_j|)^{1-α}
+    """
+    d_in = W.shape[-1]
+    if X.shape[-1] != d_in:
+        return torch.ones(d_in, device=W.device, dtype=W.dtype)
+    X_flat = X.reshape(-1, d_in)
+    max_x = X_flat.abs().amax(dim=0).clamp(min=1e-8)        # (d_in,)
+    max_w = W.abs().amax(dim=0).clamp(min=1e-8)             # (d_in,)
+    s = torch.pow(max_x, alpha) / torch.pow(max_w, 1.0 - alpha)
+    return s.clamp(min=1e-8)
+
+
+def quantize_per_channel_symmetric(
+    W: torch.Tensor,
+    axis: int = 0,
+    n_bits: int = 8,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Quantização int8 simétrica per-channel (tensor 2D).
+
+    W: 2D tensor (d_axis, d_other).
+    axis=0 → uma escala por linha (cada output channel tem sua escala).
+    Retorna: (W_int8, scale) onde W_fp ≈ W_int8 * scale e scale é shape (d_axis,).
+    """
+    assert W.dim() == 2, f"esperado tensor 2D, recebeu dim={W.dim()}"
+    qmax = 2 ** (n_bits - 1) - 1   # 127 para int8 (faixa simétrica [-127, 127])
+    qmin = -(2 ** (n_bits - 1) - 1)
+    other = 1 - axis
+    max_abs = W.abs().amax(dim=other, keepdim=True).clamp(min=1e-8)  # (d_axis, 1)
+    scale = max_abs / qmax
+    W_q = torch.round(W / scale).clamp(qmin, qmax).to(torch.int8)
+    return W_q, scale.squeeze(1)
+
+
+def quantize_per_token_symmetric(
+    X: torch.Tensor,
+    n_bits: int = 8,
+) -> Tuple[torch.Tensor, torch.Tensor]:
+    """Quantização int8 simétrica per-token (último eixo = canal).
+
+    X: (..., d_in)
+    Retorna: (X_int8, scale) onde X_fp ≈ X_int8 * scale e scale é shape (..., 1).
+    """
+    qmax = 2 ** (n_bits - 1) - 1
+    qmin = -(2 ** (n_bits - 1) - 1)
+    max_abs = X.abs().amax(dim=-1, keepdim=True).clamp(min=1e-8)
+    scale = max_abs / qmax
+    X_q = torch.round(X / scale).clamp(qmin, qmax).to(torch.int8)
+    return X_q, scale
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# STE para round() — permite gradiente fluir através de quantização
+# ═══════════════════════════════════════════════════════════════════════════
+class STEQuantize(torch.autograd.Function):
+    """Straight-Through Estimator para round + clamp.
+
+    Forward:  x_q = round(x / scale).clamp(qmin, qmax) * scale
+    Backward: grad flui direto (grad_x = grad_y), ignorando round/clamp.
+
+    Isso é necessário porque:
+      * d(round)/dx = 0 em quase todos os pontos (escada de Heaviside)
+      * d(clamp)/dx = 0 fora do intervalo, 1 dentro
+    Sem STE, gradientes não fluiriam para os pesos/α através da quantização.
+    """
+
+    @staticmethod
+    def forward(ctx, x, scale, qmin, qmax):
+        x_q = torch.round(x / scale).clamp(qmin, qmax)
+        x_deq = x_q * scale
+        return x_deq
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        # STE: gradiente passa direto
+        return grad_output, None, None, None
+
+
+def ste_quantize(x: torch.Tensor, scale: torch.Tensor, n_bits: int = 8) -> torch.Tensor:
+    """Quantiza com STE. scale deve ter shape broadcastable com x."""
+    qmax = 2 ** (n_bits - 1) - 1
+    qmin = -(2 ** (n_bits - 1) - 1)
+    return STEQuantize.apply(x, scale, qmin, qmax)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# SmoothQuantW8A8 — camada Linear W8A8 com α APRENDÍVEL (V5)
+# ═══════════════════════════════════════════════════════════════════════════
+class SmoothQuantW8A8(nn.Module):
+    """Camada Linear W8A8 com SmoothQuant e α APRENDÍVEL.
+
+    V5 vs V13.9.1:
+      * α é parâmetro treinável (via sigmoid(eta_alpha))
+      * calib_X_buf removido (era OOM em modelos grandes) — apenas max_abs
+      * STE explícito para round() — backward bem definido
+      * Quantização do peso é DIFFERENCIÁVEL w.r.t. α (via s e STE)
+
+    Modos:
+      * calibration: coleta max_abs das ativações
+      * quantized: pesos em int8, ativações quantizadas on-the-fly com STE
+
+    Args:
+        ref: nn.Linear de referência (pesos copiados)
+        init_alpha: valor inicial de α (default 0.5)
+        learnable_alpha: se True (default V5), α é treinável
+        calib_batch_size: tamanho do buffer de calibração (apenas p/ count)
+        n_bits: nº de bits (default 8)
+    """
+
+    def __init__(
+        self,
+        ref: nn.Linear,
+        init_alpha: float = 0.5,
+        learnable_alpha: bool = True,
+        calib_batch_size: int = 256,
+        n_bits: int = 8,
+    ):
+        super().__init__()
+        self.in_features = ref.in_features
+        self.out_features = ref.out_features
+        self.n_bits = n_bits
+        self.learnable_alpha = learnable_alpha
+
+        # Pesos fp (treináveis até freeze; após freeze ainda treináveis p/ α)
+        self.weight_fp = nn.Parameter(ref.weight.detach().clone())
+        self.bias = (
+            nn.Parameter(ref.bias.detach().clone()) if ref.bias is not None else None
+        )
+
+        # V5: α aprendível via sigmoid(eta_alpha) ∈ (0, 1)
+        init_eta = float(math.log(init_alpha / max(1e-6, 1.0 - init_alpha)))
+        if learnable_alpha:
+            self.eta_alpha = nn.Parameter(torch.tensor(init_eta, dtype=torch.float32))
+        else:
+            self.register_buffer("eta_alpha", torch.tensor(init_eta, dtype=torch.float32))
+
+        # Buffers de quantização
+        self.register_buffer("smooth_scale", torch.ones(self.in_features))
+        self.register_buffer("weight_scale", torch.ones(self.out_features))
+        self.register_buffer(
+            "weight_int8",
+            torch.zeros(self.out_features, self.in_features, dtype=torch.int8),
+        )
+        self.register_buffer("is_quantized", torch.tensor(False))
+        self.register_buffer("calib_collected", torch.tensor(False))
+        # V5: Apenas max-abs per channel (OOM fix — buffer completo removido)
+        self.register_buffer("calib_max_abs", torch.zeros(self.in_features))
+        self.register_buffer("calib_count", torch.tensor(0, dtype=torch.long))
+
+    @property
+    def alpha(self) -> torch.Tensor:
+        """α atual = sigmoid(eta_alpha) ∈ (0, 1)."""
+        return torch.sigmoid(self.eta_alpha)
+
+    @torch.no_grad()
+    def calibrate(self, X: torch.Tensor) -> None:
+        """Acumula estatísticas de ativação (max-abs per channel).
+
+        V5 OOM fix: não armazena tensor completo, apenas max(|X|) per channel.
+        """
+        if bool(self.is_quantized):
+            raise RuntimeError("Calibração após freeze não é permitida.")
+        flat = X.reshape(-1, self.in_features)
+        batch_max_abs = flat.abs().amax(dim=0).to(self.calib_max_abs.dtype)
+        self.calib_max_abs.copy_(torch.maximum(self.calib_max_abs, batch_max_abs))
+        self.calib_count += flat.shape[0]
+        self.calib_collected.fill_(True)
+
+    @torch.no_grad()
+    def freeze_quantization(self) -> None:
+        """Computa s com α ATUAL, quantiza W em int8 per-channel.
+
+        Nota: depois de freeze, o modelo ainda pode chamar recompute_smooth_scale()
+        para atualizar s quando α mudar (durante o treino do α).
+        """
+        if not bool(self.calib_collected):
+            logger.warning("SmoothQuantW8A8: freeze sem calibração. Usando s=1.")
+            X_calib = self.weight_fp.new_zeros(1, self.in_features)
+        else:
+            # Reconstrói tensor "representativo" das ativações a partir de max-abs
+            X_calib = self.calib_max_abs.unsqueeze(0)  # (1, d_in)
+
+        alpha_val = float(self.alpha.item())
+        s = calibrate_smoothquant(X_calib, self.weight_fp, alpha=alpha_val)
+        self.smooth_scale.copy_(s.to(self.smooth_scale.dtype))
+
+        W_smooth = self.weight_fp * s.unsqueeze(0)
+        W_q, w_scale = quantize_per_channel_symmetric(W_smooth, axis=0, n_bits=self.n_bits)
+        self.weight_int8.copy_(W_q)
+        self.weight_scale.copy_(w_scale)
+        self.is_quantized.fill_(True)
+
+    @torch.no_grad()
+    def recompute_smooth_scale(self) -> None:
+        """Recomputa s e re-quantiza W com α ATUAL (após treino de α).
+
+        V5: chamado pelo trainer a cada N steps para manter W quantizado
+        consistente com α atualizado.
+        """
+        if not bool(self.is_quantized):
+            return
+        if not bool(self.calib_collected):
+            return
+        X_calib = self.calib_max_abs.unsqueeze(0)
+        alpha_val = float(self.alpha.item())
+        s = calibrate_smoothquant(X_calib, self.weight_fp, alpha=alpha_val)
+        self.smooth_scale.copy_(s.to(self.smooth_scale.dtype))
+        W_smooth = self.weight_fp * s.unsqueeze(0)
+        W_q, w_scale = quantize_per_channel_symmetric(W_smooth, axis=0, n_bits=self.n_bits)
+        self.weight_int8.copy_(W_q)
+        self.weight_scale.copy_(w_scale)
+
+    def forward(self, X: torch.Tensor) -> torch.Tensor:
+        """Forward W8A8 com SmoothQuant e α aprendível.
+
+        V5: quando quantized, faz quantização on-the-fly com STE para que
+        gradientes fluam para eta_alpha (via s(α)).
+        """
+        if not bool(self.is_quantized):
+            # Modo calibração/treino inicial: forward fp32 normal
+            return F.linear(X, self.weight_fp, self.bias)
+
+        # V5: recompute s(α) on-the-fly (diferenciável w.r.t. eta_alpha)
+        # smooth_scale é buffer (detached), mas recalculamos s com α treinável
+        alpha_t = self.alpha  # diferenciável
+        # max_abs armazenado em calib_max_abs (detached)
+        max_x = self.calib_max_abs.clamp(min=1e-8)
+        max_w = self.weight_fp.detach().abs().amax(dim=0).clamp(min=1e-8)
+        s = torch.pow(max_x, alpha_t) / torch.pow(max_w, 1.0 - alpha_t)
+        s = s.clamp(min=1e-8)
+
+        # Smooth: X̃ = X / s, W̃_fp = weight_fp * s
+        X_smooth = X / s  # (..., d_in) — diferenciável w.r.t. eta_alpha via s
+        # W̃_fp não precisa de STE aqui porque weight_fp é treinável diretamente
+        W_smooth = self.weight_fp * s.unsqueeze(0)  # (d_out, d_in)
+
+        # Quantiza W per-channel com STE (diferenciável)
+        qmax = 2 ** (self.n_bits - 1) - 1
+        max_w_smooth = W_smooth.abs().amax(dim=1, keepdim=True).clamp(min=1e-8)
+        w_scale_dyn = max_w_smooth / qmax  # (d_out, 1)
+        W_q_deq = ste_quantize(W_smooth, w_scale_dyn, self.n_bits)  # (d_out, d_in)
+
+        # Quantiza X per-token com STE
+        max_x_smooth = X_smooth.abs().amax(dim=-1, keepdim=True).clamp(min=1e-8)
+        x_scale_dyn = max_x_smooth / qmax  # (..., 1)
+        X_q_deq = ste_quantize(X_smooth, x_scale_dyn, self.n_bits)  # (..., d_in)
+
+        # Matmul em fp32 (simulação; HW real faria INT8×INT8→INT32→fp32)
+        Y = X_q_deq @ W_q_deq.t()
+        if self.bias is not None:
+            Y = Y + self.bias
+        return Y
+
+    def quantization_error(self, X: torch.Tensor) -> float:
+        """Calcula ||Y_fp - Y_q||_F / ||Y_fp||_F como métrica de erro."""
+        with torch.no_grad():
+            Y_fp = F.linear(X, self.weight_fp, self.bias)
+            Y_q = self.forward(X)
+            num = (Y_fp - Y_q).norm().item()
+            den = max(Y_fp.norm().item(), 1e-12)
+        return num / den
+
+    def extra_repr(self) -> str:
+        return (
+            f"in_features={self.in_features}, out_features={self.out_features}, "
+            f"alpha={float(self.alpha.item()):.4f}, "
+            f"learnable_alpha={self.learnable_alpha}, "
+            f"is_quantized={bool(self.is_quantized)}"
+        )
+
+
+__all__ = [
+    "calibrate_smoothquant",
+    "quantize_per_channel_symmetric",
+    "quantize_per_token_symmetric",
+    "STEQuantize",
+    "ste_quantize",
+    "SmoothQuantW8A8",
+]

src/bigru_t/training/meta_configurator.py

@@ -2,27 +2,24 @@
 
 Implementa o Lema 4 (Auto-configuração e suavização).
 
-Mantém hiperparâmetros aprendíveis:
+V5: Mantém hiperparâmetros aprendíveis:
     - log_temperature: controla T = exp(log_temperature) do Lema 1
     - log_tau: controla τ = exp(log_tau) do Lema 3 (limiar de ativação da hipótese)
+    - log_lambda_ent: peso da reg. de entropia do module_selector (V5 NOVO)
+    - log_init_gate: gate inicial do CircularReasoning (V5 NOVO)
+
+Requisito V5: "modelo deve ajustar todos os seus parâmetros por conta própria
+sempre" — agora T, τ, λ_ent, e init_gate são todos auto-ajustados via meta-loss.
 
 Meta-objetivo:
-    L_meta(T, τ) = L_val(T, τ; θ) + λ_s * S(θ)
+    L_meta(T, τ, λ_ent, init_gate) = L_val + λ_s * S(θ)
+                                   + tracking losses para T, τ
+                                   + reg losses para λ_ent, init_gate
 
-onde S(θ) = ||∇_θ L_val||^2 é uma proxy de agudeza (sharpness) — aproximação
-de baixo custo para o maior autovalor da Hessiana.
+onde S(θ) = ||∇_θ L_val||^2 é uma proxy de agudeza (sharpness).
 
 Minimizar S(θ) empurra o modelo para mínimos planos (Keskar 2017, Foret 2021),
 onde o ruído de gradiente é menor.
-
-Reaproveita a filosofia do meta_learner.py (MAML-RNOEFLEX) e meta_orchestrator.py
-do v13.9.2, mas:
-- Substitui MAML de 2ª ordem por diferenciação implícita simplificada
-  (1ª ordem + proxy de agudeza)
-- Substitui o orchestrator de 3º nível por 2 hiperparâmetros escalares
-  (T, τ) — mais barato computacionalmente
-- A proxy de agudeza é o quadrado da norma do gradiente (não o autovalor
-  da Hessiana — seria proibitivo para 16M+ params)
 """
 from __future__ import annotations
 
@@ -33,18 +30,20 @@ import torch.nn as nn
 
 
 class MetaConfigurator:
-    """Auto-configuração de temperatura (T) e limiar (τ) via meta-aprendizado.
+    """Auto-configuração de T, τ, λ_ent, init_gate via meta-aprendizado.
+
+    V5: Agora gerencia 4 hiperparâmetros (era 2 em V3.4):
+        * log_temperature → T (softmax temperature do module_selector)
+        * log_tau → τ (limiar de ativação da hipótese)
+        * log_lambda_ent → λ_ent (peso da reg. de entropia) — V5 NOVO
+        * log_init_gate → init_gate (gate do CircularReasoning) — V5 NOVO
 
     Args:
-        model: o UnifiedModel a ser configurado
-        meta_lr: learning rate do meta-otimizador (Adam em log_T, log_tau)
+        model: o UnifiedModel a ser configurado (deve ter log_lambda_ent e
+               log_init_gate como nn.Parameters)
+        meta_lr: learning rate do meta-otimizador (Adam)
         sharpness_lambda: peso λ_s da proxy de agudeza
 
-    Atributos:
-        log_temperature: nn.Parameter — T = exp(log_temperature)
-        log_tau: nn.Parameter — τ = exp(log_tau)
-        meta_optim: Adam sobre (log_temperature, log_tau)
-
     Uso:
         meta_cfg = MetaConfigurator(model)
         # No loop de treino, a cada meta_interval batches:
@@ -66,10 +65,20 @@ class MetaConfigurator:
         self.log_temperature = nn.Parameter(torch.tensor(0.0))
         self.log_tau = nn.Parameter(torch.tensor(0.0))
 
+        # V5 NOVO: Coletar todos os parâmetros meta
+        # - log_temperature, log_tau (locais)
+        # - model.log_lambda_ent (λ_ent do UnifiedModel)
+        # - model.circular_reasoning.residual_gate (n_cycles gates, se CRW ativo)
+        meta_params = [self.log_temperature, self.log_tau]
+        if hasattr(model, 'log_lambda_ent'):
+            meta_params.append(model.log_lambda_ent)
+        if (hasattr(model, 'circular_reasoning')
+                and model.circular_reasoning is not None
+                and hasattr(model.circular_reasoning, 'residual_gate')):
+            meta_params.append(model.circular_reasoning.residual_gate)
+
         # Otimizador Adam sobre os hiperparâmetros
-        self.meta_optim = torch.optim.Adam(
-            [self.log_temperature, self.log_tau], lr=meta_lr
-        )
+        self.meta_optim = torch.optim.Adam(meta_params, lr=meta_lr)
 
     @property
     def temperature(self) -> float:
@@ -81,6 +90,20 @@ class MetaConfigurator:
         """τ atual = exp(log_tau)."""
         return float(torch.exp(self.log_tau.detach()).item())
 
+    @property
+    def lambda_ent(self) -> float:
+        """λ_ent atual = exp(model.log_lambda_ent)."""
+        if hasattr(self.model, 'log_lambda_ent'):
+            return float(torch.exp(self.model.log_lambda_ent.detach()).item())
+        return 0.01
+
+    @property
+    def init_gate(self) -> float:
+        """init_gate atual = exp(model.log_init_gate)."""
+        if hasattr(self.model, 'log_init_gate'):
+            return float(torch.exp(self.model.log_init_gate.detach()).item())
+        return 0.05
+
     def forward_with_meta(
         self,
         x_val: torch.Tensor,
@@ -95,19 +118,21 @@ class MetaConfigurator:
             criterion: função de perda (default: CrossEntropyLoss)
 
         Returns:
-            dict com: loss_val, sharpness, meta_loss, T_new, tau_new
+            dict com: loss_val, sharpness, meta_loss, T_new, tau_new, λ_ent_new, init_gate_new
 
         V3 BUGFIX: log_tau não tinha caminho de gradiente (aparecia como None).
         Agora adicionamos um termo de target-tracking: τ deve seguir loss_val
         (com margem), dando a log_tau um gradiente via MSE.
-        Também corrigimos module_selector para preservar o grafo quando
-        temperature é um tensor (torch.clamp em vez de max()).
 
         V3.2 BUGFIX (complementar): log_temperature também não movia em 1 step
-        porque o gradiente via alpha = softmax(logits/T) é ≈0 quando logits ≈0
-        (init randn*1/sqrt(K) ≈ 0). Adicionamos T_target = 1 + 0.1*(loss - 1):
-        loss alta → T alto (exploração); loss baixa → T baixo (especialização).
-        Isto dá a log_T um gradiente via MSE mesmo quando alpha é uniforme.
+        porque o gradiente via alpha = softmax(logits/T) é ≈0 quando logits ≈0.
+        Adicionamos T_target = 1 + 0.1*(loss - 1): loss alta → T alto (exploração).
+
+        V5: Agora também atualiza λ_ent e init_gate do modelo via meta-loss.
+        - λ_ent: tracking loss para manter perto de 0.01 (evita saturação
+          da entropia do module_selector)
+        - init_gate: tracking loss para manter perto de 0.05 (evita gate
+          muito grande que quebraria a contração W₂ do CircularReasoning)
         """
         if criterion is None:
             criterion = nn.CrossEntropyLoss()
@@ -115,12 +140,35 @@ class MetaConfigurator:
         # Hiperparâmetros atuais (positivos via exp)
         temp = torch.exp(self.log_temperature)
         tau_val = torch.exp(self.log_tau)
+        # V5: ler do model
+        lambda_ent_val = (
+            torch.exp(self.model.log_lambda_ent)
+            if hasattr(self.model, 'log_lambda_ent')
+            else torch.tensor(0.01)
+        )
+        # V5: residual_gate é Parameter do CircularReasoning (shape: n_cycles)
+        # Usamos a média para o tracking loss (1 escalar)
+        if (hasattr(self.model, 'circular_reasoning')
+                and self.model.circular_reasoning is not None):
+            init_gate_val = self.model.circular_reasoning.residual_gate.mean()
+        else:
+            init_gate_val = torch.tensor(0.05)
 
         # Forward do modelo com T atual (sem hipótese — só validação principal)
+        # V5: return_aux=True para capturar entropy_reg
+        #    (necessário para que λ_ent tenha gradiente via lambda_ent * entropy_reg)
         self.model.train()  # mantém dropout ativo para estimar sharpness real
-        y_hat_main, _ = self.model(x_val, temperature=temp, use_hypothesis=False)
+        y_hat_main, _, aux = self.model(
+            x_val, temperature=temp, use_hypothesis=False, return_aux=True
+        )
         loss_val = criterion(y_hat_main, y_val)
 
+        # V5: λ_ent * entropy_reg — dá a λ_ent um caminho de gradiente via
+        # o termo de regularização de entropia do module_selector (Lema 1)
+        # Isto é o "uso real" de λ_ent no treino — deve ser refletido no meta-loss
+        entropy_reg = aux.get("entropy_reg", torch.tensor(0.0))
+        entropy_loss = lambda_ent_val * entropy_reg
+
         # Proxy de agudeza: ||∇_θ L_val||^2
         # BUG FIX: create_graph=True causava OOM-Killer (second-order graph dobra RAM)
         # Correção: usar create_graph=False (first-order approximation)
@@ -157,17 +205,50 @@ class MetaConfigurator:
         T_pred = torch.exp(self.log_temperature)
         T_tracking_loss = 0.05 * (T_pred - T_target) ** 2
 
-        # Meta-perda: loss_val (atualiza log_T via temperatura → alpha → y_hat)
-        #            + T_tracking_loss (atualiza log_T via MSE target)
-        #            + tau_tracking_loss (atualiza log_tau)
-        meta_loss = loss_val + T_tracking_loss + tau_tracking_loss
+        # V5 NOVO: λ_ent tracking loss — manter perto de 0.01 (default do config)
+        # Permite variação mas evita saturação (λ_ent muito grande força entropia
+        # máxima = módulos uniformes; muito pequena = colapso para 1 módulo)
+        lambda_ent_target = torch.tensor(0.01, device=lambda_ent_val.device)
+        lambda_ent_tracking_loss = 0.01 * (lambda_ent_val - lambda_ent_target) ** 2
+
+        # V5 NOVO: init_gate tracking loss — manter perto de 0.05 (default do config)
+        # Aplicado à MÉDIA dos n_cycles gates do CircularReasoning.
+        # Permite variação mas evita gate muito grande (quebraria contração W₂)
+        init_gate_target = torch.tensor(0.05, device=init_gate_val.device)
+        init_gate_tracking_loss = 0.01 * (init_gate_val - init_gate_target) ** 2
+
+        # Meta-perda: loss_val + entropy_loss (λ_ent path)
+        #            + tracking losses para T, τ, λ_ent, init_gate
+        meta_loss = (
+            loss_val
+            + entropy_loss
+            + T_tracking_loss
+            + tau_tracking_loss
+            + lambda_ent_tracking_loss
+            + init_gate_tracking_loss
+        )
 
-        # Atualiza log_temperature e log_tau via gradiente de meta_loss
+        # Atualiza log_temperature, log_tau, model.log_lambda_ent, residual_gate
         self.meta_optim.zero_grad()
         meta_loss.backward()
-        # Guarda gradiente antes do step para logging
+        # Guarda gradientes antes do step para logging
         grad_log_T = self.log_temperature.grad.item() if self.log_temperature.grad is not None else 0.0
         grad_log_tau = self.log_tau.grad.item() if self.log_tau.grad is not None else 0.0
+        grad_log_lambda_ent = (
+            self.model.log_lambda_ent.grad.item()
+            if hasattr(self.model, 'log_lambda_ent')
+            and self.model.log_lambda_ent.grad is not None
+            else 0.0
+        )
+        # V5: gradiente do residual_gate (média sobre n_cycles gates)
+        if (hasattr(self.model, 'circular_reasoning')
+                and self.model.circular_reasoning is not None
+                and self.model.circular_reasoning.residual_gate.grad is not None):
+            grad_init_gate = float(
+                self.model.circular_reasoning.residual_gate.grad.abs().mean().item()
+            )
+        else:
+            grad_init_gate = 0.0
         self.meta_optim.step()
 
         # Sincroniza model.tau com o novo valor
@@ -180,10 +261,18 @@ class MetaConfigurator:
             "meta_loss": float(meta_loss.item()),
             "T_new": float(torch.exp(self.log_temperature.detach()).item()),
             "tau_new": float(torch.exp(self.log_tau.detach()).item()),
+            "lambda_ent_new": float(lambda_ent_val.detach().item()),
+            "init_gate_new": float(init_gate_val.detach().item()),
+            "entropy_reg": float(entropy_reg.detach().item() if isinstance(entropy_reg, torch.Tensor) else 0.0),
+            "entropy_loss": float(entropy_loss.detach().item() if isinstance(entropy_loss, torch.Tensor) else 0.0),
             "grad_log_T": grad_log_T,
             "grad_log_tau": grad_log_tau,
+            "grad_log_lambda_ent": grad_log_lambda_ent,
+            "grad_init_gate": grad_init_gate,
             "tau_target": float(tau_target.item()),
             "T_target": float(T_target.item()),
             "T_tracking_loss": float(T_tracking_loss.item()),
             "tau_tracking_loss": float(tau_tracking_loss.item()),
+            "lambda_ent_tracking_loss": float(lambda_ent_tracking_loss.item()),
+            "init_gate_tracking_loss": float(init_gate_tracking_loss.item()),
         }

v32_upload_report.json

@@ -1,6 +1,6 @@
 {
   "version": "V3.2_upload",
-  "timestamp": 1786013028.9061728,
+  "timestamp": 1786016584.7106616,
   "repo_id": "PowerMachine/BiGRU_T_version",
   "repo_type": "model",
   "folder_path": "/home/z/my-project/BiGRU_T_version",
@@ -29,15 +29,15 @@
     "*/.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,
+  "local_files_count": 67,
+  "local_files_total_bytes": 809581,
+  "remote_files_before": 67,
+  "remote_files_after": 70,
+  "new_files_count": 3,
+  "overwritten_count": 67,
   "critical_files_all_present": true,
-  "elapsed_s": 2.654574849000028,
-  "commit_info": "https://huggingface.co/PowerMachine/BiGRU_T_version/commit/a22ed76d93580e2cc99e084b60e54080bb45cc9c",
+  "elapsed_s": 2.9894082950004304,
+  "commit_info": "https://huggingface.co/PowerMachine/BiGRU_T_version/commit/0cee0098eee9c53ec2f36dec7ec24e53aa458838",
   "env": {
     "HF_HUB_ENABLE_HF_TRANSFER": "1",
     "HF_HUB_ETAG_TIMEOUT": "60",

v5_report.json

@@ -0,0 +1,127 @@
+{
+  "version": "V5",
+  "timestamp": 1786018677.168036,
+  "config": {
+    "n_multimodal": 10,
+    "n_text": 10,
+    "epochs": 2,
+    "batch_size": 4,
+    "max_seq_len": 16,
+    "num_layers_hyp": 8,
+    "triplet_weight": 0.05,
+    "meta_interval": 3,
+    "cleanup_interval": 1,
+    "triplet_ema_alpha": 0.1
+  },
+  "v5_improvements": {
+    "w8a8_learnable_alpha": true,
+    "w8a8_self_contained_trust": true,
+    "apply_w8a8_bugfix": true,
+    "num_layers_hyp_fixed_8": true,
+    "oom_mitigations": [
+      "del intermediários explícito",
+      "MetaConfigurator a cada 3 steps",
+      "gc.collect(0) a cada step",
+      "aggressive_cleanup entre epochs",
+      "torch.no_grad() em val/eval",
+      "alerts limitado a 50 entries"
+    ],
+    "learnable_params": [
+      "T (MetaConfigurator)",
+      "τ (MetaConfigurator)",
+      "λ_ent (MetaConfigurator + treino)",
+      "init_gate (residual_gate, MetaConfigurator + treino)",
+      "α smoothquant (STE, em SmoothQuantW8A8)",
+      "module_logits (treino)",
+      "todos os pesos W (AdamW)"
+    ]
+  },
+  "xeon_env": {
+    "OMP_NUM_THREADS": "2",
+    "MKL_NUM_THREADS": "2",
+    "ONEDNN_MAX_CPU_ISA": "AMX_INT8",
+    "IPEX": true,
+    "CPU_ISA": "AMX",
+    "torch_threads": 2
+  },
+  "result": {
+    "n_steps": 6,
+    "n_epochs": 2,
+    "final_train_loss": 9.665669441223145,
+    "final_val_loss": 9.436580848693847,
+    "final_perplexity": 12538.771572889684,
+    "final_overfitting_gap": 0.006072171529135417,
+    "final_eval_benchmark": 0.375,
+    "avg_tokens_per_sec": 29.505289440522088,
+    "avg_tflops_per_cpu": 0.00010685671030126807,
+    "avg_time_per_step_ms": 2553.5807878330465,
+    "avg_grad_norm": 10.784179131189982,
+    "avg_cpu_pct": 121.38333333333333,
+    "final_rss_mb": 922.49609375,
+    "max_rss_mb": 922.49609375,
+    "rss_trend": "stable",
+    "n_alerts": 0,
+    "alerts": [],
+    "alert_types": [],
+    "meta_history": [
+      {
+        "T": 1.0100501775741577,
+        "tau": 1.0100501775741577,
+        "lambda_ent": 0.009999999776482582,
+        "init_gate": 0.047456394881010056,
+        "meta_loss": 17.669658660888672,
+        "sharpness": 71.65159606933594
+      },
+      {
+        "T": 1.02021062374115,
+        "tau": 1.0202070474624634,
+        "lambda_ent": 0.009900504723191261,
+        "init_gate": 0.02058723010122776,
+        "meta_loss": 18.058149337768555,
+        "sharpness": 109.38550567626953
+      }
+    ],
+    "elapsed_s": 21.375046549000217,
+    "n_params": 9657632,
+    "hyp_T_params": 1795914,
+    "num_layers_hyp": 8,
+    "n_w8a8_layers": 80,
+    "final_learnable_params": {
+      "T": 1.02021062374115,
+      "tau": 1.0202070474624634,
+      "lambda_ent": 0.009802023880183697,
+      "init_gate": 0.05,
+      "residual_gate": [
+        0.005989676807075739,
+        0.006018564570695162,
+        0.006039654836058617
+      ],
+      "module_logits": [
+        -0.22852112352848053,
+        -0.10588397085666656,
+        0.12294353544712067,
+        -0.22121863067150116,
+        0.41890066862106323,
+        -0.01949109323322773,
+        -0.08710632473230362,
+        0.05125897005200386
+      ]
+    },
+    "final_bigru_diversity": {
+      "mean_cosine_diversity": 0.7214401364326477,
+      "mean_parallelism_score": 0.9953877925872803,
+      "mean_gate_norm_ratio": 0.09838299453258514,
+      "module_level_cosine_diversity": 1.0237387745042466,
+      "per_module_parallelism": [
+        0.9936217665672302,
+        0.9924681186676025,
+        0.9992730617523193,
+        0.9971094727516174,
+        0.9949930310249329,
+        0.9948464035987854,
+        0.9958065748214722,
+        0.9944431781768799
+      ]
+    }
+  }
+}