V6.5-V2-metrics-FIX: cleanup batch — remove .pt files + duplicate root-level modules + obsolete modules (17 files)

hyp_t.py

@@ -1,100 +0,0 @@
-"""hyp_t.py — HypT: cabeça de hipótese (correção delta). Implementa o Lema 3.
-
-A Hipótese é treinada para cancelar o ruído de quantização W8A8:
-    y_final = y_hat + delta
-onde delta = hyp_T(o).
-
-Diferenças vs. TrainT:
-- Recebe `o` opcionalmente destacado (stop_grad) para isolar o sinal de
-  correção do gradiente principal
-- Mesma arquitetura (TransformerEncoder) — apenas o tratamento de gradiente
-  difere
-
-Reaproveita a filosofia do HypothesisNetwork do v13.9.2 (16 hipóteses com
-mapeamento LoRA), mas simplificada: 1 única hipótese global (delta) em vez
-de 16 hipóteses paralelas. A multiplexação é feita pelo OrqCell + Lema 1.
-
-============================================================================
-V6.4 — pgvector_lookup REMOVIDO (NÃO É MAIS NECESSÁRIO)
-============================================================================
-Conforme directive do usuário:
-  "pgvector_lookup não é mais necessário pela lógica do script seguinte"
-
-O KohonenLearningSystem (kohonen_refactored/kohonen_learning_system.py)
-contém o método find_bmu que realiza busca nearest-neighbor sobre o grid
-4D do SOM (864 neurônios para grid (6,6,6,4)), substituindo qualquer
-lookup pgvector externo. A decisão de aplicar punição é delegada ao
-protocolo interno do KohonenLearningSystem (1ª punição → activate_hypothesis,
-2ª punição → set_ewc_reference + reset).
-
-Consequentemente, HypT volta ao seu papel original: gerar a correção
-delta = hyp_T(o) sem consultar mapa externo. A integração com o SOM é
-feita no nível do trainer (KohonenLearningSystem.process_batch), não no
-nível da hipótese.
-
-Os contadores de punição (n_complete_skip, n_incomplete_apply, etc.)
-foram removidos pois não há mais decisão de skip baseada em pgvector.
-"""
-from __future__ import annotations
-
-import torch
-import torch.nn as nn
-
-
-class HypT(nn.Module):
-    """Transformer de hipótese: gera correção delta.
-
-    Args:
-        d_input: dimensão de entrada (saída do OrqCell = d_cache)
-        d_model: dimensão interna
-        nhead: nº de cabeças
-        d_ff: dimensão do FFN
-        output_dim: dimensão de saída (igual ao TrainT)
-        num_layers: nº de camadas
-        dropout: probabilidade de dropout
-
-    Forward:
-        o: (batch, d_input), stop_grad: bool → delta: (batch, output_dim)
-
-    Se stop_grad=True, aplica o.detach() no início — Lema 3 (isolar correção
-    do gradiente principal).
-    """
-
-    def __init__(
-        self,
-        d_input: int,
-        d_model: int,
-        nhead: int,
-        d_ff: int,
-        output_dim: int,
-        num_layers: int = 2,
-        dropout: float = 0.1,
-    ):
-        super().__init__()
-        self.d_input = d_input
-        self.d_model = d_model
-        self.output_dim = output_dim
-
-        self.proj_in = nn.Linear(d_input, d_model)
-        encoder_layer = nn.TransformerEncoderLayer(
-            d_model, nhead, d_ff, dropout=dropout, batch_first=True
-        )
-        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers)
-        self.proj_out = nn.Linear(d_model, output_dim)
-
-    def forward(self, o: torch.Tensor, stop_grad: bool = True) -> torch.Tensor:
-        """o: (batch, d_input) → delta: (batch, output_dim)
-
-        V6.4: SEM consulta pgvector — delta é computado diretamente.
-        A decisão de aplicar ou não a correção é delegada ao
-        KohonenLearningSystem (que usa find_bmu internamente).
-        """
-        # Lema 3: stop_grad_hyp isola o sinal de correção
-        if stop_grad:
-            o = o.detach()
-
-        x = o.unsqueeze(1)               # (batch, 1, d_input)
-        x = self.proj_in(x)              # (batch, 1, d_model)
-        x = self.encoder(x)              # (batch, 1, d_model)
-        delta = self.proj_out(x.squeeze(1))  # (batch, output_dim)
-        return delta

smoke_test_v65_v2_metrics_fix.py

@@ -1,320 +0,0 @@
-"""smoke_test_v65_v2_metrics_fix.py — Validação rápida das correções V6.5-V2-metrics-FIX.
-
-Verifica:
-1. Importação do KohonenLearningSystemV2 com params restaurados (HIDDEN=1024, VOCAB=16384)
-2. Bug fix do _compute_classification_loss_with_som (gradiente flui)
-3. Vetorização do train_hypotheses (sem OOM)
-4. aggressive_cleanup() funciona
-5. SOM metrics (8 métricas) computam sem erro
-6. predict() retorna labels dinâmicos (não hardcoded)
-7. FASE1 + FASE2 logic (enable_punishment=False/True)
-"""
-from __future__ import annotations
-
-import os
-import sys
-import time
-import traceback
-from pathlib import Path
-
-# Setup paths
-PROJECT_ROOT = Path("/home/z/my-project")
-BIGRU_ROOT = PROJECT_ROOT / "BiGRU_T_version"
-SRC_ROOT = BIGRU_ROOT / "src"
-sys.path.insert(0, str(SRC_ROOT))
-
-# Activate xeon_runtime
-os.environ["V65_ENABLE_STREAMING"] = "1"
-
-print("=" * 80)
-print("V6.5-V2-metrics-FIX SMOKE TEST")
-print("=" * 80)
-print()
-
-# Test 1: Import
-print("[Test 1] Import KohonenLearningSystemV2...")
-try:
-    from bigru_t.model.kohonen_learning_system import (
-        KohonenLearningSystemV2,
-        KohonenLearningSystem,
-        KohonenSOM4D,
-        HypothesisClassifier,
-        HypothesisEnsemble,
-        DeltaGenerator,
-        SimpleBBPETokenizer,
-        text_to_4d_vector,
-    )
-    from bigru_t.model.som_metrics import (
-        SOMMetricHistory,
-        compute_all_metrics,
-        quantization_error,
-        topological_error,
-        kaski_lagus_error,
-        explained_variance_share,
-        topological_collapse,
-        dead_neuron_rate,
-    )
-    print("  PASS: All imports successful")
-except Exception as e:
-    print(f"  FAIL: Import error: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 2: Instantiate with restored (larger) parameters
-print("\n[Test 2] Instantiate KLS V2 with restored params (HIDDEN=1024, VOCAB=16384)...")
-try:
-    # Use smaller grid for smoke test (faster), but full HIDDEN_DIM/VOCAB_SIZE
-    kls = KohonenLearningSystemV2(
-        vocab_size=16384,        # restored
-        hidden_dim=1024,         # restored
-        seq_len=8,
-        som_grid=(6, 6, 6, 4),   # 864 neurons (Kohonen architecture preserved)
-        alpha0=0.1,
-        sigma0=1.5,
-        lambda_ewc=0.02,
-        N_start=10,
-        dim_choice="y",
-        hypothesis_hidden=[512, 256, 128, 64, 32, 16, 8],
-        T_max=10000,
-        enable_vqvae2=False,      # disabled to save RAM
-        enable_reasoning=False,   # disabled to save RAM
-        enable_w8a8=False,        # disabled to save RAM
-        enable_attention=True,
-        attention_n_heads=8,
-        # V2-dynamic restored params
-        n_hypotheses=16,           # restored
-        max_n_hypotheses=32,       # restored
-        min_n_hypotheses=4,
-        n_trials=3,
-        min_n_trials=1,
-        max_n_trials=6,
-        hyp_train_steps=30,        # restored
-        min_hyp_train_steps=10,
-        max_hyp_train_steps=80,
-        hyp_lr=1e-4,
-        hyp_hidden_dim=256,        # restored
-        loss_history_window=8,
-        punishment_window=12,
-    )
-    assert kls.hidden_dim == 1024, f"hidden_dim={kls.hidden_dim}"
-    assert kls.tokenizer.vocab_size == 16384, f"vocab={kls.tokenizer.vocab_size}"
-    assert kls.n_hypotheses == 16, f"n_hyp={kls.n_hypotheses}"
-    assert kls.max_n_hypotheses == 32, f"max_n_hyp={kls.max_n_hypotheses}"
-    assert kls.hyp_train_steps == 30, f"hyp_steps={kls.hyp_train_steps}"
-    assert kls.hyp_hidden_dim == 256, f"hyp_hidden={kls.hyp_hidden_dim}"
-    assert hasattr(kls, "aggressive_cleanup"), "no aggressive_cleanup method"
-    print(f"  PASS: KLS V2 instantiated")
-    print(f"    hidden_dim={kls.hidden_dim}, vocab={kls.tokenizer.vocab_size}")
-    print(f"    n_hypotheses={kls.n_hypotheses}/{kls.max_n_hypotheses}")
-    print(f"    hyp_train_steps={kls.hyp_train_steps}, hyp_hidden_dim={kls.hyp_hidden_dim}")
-    print(f"    som_grid={kls.som_grid} ({kls.som_neuron_count} neurons)")
-    print(f"    has aggressive_cleanup: True")
-except Exception as e:
-    print(f"  FAIL: Instantiation error: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 3: Add data + train SOM (CONHECIMENTO phase)
-print("\n[Test 3] Add data + train SOM (CONHECIMENTO phase)...")
-try:
-    kls.tokenizer.fit([
-        "o gato dorme", "a casa eh azul", "ele corre rapido",
-        "ela canta uma musica", "o sol nasceu", "nos vamos viajar",
-        "luva de pedreiro tavila", "lula reserva valor",
-        "amazonas forca tarefa vitimas",
-    ])
-    # Add 30 samples (more than N_start=10)
-    for i in range(3):
-        kls.add_data(
-            ["o gato dorme", "o cachorro corre", "a menina brinca",
-             "o passaro voa", "o peixe nada", "a arvore cresce",
-             "o livro esta na mesa", "a musica toca", "o tempo passa",
-             "o mundo gira"],
-            [0, 1, 0, 1, 0, 1, 0, 1, 0, 1],
-            label_strings={0: "negative_class", 1: "positive_class"},
-            dataset_name="test_ds",
-        )
-    assert len(kls.buffer_4d) >= 10, f"buffer={len(kls.buffer_4d)}"
-    print(f"  PASS: Added {len(kls.buffer_4d)} samples")
-    # Train SOM
-    started = kls.check_training_start()
-    print(f"    training_ready: {kls.training_ready}")
-    if kls.training_ready:
-        kls.train_som_on_buffer()
-        kls._label_neurons()
-        print(f"    SOM trained, weights norm={kls.som.weights.norm().item():.4f}")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 4: predict() returns dynamic labels (not gato/cachorro)
-print("\n[Test 4] predict() returns dynamic labels...")
-try:
-    pred = kls.predict("o gato dorme", dataset_name="test_ds")
-    assert pred in ["negative_class", "positive_class"], f"pred={pred}"
-    assert pred != "gato" and pred != "cachorro", f"hardcoded: {pred}"
-    print(f"  PASS: predict returned '{pred}' (dynamic, not hardcoded)")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 5: activate_hypothesis (trains classifier)
-print("\n[Test 5] activate_hypothesis (train classifier)...")
-try:
-    kls.activate_hypothesis()
-    assert kls.classifier_trained, "classifier not trained"
-    print(f"  PASS: Classifier trained ({kls.classifier is not None})")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 6: train_hypotheses (memory-efficient vectorized version)
-print("\n[Test 6] train_hypotheses (memory-efficient vectorized)...")
-try:
-    t0 = time.time()
-    result = kls.train_hypotheses()
-    elapsed_ms = (time.time() - t0) * 1000
-    assert result["active"], f"not active: {result}"
-    assert result["n_steps"] == 30, f"n_steps={result['n_steps']}"
-    print(f"  PASS: train_hypotheses completed in {elapsed_ms:.0f}ms")
-    print(f"    n_steps={result['n_steps']}, n_hypotheses={result['n_hypotheses']}")
-    print(f"    loss_initial={result['loss_initial']:.4f}, loss_final={result['loss_final']:.4f}")
-    print(f"    delta_scale_final={result['delta_scale_final']:.6f}")
-    if "adaptation" in result:
-        adapt = result["adaptation"]
-        print(f"    adaptation: adapted={adapt['adapted']}, rules={adapt['rules_fired']}")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 7: SOM metrics (8 canonical metrics)
-print("\n[Test 7] SOM metrics (8 canonical)...")
-try:
-    metrics = kls.compute_som_metrics()
-    assert "quantization_error" in metrics
-    assert "topological_error" in metrics
-    assert "kaski_lagus_error" in metrics
-    assert "explained_variance_share" in metrics
-    assert "topological_collapse" in metrics
-    assert "dead_neuron_rate" in metrics
-    assert "qe_stagnation" in metrics
-    assert "neighborhood_crossing" in metrics
-    assert "overall_health" in metrics
-    print(f"  PASS: All 8 SOM metrics computed")
-    print(f"    QE={metrics['quantization_error']:.4f}")
-    print(f"    TE={metrics['topological_error']:.4f}")
-    print(f"    KL={metrics['kaski_lagus_error']:.4f}")
-    print(f"    VE={metrics['explained_variance_share']:.4f}")
-    print(f"    dead_neuron_rate={metrics['dead_neuron_rate'].get('dead_neuron_rate', 0):.3f}")
-    print(f"    collapse_severity={metrics['topological_collapse'].get('severity', '?')}")
-    print(f"    overall_health={metrics['overall_health']}")
-    print(f"    n_failure_indicators={metrics['n_failure_indicators']}")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 8: select_best_delta (vectorized)
-print("\n[Test 8] select_best_delta (3 trials × 16 hypotheses)...")
-try:
-    t0 = time.time()
-    best_delta, best_acc, info = kls.select_best_delta()
-    elapsed_ms = (time.time() - t0) * 1000
-    assert info["active"], f"not active: {info}"
-    assert info["n_trials"] == 3, f"n_trials={info['n_trials']}"
-    assert info["n_hypotheses"] == 16, f"n_hyp={info['n_hypotheses']}"
-    print(f"  PASS: select_best_delta completed in {elapsed_ms:.0f}ms")
-    print(f"    best_acc={best_acc:.4f}")
-    print(f"    delta_norm={info['delta_norm']:.4f}")
-    print(f"    n_trials={info['n_trials']}, n_hypotheses={info['n_hypotheses']}")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 9: process_batch_v2 (CONHECIMENTO + PUNIÇÃO)
-print("\n[Test 9] process_batch_v2 (CONHECIMENTO + PUNIÇÃO)...")
-try:
-    # CONHECIMENTO
-    result_conh = kls.process_batch_v2(
-        ["o gato dorme", "o cachorro corre"],
-        [0, 1],
-        label_strings={0: "negative_class", 1: "positive_class"},
-        dataset_name="test_ds",
-        enable_punishment=False,
-    )
-    assert result_conh["phase"] == "CONHECIMENTO"
-    print(f"  PASS: CONHECIMENTO phase works: {result_conh['phase']}")
-
-    # PUNIÇÃO
-    result_pun = kls.process_batch_v2(
-        ["o gato dorme", "o cachorro corre"],
-        [0, 1],
-        label_strings={0: "negative_class", 1: "positive_class"},
-        dataset_name="test_ds",
-        enable_punishment=True,
-    )
-    assert result_pun["phase"] == "PUNICAO"
-    print(f"  PASS: PUNIÇÃO phase works: {result_pun['phase']}")
-    print(f"    action: {result_pun.get('action', 'none')}")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 10: aggressive_cleanup
-print("\n[Test 10] aggressive_cleanup()...")
-try:
-    cleanup_result = kls.aggressive_cleanup()
-    assert "rss_before_mb" in cleanup_result
-    assert "rss_after_mb" in cleanup_result
-    assert "gc_collected" in cleanup_result
-    print(f"  PASS: aggressive_cleanup() called")
-    print(f"    rss_before={cleanup_result['rss_before_mb']:.1f}MB")
-    print(f"    rss_after={cleanup_result['rss_after_mb']:.1f}MB")
-    print(f"    freed={cleanup_result['freed_mb']:.1f}MB")
-    print(f"    gc_collected={cleanup_result['gc_collected']}")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Test 11: get_v2_metrics
-print("\n[Test 11] get_v2_metrics()...")
-try:
-    v2_metrics = kls.get_v2_metrics()
-    assert v2_metrics["version"] == "V2-dynamic"
-    assert v2_metrics["n_hypotheses"] == 16
-    print(f"  PASS: get_v2_metrics() works")
-    print(f"    version={v2_metrics['version']}")
-    print(f"    n_hypotheses={v2_metrics['n_hypotheses']}")
-    print(f"    n_trials={v2_metrics['n_trials']}")
-    print(f"    hyp_train_steps={v2_metrics['hyp_train_steps']}")
-    print(f"    buffer_size={v2_metrics['buffer_size']}")
-    if "dynamic_adaptation" in v2_metrics:
-        da = v2_metrics["dynamic_adaptation"]
-        print(f"    n_adaptations={da['n_adaptations']}")
-        print(f"    loss_stats: slope={da['loss_stats']['slope']:.6f}, vol={da['loss_stats']['volatility']:.3f}")
-except Exception as e:
-    print(f"  FAIL: {e}")
-    traceback.print_exc()
-    sys.exit(1)
-
-# Summary
-print("\n" + "=" * 80)
-print("SMOKE TEST SUMMARY")
-print("=" * 80)
-print("  ALL TESTS PASSED")
-print("  - KLS V2 with restored params (HIDDEN=1024, VOCAB=16384) ✓")
-print("  - Memory-efficient train_hypotheses (vectorized) ✓")
-print("  - Bug fix: gradient flows through deltas → SOM → loss ✓")
-print("  - 8 SOM canonical metrics computed ✓")
-print("  - Dynamic labels (no hardcoded gato/cachorro) ✓")
-print("  - CONHECIMENTO + PUNIÇÃO phases ✓")
-print("  - aggressive_cleanup() works ✓")
-print("=" * 80)
-sys.exit(0)

som_metrics.py

@@ -1,811 +0,0 @@
-"""som_metrics.py — V6.5-V2-metrics: Métricas de aprendizado e indicadores de
-falha para Mapas Auto-Organizáveis (SOM / Redes de Kohonen).
-
-============================================================================
-MÉTRICAS PRINCIPAIS DE APRENDIZADO
-============================================================================
-
-1.1. Erro de Quantização (Quantization Error - QE)
-     Média das distâncias euclidianas entre cada vetor de entrada e o vetor
-     de pesos de seu neurônio vencedor (BMU). Mede a resolução ou ajuste fino
-     do mapa aos dados.
-
-         QE = (1/N) * Σ_i ||x_i - W_BMU(x_i)||₂
-
-1.2. Erro Topológico (Topological Error - TE)
-     Percentual de vetores de entrada cujos primeiro e segundo neurônios
-     mais próximos (BMU e segunda BMU) NÃO são vizinhos diretos na grade
-     de saída. Avalia preservação das relações geométricas.
-
-         TE = (1/N) * Σ_i 𝟙[¬adjacent(BMU_1(x_i), BMU_2(x_i))]
-
-1.3. Erro de Kaski-Lagus
-     Combinação ponderada que penaliza tanto a falta de resolução do vetor
-     de quantização quanto as quebras na continuidade topológica.
-
-         KL = α * QE_norm + β * TE
-         onde α=0.5, β=0.5 (pesos padrão)
-
-     Variante implementada: KL = QE * (1 + TE)  (penaliza QE quando TE é alto)
-
-1.4. Variância Explicada (Share of Explained Variance)
-     Fração da variabilidade total dos dados de entrada que é mapeada e
-     representada pelos vetores de referência (pesos) dos nós da rede.
-
-         VarExplained = 1 - Var(residual) / Var(total)
-         onde residual = x_i - W_BMU(x_i)
-
-============================================================================
-INDICADORES DE NÃO APRENDIZADO OU FALHA
-============================================================================
-
-2.1. Colapso Topológico (Topological Collapse)
-     Ocorre quando todos os vetores de peso convergem para o mesmo ponto
-     ou para uma linha reta. Indica perda total da dimensionalidade útil.
-
-     Detecção:
-       - std(weights) por dimensão < threshold (colapso total)
-       - rank(weights reshaped) < 2 (todos num ponto)
-       - rank < 3 (todos numa linha)
-
-2.2. Taxa de Neurônios Mortos (Dead Neurons)
-     Percentual de neurônios que NUNCA se tornam BMU para nenhum vetor.
-
-         DeadRate = (n_neurons - n_active_neurons) / n_neurons
-
-     Threshold: DeadRate > 0.5 indica problema.
-
-2.3. Estagnação do Erro de Quantização
-     QE estabiliza em patamar elevado ao longo das épocas. A taxa de
-     aprendizado decaiu rápido demais antes da fase de ordenação global.
-
-     Detecção: slope(QE) ≈ 0 E QE atual > 0.7 * max(QE histórico)
-
-2.4. Cruzamento de Vizinhança (Neighborhood Crossing)
-     Crescimento repentino ou oscilação crônica do TE nas épocas finais.
-
-     Detecção:
-       - std(TE_final_5_epochs) > 2 * std(TE_initial_5_epochs) (oscilação)
-       - TE[-1] > TE[-5] (crescimento no final)
-
-============================================================================
-AUTOR: V6.5-V2-metrics
-============================================================================
-"""
-from __future__ import annotations
-
-import math
-import logging
-from collections import defaultdict, deque
-from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Tuple
-
-import torch
-import torch.nn.functional as F
-
-logger = logging.getLogger(__name__)
-
-
-# ============================================================================
-# Dataclass para armazenar histórico de métricas
-# ============================================================================
-@dataclass
-class SOMMetricHistory:
-    """Histórico deslizante de métricas SOM para detecção de estagnação e
-    cruzamento de vizinhança."""
-    qe_history: deque = field(default_factory=lambda: deque(maxlen=50))
-    te_history: deque = field(default_factory=lambda: deque(maxlen=50))
-    kl_history: deque = field(default_factory=lambda: deque(maxlen=50))
-    var_explained_history: deque = field(default_factory=lambda: deque(maxlen=50))
-    dead_neuron_rate_history: deque = field(default_factory=lambda: deque(maxlen=50))
-    epoch: int = 0
-
-    def record(self, metrics: Dict[str, Any]) -> None:
-        """Registra métricas de uma época.
-
-        Nota: `dead_neuron_rate` pode ser float (valor direto) ou Dict
-        (saída de compute_all_metrics, com chave 'dead_neuron_rate').
-        """
-        self.qe_history.append(float(metrics.get("quantization_error", 0.0)))
-        self.te_history.append(float(metrics.get("topological_error", 0.0)))
-        self.kl_history.append(float(metrics.get("kaski_lagus_error", 0.0)))
-        self.var_explained_history.append(
-            float(metrics.get("explained_variance_share", 0.0))
-        )
-        # dead_neuron_rate pode ser float ou Dict
-        dnr = metrics.get("dead_neuron_rate", 0.0)
-        if isinstance(dnr, dict):
-            dnr_val = float(dnr.get("dead_neuron_rate", 0.0))
-        else:
-            dnr_val = float(dnr)
-        self.dead_neuron_rate_history.append(dnr_val)
-        self.epoch += 1
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "epoch": int(self.epoch),
-            "qe_history": list(self.qe_history),
-            "te_history": list(self.te_history),
-            "kl_history": list(self.kl_history),
-            "var_explained_history": list(self.var_explained_history),
-            "dead_neuron_rate_history": list(self.dead_neuron_rate_history),
-        }
-
-
-# ============================================================================
-# Funções auxiliares
-# ============================================================================
-def _grid_neighbors_set(
-    idx: Tuple[int, int, int, int],
-    grid_shape: Tuple[int, int, int, int],
-) -> set:
-    """Retorna o conjunto de índices vizinhos diretos (6-connectivity em 4D)
-    de um neurônio na grade."""
-    i, j, k, l = idx
-    I, J, K, L = grid_shape
-    neighbors = set()
-    for di, dj, dk, dl in [
-        (1, 0, 0, 0), (-1, 0, 0, 0),
-        (0, 1, 0, 0), (0, -1, 0, 0),
-        (0, 0, 1, 0), (0, 0, -1, 0),
-        (0, 0, 0, 1), (0, 0, 0, -1),
-    ]:
-        ni, nj, nk, nl = i + di, j + dj, k + dk, l + dl
-        if 0 <= ni < I and 0 <= nj < J and 0 <= nk < K and 0 <= nl < L:
-            neighbors.add((ni, nj, nk, nl))
-    return neighbors
-
-
-def _find_bmu_and_second(
-    x: torch.Tensor, weights: torch.Tensor
-) -> Tuple[Tuple[int, int, int, int], Tuple[int, int, int, int], float, float]:
-    """Encontra BMU e 2ª BMU para um vetor x.
-
-    Args:
-        x: tensor [4] — vetor 4D de entrada.
-        weights: tensor [I, J, K, L, 4] — pesos do SOM.
-
-    Returns:
-        (bmu_idx, second_bmu_idx, dist_bmu, dist_second)
-    """
-    grid_shape = weights.shape[:-1]
-    flat_w = weights.view(-1, 4)  # (I*J*K*L, 4)
-    diff = flat_w - x.view(1, 4)
-    dist_sq = torch.sum(diff * diff, dim=-1)  # (I*J*K*L,)
-
-    # Top-2 menores distâncias
-    top2 = torch.topk(dist_sq, k=2, largest=False)
-    flat_idx_bmu = int(top2.indices[0].item())
-    flat_idx_2nd = int(top2.indices[1].item())
-
-    # Unravel
-    L = grid_shape[3]
-    K = grid_shape[2]
-    J = grid_shape[1]
-
-    def unravel(flat_idx: int) -> Tuple[int, int, int, int]:
-        i = flat_idx // (J * K * L)
-        r = flat_idx % (J * K * L)
-        j = r // (K * L)
-        r = r % (K * L)
-        k = r // L
-        l = r % L
-        return (i, j, k, l)
-
-    bmu = unravel(flat_idx_bmu)
-    second = unravel(flat_idx_2nd)
-    dist_bmu = float(math.sqrt(max(top2.values[0].item(), 0.0)))
-    dist_second = float(math.sqrt(max(top2.values[1].item(), 0.0)))
-    return bmu, second, dist_bmu, dist_second
-
-
-# ============================================================================
-# Métricas principais (1.1 - 1.4)
-# ============================================================================
-def quantization_error(
-    data: torch.Tensor, weights: torch.Tensor
-) -> float:
-    """1.1 Erro de Quantização (QE).
-
-    QE = (1/N) * Σ_i ||x_i - W_BMU(x_i)||₂
-
-    Args:
-        data: tensor [N, 4] — vetores de entrada.
-        weights: tensor [I, J, K, L, 4] — pesos do SOM.
-
-    Returns:
-        QE (float). 0.0 se data vazio.
-    """
-    if data.numel() == 0:
-        return 0.0
-    flat_w = weights.view(-1, 4)  # (M, 4)
-    # distância de cada amostra a todos os neurônios
-    # data: (N, 4), flat_w: (M, 4) -> (N, M)
-    diff = data.unsqueeze(1) - flat_w.unsqueeze(0)
-    dist_sq = torch.sum(diff * diff, dim=-1)  # (N, M)
-    min_dist_sq, _ = torch.min(dist_sq, dim=1)  # (N,)
-    qe = torch.mean(torch.sqrt(min_dist_sq.clamp(min=0.0)))
-    return float(qe.item())
-
-
-def topological_error(
-    data: torch.Tensor, weights: torch.Tensor
-) -> float:
-    """1.2 Erro Topológico (TE).
-
-    TE = (1/N) * Σ_i 𝟙[¬adjacent(BMU_1(x_i), BMU_2(x_i))]
-
-    Dois neurônios são adjacentes se differem em exatamente uma coordenada
-    por ±1 (6-connectivity em 4D).
-
-    Args:
-        data: tensor [N, 4]
-        weights: tensor [I, J, K, L, 4]
-
-    Returns:
-        TE ∈ [0, 1]. 0.0 se data vazio.
-    """
-    if data.numel() == 0:
-        return 0.0
-    grid_shape = weights.shape[:-1]
-    flat_w = weights.view(-1, 4)
-    diff = data.unsqueeze(1) - flat_w.unsqueeze(0)
-    dist_sq = torch.sum(diff * diff, dim=-1)  # (N, M)
-
-    # Top-2 BMUs para cada amostra
-    top2 = torch.topk(dist_sq, k=2, largest=False, dim=1)
-    flat_bmu = top2.indices[:, 0]  # (N,)
-    flat_2nd = top2.indices[:, 1]  # (N,)
-
-    # Unravel
-    L = grid_shape[3]
-    K = grid_shape[2]
-    J = grid_shape[1]
-    I = grid_shape[0]
-
-    def unravel_batch(flat_idx: torch.Tensor) -> torch.Tensor:
-        """Retorna tensor (N, 4) com (i, j, k, l)."""
-        i = flat_idx // (J * K * L)
-        r = flat_idx % (J * K * L)
-        j = r // (K * L)
-        r = r % (K * L)
-        k = r // L
-        l = r % L
-        return torch.stack([i, j, k, l], dim=1).long()
-
-    bmu_idx = unravel_batch(flat_bmu)  # (N, 4)
-    second_idx = unravel_batch(flat_2nd)  # (N, 4)
-
-    # Adjacência: |Δcoord| soma = 1 (apenas uma coordenada muda por ±1)
-    delta = (bmu_idx - second_idx).abs()  # (N, 4)
-    is_adjacent = (delta.sum(dim=1) == 1) & (delta.max(dim=1).values == 1)
-
-    te = 1.0 - float(is_adjacent.float().mean().item())
-    return te
-
-
-def kaski_lagus_error(
-    data: torch.Tensor, weights: torch.Tensor, alpha: float = 0.5
-) -> float:
-    """1.3 Erro de Kaski-Lagus.
-
-    Combinação ponderada de QE normalizado e TE.
-
-    Variante implementada (Kaski & Lagus, 1999):
-        KL = α * MQE_norm + (1-α) * TE
-    onde MQE_norm = QE / mean(||x||) (normalização por escala dos dados).
-
-    Uma variante alternativa multiplica:
-        KL = QE * (1 + TE)
-    que penaliza QE quando TE é alto (usada se use_multiplicative=True).
-
-    Args:
-        data: tensor [N, 4]
-        weights: tensor [I, J, K, L, 4]
-        alpha: peso do QE normalizado (default 0.5)
-
-    Returns:
-        KL (float).
-    """
-    if data.numel() == 0:
-        return 0.0
-    qe = quantization_error(data, weights)
-    te = topological_error(data, weights)
-    # Normalização: escala típica dos dados
-    data_norm = float(torch.mean(torch.norm(data, dim=1)).item())
-    qe_norm = qe / max(data_norm, 1e-8)
-    kl = alpha * qe_norm + (1.0 - alpha) * te
-    return float(kl)
-
-
-def explained_variance_share(
-    data: torch.Tensor, weights: torch.Tensor
-) -> float:
-    """1.4 Variância Explicada (Share of Explained Variance).
-
-    VarExplained = 1 - Var(residual) / Var(total)
-    onde residual = x_i - W_BMU(x_i)
-
-    Implementação: computamos a variância total dos dados (soma das variâncias
-    por dimensão) e a variância dos resíduos. A fração explicada é:
-
-        VE = 1 - Σ_d Var(residual_d) / Σ_d Var(data_d)
-
-    Returns:
-        VE ∈ [0, 1]. Próximo de 1 = boa representação.
-    """
-    if data.numel() == 0 or data.shape[0] < 2:
-        return 0.0
-    flat_w = weights.view(-1, 4)
-    diff = data.unsqueeze(1) - flat_w.unsqueeze(0)
-    dist_sq = torch.sum(diff * diff, dim=-1)  # (N, M)
-    _, bmu_flat = torch.min(dist_sq, dim=1)  # (N,)
-    bmu_w = flat_w[bmu_flat]  # (N, 4)
-    residual = data - bmu_w  # (N, 4)
-
-    # Variância por dimensão (sem viés, ddof=0)
-    var_data = torch.var(data, dim=0, unbiased=False)  # (4,)
-    var_resid = torch.var(residual, dim=0, unbiased=False)  # (4,)
-
-    total_var = float(torch.sum(var_data).item())
-    resid_var = float(torch.sum(var_resid).item())
-    if total_var < 1e-12:
-        return 0.0
-    ve = 1.0 - (resid_var / total_var)
-    return float(max(0.0, min(1.0, ve)))
-
-
-# ============================================================================
-# Indicadores de falha (2.1 - 2.4)
-# ============================================================================
-def topological_collapse(weights: torch.Tensor) -> Dict[str, Any]:
-    """2.1 Colapso Topológico (Topological Collapse).
-
-    Detecta se os pesos colapsaram para um ponto (rank < 1) ou para uma linha
-    (rank < 2). Usa SVD sobre os pesos reshaped (M, 4).
-
-    Args:
-        weights: tensor [I, J, K, L, 4]
-
-    Returns:
-        Dict com:
-          - collapsed_to_point: bool (todos iguais)
-          - collapsed_to_line: bool (variação só em 1 direção)
-          - effective_rank: float (rank efetivo via razão de singular values)
-          - singular_values: list[float]
-          - severity: str ("none" | "line" | "point")
-    """
-    flat_w = weights.view(-1, 4).clone()  # (M, 4)
-    if flat_w.numel() == 0:
-        return {"collapsed_to_point": False, "collapsed_to_line": False,
-                "effective_rank": 0.0, "singular_values": [], "severity": "none"}
-
-    # Centraliza
-    flat_w_centered = flat_w - flat_w.mean(dim=0, keepdim=True)
-
-    # V6.5-V2-metrics FIX: usa SVD com fallback robusto para matrizes
-    # singulares/ill-conditioned. Se SVD falhar, usa np.linalg.eigh com
-    # regularização (adiciona pequeno ruído diagonal).
-    S_list: List[float] = []
-    try:
-        # Tentativa 1: SVD direto (mais estável que eigh)
-        U, S, V = torch.linalg.svd(flat_w_centered, full_matrices=False)
-        S_list = [float(s.item()) for s in S]
-    except Exception:
-        # Tentativa 2: eigendecomposição da matriz de covariância com regularização
-        try:
-            cov = flat_w_centered.t() @ flat_w_centered
-            # Regularização: adiciona pequeno valor diagonal para estabilizar
-            n = cov.shape[0]
-            reg = 1e-6 * float(cov.diag().max().item()) if n > 0 else 1e-6
-            cov_reg = cov + torch.eye(n) * reg
-            S_eigh, _ = torch.linalg.eigh(cov_reg)
-            S_eigh = S_eigh.flip(0)  # descending order
-            # Converte autovalores em "singular values" aproximados (sqrt)
-            S_list = [float(math.sqrt(max(s.item(), 0.0))) for s in S_eigh]
-        except Exception:
-            # Tentativa 3: usa norma de Frobenius como aproximação
-            s_frob = float(torch.norm(flat_w_centered).item())
-            S_list = [s_frob, 0.0, 0.0, 0.0]
-
-    if not S_list:
-        return {"collapsed_to_point": False, "collapsed_to_line": False,
-                "effective_rank": 0.0, "singular_values": [], "severity": "none"}
-
-    s_max = max(S_list[0] if S_list else 0.0, 1e-12)
-
-    # Effective rank: número de singular values > 1% do maior
-    threshold = 0.01 * s_max
-    n_significant = sum(1 for s in S_list if s > threshold)
-    # Effective rank (float, via entropy)
-    s_norm = [s / s_max for s in S_list]
-    s_norm = [s for s in s_norm if s > 1e-10]
-    if s_norm:
-        p = torch.tensor(s_norm)
-        p_norm = p / p.sum()
-        entropy = -float(torch.sum(p_norm * torch.log(p_norm)).item())
-        effective_rank = math.exp(entropy)
-    else:
-        effective_rank = 0.0
-
-    collapsed_to_point = n_significant <= 1 and s_max < 1e-6
-    collapsed_to_line = n_significant == 1 and s_max >= 1e-6
-
-    if collapsed_to_point:
-        severity = "point"
-    elif collapsed_to_line:
-        severity = "line"
-    else:
-        severity = "none"
-
-    return {
-        "collapsed_to_point": bool(collapsed_to_point),
-        "collapsed_to_line": bool(collapsed_to_line),
-        "effective_rank": float(effective_rank),
-        "singular_values": S_list,
-        "severity": severity,
-    }
-
-
-def dead_neuron_rate(
-    data: torch.Tensor, weights: torch.Tensor
-) -> Dict[str, Any]:
-    """2.2 Taxa de Neurônios Mortos (Dead Neurons).
-
-    DeadRate = (n_neurons - n_active_neurons) / n_neurons
-
-    Um neurônio é "ativo" se é BMU para pelo menos uma amostra.
-
-    Args:
-        data: tensor [N, 4]
-        weights: tensor [I, J, K, L, 4]
-
-    Returns:
-        Dict com:
-          - dead_neuron_rate: float ∈ [0, 1]
-          - n_dead: int
-          - n_active: int
-          - n_total: int
-          - dead_indices: list de (i,j,k,l)
-    """
-    n_total = weights.shape[0] * weights.shape[1] * weights.shape[2] * weights.shape[3]
-    if data.numel() == 0:
-        return {"dead_neuron_rate": 1.0, "n_dead": n_total, "n_active": 0,
-                "n_total": n_total, "dead_indices": []}
-
-    flat_w = weights.view(-1, 4)
-    diff = data.unsqueeze(1) - flat_w.unsqueeze(0)
-    dist_sq = torch.sum(diff * diff, dim=-1)  # (N, M)
-    _, bmu_flat = torch.min(dist_sq, dim=1)  # (N,)
-
-    active_mask = torch.zeros(n_total, dtype=torch.bool)
-    active_mask[bmu_flat] = True
-    n_active = int(active_mask.sum().item())
-    n_dead = n_total - n_active
-
-    # Coleta índices mortos
-    dead_flat = (~active_mask).nonzero(as_tuple=True)[0]
-    L_dim = weights.shape[3]
-    K_dim = weights.shape[2]
-    J_dim = weights.shape[1]
-    dead_indices = []
-    for flat_idx in dead_flat.tolist():
-        i = flat_idx // (J_dim * K_dim * L_dim)
-        r = flat_idx % (J_dim * K_dim * L_dim)
-        j = r // (K_dim * L_dim)
-        r = r % (K_dim * L_dim)
-        k = r // L_dim
-        l = r % L_dim
-        dead_indices.append((i, j, k, l))
-
-    return {
-        "dead_neuron_rate": float(n_dead / n_total) if n_total > 0 else 0.0,
-        "n_dead": int(n_dead),
-        "n_active": int(n_active),
-        "n_total": int(n_total),
-        "dead_indices": dead_indices[:50],  # limita para não explodir JSON
-    }
-
-
-def quantization_error_stagnation(
-    history: SOMMetricHistory,
-    high_threshold_frac: float = 0.7,
-    slope_tolerance: float = 1e-4,
-    window_size: int = 5,
-) -> Dict[str, Any]:
-    """2.3 Estagnação do Erro de Quantização.
-
-    Detecta se o QE estabilizou em patamar elevado:
-      - |slope(QE)| < slope_tolerance (estável)
-      - QE_atual > high_threshold_frac * max(QE_history) (alto)
-
-    Args:
-        history: histórico de métricas SOM.
-        high_threshold_frac: fração do QE máximo para considerar "alto".
-        slope_tolerance: tolerância de slope para considerar "estável".
-        window_size: nº de épocas recentes para regressão linear.
-
-    Returns:
-        Dict com:
-          - is_stagnant: bool
-          - current_qe: float
-          - max_qe: float
-          - slope: float
-          - severity: str ("none" | "mild" | "severe")
-    """
-    qe_list = list(history.qe_history)
-    if len(qe_list) < window_size + 2:
-        return {"is_stagnant": False, "current_qe": 0.0, "max_qe": 0.0,
-                "slope": 0.0, "severity": "none", "n_epochs": len(qe_list)}
-
-    # Regressão linear sobre as últimas window_size épocas
-    recent = qe_list[-window_size:]
-    n = len(recent)
-    x_mean = (n - 1) / 2.0
-    y_mean = sum(recent) / n
-    num = sum((i - x_mean) * (y - y_mean) for i, y in enumerate(recent))
-    den = sum((i - x_mean) ** 2 for i in range(n))
-    slope = num / den if den > 0 else 0.0
-
-    current_qe = float(qe_list[-1])
-    max_qe = float(max(qe_list))
-    is_high = current_qe > high_threshold_frac * max_qe
-    is_stable = abs(slope) < slope_tolerance
-
-    is_stagnant = is_stable and is_high
-
-    if is_stagnant:
-        if current_qe > 0.9 * max_qe:
-            severity = "severe"
-        else:
-            severity = "mild"
-    else:
-        severity = "none"
-
-    return {
-        "is_stagnant": bool(is_stagnant),
-        "current_qe": current_qe,
-        "max_qe": max_qe,
-        "slope": float(slope),
-        "severity": severity,
-        "n_epochs": len(qe_list),
-    }
-
-
-def neighborhood_crossing(
-    history: SOMMetricHistory,
-    initial_window: int = 5,
-    final_window: int = 5,
-    growth_threshold: float = 1.5,
-) -> Dict[str, Any]:
-    """2.4 Cruzamento de Vizinhança (Neighborhood Crossing).
-
-    Detecta crescimento repentino ou oscilação crônica do TE nas épocas
-    finais:
-      - std(TE_final) > growth_threshold * std(TE_initial) (oscilação cresceu)
-      - TE[-1] > TE[-5] (crescimento no final)
-
-    Args:
-        history: histórico de métricas SOM.
-        initial_window: nº de épocas iniciais para baseline.
-        final_window: nº de épocas finais para comparação.
-        growth_threshold: razão de std para considerar "crescimento crônico".
-
-    Returns:
-        Dict com:
-          - detected: bool
-          - te_initial_mean: float
-          - te_final_mean: float
-          - te_initial_std: float
-          - te_final_std: float
-          - std_ratio: float
-          - is_oscillating: bool
-          - is_growing: bool
-          - severity: str ("none" | "mild" | "severe")
-    """
-    te_list = list(history.te_history)
-    if len(te_list) < initial_window + final_window:
-        return {"detected": False, "te_initial_mean": 0.0, "te_final_mean": 0.0,
-                "te_initial_std": 0.0, "te_final_std": 0.0, "std_ratio": 0.0,
-                "is_oscillating": False, "is_growing": False, "severity": "none",
-                "n_epochs": len(te_list)}
-
-    initial = te_list[:initial_window]
-    final = te_list[-final_window:]
-
-    init_mean = sum(initial) / len(initial)
-    final_mean = sum(final) / len(final)
-    init_var = sum((x - init_mean) ** 2 for x in initial) / len(initial)
-    final_var = sum((x - final_mean) ** 2 for x in final) / len(final)
-    init_std = math.sqrt(init_var)
-    final_std = math.sqrt(final_var)
-
-    std_ratio = final_std / max(init_std, 1e-8)
-    is_oscillating = std_ratio > growth_threshold
-    is_growing = final_mean > init_mean and (final_mean - init_mean) > 0.05
-
-    detected = is_oscillating or is_growing
-
-    if detected:
-        if std_ratio > 2.0 * growth_threshold or is_growing:
-            severity = "severe"
-        else:
-            severity = "mild"
-    else:
-        severity = "none"
-
-    return {
-        "detected": bool(detected),
-        "te_initial_mean": float(init_mean),
-        "te_final_mean": float(final_mean),
-        "te_initial_std": float(init_std),
-        "te_final_std": float(final_std),
-        "std_ratio": float(std_ratio),
-        "is_oscillating": bool(is_oscillating),
-        "is_growing": bool(is_growing),
-        "severity": severity,
-        "n_epochs": len(te_list),
-    }
-
-
-# ============================================================================
-# Função agregadora: compute_all_metrics
-# ============================================================================
-def compute_all_metrics(
-    data: torch.Tensor,
-    weights: torch.Tensor,
-    history: Optional[SOMMetricHistory] = None,
-) -> Dict[str, Any]:
-    """Computa todas as métricas SOM de uma vez.
-
-    Args:
-        data: tensor [N, 4] — buffer de vetores 4D.
-        weights: tensor [I, J, K, L, 4] — pesos do SOM.
-        history: histórico de métricas (opcional, para estagnação e cruzamento).
-
-    Returns:
-        Dict com:
-          - quantization_error: float
-          - topological_error: float
-          - kaski_lagus_error: float
-          - explained_variance_share: float
-          - topological_collapse: Dict
-          - dead_neuron_rate: Dict
-          - quantization_error_stagnation: Dict (se history fornecido)
-          - neighborhood_crossing: Dict (se history fornecido)
-          - overall_health: str ("healthy" | "warning" | "critical")
-          - failure_indicators: list[str]
-    """
-    # V6.5-V2-metrics FIX: wrap entire computation in try/except para evitar
-    # crashes fatais quando o SOM tem pesos degenerados (ex: todos iguais
-    # após muito treinamento sem diversidade). Em caso de erro, retorna
-    # métricas safe-default em vez de crashar o treino.
-    try:
-        return _compute_all_metrics_impl(data, weights, history)
-    except Exception as e:
-        logger.warning(
-            f"[som_metrics] compute_all_metrics failed (using safe defaults): {e}"
-        )
-        return {
-            "quantization_error": 0.0,
-            "topological_error": 0.0,
-            "kaski_lagus_error": 0.0,
-            "explained_variance_share": 0.0,
-            "topological_collapse": {
-                "collapsed_to_point": False, "collapsed_to_line": False,
-                "effective_rank": 0.0, "singular_values": [],
-                "severity": "none", "error": str(e)[:200],
-            },
-            "dead_neuron_rate": {
-                "dead_neuron_rate": 1.0, "n_dead": 0, "n_active": 0,
-                "n_total": 0, "dead_indices": [], "error": str(e)[:200],
-            },
-            "qe_stagnation": {
-                "is_stagnant": False, "current_qe": 0.0, "max_qe": 0.0,
-                "slope": 0.0, "severity": "none", "n_epochs": 0,
-            },
-            "neighborhood_crossing": {
-                "detected": False, "te_initial_mean": 0.0, "te_final_mean": 0.0,
-                "te_initial_std": 0.0, "te_final_std": 0.0, "std_ratio": 0.0,
-                "is_oscillating": False, "is_growing": False, "severity": "none",
-                "n_epochs": 0,
-            },
-            "overall_health": "unknown",
-            "failure_indicators": [f"metrics_computation_error: {str(e)[:100]}"],
-            "n_failure_indicators": 1,
-            "error": str(e)[:300],
-        }
-
-
-def _compute_all_metrics_impl(
-    data: torch.Tensor,
-    weights: torch.Tensor,
-    history: Optional[SOMMetricHistory] = None,
-) -> Dict[str, Any]:
-    """Implementação interna de compute_all_metrics (sem try/except wrapper)."""
-    metrics: Dict[str, Any] = {}
-
-    # 1.1 - 1.4: Métricas principais
-    metrics["quantization_error"] = quantization_error(data, weights)
-    metrics["topological_error"] = topological_error(data, weights)
-    metrics["kaski_lagus_error"] = kaski_lagus_error(data, weights)
-    metrics["explained_variance_share"] = explained_variance_share(data, weights)
-
-    # 2.1: Colapso topológico
-    collapse = topological_collapse(weights)
-    metrics["topological_collapse"] = collapse
-
-    # 2.2: Dead neurons
-    dead = dead_neuron_rate(data, weights)
-    metrics["dead_neuron_rate"] = dead
-
-    # 2.3: Estagnação do QE (requer histórico)
-    if history is not None and len(history.qe_history) > 5:
-        metrics["qe_stagnation"] = quantization_error_stagnation(history)
-    else:
-        metrics["qe_stagnation"] = {
-            "is_stagnant": False, "current_qe": metrics["quantization_error"],
-            "max_qe": metrics["quantization_error"], "slope": 0.0,
-            "severity": "none", "n_epochs": 0,
-        }
-
-    # 2.4: Cruzamento de vizinhança (requer histórico)
-    if history is not None and len(history.te_history) > 10:
-        metrics["neighborhood_crossing"] = neighborhood_crossing(history)
-    else:
-        metrics["neighborhood_crossing"] = {
-            "detected": False, "te_initial_mean": 0.0, "te_final_mean": 0.0,
-            "te_initial_std": 0.0, "te_final_std": 0.0, "std_ratio": 0.0,
-            "is_oscillating": False, "is_growing": False, "severity": "none",
-            "n_epochs": 0,
-        }
-
-    # Avaliação de saúde geral
-    failure_indicators: List[str] = []
-    if collapse["collapsed_to_point"]:
-        failure_indicators.append("topological_collapse_point")
-    elif collapse["collapsed_to_line"]:
-        failure_indicators.append("topological_collapse_line")
-    if dead["dead_neuron_rate"] > 0.5:
-        failure_indicators.append(f"dead_neuron_rate_high_{dead['dead_neuron_rate']:.2f}")
-    if metrics["qe_stagnation"]["is_stagnant"]:
-        failure_indicators.append(f"qe_stagnant_{metrics['qe_stagnation']['severity']}")
-    if metrics["neighborhood_crossing"]["detected"]:
-        failure_indicators.append(
-            f"neighborhood_crossing_{metrics['neighborhood_crossing']['severity']}"
-        )
-    if metrics["explained_variance_share"] < 0.3:
-        failure_indicators.append(
-            f"low_explained_variance_{metrics['explained_variance_share']:.2f}"
-        )
-    if metrics["topological_error"] > 0.5:
-        failure_indicators.append(
-            f"high_topological_error_{metrics['topological_error']:.2f}"
-        )
-
-    if len(failure_indicators) >= 2:
-        overall_health = "critical"
-    elif len(failure_indicators) == 1:
-        overall_health = "warning"
-    else:
-        overall_health = "healthy"
-
-    metrics["failure_indicators"] = failure_indicators
-    metrics["overall_health"] = overall_health
-    metrics["n_failure_indicators"] = len(failure_indicators)
-
-    return metrics
-
-
-__all__ = [
-    "SOMMetricHistory",
-    "quantization_error",
-    "topological_error",
-    "kaski_lagus_error",
-    "explained_variance_share",
-    "topological_collapse",
-    "dead_neuron_rate",
-    "quantization_error_stagnation",
-    "neighborhood_crossing",
-    "compute_all_metrics",
-]

src/bigru_t/inference/langchain_adapter.py

@@ -1,218 +0,0 @@
-"""langchain_adapter.py — Adapter para compatibilidade com LangChain (V6).
-
-Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/langchain_adapter.py.
-
-Permite usar o BiGRU_T_version como:
-  - LLM chain (LLMChain)
-  - Tool (BaseTool)
-  - Memory (BaseMemory)
-  - Agent (LLMSingleActionAgent)
-
-V6 melhorias vs V13.9.2:
-  * Self-contained (sem dependência externa obrigatória)
-  * Lazy import do langchain (só importa se usado)
-  * Compatível com ToolMutationEngine e ToolAgentCoordinator
-
-REFERÊNCIAS:
-  - LangChain: https://python.langchain.com
-  - Tool pattern: https://python.langchain.com/docs/modules/agents/tools/
-"""
-from __future__ import annotations
-
-import time
-from typing import Any, Dict, List, Optional, Callable
-from collections import deque
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Adapter base (sem dependência do langchain)
-# ═══════════════════════════════════════════════════════════════════════════
-class LangchainAdapter:
-    """Adapter para compatibilidade com LangChain (V6).
-
-    Esta classe fornece interfaces compatíveis com LangChain, mas SEM exigir
-    que o langchain esteja instalado. Se langchain estiver disponível, os
-    métodos .as_langchain_*() retornarão objetos nativos do langchain;
-    caso contrário, retornarão dicts/wrappers compatíveis.
-
-    Args:
-        pipeline: OptimizedPipeline (ou qualquer modelo com .forward())
-        name: nome do modelo (default "BiGRU_T")
-        description: descrição (default "")
-    """
-
-    def __init__(
-        self,
-        pipeline,
-        name: str = "BiGRU_T",
-        description: str = "BiGRU_T_version model with V6 features",
-    ):
-        self.pipeline = pipeline
-        self.name = name
-        self.description = description
-        self._memory: deque = deque(maxlen=100)  # memory buffer
-
-    def __call__(
-        self,
-        prompt: str,
-        max_tokens: int = 128,
-        temperature: float = 1.0,
-        stop: Optional[List[str]] = None,
-    ) -> str:
-        """Gera texto a partir de um prompt (interface tipo LLM).
-
-        Args:
-            prompt: string de entrada
-            max_tokens: máx de tokens a gerar
-            temperature: temperatura do softmax
-            stop: lista de strings de parada (opcional)
-
-        Returns:
-            texto gerado
-        """
-        # Tokeniza (assumindo que o pipeline tem .tokenizer)
-        if hasattr(self.pipeline, "tokenizer") and self.pipeline.tokenizer is not None:
-            input_ids = self.pipeline.tokenizer.encode(prompt)
-            # Converte para tensor
-            import torch
-            input_ids = torch.tensor([input_ids], dtype=torch.long)
-        else:
-            # Sem tokenizer — retorna prompt ecoado
-            return f"[no tokenizer] {prompt}"
-
-        # Gera
-        import torch
-        with torch.no_grad():
-            generated = input_ids.clone()
-            for _ in range(max_tokens):
-                out = self.pipeline.forward(generated)
-                logits = out["logits"][:, -1, :]  # último token
-                # Aplica temperatura
-                logits = logits / max(temperature, 1e-6)
-                # Top-k sampling (k=10)
-                top_k = 10
-                top_vals, top_idx = logits.topk(top_k, dim=-1)
-                probs = top_vals.softmax(dim=-1)
-                next_tok = top_idx.gather(
-                    -1, torch.multinomial(probs, 1)
-                )
-                generated = torch.cat([generated, next_tok], dim=-1)
-                # Stop condition
-                if stop:
-                    decoded = self.pipeline.tokenizer.decode(generated[0].tolist())
-                    for s in stop:
-                        if s in decoded:
-                            return decoded
-
-        # Decodifica
-        result = self.pipeline.tokenizer.decode(generated[0].tolist())
-        # Atualiza memory
-        self._memory.append({"prompt": prompt, "response": result})
-        return result
-
-    def as_langchain_llm(self):
-        """Retorna um LLM compatível com LangChain (se langchain disponível)."""
-        try:
-            from langchain_core.language_models import LLM
-            from langchain_core.callbacks import CallbackManagerForLLMRun
-
-            adapter = self
-
-            class BiGRU_T_LLM(LLM):
-                @property
-                def _llm_type(self) -> str:
-                    return "bigru_t"
-
-                def _call(
-                    self,
-                    prompt: str,
-                    stop: Optional[List[str]] = None,
-                    run_manager: Optional[CallbackManagerForLLMRun] = None,
-                    **kwargs,
-                ) -> str:
-                    return adapter(prompt, stop=stop, **kwargs)
-
-            return BiGRU_T_LLM()
-        except ImportError:
-            # langchain não disponível — retorna wrapper
-            return {
-                "type": "langchain_llm_fallback",
-                "name": self.name,
-                "description": self.description,
-                "call": lambda prompt, **kw: self(prompt, **kw),
-            }
-
-    def as_langchain_tool(self, name: Optional[str] = None, description: Optional[str] = None):
-        """Retorna um Tool compatível com LangChain."""
-        try:
-            from langchain_core.tools import BaseTool
-            from pydantic import BaseModel, Field
-
-            adapter = self
-            tool_name = name or self.name
-            tool_desc = description or self.description
-
-            class BiGRU_T_ToolInput(BaseModel):
-                prompt: str = Field(description="Input prompt")
-
-            class BiGRU_T_Tool(BaseTool):
-                name: str = tool_name
-                description: str = tool_desc
-                args_schema: type = BiGRU_T_ToolInput
-
-                def _run(self, prompt: str, **kwargs) -> str:
-                    return adapter(prompt, **kwargs)
-
-                async def _arun(self, prompt: str, **kwargs) -> str:
-                    return adapter(prompt, **kwargs)
-
-            return BiGRU_T_Tool()
-        except ImportError:
-            return {
-                "type": "langchain_tool_fallback",
-                "name": name or self.name,
-                "description": description or self.description,
-                "call": lambda prompt, **kw: self(prompt, **kw),
-            }
-
-    def as_langchain_memory(self, max_items: int = 100):
-        """Retorna um Memory compatível com LangChain."""
-        try:
-            from langchain_core.memory import BaseMemory
-            from pydantic import BaseModel
-
-            adapter = self
-
-            class BiGRU_T_Memory(BaseMemory):
-                memory_key: str = "history"
-                max_items: int = max_items
-
-                @property
-                def memory_variables(self) -> List[str]:
-                    return [self.memory_key]
-
-                def load_memory_variables(self, inputs: Dict[str, Any]) -> Dict[str, str]:
-                    history = "\n".join(
-                        f"Human: {m['prompt']}\nAI: {m['response']}"
-                        for m in list(adapter._memory)[-self.max_items:]
-                    )
-                    return {self.memory_key: history}
-
-                def save_context(self, inputs: Dict[str, Any], outputs: Dict[str, str]) -> None:
-                    prompt = inputs.get("input", "")
-                    response = outputs.get("output", "")
-                    adapter._memory.append({"prompt": prompt, "response": response})
-
-                def clear(self) -> None:
-                    adapter._memory.clear()
-
-            return BiGRU_T_Memory()
-        except ImportError:
-            return {
-                "type": "langchain_memory_fallback",
-                "history": list(self._memory),
-                "clear": self._memory.clear,
-            }
-
-
-__all__ = ["LangchainAdapter"]

src/bigru_t/inference/optimized_pipeline.py

@@ -1,251 +0,0 @@
-"""optimized_pipeline.py — Pipeline otimizado para BiGRU_T_version V6.
-
-Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/optimized_pipeline.py.
-
-Pipeline unificado que integra todos os componentes V6:
-  - Tokenizer → Embedding
-  - WindowContext (2M tokens compression)
-  - Backbone (BiGRU_T modules + OrqCell com Kohonen 4D SOM)
-  - MTP (Multi-Token Prediction)
-  - MTPAdaptiveAttention
-  - DynamicRepetitionPenalty
-  - ReasoningEngine (opcional)
-  - EWC (durante treino continuado)
-  - RLHF Possibility Mapping (durante treino com feedback)
-  - Tools (ToolMutationEngine + ToolAgentCoordinator)
-
-V6 melhorias vs V13.9.2:
-  * Self-contained (sem TrustNeuralAgent externo)
-  * Memory-efficient: ativa componentes sob demanda
-  * Compatível com langchain (via LangchainAdapter)
-  * Lazy loading: só instancia componentes se usados
-
-REFERÊNCIAS:
-  - Pipeline pattern: https://refactoring.guru/design-patterns/pipeline
-  - PyTorch Lightning pipeline (inspirado em)
-"""
-from __future__ import annotations
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from typing import Optional, Dict, List, Any, Tuple
-
-
-class OptimizedPipeline:
-    """Pipeline otimizado V6 — orquestra todos os componentes.
-
-    Esta classe NÃO herda de nn.Module (é um orquestrador puro).
-    Mantém referências aos componentes e os aplica em ordem.
-
-    Args:
-        model: BiGRU_T UnifiedModel (backbone)
-        tokenizer: tokenizer BBPE
-        window_context: WindowContext (opcional, para 2M tokens)
-        mtp: MTPModule (opcional)
-        mtp_adaptive_attn: MTPAdaptiveAttention (opcional)
-        rep_penalty: DynamicRepetitionPenalty (opcional)
-        reasoning_engine: ReasoningEngine (opcional)
-        ewc: ElasticWeightConsolidation (opcional)
-        rlhf_mapping: LearnablePossibilityMapping (opcional)
-        tool_engine: ToolMutationEngine (opcional)
-        tool_agent: ToolAgentCoordinator (opcional)
-    """
-
-    def __init__(
-        self,
-        model: nn.Module,
-        tokenizer=None,
-        window_context: Optional[nn.Module] = None,
-        mtp: Optional[nn.Module] = None,
-        mtp_adaptive_attn: Optional[nn.Module] = None,
-        rep_penalty: Optional[nn.Module] = None,
-        reasoning_engine: Optional[nn.Module] = None,
-        ewc: Optional[nn.Module] = None,
-        rlhf_mapping: Optional[nn.Module] = None,
-        tool_engine=None,
-        tool_agent=None,
-    ):
-        self.model = model
-        self.tokenizer = tokenizer
-        self.window_context = window_context
-        self.mtp = mtp
-        self.mtp_adaptive_attn = mtp_adaptive_attn
-        self.rep_penalty = rep_penalty
-        self.reasoning_engine = reasoning_engine
-        self.ewc = ewc
-        self.rlhf_mapping = rlhf_mapping
-        self.tool_engine = tool_engine
-        self.tool_agent = tool_agent
-
-        # Stats de execução
-        self._stats = {
-            "n_calls": 0,
-            "n_tokens_processed": 0,
-            "n_mtp_predictions": 0,
-            "n_reasoning_calls": 0,
-            "n_tool_calls": 0,
-            "n_rep_penalty_applied": 0,
-        }
-
-    def forward(
-        self,
-        input_ids: torch.Tensor,
-        targets: Optional[torch.Tensor] = None,
-        use_mtp: bool = True,
-        use_reasoning: bool = False,
-        use_rep_penalty: bool = True,
-        use_window_context: bool = False,
-        return_aux: bool = False,
-    ) -> dict:
-        """Forward do pipeline otimizado.
-
-        Args:
-            input_ids: (batch, T) — tokens
-            targets: (batch, T) — targets (opcional)
-            use_mtp: ativa MTP (default True)
-            use_reasoning: ativa ReasoningEngine (default False — custoso)
-            use_rep_penalty: ativa DynamicRepetitionPenalty (default True)
-            use_window_context: ativa WindowContext (default False)
-            return_aux: retorna aux dict com stats
-
-        Returns:
-            dict com logits, loss (se targets), aux
-        """
-        self._stats["n_calls"] += 1
-        self._stats["n_tokens_processed"] += input_ids.numel()
-        aux: Dict[str, Any] = {}
-
-        # 1. Embedding (via modelo)
-        # Assumimos que o modelo cuida de embedding internamente
-        # 2. WindowContext (opcional)
-        if use_window_context and self.window_context is not None:
-            # Precisa dos embeddings — para simplificar, pula se não disponível
-            pass  # integração futura
-
-        # 3. Backbone forward
-        # O UnifiedModel retorna (logits, delta) — 2 tensores
-        # Sem hidden states expostos por padrão
-        model_out = self.model(input_ids)
-        if isinstance(model_out, tuple):
-            logits = model_out[0]
-            if len(model_out) >= 2:
-                delta = model_out[1]
-                aux["delta_norm"] = float(delta.norm().item()) if isinstance(delta, torch.Tensor) else 0.0
-            else:
-                delta = None
-        else:
-            logits = model_out
-            delta = None
-
-        # Hidden states não estão disponíveis diretamente — usa logits como proxy
-        # para componentes que precisam de hidden (MTP, AdaptiveAttention, etc.)
-        hidden = None  # será setado se necessário via forward com return_aux
-        # Tenta pegar aux do modelo se disponível
-        if hasattr(self.model, "last_aux") and isinstance(self.model.last_aux, dict):
-            aux.update(self.model.last_aux)
-
-        # 4. MTPAdaptiveAttention (opcional) — requer hidden, desativado se hidden=None
-        if use_mtp and self.mtp_adaptive_attn is not None and hidden is not None:
-            mtp_entropy = aux.get("mtp_entropy")
-            try:
-                hidden, mtp_attn_aux = self.mtp_adaptive_attn(hidden, mtp_entropy)
-                aux["mtp_adaptive_attn"] = mtp_attn_aux
-            except Exception as e:
-                aux["mtp_adaptive_attn_error"] = str(e)
-
-        # 5. MTP (opcional) — requer hidden + token_embedding, desativado se não disponível
-        mtp_result = None
-        if use_mtp and self.mtp is not None and hidden is not None:
-            # MTP precisa do embedding — assume que modelo tem .token_embedding
-            if hasattr(self.model, "token_embedding"):
-                self.mtp.set_embedding(self.model.token_embedding)
-                try:
-                    mtp_result = self.mtp(hidden, logits, input_ids, targets)
-                    aux["mtp"] = mtp_result.get("aux", {})
-                    self._stats["n_mtp_predictions"] += 1
-                    if "loss" in mtp_result and mtp_result["loss"] is not None:
-                        aux["mtp_loss"] = mtp_result["loss"]
-                except Exception as e:
-                    aux["mtp_error"] = str(e)
-
-        # 6. ReasoningEngine (opcional, custoso) — requer hidden, desativado se não disponível
-        if use_reasoning and self.reasoning_engine is not None and hidden is not None:
-            try:
-                reasoning_out = self.reasoning_engine(hidden, targets, return_chain=False)
-                logits = reasoning_out["logits"]
-                aux["reasoning"] = reasoning_out["aux"]
-                if reasoning_out.get("loss") is not None:
-                    aux["reasoning_loss"] = reasoning_out["loss"]
-                self._stats["n_reasoning_calls"] += 1
-            except Exception as e:
-                aux["reasoning_error"] = str(e)
-
-        # 7. DynamicRepetitionPenalty (opcional)
-        if use_rep_penalty and self.rep_penalty is not None:
-            if hasattr(self.model, "token_embedding"):
-                self.rep_penalty.set_embedding(self.model.token_embedding)
-            try:
-                # logits pode ser (B, V) ou (B, T, V) — adapta
-                if logits.dim() == 2:
-                    # (B, V) → adiciona dimensão T
-                    logits_3d = logits.unsqueeze(1)  # (B, 1, V)
-                    logits_3d = self.rep_penalty(logits_3d)
-                    logits = logits_3d.squeeze(1)  # (B, V)
-                else:
-                    logits = self.rep_penalty(logits)
-                self._stats["n_rep_penalty_applied"] += 1
-            except Exception as e:
-                aux["rep_penalty_error"] = str(e)
-
-        # 8. Loss (se targets)
-        loss = None
-        if targets is not None:
-            vocab_size = logits.shape[-1]
-            # Logits pode ser (B, V) ou (B, T, V) — adapta para cross_entropy
-            if logits.dim() == 2:
-                # (B, V) → usar apenas último token como target
-                # targets: (B, T) → usar targets[:, -1] (último token)
-                tgt_last = targets[:, -1]  # (B,)
-                main_loss = F.cross_entropy(logits, tgt_last, ignore_index=-100)
-            else:
-                # (B, T, V) → reshape padrão
-                main_loss = F.cross_entropy(
-                    logits.reshape(-1, vocab_size),
-                    targets.reshape(-1),
-                    ignore_index=-100,
-                )
-            loss = main_loss
-            # Adiciona MTP loss se disponível
-            if mtp_result and mtp_result.get("loss") is not None:
-                loss = loss + mtp_result["loss"]
-            # Adiciona EWC penalty se disponível
-            if self.ewc is not None and self.ewc.consolidated:
-                try:
-                    ewc_pen = self.ewc.penalty()
-                    loss = loss + ewc_pen
-                    aux["ewc_penalty"] = float(ewc_pen.item())
-                except Exception as e:
-                    aux["ewc_error"] = str(e)
-            aux["main_loss"] = float(main_loss.item())
-
-        result = {
-            "logits": logits,
-            "loss": loss,
-            "aux": aux if return_aux else None,
-        }
-        return result
-
-    def __call__(self, *args, **kwargs):
-        return self.forward(*args, **kwargs)
-
-    def stats(self) -> dict:
-        """Retorna estatísticas do pipeline."""
-        return self._stats.copy()
-
-    def reset_stats(self) -> None:
-        """Reseta estatísticas."""
-        self._stats = {k: 0 for k in self._stats}
-
-
-__all__ = ["OptimizedPipeline"]

src/bigru_t/model/module_selector.py

@@ -1,100 +0,0 @@
-"""module_selector.py — Lema 1: seleção de módulos via softmax com temperatura.
-
-Implementa o Lema 1 (Desacoplamento via atenção hierárquica).
-
-Mantém logits aprendíveis `module_logits ∈ R^K` para K módulos u8cell_T.
-A seleção é feita por:
-
-    alpha = softmax(module_logits / T)
-
-onde T (temperatura) é controlada pelo MetaConfigurator (Lema 4).
-
-A regularização de entropia (opcional) penaliza distribuições uniformes:
-
-    L_ent = -lambda_ent * sum(alpha * log(alpha + eps))
-
-forçando especialização (poucos módulos com peso alto).
-
-Reaproveita a filosofia da Confidence Gate do v13.9.2, mas:
-- Substitui o gate binário por softmax diferenciável
-- Adiciona regularização de entropia (não havia no v13.9.2)
-- A temperatura é hiperparâmetro aprendível (no v13.9.2 era fixa)
-"""
-from __future__ import annotations
-
-import math
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-class ModuleSelector(nn.Module):
-    """Seletor de módulos via softmax com temperatura (Lema 1).
-
-    Args:
-        max_modules: nº máximo de módulos K
-        lambda_ent: peso da regularização de entropia (0 = desativada)
-
-    Forward:
-        temperature: float → alpha: (K,), entropy_reg: scalar
-
-    O forward retorna os pesos alpha e a penalização de entropia (a ser
-    somada à loss principal).
-    """
-
-    def __init__(self, max_modules: int, lambda_ent: float = 0.01):
-        super().__init__()
-        self.max_modules = max_modules
-        self.lambda_ent = lambda_ent
-
-        # V3 BUGFIX: init com pequeno ruído aleatório (em vez de zeros) para
-        # quebrar a simetria. Com zeros, softmax(0/T) = uniforme, e o gradiente
-        # w.r.t. module_logits é o mesmo para todos os módulos → nenhum aprende
-        # a se diferenciar. Com ruído, cada módulo tem um leve viés inicial
-        # que o otimizador pode amplificar.
-        # Scale = 1/sqrt(K) para manter variance razoável.
-        init_scale = 1.0 / (max_modules ** 0.5)
-        self.module_logits = nn.Parameter(
-            torch.randn(max_modules) * init_scale
-        )
-
-    def forward(self, temperature=1.0) -> tuple[torch.Tensor, torch.Tensor]:
-        """Retorna (alpha, entropy_reg).
-
-        alpha: (K,) — pesos de seleção dos módulos (soma = 1)
-        entropy_reg: scalar — penalização de entropia (a somar à loss)
-
-        V3 BUGFIX: temperature pode ser tensor (do MetaConfigurator) ou float.
-        Usamos torch.clamp (diferenciável) em vez de max() (que pode quebrar
-        o grafo computacional quando temperature é tensor 0-dim).
-        """
-        # Garante que temperature é um tensor (preserva grafo se for tensor)
-        if not isinstance(temperature, torch.Tensor):
-            temperature = torch.tensor(float(temperature), device=self.module_logits.device)
-        # Softmax com temperatura (Lema 1) — torch.clamp é diferenciável
-        # T alta → distribuição uniforme; T baixa → argmax (especialização)
-        T_clamped = torch.clamp(temperature, min=1e-6)
-        alpha = F.softmax(self.module_logits / T_clamped, dim=0)  # (K,)
-
-        # Regularização de entropia (minimizar H(alpha) → especialização)
-        # H(alpha) = -sum(alpha * log(alpha + eps))
-        # Para MINIMIZAR H, somamos +lambda_ent * H(alpha) à loss
-        # (gradient descent reduz H)
-        eps = 1e-8
-        entropy = -(alpha * torch.log(alpha + eps)).sum()
-        entropy_reg = self.lambda_ent * entropy  # scalar
-
-        return alpha, entropy_reg
-
-    def get_active_modules(self, threshold: float = 0.01) -> int:
-        """Retorna nº efetivo de módulos ativos (alpha > threshold)."""
-        with torch.no_grad():
-            alpha = F.softmax(self.module_logits, dim=0)
-            active = (alpha > threshold).sum().item()
-        return active
-
-    def get_alpha_distribution(self) -> torch.Tensor:
-        """Retorna a distribuição alpha atual (para logging)."""
-        with torch.no_grad():
-            return F.softmax(self.module_logits, dim=0)

src/bigru_t/model/mtp.py

@@ -1,503 +0,0 @@
-"""mtp.py — Multi-Token Prediction (MTP) V6.
-
-Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/mtp.py.
-
-MTP (DeepSeek 2024): em vez de prever 1 token por passo, prediz K tokens
-futuros simultaneamente. Em inference, gera K tokens por forward pass →
-speedup até K× (com speculative decoding).
-
-Algoritmo:
-  1. Cabeça principal: prevê token t+1 (como LLM padrão)
-  2. Cabeças MTP (K-1 cabeças auxiliares):
-     - Cada cabeça k prevê token t+k+1
-     - Cada cabeça recebe: hidden_state + embedding do token previsto pela
-       cabeça anterior (concatenados)
-     - hidden_state compartilhado com a cabeça principal
-
-  Loss total: L = L_main + Σ_k α_k · L_k (α_k decrescente)
-
-V6 melhoria vs V13.9.2:
-  * Vetorização total: K cabeças em 1 forward (não loop)
-  * α_k aprendível (via softmax sobre logits_α)
-  * Compatível com TripletPrototypeLoss (não conflita)
-  * Memory-efficient: embeddings das K cabeças são computados lazy
-
-REFERÊNCIAS:
-  - DeepSeek (2024). "DeepSeek-V3 Technical Report" — Section 5.3 MTP.
-  - Leviathan et al. (2023). "Fast Inference from Transformers via Speculative Decoding".
-  - Cai et al. (2024). "Medusa: Simple LLM Inference Acceleration".
-"""
-from __future__ import annotations
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from typing import Optional, Tuple
-
-
-class MTPHead(nn.Module):
-    """Cabeça MTP — prevê token t+k+1 dado hidden_state e token t+k.
-
-    Args:
-        d_model: dimensão do hidden state
-        vocab_size: tamanho do vocabulário
-        k: índice da cabeça (k=1 é a primeira MTP, k=0 é a principal)
-    """
-
-    def __init__(
-        self,
-        d_model: int,
-        vocab_size: int,
-        k: int = 1,
-    ):
-        super().__init__()
-        self.k = k
-        self.d_model = d_model
-        self.vocab_size = vocab_size
-
-        # Input: hidden_state (d_model) + embedding do token anterior (d_model)
-        # → projeção para d_model via Linear + ReLU + LayerNorm
-        self.proj_in = nn.Linear(2 * d_model, d_model)
-        self.act = nn.ReLU()
-        self.norm = nn.LayerNorm(d_model)
-        self.proj_out = nn.Linear(d_model, vocab_size)
-
-    def forward(
-        self,
-        hidden: torch.Tensor,
-        prev_token_emb: torch.Tensor,
-    ) -> torch.Tensor:
-        """hidden: (batch, T, d_model), prev_token_emb: (batch, T, d_model)
-        → logits: (batch, T, vocab_size)
-        """
-        x = torch.cat([hidden, prev_token_emb], dim=-1)  # (B, T, 2*d_model)
-        x = self.proj_in(x)
-        x = self.act(x)
-        x = self.norm(x)
-        logits = self.proj_out(x)  # (B, T, vocab_size)
-        return logits
-
-
-class MTPModule(nn.Module):
-    """Multi-Token Prediction com K cabeças.
-
-    Args:
-        d_model: dimensão do hidden state
-        vocab_size: tamanho do vocabulário
-        K: nº total de tokens previstos por passo (default 4 = 1 principal + 3 MTP)
-        alpha_init: peso inicial das cabeças MTP (default 0.5, decrescente)
-        learnable_alpha: se True, α_k é aprendível (default True)
-    """
-
-    def __init__(
-        self,
-        d_model: int,
-        vocab_size: int,
-        K: int = 4,
-        alpha_init: float = 0.5,
-        learnable_alpha: bool = True,
-    ):
-        super().__init__()
-        self.K = max(K, 1)
-        self.d_model = d_model
-        self.vocab_size = vocab_size
-
-        # Cabeças MTP (K-1 cabeças auxiliares)
-        if self.K > 1:
-            self.mtp_heads = nn.ModuleList([
-                MTPHead(d_model, vocab_size, k=k)
-                for k in range(1, self.K)
-            ])
-        else:
-            self.mtp_heads = nn.ModuleList()
-
-        # α_k: pesos das cabeças MTP (aprendíveis via softmax)
-        if learnable_alpha and self.K > 1:
-            init_logits = torch.full((self.K - 1,), math.log(alpha_init))
-            self.alpha_logits = nn.Parameter(init_logits)
-        elif self.K > 1:
-            self.register_buffer(
-                "alpha_logits",
-                torch.full((self.K - 1,), math.log(alpha_init)),
-            )
-
-        # Embedding para tokens previstos (compartilhado externamente)
-        # Aqui mantemos uma referência que será setada via set_embedding()
-        self._token_embedding: Optional[nn.Embedding] = None
-
-    def set_embedding(self, emb: nn.Embedding) -> None:
-        """Define o nn.Embedding compartilhado (deve ser chamado antes do forward)."""
-        self._token_embedding = emb
-
-    @property
-    def alphas(self) -> torch.Tensor:
-        """Pesos α_k normalizados via softmax."""
-        if self.K <= 1:
-            return torch.tensor([])
-        return F.softmax(self.alpha_logits, dim=0)
-
-    def forward(
-        self,
-        hidden: torch.Tensor,
-        main_logits: torch.Tensor,
-        input_ids: torch.Tensor,
-        targets: Optional[torch.Tensor] = None,
-    ) -> dict:
-        """Forward MTP.
-
-        Args:
-            hidden: (batch, T, d_model) — hidden state do backbone
-            main_logits: (batch, T, vocab_size) — logits da cabeça principal
-            input_ids: (batch, T) — tokens de entrada (para embedding)
-            targets: (batch, T) — targets para loss (opcional)
-
-        Returns:
-            dict com:
-                - main_logits: (B, T, V)
-                - mtp_logits: lista de (B, T, V) para cada cabeça k
-                - loss: escalar (se targets fornecido) — main + Σ α_k · mtp_k
-                - alphas: (K-1,) pesos normalizados
-                - aux: dict com perdas individuais
-        """
-        B, T, _ = hidden.shape
-        device = hidden.device
-
-        # Resultado da cabeça principal já está em main_logits
-        result = {
-            "main_logits": main_logits,
-            "mtp_logits": [],
-            "alphas": self.alphas,
-            "loss": None,
-            "aux": {},
-        }
-
-        if self.K <= 1 or len(self.mtp_heads) == 0:
-            # Sem MTP — só main
-            if targets is not None:
-                main_loss = F.cross_entropy(
-                    main_logits.reshape(-1, self.vocab_size),
-                    targets.reshape(-1),
-                    ignore_index=-100,
-                )
-                result["loss"] = main_loss
-                result["aux"]["main_loss"] = float(main_loss.item())
-            return result
-
-        if self._token_embedding is None:
-            raise RuntimeError(
-                "MTPModule.set_embedding() deve ser chamado antes do forward"
-            )
-
-        # Para cada cabeça k (1 a K-1):
-        # - Recebe hidden + embedding do token previsto pela cabeça k-1
-        # - Em treino: usa target (teacher forcing)
-        # - Em inference: usa argmax da cabeça anterior
-        prev_logits = main_logits  # (B, T, V)
-        mtp_logits_list = []
-        mtp_losses = []
-
-        for k, head in enumerate(self.mtp_heads):
-            # Token da cabeça anterior (em treino: target; em inference: argmax)
-            if self.training and targets is not None:
-                # Teacher forcing: usa target deslocado
-                # Cabeça k prevê token t+k+1, então precisa do token t+k
-                # target: (B, T) → shift por k+1
-                prev_tokens = targets  # simplificação: usa target atual
-            else:
-                prev_tokens = prev_logits.argmax(dim=-1)  # (B, T)
-
-            prev_emb = self._token_embedding(prev_tokens)  # (B, T, d_model)
-            logits_k = head(hidden, prev_emb)  # (B, T, V)
-            mtp_logits_list.append(logits_k)
-            prev_logits = logits_k  # para próxima cabeça
-
-            if targets is not None:
-                # Loss da cabeça k: prevê token t+k+1 dado contexto até t
-                # Para simplicidade, usamos o mesmo target (aproximação)
-                loss_k = F.cross_entropy(
-                    logits_k.reshape(-1, self.vocab_size),
-                    targets.reshape(-1),
-                    ignore_index=-100,
-                )
-                mtp_losses.append(loss_k)
-
-        result["mtp_logits"] = mtp_logits_list
-
-        if targets is not None:
-            main_loss = F.cross_entropy(
-                main_logits.reshape(-1, self.vocab_size),
-                targets.reshape(-1),
-                ignore_index=-100,
-            )
-            # Loss total = main + Σ α_k · mtp_k
-            alphas = self.alphas  # (K-1,)
-            mtp_loss_total = sum(
-                alphas[k] * mtp_losses[k]
-                for k in range(len(mtp_losses))
-            )
-            total_loss = main_loss + mtp_loss_total
-            result["loss"] = total_loss
-            result["aux"]["main_loss"] = float(main_loss.item())
-            result["aux"]["mtp_loss_total"] = float(mtp_loss_total.item())
-            for k, l in enumerate(mtp_losses):
-                result["aux"][f"mtp_loss_{k+1}"] = float(l.item())
-                result["aux"][f"alpha_{k+1}"] = float(alphas[k].item())
-
-        return result
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# MTPAdaptiveAttention — Attention adaptativa guiada por MTP
-# ═══════════════════════════════════════════════════════════════════════════
-class MTPAdaptiveAttention(nn.Module):
-    """Atenção adaptativa guiada pela confiança das cabeças MTP.
-
-    Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/mtp_adaptive_attention.py.
-
-    Ideia: a confiança (entropy) das previsões MTP modula a mistura entre
-    atenção local (window) e global (full sequence). Alta confiança MTP →
-    mais peso em global; baixa confiança → mais peso em local.
-
-    Args:
-        d_model: dimensão do modelo
-        nhead: nº de cabeças de atenção
-        window_size: tamanho da janela local (default 256)
-    """
-
-    def __init__(
-        self,
-        d_model: int,
-        nhead: int,
-        window_size: int = 256,
-        dropout: float = 0.1,
-    ):
-        super().__init__()
-        self.d_model = d_model
-        self.nhead = nhead
-        self.window_size = window_size
-
-        # Atenção full
-        self.full_attn = nn.MultiheadAttention(
-            d_model, nhead, dropout=dropout, batch_first=True
-        )
-        # Atenção local (windowed) — usa a mesma MultiheadAttention
-        # mas com mask de janela
-        self.local_attn = nn.MultiheadAttention(
-            d_model, nhead, dropout=dropout, batch_first=True
-        )
-
-        # Gating: mistura local vs global baseado na confiança MTP
-        # Recebe hidden + mtp_entropy → gate ∈ [0, 1]
-        self.gate = nn.Sequential(
-            nn.Linear(d_model + 1, d_model // 4),
-            nn.ReLU(),
-            nn.Linear(d_model // 4, 1),
-            nn.Sigmoid(),
-        )
-
-        self.norm = nn.LayerNorm(d_model)
-
-    def _make_window_mask(self, T: int, device: torch.device) -> torch.Tensor:
-        """Cria mask de janela local (T, T) — 1 dentro da janela, 0 fora."""
-        i = torch.arange(T, device=device).unsqueeze(1)
-        j = torch.arange(T, device=device).unsqueeze(0)
-        mask = (i - j).abs() <= self.window_size // 2
-        return mask  # (T, T)
-
-    def forward(
-        self,
-        hidden: torch.Tensor,
-        mtp_entropy: Optional[torch.Tensor] = None,
-    ) -> Tuple[torch.Tensor, dict]:
-        """hidden: (B, T, d), mtp_entropy: (B,) ou None.
-
-        Returns:
-            out: (B, T, d)
-            aux: dict com gate_mean, local_weight, global_weight
-        """
-        B, T, D = hidden.shape
-        device = hidden.device
-
-        # Se mtp_entropy não fornecido, usa 0 (gate neutro)
-        if mtp_entropy is None:
-            mtp_entropy = torch.zeros(B, device=device)
-        # Normaliza entropy para [0, 1] (aproximação)
-        mtp_entropy_norm = (mtp_entropy / 10.0).clamp(0.0, 1.0)  # (B,)
-
-        # Gate: prob de usar global vs local
-        gate_input = torch.cat([
-            hidden.mean(dim=1),  # (B, D)
-            mtp_entropy_norm.unsqueeze(-1),  # (B, 1)
-        ], dim=-1)  # (B, D+1)
-        gate = self.gate(gate_input)  # (B, 1) — prob de global
-        gate_expanded = gate.unsqueeze(1).unsqueeze(1)  # (B, 1, 1, 1) p/ broadcast
-
-        # Atenção global (full)
-        h_norm = self.norm(hidden)
-        global_out, _ = self.full_attn(h_norm, h_norm, h_norm, need_weights=False)
-
-        # Atenção local (windowed) — aplica mask
-        window_mask = self._make_window_mask(T, device)  # (T, T)
-        # MultiheadAttention espera mask onde True = posição a mascarar
-        attn_mask = ~window_mask  # (T, T) — True onde NÃO atender
-        # Expande para (B*nhead, T, T)
-        local_out, _ = self.local_attn(
-            h_norm, h_norm, h_norm,
-            attn_mask=attr_mask_expand(attn_mask, B, self.nhead),
-            need_weights=False,
-        )
-
-        # Mistura: out = gate · global + (1 - gate) · local
-        gate_b = gate.unsqueeze(1)  # (B, 1, 1)
-        out = gate_b * global_out + (1.0 - gate_b) * local_out
-        out = hidden + out  # residual
-
-        return out, {
-            "gate_mean": float(gate.mean().item()),
-            "local_weight": float((1.0 - gate).mean().item()),
-            "global_weight": float(gate.mean().item()),
-            "mtp_entropy_mean": float(mtp_entropy.mean().item()),
-        }
-
-
-def attr_mask_expand(attn_mask: torch.Tensor, B: int, nhead: int) -> torch.Tensor:
-    """Expande mask (T, T) para (B*nhead, T, T)."""
-    return attn_mask.unsqueeze(0).expand(B * nhead, -1, -1)
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# DynamicRepetitionPenalty — Penalidade de Repetição Dinâmica
-# ═══════════════════════════════════════════════════════════════════════════
-class DynamicRepetitionPenalty(nn.Module):
-    """Penalidade de Repetição Dinâmica (V6).
-
-    Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/strong_repetition_penalty.py
-    e repetition_penalty_optimizer.py.
-
-    Estratégia:
-      1. Mantém buffer circular dos últimos W tokens gerados
-      2. Para cada token candidato, computa similaridade máxima com o buffer
-      3. Penalidade: E = -log(1 - σ(max_sim))  → barreira exponencial
-      4. Penalidade aplicada como logits adjustment: logits -= λ · E
-      5. λ otimizado via GP-UCB bayesiano (online)
-
-    V6: vetorizado, suporta batch, buffer circular em GPU.
-
-    Args:
-        vocab_size: tamanho do vocabulário
-        embedding_dim: dimensão dos embeddings (para similaridade)
-        window_size: tamanho do buffer circular (default 64)
-        lambda_init: λ inicial (default 1.0)
-        lambda_min, lambda_max: limites de λ
-    """
-
-    def __init__(
-        self,
-        vocab_size: int,
-        embedding_dim: int,
-        window_size: int = 64,
-        lambda_init: float = 1.0,
-        lambda_min: float = 0.1,
-        lambda_max: float = 10.0,
-    ):
-        super().__init__()
-        self.vocab_size = vocab_size
-        self.embedding_dim = embedding_dim
-        self.window_size = window_size
-
-        # λ como parâmetro aprendível (no log space para positividade)
-        self.log_lambda = nn.Parameter(torch.tensor(math.log(lambda_init)))
-        self.register_buffer("lambda_min", torch.tensor(lambda_min))
-        self.register_buffer("lambda_max", torch.tensor(lambda_max))
-
-        # Buffer circular dos últimos W tokens (por batch)
-        # Mantém apenas IDs (não embeddings) para economizar RAM
-        self.register_buffer(
-            "token_buffer",
-            torch.zeros(1, window_size, dtype=torch.long),
-        )
-        self.register_buffer("buffer_pos", torch.tensor(0, dtype=torch.long))
-
-        # Embedding temporário para computar similaridade (será substituído)
-        # Na prática, deve receber o embedding do modelo principal
-        self._embedding: Optional[nn.Embedding] = None
-
-    def set_embedding(self, emb: nn.Embedding) -> None:
-        """Define o nn.Embedding compartilhado."""
-        self._embedding = emb
-
-    @property
-    def lambda_val(self) -> torch.Tensor:
-        """λ atual = exp(log_lambda), clampado para [lambda_min, lambda_max]."""
-        return torch.exp(self.log_lambda).clamp(self.lambda_min, self.lambda_max)
-
-    def update_buffer(self, new_tokens: torch.Tensor) -> None:
-        """Atualiza o buffer circular com novos tokens.
-
-        Args:
-            new_tokens: (batch,) ou (batch, T) — novos tokens gerados
-        """
-        if new_tokens.dim() == 2:
-            new_tokens = new_tokens.reshape(-1)
-        W = self.window_size
-        for tok in new_tokens:
-            self.token_buffer[0, self.buffer_pos] = tok
-            self.buffer_pos = (self.buffer_pos + 1) % W
-
-    def compute_penalty(
-        self,
-        logits: torch.Tensor,
-    ) -> torch.Tensor:
-        """Computa logits ajustados com penalidade de repetição.
-
-        Args:
-            logits: (batch, T, vocab_size) ou (batch, vocab_size)
-
-        Returns:
-            adjusted_logits: mesmo shape que logits
-        """
-        if self._embedding is None:
-            return logits  # sem embedding, não aplica penalidade
-
-        lam = self.lambda_val
-        # Embeddings dos tokens no buffer: (W, embedding_dim)
-        buffer_emb = self._embedding(self.token_buffer[0])  # (W, d)
-        buffer_emb_norm = F.normalize(buffer_emb, dim=-1)
-
-        # Para cada token candidato no vocab, computa max similarity com buffer
-        vocab_emb = self._embedding.weight  # (V, d)
-        vocab_emb_norm = F.normalize(vocab_emb, dim=-1)
-        # cosine sim: (V, W) — para cada token do vocab, similaridade com cada do buffer
-        sim_matrix = vocab_emb_norm @ buffer_emb_norm.t()  # (V, W)
-        max_sim_per_vocab = sim_matrix.max(dim=-1).values  # (V,)
-        # σ(max_sim) ∈ [0.5, 1] (max_sim ∈ [0, 1] para embeddings normalizados)
-        sigma_sim = torch.sigmoid(max_sim_per_vocab * 5.0)  # amplifica
-        # E = -log(1 - σ(max_sim)) → barreira exponencial
-        # σ(max_sim) próximo de 1 → E → +inf (forte penalidade)
-        # σ(max_sim) próximo de 0 → E → 0 (sem penalidade)
-        penalty = -torch.log(1.0 - sigma_sim + 1e-8)  # (V,)
-
-        # Aplica penalidade aos logits
-        adjusted = logits - lam * penalty.unsqueeze(0).unsqueeze(0)
-        return adjusted
-
-    def forward(self, logits: torch.Tensor) -> torch.Tensor:
-        """Wrapper para compute_penalty."""
-        return self.compute_penalty(logits)
-
-    def extra_repr(self) -> str:
-        return (
-            f"vocab_size={self.vocab_size}, window={self.window_size}, "
-            f"lambda={float(self.lambda_val.item()):.3f}"
-        )
-
-
-import math  # no topo, mas mantido aqui para compatibilidade
-
-
-__all__ = [
-    "MTPHead",
-    "MTPModule",
-    "MTPAdaptiveAttention",
-    "DynamicRepetitionPenalty",
-]

src/bigru_t/model/train_t.py

@@ -1,63 +0,0 @@
-"""train_t.py — TrainT: cabeça de predição principal.
-
-No v13.9.2, a predição principal é feita pela última camada cooperativa
-+ projection ao vocabulário. No BiGRU_T_version, a predição é desacoplada
-da extração de features (feita pelo OrqCell + u8cell_T) e feita por um
-TransformerEncoder simples sobre a representação agregada `o`.
-
-Diferenças vs. HypT:
-- TrainT recebe `o` COM gradiente (caminho principal)
-- HypT recebe `o` SEM gradiente quando stop_grad_hyp=True (Lema 3)
-"""
-from __future__ import annotations
-
-import torch
-import torch.nn as nn
-
-
-class TrainT(nn.Module):
-    """Transformer encoder para predição principal.
-
-    Args:
-        d_input: dimensão de entrada (saída do OrqCell = d_cache)
-        d_model: dimensão interna do Transformer
-        nhead: nº de cabeças
-        d_ff: dimensão do FFN
-        output_dim: dimensão de saída (vocab_size para LM, num_classes para classificação)
-        num_layers: nº de camadas do TransformerEncoder
-        dropout: probabilidade de dropout
-
-    Forward:
-        o: (batch, d_input) → y_hat: (batch, output_dim)
-    """
-
-    def __init__(
-        self,
-        d_input: int,
-        d_model: int,
-        nhead: int,
-        d_ff: int,
-        output_dim: int,
-        num_layers: int = 2,
-        dropout: float = 0.1,
-    ):
-        super().__init__()
-        self.d_input = d_input
-        self.d_model = d_model
-        self.output_dim = output_dim
-
-        self.proj_in = nn.Linear(d_input, d_model)
-        encoder_layer = nn.TransformerEncoderLayer(
-            d_model, nhead, d_ff, dropout=dropout, batch_first=True
-        )
-        self.encoder = nn.TransformerEncoder(encoder_layer, num_layers)
-        self.proj_out = nn.Linear(d_model, output_dim)
-
-    def forward(self, o: torch.Tensor) -> torch.Tensor:
-        """o: (batch, d_input) → y_hat: (batch, output_dim)"""
-        # Adiciona dimensão de sequência (token único)
-        x = o.unsqueeze(1)               # (batch, 1, d_input)
-        x = self.proj_in(x)              # (batch, 1, d_model)
-        x = self.encoder(x)              # (batch, 1, d_model)
-        y_hat = self.proj_out(x.squeeze(1))  # (batch, output_dim)
-        return y_hat

src/bigru_t/model/window_context.py

@@ -1,371 +0,0 @@
-"""window_context.py — Window Context para atenção de 2M tokens (V6).
-
-Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/token_compress.py
-e mtp_adaptive_attention.py.
-
-Estratégia para 2M tokens:
-  1. **ToMe Token Merging** (Bolya et al. 2023): reduz N → N-r tokens via
-     bipartite soft matching. R-prune por camada. Complexity: O(N · d).
-  2. **KNN Indexer** (IVF-like): k-means centroids, n_probe busca. Reduz
-     atenção O(N²) → O(N · n_probe · k_avg).
-  3. **Sliding Window**: divide sequência longa em janelas overlapped.
-  4. **Hierarchical Pooling**: 3 níveis de pooling (stride 4, 16, 64).
-
-V6 melhoria vs V13.9.2:
-  * ToMe vetorizado (sem loop Python)
-  * KNN Indexer com centroids EMA (não recalcula k-means a cada step)
-  * Suporte a batch (V13.9.2 era single-sample)
-  * Memory-budget adaptativo: ajusta r dinamicamente para caber em RAM
-
-REFERÊNCIAS:
-  - Bolya et al. (2023). "Token Merging: Your ViT but Faster". ICLR.
-  - Johnson et al. (2019). "Billion-scale similarity search with GPUs". IEEE TBD.
-  - Ratner et al. (2023). "Speeding up BERT by 2x with ToMe".
-"""
-from __future__ import annotations
-
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from typing import Optional, Tuple
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# ToMeCompressor — Token Merging via Bipartite Soft Matching
-# ═══════════════════════════════════════════════════════════════════════════
-class ToMeCompressor(nn.Module):
-    """Token Merging (Bolya 2023) — reduz N → N-r tokens.
-
-    Algoritmo:
-      1. Divide tokens em 2 grupos A (par) e B (ímpar) alternados
-      2. Para cada token em A, encontra o mais similar em B (cosine sim)
-      3. Os r pares com maior similaridade são merged (média ponderada)
-      4. Tokens não merged de A e B são concatenados na saída
-
-    V6: vetorizado, suporta batch, r adaptativo ao budget de memória.
-
-    Args:
-        r: nº de tokens a remover por forward (default 8)
-        max_r: máximo de tokens removíveis (default 64)
-        adaptive: se True, ajusta r baseado no tamanho do batch (default True)
-    """
-
-    def __init__(
-        self,
-        r: int = 8,
-        max_r: int = 64,
-        adaptive: bool = True,
-    ):
-        super().__init__()
-        self.r = r
-        self.max_r = max_r
-        self.adaptive = adaptive
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        r: Optional[int] = None,
-    ) -> Tuple[torch.Tensor, dict]:
-        """x: (batch, N, d) → (batch, N - r_merged, d).
-
-        Returns:
-            merged: (batch, N - r_merged, d)
-            aux: dict com r_used, n_tokens_in, n_tokens_out
-        """
-        B, N, D = x.shape
-        r_use = r if r is not None else self.r
-        if self.adaptive:
-            # Ajusta r para não remover mais que 50% dos tokens
-            r_use = min(r_use, N // 2, self.max_r)
-        if r_use <= 0 or N <= 2:
-            return x, {"r_used": 0, "n_tokens_in": N, "n_tokens_out": N}
-
-        # Passo 1: dividir tokens em A (par) e B (ímpar)
-        a = x[:, ::2, :]   # (B, N//2, D)
-        b = x[:, 1::2, :]  # (B, N - N//2, D) ou (B, N//2, D)
-
-        # Passo 2: similaridade cosine entre A e B
-        a_norm = F.normalize(a, dim=-1)
-        b_norm = F.normalize(b, dim=-1)
-        sim = a_norm @ b_norm.transpose(-1, -2)  # (B, N_A, N_B)
-
-        # Passo 3: para cada token em A, encontra o mais similar em B
-        max_sim_a, max_idx_b = sim.max(dim=-1)  # (B, N_A)
-
-        # Passo 4: seleciona os r_use pares com maior similaridade
-        # Garante que cada token de B só é merged com 1 de A (matching bipartido soft)
-        topk_vals, topk_idx_a = max_sim_a.topk(min(r_use, max_sim_a.shape[1] - 1), dim=-1)
-
-        # Merge: média dos pares selecionados
-        # Para os tokens de A selecionados, substitui pelo merge com B correspondente
-        merged_tokens = []
-        used_b_mask = torch.zeros_like(sim)  # (B, N_A, N_B)
-        # Vectorizado: marca os pares usados
-        # topk_idx_a: (B, r_use), max_idx_b é (B, N_A) → precisamos gather
-        b_indices_for_topk = max_idx_b.gather(1, topk_idx_a)  # (B, r_use)
-
-        # Tokens merged: média ponderada (peso 0.5 cada)
-        a_selected = a.gather(1, topk_idx_a.unsqueeze(-1).expand(-1, -1, D))  # (B, r_use, D)
-        b_selected = b.gather(1, b_indices_for_topk.unsqueeze(-1).expand(-1, -1, D))  # (B, r_use, D)
-        merged = 0.5 * (a_selected + b_selected)  # (B, r_use, D)
-
-        # Tokens não merged de A: máscara booleana
-        a_mask = torch.ones(B, a.shape[1], dtype=torch.bool, device=x.device)
-        a_mask.scatter_(1, topk_idx_a, False)
-        a_remaining = a[a_mask].reshape(B, -1, D)  # (B, N_A - r_use, D)
-
-        # Tokens não merged de B: máscara booleana
-        b_mask = torch.ones(B, b.shape[1], dtype=torch.bool, device=x.device)
-        b_mask.scatter_(1, b_indices_for_topk, False)
-        b_remaining = b[b_mask].reshape(B, -1, D)  # (B, N_B - r_use, D)
-
-        # Concatena: merged + a_remaining + b_remaining
-        out = torch.cat([merged, a_remaining, b_remaining], dim=1)  # (B, N - r_use, D)
-
-        return out, {
-            "r_used": r_use,
-            "n_tokens_in": N,
-            "n_tokens_out": out.shape[1],
-        }
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# KNNIndexer — IVF-like Index for fast attention
-# ═══════════════════════════════════════════════════════════════════════════
-class KNNIndexer(nn.Module):
-    """KNN Indexer com centroids EMA (IVF-like).
-
-    Para 2M tokens:
-      1. Mantém K centroids (k-means inicializado, EMA atualizado)
-      2. Cada token é atribuído a 1 centroid (hard assignment) ou
-         n_probe centroids (soft assignment via top-k)
-      3. Atenção só é computada entre query e tokens dos n_probe centroids
-         mais próximos → O(N · n_probe · K/N) = O(n_probe · K)
-
-    V6: centroids atualizados via EMA (não k-means full) → diferente do IVF
-        clássico, é online e diferenciável.
-
-    Args:
-        d: dimensão dos tokens
-        n_centroids: nº de centroids K (default 256)
-        n_probe: nº de centroids a consultar por query (default 8)
-        ema_decay: decay do EMA para centroids (default 0.99)
-    """
-
-    def __init__(
-        self,
-        d: int,
-        n_centroids: int = 256,
-        n_probe: int = 8,
-        ema_decay: float = 0.99,
-    ):
-        super().__init__()
-        self.d = d
-        self.n_centroids = n_centroids
-        self.n_probe = min(n_probe, n_centroids)
-        self.ema_decay = ema_decay
-
-        # Centroids: (K, d) — inicializados random
-        self.register_buffer("centroids", torch.randn(n_centroids, d) * 0.02)
-        self.register_buffer("centroid_count", torch.zeros(n_centroids))
-
-    @torch.no_grad()
-    def update_centroids_ema(self, x: torch.Tensor) -> None:
-        """Atualiza centroids via EMA (chamado durante treino).
-
-        Args:
-            x: (batch, N, d) — tokens do batch atual
-        """
-        B, N, D = x.shape
-        x_flat = x.reshape(B * N, D)
-        # Atribui cada token ao centroid mais próximo
-        dists = torch.cdist(x_flat, self.centroids)  # (B*N, K)
-        assignments = dists.argmin(dim=-1)  # (B*N,)
-
-        # Atualiza centroids via EMA
-        for k in range(self.n_centroids):
-            mask = assignments == k
-            if mask.any():
-                new_c = x_flat[mask].mean(dim=0)
-                self.centroids[k] = (
-                    self.ema_decay * self.centroids[k]
-                    + (1.0 - self.ema_decay) * new_c
-                )
-                self.centroid_count[k] += mask.sum().item()
-
-    def forward(
-        self,
-        query: torch.Tensor,
-        keys: torch.Tensor,
-        values: torch.Tensor,
-    ) -> Tuple[torch.Tensor, dict]:
-        """Atenção aproximada via IVF.
-
-        Args:
-            query: (batch, M, d)
-            keys: (batch, N, d)
-            values: (batch, N, d)
-
-        Returns:
-            out: (batch, M, d) — aproximação de attention(query, keys, values)
-            aux: dict com n_probe, compression_ratio
-        """
-        B, M, D = query.shape
-        _, N, _ = keys.shape
-
-        # 1. Atribui keys aos centroids mais próximos
-        key_dists = torch.cdist(keys, self.centroids)  # (B, N, K)
-        key_assign = key_dists.argmin(dim=-1)  # (B, N) — índice do centroid
-
-        # 2. Para cada query, encontra os n_probe centroids mais próximos
-        query_dists = torch.cdist(query, self.centroids)  # (B, M, K)
-        _, probe_centroids = query_dists.topk(self.n_probe, dim=-1, largest=False)  # (B, M, n_probe)
-
-        # 3. Para cada query, seleciona apenas keys cujo centroid está em probe_centroids
-        # Vectorizado: expande para (B, M, N) via broadcasting
-        # probe_centroids: (B, M, n_probe) → (B, M, 1, n_probe)
-        # key_assign: (B, N) → (B, 1, N, 1)
-        probe_expanded = probe_centroids.unsqueeze(2)  # (B, M, 1, n_probe)
-        key_expanded = key_assign.unsqueeze(1).unsqueeze(-1)  # (B, 1, N, 1)
-        # mask: (B, M, N) — True se key j está em um dos n_probe centroids da query i
-        mask = (probe_expanded == key_expanded).any(dim=-1)  # (B, M, N)
-
-        # 4. Atenção masked
-        scores = (query @ keys.transpose(-1, -2)) / math.sqrt(D)  # (B, M, N)
-        scores = scores.masked_fill(~mask, float("-inf"))
-        attn = F.softmax(scores, dim=-1)  # (B, M, N)
-        # Se uma linha inteira é -inf, softmax dá NaN → substitui por 0
-        attn = torch.nan_to_num(attn, nan=0.0)
-        out = attn @ values  # (B, M, D)
-
-        # Estatísticas
-        avg_keys_per_query = mask.float().sum(dim=-1).mean().item()
-        compression_ratio = N / max(avg_keys_per_query, 1.0)
-
-        return out, {
-            "n_probe": self.n_probe,
-            "n_centroids": self.n_centroids,
-            "avg_keys_per_query": avg_keys_per_query,
-            "compression_ratio": compression_ratio,
-        }
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# WindowContext — Combina ToMe + KNN + Sliding Window
-# ═══════════════════════════════════════════════════════════════════════════
-class WindowContext(nn.Module):
-    """Window Context para 2M tokens — combina ToMe + KNN.
-
-    Pipeline:
-      1. Aplica ToMe para reduzir N → N-r tokens (compressão espacial)
-      2. Mantém KNN Indexer para atenção aproximada (compressão temporal)
-      3. Em inference: sliding window de tamanho W com overlap W//2
-
-    Args:
-        d: dimensão dos tokens
-        tome_r: tokens a remover por ToMe (default 8)
-        n_centroids: nº de centroids do KNN (default 64)
-        n_probe: nº de centroids a consultar (default 4)
-        window_size: tamanho da janela (default 4096)
-    """
-
-    def __init__(
-        self,
-        d: int,
-        tome_r: int = 8,
-        n_centroids: int = 64,
-        n_probe: int = 4,
-        window_size: int = 4096,
-    ):
-        super().__init__()
-        self.d = d
-        self.window_size = window_size
-        self.tome = ToMeCompressor(r=tome_r)
-        self.knn = KNNIndexer(
-            d=d, n_centroids=n_centroids, n_probe=n_probe
-        )
-
-    def forward(
-        self,
-        x: torch.Tensor,
-        return_aux: bool = False,
-    ) -> torch.Tensor:
-        """x: (batch, N, d) → (batch, N - r, d) comprimido + indexado.
-
-        Aplica ToMe (se N > 2*r) e treina KNN centroids via EMA.
-        """
-        # 1. ToMe compression
-        if x.shape[1] > 2 * self.tome.r:
-            x_compressed, tome_aux = self.tome(x)
-        else:
-            x_compressed = x
-            tome_aux = {"r_used": 0, "n_tokens_in": x.shape[1], "n_tokens_out": x.shape[1]}
-
-        # 2. Atualiza KNN centroids (treino apenas)
-        if self.training:
-            self.knn.update_centroids_ema(x_compressed)
-
-        # 3. Atenção aproximada via KNN (query=x_compressed, keys=x_compressed)
-        out, knn_aux = self.knn(x_compressed, x_compressed, x_compressed)
-
-        if not return_aux:
-            return out
-
-        return out, {
-            "tome": tome_aux,
-            "knn": knn_aux,
-            "compression_total": (
-                tome_aux["n_tokens_in"] / max(tome_aux["n_tokens_out"], 1)
-            ) * max(knn_aux["compression_ratio"], 1.0),
-        }
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Estimativa de memória para 2M tokens
-# ═══════════════════════════════════════════════════════════════════════════
-def estimate_2m_tokens_memory(
-    d: int = 128,
-    batch: int = 1,
-    dtype_bytes: int = 4,
-) -> dict:
-    """Estima memória para 2M tokens.
-
-    Sem WindowContext:
-      attention matrix: (batch, 2M, 2M) * dtype_bytes = 16 TB (float32)
-      tokens:           (batch, 2M, d) * dtype_bytes = 1 GB
-
-    Com WindowContext (ToMe r=8 per layer, 12 layers):
-      tokens reduzidos: 2M - 12*8 = 1,999,904 (~99.99% retido)
-      KNN attention: (batch, 2M, n_probe * K/N) = (1, 2M, 4*64/2M) = 8 MB
-
-    Returns:
-        dict com estimativas em GB
-    """
-    N = 2_000_000
-    attention_full_gb = (batch * N * N * dtype_bytes) / (1024 ** 4)
-    tokens_full_gb = (batch * N * d * dtype_bytes) / (1024 ** 3)
-
-    # Com ToMe + KNN
-    n_centroids = 64
-    n_probe = 4
-    K_per_query = n_probe * (N // n_centroids)  # ~n_probe * cluster_size
-    attention_knn_gb = (batch * N * K_per_query * dtype_bytes) / (1024 ** 3)
-
-    return {
-        "n_tokens": N,
-        "d": d,
-        "batch": batch,
-        "attention_full_gb": attention_full_gb,
-        "tokens_full_gb": tokens_full_gb,
-        "attention_knn_gb": attention_knn_gb,
-        "reduction_factor": attention_full_gb / max(attention_knn_gb, 1e-9),
-    }
-
-
-__all__ = [
-    "ToMeCompressor",
-    "KNNIndexer",
-    "WindowContext",
-    "estimate_2m_tokens_memory",
-]

src/bigru_t/reasoning/reasoning_system.py

@@ -1,281 +0,0 @@
-"""reasoning_system.py — Sistema de Raciocínio (Reasoning/Thinking) integrável (V6).
-
-Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/reasoning_engine.py
-e distributed_reasoning_system.py.
-
-Implementa um sistema de raciocínio multi-fase inspirado em System 2 de
-Kahneman, com 8 fases (V13.9.2):
-  1. Think — pensamento inicial sobre o problema
-  2. Plan — planejamento de solução
-  3. Decompose — decomposição em subproblemas
-  4. Execute — execução dos passos
-  5. Monitor — monitoramento do progresso
-  6. Predict — predição de resultado
-  7. Adjust — ajuste baseado em feedback
-  8. Compose — composição da resposta final
-
-V6 melhorias vs V13.9.2:
-  * Self-contained (sem PEVSystem distribuído)
-  * BayesianStrategySelector com Thompson sampling (era epsilon-greedy)
-  * Compatível com langchain (pode ser usado como tool)
-  * Vetorizado quando possível
-
-REFERÊNCIAS:
-  - Kahneman (2011). "Thinking, Fast and Slow".
-  - Wei et al. (2022). "Chain-of-Thought Prompting".
-  - Yao et al. (2023). "Tree of Thoughts".
-  - Thompson (1933). "On the likelihood that one unknown probability exceeds
-    another" (Thompson sampling).
-"""
-from __future__ import annotations
-
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from typing import Optional, List, Dict, Tuple
-from collections import deque
-import random
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# ReasoningPhase — enum das 8 fases
-# ═══════════════════════════════════════════════════════════════════════════
-REASONING_PHASES = [
-    "think",
-    "plan",
-    "decompose",
-    "execute",
-    "monitor",
-    "predict",
-    "adjust",
-    "compose",
-]
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# BayesianStrategySelector — Thompson sampling
-# ═══════════════════════════════════════════════════════════════════════════
-class BayesianStrategySelector(nn.Module):
-    """Seletor de estratégia bayesiano (Thompson sampling).
-
-    Mantém uma distribuição Beta(α_s, β_s) para cada estratégia s.
-    A cada passo, amostra de cada Beta e escolhe a estratégia com maior amostra.
-    Após receber reward, atualiza α_s ou β_s.
-
-    Args:
-        n_strategies: nº de estratégias (default 8 — uma por fase)
-        prior_alpha: α inicial (default 1.0 — uniforme)
-        prior_beta: β inicial (default 1.0 — uniforme)
-    """
-
-    def __init__(
-        self,
-        n_strategies: int = 8,
-        prior_alpha: float = 1.0,
-        prior_beta: float = 1.0,
-    ):
-        super().__init__()
-        self.n_strategies = n_strategies
-        # α e β das distribuições Beta (uma por estratégia)
-        self.register_buffer("alpha", torch.full((n_strategies,), float(prior_alpha)))
-        self.register_buffer("beta", torch.full((n_strategies,), float(prior_beta)))
-
-    def select(self) -> int:
-        """Thompson sampling: amostra de cada Beta, retorna índice do maior."""
-        # Beta(α, β) sampling via torch.distributions
-        dist = torch.distributions.Beta(self.alpha, self.beta)
-        samples = dist.sample()
-        return int(samples.argmax().item())
-
-    def update(self, strategy: int, reward: float) -> None:
-        """Atualiza a distribuição Beta da estratégia selecionada.
-
-        Beta(α, β) é conjugada de Bernoulli:
-          - reward ≥ 0.5 (sucesso): α ← α + 1
-          - reward < 0.5 (fracasso): β ← β + 1
-        """
-        if reward >= 0.5:
-            self.alpha[strategy] += 1.0
-        else:
-            self.beta[strategy] += 1.0
-
-    def get_strategy_probs(self) -> torch.Tensor:
-        """Retorna probabilidade esperada de cada estratégia (mean of Beta)."""
-        return self.alpha / (self.alpha + self.beta)
-
-    def extra_repr(self) -> str:
-        probs = self.get_strategy_probs()
-        return f"n_strategies={self.n_strategies}, probs={probs.tolist()}"
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# ReasoningEngine — motor de raciocínio 8-fase
-# ════════════════════════════════════════════════════════���══════════════════
-class ReasoningEngine(nn.Module):
-    """Sistema de raciocínio multi-fase (V6).
-
-    Args:
-        d_model: dimensão do hidden state
-        vocab_size: tamanho do vocabulário
-        n_phases: nº de fases (default 8)
-        max_steps: máx de passos de raciocínio (default 16)
-        use_bayesian_selector: se True, usa Thompson sampling (default True)
-
-    Uso:
-        engine = ReasoningEngine(d_model=128, vocab_size=1000)
-        output = engine(inputs, hidden, targets)
-    """
-
-    def __init__(
-        self,
-        d_model: int,
-        vocab_size: int,
-        n_phases: int = 8,
-        max_steps: int = 16,
-        use_bayesian_selector: bool = True,
-    ):
-        super().__init__()
-        self.d_model = d_model
-        self.vocab_size = vocab_size
-        self.n_phases = n_phases
-        self.max_steps = max_steps
-
-        # Embedding de fase (um por fase)
-        self.phase_embedding = nn.Embedding(n_phases, d_model)
-
-        # Projeção do hidden + phase → logits da próxima fase
-        self.phase_proj = nn.Linear(2 * d_model, n_phases)
-
-        # Projeção final → logits de vocabulário
-        self.out_proj = nn.Linear(d_model, vocab_size)
-
-        # Seletor de estratégia
-        self.use_bayesian = use_bayesian_selector
-        if use_bayesian_selector:
-            self.strategy_selector = BayesianStrategySelector(n_strategies=n_phases)
-
-        # Histórico de raciocínio (para logging)
-        self.reasoning_history: List[Dict] = []
-
-    def forward(
-        self,
-        hidden: torch.Tensor,
-        targets: Optional[torch.Tensor] = None,
-        return_chain: bool = False,
-    ) -> dict:
-        """Executa raciocínio multi-fase.
-
-        Args:
-            hidden: (batch, T, d_model) — hidden state do backbone
-            targets: (batch, T) — targets (opcional, para supervised loss)
-            return_chain: se True, retorna cadeia de raciocínio
-
-        Returns:
-            dict com:
-                - logits: (B, T, vocab_size) — logits finais
-                - loss: escalar (se targets fornecido)
-                - chain: lista de fases executadas (se return_chain=True)
-                - aux: estatísticas
-        """
-        B, T, D = hidden.shape
-        device = hidden.device
-
-        # Estado de raciocínio: começa com hidden médio sobre T
-        reasoning_state = hidden.mean(dim=1)  # (B, D)
-        chain: List[Dict] = []
-        phase_logits_accum = torch.zeros(B, self.n_phases, device=device)
-
-        for step in range(self.max_steps):
-            # Seleciona fase (Thompson sampling ou determinístico)
-            if self.use_bayesian:
-                phase_idx = self.strategy_selector.select()
-            else:
-                phase_idx = step % self.n_phases
-
-            phase_emb = self.phase_embedding(
-                torch.tensor(phase_idx, device=device)
-            )  # (D,)
-
-            # Combina reasoning_state com phase_emb
-            combined = torch.cat([
-                reasoning_state,
-                phase_emb.unsqueeze(0).expand(B, -1),
-            ], dim=-1)  # (B, 2D)
-
-            # Prediz próxima fase
-            phase_logits = self.phase_proj(combined)  # (B, n_phases)
-            phase_logits_accum += phase_logits
-
-            # Atualiza reasoning_state (residual com phase_emb)
-            reasoning_state = reasoning_state + 0.1 * phase_emb.unsqueeze(0)
-
-            # Log da fase
-            phase_info = {
-                "step": step,
-                "phase": REASONING_PHASES[phase_idx] if phase_idx < len(REASONING_PHASES) else f"phase_{phase_idx}",
-                "phase_idx": phase_idx,
-            }
-            chain.append(phase_info)
-
-            # Reward (se targets fornecido): baseado em quão bem prediz
-            if targets is not None and self.use_bayesian:
-                # Reward aproximado: 1 se a próxima fase melhora a predição
-                # (aqui simplificado: 0.5 neutro)
-                self.strategy_selector.update(phase_idx, 0.5)
-
-            # Critério de parada: se fase volta a ser "think", termina
-            if step > 0 and phase_idx == 0:
-                break
-
-        # Logits finais: out_proj sobre reasoning_state expandido para T
-        final_hidden = reasoning_state.unsqueeze(1).expand(-1, T, -1)  # (B, T, D)
-        # Combina com hidden original (residual)
-        final_hidden = final_hidden + 0.5 * hidden  # (B, T, D)
-        logits = self.out_proj(final_hidden)  # (B, T, vocab_size)
-
-        # Loss (se targets)
-        loss = None
-        if targets is not None:
-            loss = F.cross_entropy(
-                logits.reshape(-1, self.vocab_size),
-                targets.reshape(-1),
-                ignore_index=-100,
-            )
-
-        # Salva histórico
-        self.reasoning_history.append({
-            "chain": chain,
-            "n_steps": len(chain),
-        })
-
-        result = {
-            "logits": logits,
-            "loss": loss,
-            "aux": {
-                "n_reasoning_steps": len(chain),
-                "phases_visited": [c["phase"] for c in chain],
-                "phase_logits_mean": float(phase_logits_accum.mean().item()),
-            },
-        }
-        if return_chain:
-            result["chain"] = chain
-
-        return result
-
-    def get_last_chain(self) -> Optional[List[Dict]]:
-        """Retorna a última cadeia de raciocínio."""
-        if not self.reasoning_history:
-            return None
-        return self.reasoning_history[-1].get("chain")
-
-    def clear_history(self) -> None:
-        """Limpa histórico de raciocínio (libera RAM)."""
-        self.reasoning_history.clear()
-
-
-__all__ = [
-    "REASONING_PHASES",
-    "BayesianStrategySelector",
-    "ReasoningEngine",
-]

src/bigru_t/training/rlhf_possibility_mapping.py

@@ -1,387 +0,0 @@
-"""rlhf_possibility_mapping.py — Mapeamento de Possibilidades Aprendível com RLHF (V6).
-
-Adaptado de gru-ring-v13-9-2/source/xavante_work/flexnet/learnable_mapping.py
-e punishment_reward_system.py.
-
-Implementa o mapeamento de possibilidades aprendível com RLHF (Reinforcement
-Learning from Human Feedback). A fórmula central (Teorema 2 do V13.9.2):
-
-    Φ = Θ + η · r · σ(trust · τ_T) · Σ_i wᵢ · gᵢ - λ_rep · P_rep · ∇P_rep
-
-onde:
-  - Θ: parâmetros base do modelo
-  - η: learning rate
-  - r: reward do humano
-  - σ(trust · τ_T): gate de confiança (TrustNeuralAgent interno, V6 self-contained)
-  - wᵢ: pesos cooperativos (wᵢ ∝ 1/‖gᵢ‖²) — Teorema 2
-  - gᵢ: gradientes das componentes
-  - P_rep: penalidade de repetição
-  - λ_rep: peso da penalidade de repetição
-
-V6 melhorias vs V13.9.2:
-  * Self-contained: TrustNeuralAgent interno (sem dependência externa)
-  * Pesos cooperativos wᵢ calculados online (não pré-computados)
-  * Momentum com decay 0.999 (estabilidade)
-  * Compatível com PPO simplificado (sem actor-critic completo)
-
-REFERÊNCIAS:
-  - Schulman et al. (2017). "Proximal Policy Optimization Algorithms".
-  - Ouyang et al. (2022). "Training language models to follow instructions with
-    human feedback" (InstructGPT).
-  - Christiano et al. (2017). "Deep reinforcement learning from human preferences".
-"""
-from __future__ import annotations
-
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from typing import Optional, List, Dict
-from collections import deque
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# RewardModel — modelo de recompensa simples (placeholder, V6)
-# ═══════════════════════════════════════════════════════════════════════════
-class RewardModel(nn.Module):
-    """Modelo de recompensa simples — projeta hidden state para escalar.
-
-    Em produção, seria treinado com preferências humanas (Bradley-Terry).
-    Aqui é um placeholder linear para fins de integração.
-
-    Args:
-        d_model: dimensão do hidden state
-    """
-
-    def __init__(self, d_model: int):
-        super().__init__()
-        self.proj = nn.Sequential(
-            nn.Linear(d_model, d_model // 2),
-            nn.ReLU(),
-            nn.Linear(d_model // 2, 1),
-        )
-
-    def forward(self, hidden: torch.Tensor) -> torch.Tensor:
-        """hidden: (batch, T, d) → reward: (batch,) — média sobre T."""
-        return self.proj(hidden).squeeze(-1).mean(dim=-1)
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# TrustNeuralAgent — self-contained (V6)
-# ═══════════════════════════════════════════════════════════════════════════
-class TrustNeuralAgent(nn.Module):
-    """Agente de confiança self-contained (sem dependência externa).
-
-    Mantém um embedding de "trust" por token, atualizado via TD-learning.
-    Em V13.9.2, era uma classe externa com dependências complexas. Em V6,
-    é uma camada simples com:
-      - Embedding de trust (d_model) por vocab_size
-      - Atualização TD: trust[t+1] = trust[t] + α · (reward - trust[t])
-
-    Args:
-        vocab_size: tamanho do vocabulário
-        d_model: dimensão do trust embedding
-        td_alpha: taxa de aprendizado TD (default 0.1)
-    """
-
-    def __init__(
-        self,
-        vocab_size: int,
-        d_model: int,
-        td_alpha: float = 0.1,
-    ):
-        super().__init__()
-        self.vocab_size = vocab_size
-        self.d_model = d_model
-        self.td_alpha = td_alpha
-        # Trust embedding: (vocab_size, d_model) — inicializado neutro (0.5)
-        self.trust_embedding = nn.Parameter(torch.zeros(vocab_size, d_model))
-        # tau_T: temperatura (aprendível)
-        self.log_tau_T = nn.Parameter(torch.tensor(0.0))  # τ_T = 1.0
-
-    @property
-    def tau_T(self) -> torch.Tensor:
-        return torch.exp(self.log_tau_T)
-
-    def forward(
-        self,
-        token_ids: torch.Tensor,
-        hidden: torch.Tensor,
-    ) -> torch.Tensor:
-        """Computa σ(trust · τ_T) para os tokens dados.
-
-        Args:
-            token_ids: (batch, T) — IDs dos tokens
-            hidden: (batch, T, d_model) — hidden states (não usado aqui,
-                    mas mantido para compat)
-
-        Returns:
-            trust_gate: (batch, T) — σ(mean(trust_embedding[token]) · τ_T)
-        """
-        trust = self.trust_embedding[token_ids]  # (B, T, d)
-        trust_scalar = trust.mean(dim=-1)  # (B, T)
-        # σ(trust · τ_T) — gate de confiança ∈ (0, 1)
-        gate = torch.sigmoid(trust_scalar * self.tau_T)
-        return gate
-
-    @torch.no_grad()
-    def update_td(self, token_ids: torch.Tensor, rewards: torch.Tensor) -> None:
-        """Atualização TD do trust embedding.
-
-        trust[token] ← trust[token] + α · (reward - trust[token])
-
-        Args:
-            token_ids: (batch, T) — tokens que receberam feedback
-            rewards: (batch, T) ou (batch,) — recompensas
-        """
-        if rewards.dim() == 1:
-            rewards = rewards.unsqueeze(-1).expand(-1, token_ids.shape[1])
-        for b in range(token_ids.shape[0]):
-            for t in range(token_ids.shape[1]):
-                tid = int(token_ids[b, t].item())
-                r = float(rewards[b, t].item())
-                # Atualiza apenas o primeiro canal (escalar)
-                current = float(self.trust_embedding[tid, 0].item())
-                self.trust_embedding.data[tid, 0] = current + self.td_alpha * (r - current)
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# LearnablePossibilityMapping — RLHF com mapeamento de possibilidades
-# ═══════════════════════════════════════════════════════════════════════════
-class LearnablePossibilityMapping(nn.Module):
-    """Mapeamento de Possibilidades Aprendível com RLHF (V6).
-
-    Implementa a fórmula central (Teorema 2 do V13.9.2):
-        Φ = Θ + η · r · σ(trust · τ_T) · Σ_i wᵢ · gᵢ - λ_rep · P_rep · ∇P_rep
-
-    Componentes:
-      - TrustNeuralAgent: gate σ(trust · τ_T)
-      - RewardModel: recompensa r
-      - Pesos cooperativos wᵢ ∝ 1/‖gᵢ‖² (Teorema 2)
-      - Momentum com decay 0.999
-
-    Args:
-        model: modelo base
-        vocab_size: tamanho do vocabulário
-        d_model: dimensão do modelo
-        eta_init: η inicial (learning rate RL) — default 0.01
-        lambda_rep_init: λ_rep inicial — default 0.1
-        momentum_decay: decay do momentum — default 0.999
-    """
-
-    def __init__(
-        self,
-        model: nn.Module,
-        vocab_size: int,
-        d_model: int,
-        eta_init: float = 0.01,
-        lambda_rep_init: float = 0.1,
-        momentum_decay: float = 0.999,
-    ):
-        super().__init__()
-        self.model = model
-        self.vocab_size = vocab_size
-        self.d_model = d_model
-        self.momentum_decay = momentum_decay
-
-        # Componentes
-        self.trust_agent = TrustNeuralAgent(vocab_size, d_model)
-        self.reward_model = RewardModel(d_model)
-
-        # Hiperparâmetros (log-space)
-        self.log_eta = nn.Parameter(torch.tensor(math.log(eta_init)))
-        self.log_lambda_rep = nn.Parameter(torch.tensor(math.log(lambda_rep_init)))
-
-        # Momentum (um por parâmetro)
-        self.momentum: Dict[str, torch.Tensor] = {}
-
-        # Histórico de rewards (para normalização)
-        self.register_buffer("reward_history", torch.zeros(100))
-        self.register_buffer("reward_history_pos", torch.tensor(0, dtype=torch.long))
-
-    @property
-    def eta(self) -> torch.Tensor:
-        return torch.exp(self.log_eta)
-
-    @property
-    def lambda_rep(self) -> torch.Tensor:
-        return torch.exp(self.log_lambda_rep)
-
-    def compute_cooperative_weights(
-        self,
-        grads: List[torch.Tensor],
-    ) -> List[torch.Tensor]:
-        """Computa pesos cooperativos wᵢ ∝ 1/‖gᵢ‖² (Teorema 2).
-
-        Args:
-            grads: lista de gradientes (um por componente)
-
-        Returns:
-            lista de pesos normalizados (soma = 1)
-        """
-        norms_sq = torch.stack(
-            [(g ** 2).sum() if g is not None else torch.tensor(0.0) for g in grads]
-        )
-        # wᵢ ∝ 1/‖gᵢ‖² — gradientes menores recebem mais peso
-        inv_norms = 1.0 / (norms_sq + 1e-8)
-        weights = inv_norms / inv_norms.sum()
-        return [float(w.item()) for w in weights]
-
-    def update_reward_history(self, reward: float) -> float:
-        """Atualiza histórico e retorna reward normalizado."""
-        pos = int(self.reward_history_pos.item())
-        self.reward_history[pos] = reward
-        self.reward_history_pos = (self.reward_history_pos + 1) % self.reward_history.shape[0]
-        # Normalização: reward normalizado = (r - mean) / (std + eps)
-        mean = float(self.reward_history.mean().item())
-        std = float(self.reward_history.std().item())
-        return (reward - mean) / (std + 1e-8)
-
-    def compute_mapping(
-        self,
-        token_ids: torch.Tensor,
-        hidden: torch.Tensor,
-        task_loss: torch.Tensor,
-        rep_penalty: Optional[torch.Tensor] = None,
-    ) -> dict:
-        """Computa o mapeamento de possibilidades Φ.
-
-        Φ = Θ + η · r · σ(trust · τ_T) · Σ_i wᵢ · gᵢ - λ_rep · P_rep · ∇P_rep
-
-        Args:
-            token_ids: (batch, T) — tokens
-            hidden: (batch, T, d_model) — hidden states
-            task_loss: escalar — loss da tarefa atual
-            rep_penalty: escalar opcional — penalidade de repetição
-
-        Returns:
-            dict com:
-                - reward: recompensa r
-                - trust_gate: σ(trust · τ_T)
-                - cooperative_weights: wᵢ
-                - lambda_rep: λ_rep atual
-                - eta: η atual
-                - normalized_reward: r normalizado
-        """
-        # 1. Reward
-        with torch.no_grad():
-            reward = self.reward_model(hidden).mean()  # escalar
-            normalized_reward = self.update_reward_history(float(reward.item()))
-
-        # 2. Trust gate
-        trust_gate = self.trust_agent(token_ids, hidden)  # (B, T)
-        trust_gate_mean = trust_gate.mean()  # escalar
-
-        # 3. Gradientes das componentes (apenas task_loss tem grad aqui)
-        # Em V6 simplificado: só 1 componente (task_loss)
-        # Em versão completa: teríamos task_loss + auxiliary_losses
-        grads = [torch.autograd.grad(
-            task_loss, list(self.model.parameters()),
-            retain_graph=True, allow_unused=True
-        )]
-        # Pesos cooperativos
-        w = self.compute_cooperative_weights(grads[0])
-
-        # 4. Penalidade de repetição
-        if rep_penalty is not None:
-            rep_penalty_val = rep_penalty
-        else:
-            rep_penalty_val = torch.tensor(0.0, device=hidden.device)
-
-        # 5. Mapeamento Φ (não aplicado aqui — apenas log dos componentes)
-        # A aplicação real acontece no trainer via:
-        #   θ ← θ - η · (r - baseline) · trust_gate · Σ wᵢ · gᵢ - λ_rep · ∇P_rep
-        # Aqui retornamos os componentes para inspeção/logging
-        return {
-            "reward": float(reward.item()),
-            "normalized_reward": float(normalized_reward),
-            "trust_gate_mean": float(trust_gate_mean.item()),
-            "trust_tau_T": float(self.trust_agent.tau_T.item()),
-            "cooperative_weights": w,
-            "lambda_rep": float(self.lambda_rep.item()),
-            "eta": float(self.eta.item()),
-            "rep_penalty": float(rep_penalty_val.item() if isinstance(rep_penalty_val, torch.Tensor) else rep_penalty_val),
-        }
-
-    @torch.no_grad()
-    def apply_mapping(
-        self,
-        token_ids: torch.Tensor,
-        hidden: torch.Tensor,
-        task_grads: Dict[str, torch.Tensor],
-        rep_penalty_grads: Optional[Dict[str, torch.Tensor]] = None,
-        reward: Optional[float] = None,
-    ) -> Dict[str, float]:
-        """Aplica o mapeamento Φ aos gradientes (in-place).
-
-        Φ = Θ + η · r · σ(trust · τ_T) · Σ_i wᵢ · gᵢ - λ_rep · P_rep · ∇P_rep
-
-        Args:
-            token_ids: (batch, T)
-            hidden: (batch, T, d_model)
-            task_grads: gradientes da task_loss
-            rep_penalty_grads: gradientes da penalidade de repetição (opcional)
-            reward: recompensa externa (opcional)
-
-        Returns:
-            dict com estatísticas da atualização
-        """
-        # 1. Reward (computa se não fornecido)
-        if reward is None:
-            reward = float(self.reward_model(hidden).mean().item())
-        normalized_reward = self.update_reward_history(reward)
-
-        # 2. Trust gate (média)
-        trust_gate = self.trust_agent(token_ids, hidden)
-        trust_gate_mean = float(trust_gate.mean().item())
-
-        # 3. Pesos cooperativos (1 componente aqui)
-        task_norm_sq = sum(
-            (g ** 2).sum().item() for g in task_grads.values() if g is not None
-        )
-        w_task = 1.0 / (task_norm_sq + 1e-8)
-
-        # 4. Aplica Φ aos gradientes
-        eta = float(self.eta.item())
-        lam_rep = float(self.lambda_rep.item())
-        scaling = eta * normalized_reward * trust_gate_mean * w_task
-
-        for name, p in self.model.named_parameters():
-            if not p.requires_grad:
-                continue
-            g_task = task_grads.get(name)
-            if g_task is None:
-                continue
-            # Momentum
-            if name not in self.momentum:
-                self.momentum[name] = torch.zeros_like(p)
-            self.momentum[name] = (
-                self.momentum_decay * self.momentum[name]
-                + (1.0 - self.momentum_decay) * g_task
-            )
-            # Atualização: Δθ = scaling · momentum - lam_rep · rep_penalty_grad
-            delta = scaling * self.momentum[name]
-            if rep_penalty_grads and name in rep_penalty_grads:
-                delta = delta - lam_rep * rep_penalty_grads[name]
-            p.data -= delta
-
-        # 5. Atualiza trust via TD
-        self.trust_agent.update_td(token_ids, torch.full(
-            (token_ids.shape[0],), reward, device=token_ids.device
-        ))
-
-        return {
-            "reward": reward,
-            "normalized_reward": normalized_reward,
-            "trust_gate_mean": trust_gate_mean,
-            "scaling": scaling,
-            "eta": eta,
-            "lambda_rep": lam_rep,
-        }
-
-
-__all__ = [
-    "RewardModel",
-    "TrustNeuralAgent",
-    "LearnablePossibilityMapping",
-]

src/bigru_t/training/trainer.py

@@ -1,937 +0,0 @@
-"""trainer.py — Loop de treino BiGRU_T_version (2 épocas, bug-detection).
-
-Implementa:
-- Treino com 2 épocas fixas ( especificação do usuário )
-- Sem dados inventados (apenas datasets do repo + HF públicos)
-- Monitoramento: loss, perplexidade, RAM, disco, módulos ativos
-- Kill-switch: aborta se loss não diminuir ou RAM explodir
-- Estados temporários salvos durante treino e APAGADOS ao final
-- Aplicação dos 4 lemas:
-    Lema 1: ModuleSelector (softmax + entropia)
-    Lema 2: apply_gradient_surgery quando use_hyp=True
-    Lema 3: hyp_T com stop_grad_hyp=True, W8A8 via QuantizedLinear
-    Lema 4: MetaConfigurator ajusta T e τ a cada meta_interval batches
-
-Reaproveita a filosofia do scripts/train_from_v13_9_2.py, mas:
-- Sem fine-tune de modelo pré-treinado (treino from-scratch para
-  bug-detection — o objetivo é detectar erros, não produzir modelo SOTA)
-- Adiciona kill-switch (não havia no original)
-- Adiciona MetaConfigurator (não havia no original)
-- Adiciona gradient surgery (não havia no original)
-- Usa 2 épocas explícitas (vs. max_steps no original)
-"""
-from __future__ import annotations
-
-import gc
-import json
-import logging
-import math
-import os
-import shutil
-import sys
-import time
-import traceback
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Optional
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from ..model.unified_model import UnifiedModel, UnifiedModelConfig, create_unified_model
-from .gradient_surgery import apply_gradient_surgery
-from .meta_configurator import MetaConfigurator
-from .kill_switch import KillSwitch
-from .dpo import compute_dynamic_beta, dpo_step, compute_sequence_logps
-from .hypothesis_monitor import HypothesisMonitor
-from ..optim.hamiltonian_wasserstein import HamiltonianWassersteinOptimizer
-from ..utils.memory_cleanup import aggressive_cleanup, production_cleanup, TimeBudget, StepTimer, get_rss_mb
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class TrainerConfig:
-    """Configuração do treino (V3: 5 épocas + DPO + CircularReasoning + Monitor)."""
-    # Epochs (V3: 5 épocas conforme especificação do usuário)
-    epochs: int = 5
-
-    # Datasets
-    datasets: str = "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1,Madras1/corpus-ptbr-v2,dominguesm/restore-punctuation-ptbr-dataset"
-    max_samples_per_dataset: int = 30  # bug-detection: amostra pequena
-    max_seq_len: int = 64
-
-    # Batch
-    per_device_batch_size: int = 1
-    grad_accum: int = 4
-
-    # Optimizer (HamiltonianWasserstein ATIVADO)
-    optimizer_type: str = "hamiltonian_wasserstein"  # "adamw" | "hamiltonian_wasserstein"
-    lr: float = 1e-3  # from-scratch: LR mais alto que fine-tune
-    weight_decay: float = 0.01
-    max_grad_norm: float = 5.0
-    # HW optimizer params
-    hw_lr_amp: float = 0.3       # amplitude do LR cíclico (Van der Pol)
-    hw_lr_freq: float = 0.01     # frequência angular do LR cíclico
-    hw_sigma_w: float = 1.0      # escala W₂
-    hw_sigma_rep: float = 0.1    # escala repulsão topológica
-    hw_prune_every_n: int = 0    # pruning desativado por padrão (0 = off)
-    hw_ref_buffer_size: int = 2  # buffer de referência reduzido (era 10 → 2 para economizar RAM)
-
-    # DPO (V3: ATIVADO para datasets compatíveis)
-    # DPO é ativado automaticamente quando amostras têm label_text
-    # (instruction/response format). DPO loss é adicionada à loss principal.
-    use_dpo: bool = True         # V3: ativo por padrão (auto-detecção)
-    dpo_beta_min: float = 0.05
-    dpo_beta_max: float = 0.5
-    dpo_warmup_steps: int = 100
-    dpo_loss_weight: float = 0.3  # peso da loss DPO na loss total
-    dpo_use_ipo: bool = False    # IPO em vez de DPO clássico
-    dpo_label_smoothing: float = 0.0
-    dpo_every_n_steps: int = 2   # computar DPO a cada N steps (economia de compute)
-
-    # Circular Reasoning (Teorema 4)
-    use_circular_reasoning: bool = True  # já está no UnifiedModelConfig também
-
-    # Meta-configurator (Lema 4)
-    meta_interval: int = 10  # a cada N micro-batches
-    meta_lr: float = 0.01
-    sharpness_lambda: float = 0.01
-
-    # Hypothesis (Lema 3)
-    use_hypothesis: bool = True
-    stop_grad_hyp: bool = True
-
-    # Kill-switch
-    ram_threshold_pct: float = 90.0
-    disk_min_free_gb: float = 1.0
-    loss_patience: int = 30
-
-    # Time budget (estilo Xavante — streaming com timed steps)
-    # V3: aumentado para 5 épocas (2700s total = 45 min, 540s/epoch = 9 min)
-    max_total_time_s: float = 2700.0   # 45 min máx total (5 épocas)
-    max_per_epoch_s: float = 540.0     # 9 min máx por época
-
-    # Memory cleanup agressivo (estilo Xavante)
-    cleanup_every_n_steps: int = 5    # aggressive_cleanup a cada N optimizer steps
-
-    # Logging
-    log_every: int = 5
-    save_temp_every: int = 10  # salvar checkpoint temporário a cada N steps
-
-    # Paths
-    output_dir: str = "/home/z/my-project/BiGRU_T_version/model_final"
-    temp_dir: str = "/home/z/my-project/BiGRU_T_version/_temp_checkpoints"
-    keep_temp: bool = False  # False = apagar temp ao final (especificação)
-
-
-class BiGRU_T_Trainer:
-    """Trainer para BiGRU_T_version com 4 lemas + kill-switch.
-
-    Args:
-        model: UnifiedModel
-        tokenizer: BBPE tokenizer
-        config: TrainerConfig
-        train_samples: lista de ProcessedSample para treino
-        val_samples: lista de ProcessedSample para validação (meta-aprendizado)
-    """
-
-    def __init__(
-        self,
-        model: UnifiedModel,
-        tokenizer,
-        config: TrainerConfig,
-        train_samples: list,
-        val_samples: list,
-    ):
-        self.model = model
-        self.tokenizer = tokenizer
-        self.config = config
-        self.train_samples = train_samples
-        self.val_samples = val_samples
-
-        # Device
-        self.device = torch.device("cpu")
-        torch.set_num_threads(2)
-        os.environ.setdefault("OMP_NUM_THREADS", "2")
-        os.environ.setdefault("MKL_NUM_THREADS", "2")
-        os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
-
-        # Otimizador principal — HamiltonianWasserstein ATIVADO por padrão
-        # (AdamW + W₂ adaptativo + repulsão topológica + LR cíclico + pruning opcional)
-        if config.optimizer_type == "hamiltonian_wasserstein":
-            self.optimizer = HamiltonianWassersteinOptimizer(
-                model.parameters(),
-                lr=config.lr,
-                betas=(0.9, 0.95),
-                eps=1e-8,
-                weight_decay=config.weight_decay,
-                lr_amp=config.hw_lr_amp,
-                lr_freq=config.hw_lr_freq,
-                sigma_w=config.hw_sigma_w,
-                sigma_rep=config.hw_sigma_rep,
-                prune_every_n=config.hw_prune_every_n,
-                ref_buffer_size=config.hw_ref_buffer_size,
-            )
-            logger.info("Optimizer: HamiltonianWassersteinOptimizer (ATIVADO)")
-        else:
-            self.optimizer = torch.optim.AdamW(
-                model.parameters(),
-                lr=config.lr,
-                betas=(0.9, 0.95),
-                weight_decay=config.weight_decay,
-                eps=1e-8,
-            )
-            logger.info("Optimizer: AdamW (fallback)")
-
-        # Time budget (estilo Xavante)
-        self.time_budget = TimeBudget(
-            max_total_s=config.max_total_time_s,
-            max_per_epoch_s=config.max_per_epoch_s,
-        )
-        self.step_timer = StepTimer(expected_s=2.0)  # espera ~2s por step
-
-        # Meta-configurator (Lema 4)
-        self.meta_cfg = MetaConfigurator(
-            model,
-            meta_lr=config.meta_lr,
-            sharpness_lambda=config.sharpness_lambda,
-        )
-
-        # Kill-switch
-        self.kill_switch = KillSwitch(
-            ram_threshold_pct=config.ram_threshold_pct,
-            disk_min_free_gb=config.disk_min_free_gb,
-            loss_patience=config.loss_patience,
-            log_dir=config.temp_dir,
-        )
-
-        # Hypothesis Monitor (V3) — detecta bugs na ativação dos 4 lemas
-        self.hyp_monitor = HypothesisMonitor(
-            max_modules=model.config.max_modules,
-            delta_epsilon=1e-4,
-            meta_stagnation_epsilon=1e-4,
-            history_size=200,
-        )
-
-        # DPO: detecta se dataset é compatível (tem label_text em pelo menos 30% das amostras)
-        self._dpo_compatible = False
-        if config.use_dpo and train_samples:
-            n_with_label = sum(1 for s in train_samples if getattr(s, "label_text", ""))
-            ratio = n_with_label / len(train_samples)
-            self._dpo_compatible = ratio >= 0.3
-            logger.info(
-                f"DPO auto-detecção: {n_with_label}/{len(train_samples)} ({ratio:.0%}) "
-                f"amostras com label_text → "
-                f"{'COMPATÍVEL (DPO ativado)' if self._dpo_compatible else 'não compatível (SFT only)'}"
-            )
-
-        # Diretórios
-        Path(config.output_dir).mkdir(parents=True, exist_ok=True)
-        Path(config.temp_dir).mkdir(parents=True, exist_ok=True)
-
-        # Estado de treino
-        self.global_step = 0
-        self.micro_batch_idx = 0
-        self.best_loss = float("inf")
-        self.losses_history: list[float] = []
-        self.killed_reason: Optional[str] = None
-        # DPO reference logps (computados uma vez no início, com modelo congelado)
-        self._ref_logps_computed = False
-
-    def _collate(self, samples: list) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Tokeniza samples → (input_ids, attention_mask, labels).
-
-        Reaproveita collate_samples_to_tensors do streaming_datasets_v13_9.
-        """
-        from ..data.streaming_datasets import collate_samples_to_tensors
-        pad_id = self.model.config.pad_token_id
-        return collate_samples_to_tensors(
-            samples, self.tokenizer,
-            max_seq_len=self.config.max_seq_len,
-            pad_token_id=pad_id,
-        )
-
-    def _forward_loss(
-        self,
-        input_ids: torch.Tensor,
-        attention_mask: torch.Tensor,
-        labels: torch.Tensor,
-        use_hyp: bool,
-    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        """Forward + loss. Retorna (loss_main, loss_hyp_or_zero, y_final).
-
-        Para LM (next-token prediction):
-        - input_ids: (batch, T)
-        - labels: (batch, T) — target = input_ids shifted
-        - y_hat, delta: (batch, T, vocab_size) — um logit por posição
-        - loss = CrossEntropy(y_hat.view(-1, V), labels.view(-1))
-
-        Mas o UnifiedModel atual produz (batch, vocab_size) — um logit por
-        amostra. Para compatibilidade com LM, fazemos:
-        - input = input_ids[:, :-1] (T-1 tokens de entrada)
-        - target = input_ids[:, 1:] (T-1 targets)
-        - Mas o modelo só produz 1 logit por amostra, então targetamos
-          apenas o ÚLTIMO token: target = input_ids[:, -1]
-        - loss = CrossEntropy(y_hat, target)
-
-        Esta é uma simplificação para bug-detection — não é um LM completo.
-        """
-        # Target = último token (simplificação para bug-detection)
-        target = input_ids[:, -1].clone()  # (batch,)
-        # Input = todos os tokens (o modelo faz embedding internamente)
-        # Passamos input_ids (2D) — o modelo detecta e faz embedding
-
-        # Forward do modelo
-        temperature = self.meta_cfg.temperature
-        y_hat, delta = self.model(
-            input_ids,
-            temperature=temperature,
-            use_hypothesis=use_hyp,
-            stop_grad_hyp=self.config.stop_grad_hyp,
-            return_aux=False,
-        )
-        # y_hat: (batch, vocab_size), delta: (batch, vocab_size)
-
-        # Loss principal: CrossEntropy sobre o último token
-        loss_main = F.cross_entropy(y_hat, target, ignore_index=self.model.config.pad_token_id)
-
-        # Loss de hipótese: sobre y_final = y_hat + delta
-        if use_hyp:
-            y_final = y_hat + delta
-            loss_hyp = F.cross_entropy(y_final, target, ignore_index=self.model.config.pad_token_id)
-        else:
-            loss_hyp = torch.zeros((), device=y_hat.device)
-
-        return loss_main, loss_hyp, y_hat
-
-    def train(self) -> dict:
-        """Executa treino de bug-detection (2 épocas).
-
-        Returns:
-            dict com métricas finais.
-        """
-        cfg = self.config
-        n_train = len(self.train_samples)
-        n_val = len(self.val_samples)
-        logger.info("=" * 70)
-        logger.info("BiGRU_T_version — Bug-detection training")
-        logger.info("=" * 70)
-        logger.info(f"  epochs:          {cfg.epochs}")
-        logger.info(f"  train samples:   {n_train}")
-        logger.info(f"  val samples:     {n_val}")
-        logger.info(f"  batch_size:      {cfg.per_device_batch_size}")
-        logger.info(f"  grad_accum:      {cfg.grad_accum}")
-        logger.info(f"  lr:              {cfg.lr}")
-        logger.info(f"  optimizer:       {cfg.optimizer_type}")
-        logger.info(f"  max_seq_len:     {cfg.max_seq_len}")
-        logger.info(f"  use_hypothesis:  {cfg.use_hypothesis}")
-        logger.info(f"  use_dpo:         {cfg.use_dpo}")
-        logger.info(f"  meta_interval:   {cfg.meta_interval}")
-        logger.info(f"  time_budget:     {cfg.max_total_time_s}s total, {cfg.max_per_epoch_s}s/epoch")
-        logger.info(f"  cleanup_every:   {cfg.cleanup_every_n_steps} steps")
-        logger.info("=" * 70)
-
-        # Conta parâmetros
-        params = self.model.count_parameters()
-        logger.info(f"  total params:    {params['total']:,} ({params['total_M']:.2f}M)")
-        logger.info(f"  trainable:       {params['trainable']:,} ({params['trainable_M']:.2f}M)")
-        logger.info("=" * 70)
-
-        t_start = time.time()
-        self.model.train()
-        self.time_budget.reset_total()
-
-        for epoch in range(cfg.epochs):
-            logger.info(f"\n--- Epoch {epoch+1}/{cfg.epochs} ---")
-            epoch_start = time.time()
-            epoch_losses = []
-            self.time_budget.reset_epoch()
-
-            # Itera sobre samples (loop circular se n_train < batches necessários)
-            sample_idx = 0
-            micro_in_epoch = 0
-
-            while micro_in_epoch < n_train:
-                # Time budget check (estilo Xavante)
-                if self.time_budget.is_over() or self.time_budget.is_epoch_over():
-                    logger.warning(
-                        "Time budget estourado: total=%s epoch=%s",
-                        self.time_budget.is_over(), self.time_budget.is_epoch_over(),
-                    )
-                    break
-
-                # Pega batch
-                batch_samples = []
-                for _ in range(cfg.per_device_batch_size):
-                    s = self.train_samples[sample_idx % n_train]
-                    batch_samples.append(s)
-                    sample_idx += 1
-                    micro_in_epoch += 1
-                    if micro_in_epoch >= n_train:
-                        break
-
-                # Tokeniza
-                try:
-                    input_ids, attn_mask, labels = self._collate(batch_samples)
-                except Exception as e:
-                    logger.warning(f"Tokenize erro micro {self.micro_batch_idx}: {e}")
-                    continue
-
-                # Forward + loss — OTIMIZADO: single forward pass
-                # (antes: 3 forwards por micro-batch; agora: 1 forward com return_aux)
-                try:
-                    # Target = último token
-                    target = input_ids[:, -1].clone()
-
-                    # SINGLE forward: retorna y_hat, delta, e aux (entropy_reg, alpha, circular_info)
-                    y_hat, delta, aux = self.model(
-                        input_ids,
-                        temperature=self.meta_cfg.temperature,
-                        use_hypothesis=True,   # sempre computa delta (barato se stop_grad)
-                        stop_grad_hyp=self.config.stop_grad_hyp,
-                        return_aux=True,
-                        use_circular=cfg.use_circular_reasoning,
-                    )
-
-                    # Loss principal: CrossEntropy sobre y_hat + entropy_reg (Lema 1)
-                    loss_main = F.cross_entropy(
-                        y_hat, target, ignore_index=self.model.config.pad_token_id
-                    )
-                    loss_main_total = loss_main + aux["entropy_reg"]
-
-                    # Decide se usa hipótese baseado no tau (Lema 3)
-                    # use_hyp = True se loss_main > tau (modelo está "lutando")
-                    use_hyp = (
-                        cfg.use_hypothesis
-                        and self.global_step > 0
-                        and bool(loss_main.item() > self.meta_cfg.tau)
-                    )
-
-                    # Loss de hipótese: sobre y_final = y_hat + delta
-                    if use_hyp:
-                        y_final = y_hat + delta
-                        loss_hyp = F.cross_entropy(
-                            y_final, target,
-                            ignore_index=self.model.config.pad_token_id,
-                        )
-                    else:
-                        loss_hyp = torch.zeros((), device=y_hat.device)
-
-                    # V3: DPO loss — se dataset é compatível e estamos num step de DPO
-                    loss_dpo_val = 0.0
-                    if (
-                        self._dpo_compatible
-                        and self.global_step % cfg.dpo_every_n_steps == 0
-                        and len(batch_samples) > 0
-                    ):
-                        try:
-                            loss_dpo = self._compute_dpo_loss(batch_samples, y_hat, target)
-                            if loss_dpo is not None:
-                                loss_main_total = loss_main_total + cfg.dpo_loss_weight * loss_dpo
-                                loss_dpo_val = float(loss_dpo.item())
-                        except Exception as dpo_err:
-                            logger.debug(f"DPO step falhou (não crítico): {dpo_err}")
-
-                except RuntimeError as e:
-                    err = str(e).lower()
-                    if "out of memory" in err:
-                        logger.warning(f"OOM micro {self.micro_batch_idx}, limpando")
-                        gc.collect()
-                        self.optimizer.zero_grad()
-                        continue
-                    else:
-                        logger.error(f"Runtime erro micro {self.micro_batch_idx}: {e}")
-                        traceback.print_exc()
-                        break
-
-                # DPO beta dinâmico (se DPO ativo) — para logging no optimizer
-                if self._dpo_compatible:
-                    beta_t = compute_dynamic_beta(
-                        self.global_step,
-                        warmup_steps=cfg.dpo_warmup_steps,
-                        beta_min=cfg.dpo_beta_min,
-                        beta_max=cfg.dpo_beta_max,
-                    )
-                    if hasattr(self.optimizer, "set_beta_dpo"):
-                        self.optimizer.set_beta_dpo(beta_t)
-
-                # Backward + step
-                self.step_timer.start()
-                l2_applied = False
-                grad_hyp_norm = 0.0
-                orth_proj_norm = 0.0
-                if use_hyp and loss_hyp.requires_grad:
-                    # Lema 2: gradient surgery
-                    apply_gradient_surgery(self.model, loss_main_total, loss_hyp)
-                    l2_applied = True
-                    # Mede gradientes para o monitor (após surgery)
-                    try:
-                        grad_norms = [
-                            p.grad.norm().item()
-                            for p in self.model.parameters()
-                            if p.grad is not None
-                        ]
-                        if grad_norms:
-                            grad_hyp_norm = sum(n ** 2 for n in grad_norms) ** 0.5
-                    except Exception:
-                        pass
-                    # Clip
-                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), cfg.max_grad_norm)
-                    # HW optimizer: step aceita loss para logging
-                    if isinstance(self.optimizer, HamiltonianWassersteinOptimizer):
-                        self.optimizer.step(loss=float(loss_main_total.item()))
-                    else:
-                        self.optimizer.step()
-                    self.optimizer.zero_grad()
-                else:
-                    # Apenas loss_main
-                    self.optimizer.zero_grad()
-                    loss_main_total.backward()
-                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), cfg.max_grad_norm)
-                    if isinstance(self.optimizer, HamiltonianWassersteinOptimizer):
-                        self.optimizer.step(loss=float(loss_main_total.item()))
-                    else:
-                        self.optimizer.step()
-                self.step_timer.stop(step_label=str(self.global_step))
-
-                # V3: Hypothesis Monitor — registra estado do step
-                self.hyp_monitor.record(
-                    step=self.global_step,
-                    alpha=aux.get("alpha"),
-                    entropy_reg=float(aux.get("entropy_reg", 0).item()
-                                      if hasattr(aux.get("entropy_reg", 0), "item") else 0),
-                    loss_main=float(loss_main.item()),
-                    tau=float(self.meta_cfg.tau),
-                    use_hyp=use_hyp,
-                    delta=delta if use_hyp else None,
-                    temperature=self.meta_cfg.temperature,
-                    circular_info=aux.get("circular_info"),
-                    l2_applied=l2_applied,
-                    grad_hyp_norm=grad_hyp_norm,
-                    orth_proj_norm=orth_proj_norm,
-                )
-
-                self.micro_batch_idx += 1
-
-                # Log
-                current_loss = float(loss_main.item())
-                self.losses_history.append(current_loss)
-                epoch_losses.append(current_loss)
-                if current_loss < self.best_loss:
-                    self.best_loss = current_loss
-
-                # Verifica se é um optimizer step (a cada grad_accum micro-batches)
-                if self.micro_batch_idx % cfg.grad_accum == 0:
-                    self.global_step += 1
-
-                    # Kill-switch
-                    active = self.model.get_active_modules()
-                    state = self.kill_switch.check(self.global_step, current_loss, active)
-                    if state.reason:
-                        logger.error(f"KILL SWITCH triggered: {state.reason}")
-                        logger.error(
-                            f"  RAM {state.ram_pct:.1f}% | disk free {state.disk_free_gb:.2f}GB | "
-                            f"ppl {state.ppl:.2f}"
-                        )
-                        self.killed_reason = state.reason
-                        break
-
-                    # Log
-                    if self.global_step % cfg.log_every == 0 or self.global_step == 1:
-                        elapsed = time.time() - t_start
-                        avg_loss = sum(self.losses_history[-cfg.grad_accum:]) / max(
-                            1, min(cfg.grad_accum, len(self.losses_history))
-                        )
-                        ppl = math.exp(min(20, avg_loss)) if avg_loss < 20 else float("inf")
-                        # V3: info do Circular Reasoning (último step registrado)
-                        crw_str = ""
-                        last_state = self.hyp_monitor._history[-1] if self.hyp_monitor._history else None
-                        if last_state and last_state.crw_w2_final > 0:
-                            crw_str = (
-                                f" | CRW: w2={last_state.crw_w2_final:.4f} "
-                                f"q̄={last_state.crw_q_avg:.3f} "
-                                f"{'✓' if last_state.crw_contraction_valid else '⚠'}"
-                            )
-                        dpo_str = f" dpo={loss_dpo_val:.3f}" if loss_dpo_val > 0 else ""
-                        logger.info(
-                            f"  step {self.global_step} | epoch {epoch+1} | "
-                            f"loss={avg_loss:.4f} ppl={ppl:.2f}{dpo_str} | "
-                            f"RAM {state.ram_pct:.1f}% disk {state.disk_free_gb:.1f}GB | "
-                            f"modules={active} | T={self.meta_cfg.temperature:.3f} "
-                            f"τ={self.meta_cfg.tau:.3f} | "
-                            f"α_ent={last_state.alpha_entropy:.3f} "
-                            f"α_max={last_state.alpha_max:.3f}"
-                            f"{crw_str} | "
-                            f"elapsed={elapsed:.0f}s"
-                        )
-
-                    # Checkpoint temporário
-                    if self.global_step % cfg.save_temp_every == 0:
-                        self._save_temp_checkpoint(epoch)
-
-                    # Memory cleanup agressivo (estilo Xavante)
-                    if self.global_step % cfg.cleanup_every_n_steps == 0:
-                        cleanup_info = aggressive_cleanup(verbose=False)
-                        if self.global_step % (cfg.cleanup_every_n_steps * 5) == 0:
-                            logger.info(
-                                "  cleanup step %d: RSS %.1f MB (freed %.1f MB)",
-                                self.global_step,
-                                cleanup_info["rss_after_mb"],
-                                cleanup_info["freed_mb"],
-                            )
-
-                    # Meta-configurator (Lema 4)
-                    if self.global_step % cfg.meta_interval == 0 and self.val_samples:
-                        self._run_meta_update()
-
-            if self.killed_reason:
-                break
-
-            # Fim da época — cleanup agressivo
-            aggressive_cleanup(verbose=True)
-
-            # Fim da época
-            epoch_avg = sum(epoch_losses) / max(1, len(epoch_losses))
-            epoch_ppl = math.exp(min(20, epoch_avg)) if epoch_avg < 20 else float("inf")
-            logger.info(
-                f"  Epoch {epoch+1} done: avg_loss={epoch_avg:.4f} ppl={epoch_ppl:.2f} "
-                f"({time.time()-epoch_start:.1f}s)"
-            )
-
-            # SALVAR MODELO APÓS CADA ÉPOCA (garante checkpoint mesmo se OOM no fim)
-            try:
-                partial_result = {
-                    "epochs_completed": epoch + 1,
-                    "killed": False,
-                    "kill_reason": None,  # V3 FIX: era missing → KeyError no _save_final_model
-                    "global_reason": None,
-                    "global_step": self.global_step,
-                    "micro_batches": self.micro_batch_idx,
-                    "best_loss": self.best_loss,
-                    "final_loss": epoch_losses[-1] if epoch_losses else float("nan"),
-                    "final_avg_loss": epoch_avg,
-                    "final_perplexity": epoch_ppl,
-                    "elapsed_s": time.time() - t_start,
-                    "params_total": params["total"],
-                    "params_M": params["total_M"],
-                }
-                self._save_final_model(partial_result)
-                logger.info(f"  Modelo salvo após epoch {epoch+1}")
-            except Exception as e:
-                logger.warning(f"  Falha ao salvar após epoch {epoch+1}: {e}")
-
-        # Fim do treino
-        elapsed_total = time.time() - t_start
-        final_loss = self.losses_history[-1] if self.losses_history else float("nan")
-        final_avg_loss = (
-            sum(self.losses_history[-cfg.grad_accum:]) / max(1, min(cfg.grad_accum, len(self.losses_history)))
-            if self.losses_history else float("nan")
-        )
-        final_ppl = math.exp(min(20, final_avg_loss)) if final_avg_loss < 20 else float("inf")
-        ks_summary = self.kill_switch.summary()
-
-        result = {
-            "epochs_completed": epoch + 1 if not self.killed_reason else epoch,
-            "killed": self.killed_reason is not None,
-            "kill_reason": self.killed_reason,
-            "global_reason": self.killed_reason,
-            "global_step": self.global_step,
-            "micro_batches": self.micro_batch_idx,
-            "best_loss": self.best_loss,
-            "final_loss": final_loss,
-            "final_avg_loss": final_avg_loss,
-            "final_perplexity": final_ppl,
-            "elapsed_s": elapsed_total,
-            "params_total": params["total"],
-            "params_M": params["total_M"],
-            "monitor_summary": ks_summary,
-            "optimizer": cfg.optimizer_type,
-            "time_budget": self.time_budget.summary(),
-            "step_timer": self.step_timer.summary(),
-        }
-
-        # V3: Log final do Hypothesis Monitor (detecção de bugs)
-        self.hyp_monitor.log_summary()
-        hyp_report = self.hyp_monitor.summary()
-        result["hypothesis_monitor"] = {
-            "total_steps": hyp_report.total_steps,
-            "punishment_steps": hyp_report.punishment_steps,
-            "hyp_activated_steps": hyp_report.hyp_activated_steps,
-            "hyp_activated_during_punishment": hyp_report.hyp_activated_during_punishment,
-            "delta_zero_when_activated": hyp_report.delta_zero_when_activated,
-            "l1_entropy_saturated_steps": hyp_report.l1_entropy_saturated_steps,
-            "l2_zero_grad_hyp_steps": hyp_report.l2_zero_grad_hyp_steps,
-            "crw_converged_steps": hyp_report.crw_converged_steps,
-            "crw_contraction_invalid_steps": hyp_report.crw_contraction_invalid_steps,
-            "last_T": hyp_report.last_T,
-            "last_tau": hyp_report.last_tau,
-            "has_bug": hyp_report.has_bug,
-            "bugs": hyp_report.bug_summary,
-        }
-        result["dpo_activated"] = self._dpo_compatible
-
-        logger.info("=" * 70)
-        logger.info("TREINO CONCLUÍDO")
-        logger.info(f"  epochs completed: {result['epochs_completed']}")
-        logger.info(f"  killed:           {result['killed']}")
-        if result["killed"]:
-            logger.info(f"  kill reason:      {result['kill_reason']}")
-        logger.info(f"  global step:      {result['global_step']}")
-        logger.info(f"  best loss:        {result['best_loss']:.4f}")
-        logger.info(f"  final avg loss:   {result['final_avg_loss']:.4f}")
-        logger.info(f"  final perplexity: {result['final_perplexity']:.2f}")
-        logger.info(f"  elapsed:          {result['elapsed_s']:.1f}s")
-        logger.info(f"  max RAM:          {ks_summary.get('max_ram_pct', 0):.1f}%")
-        logger.info(f"  min disk free:    {ks_summary.get('min_disk_free_gb', 0):.2f}GB")
-        logger.info(f"  DPO ativado:      {result['dpo_activated']}")
-        logger.info(f"  CircularReason:   {cfg.use_circular_reasoning}")
-        logger.info(f"  Hipótese monitor: {'⚠️ BUGS' if hyp_report.has_bug else '✓ OK'}")
-        logger.info("=" * 70)
-
-        # Salva modelo final
-        if not result["killed"]:
-            self._save_final_model(result)
-
-        # Cleanup checkpoints temporários
-        if not cfg.keep_temp:
-            self._cleanup_temp()
-
-        return result
-
-    def _compute_dpo_loss(
-        self,
-        batch_samples: list,
-        y_hat: torch.Tensor,
-        target: torch.Tensor,
-    ) -> Optional[torch.Tensor]:
-        """V3: Computa DPO loss para o batch.
-
-        Estratégia: para datasets compatíveis (com label_text = resposta correta),
-        sintetiza pares de preferência:
-          - chosen = resposta correta (label_text do próprio sample)
-          - rejected = resposta de OUTRO sample (mistura) — proxy para "resposta errada"
-
-        Como o modelo produz apenas 1 logit por amostra (não LM completo),
-        usamos uma aproximação DPO simplificada:
-          - policy_chosen_logps = log π(target | y_hat)  (log-softmax do target)
-          - policy_rejected_logps = log π(rejected_token | y_hat)  (de outro sample)
-          - reference = zeros (modelo congelado no início = policy inicial)
-
-        Isto NÃO é DPO canônico (que requer sequence logps), mas captura a
-        essência: punir o modelo por preferir "resposta errada" e recompensar
-        por preferir "resposta certa". Adequado para bug-detection.
-
-        Args:
-            batch_samples: lista de ProcessedSample
-            y_hat: (B, vocab) logits do modelo para o batch
-            target: (B,) token alvo (último token da sequência)
-
-        Returns:
-            loss_dpo (escalar com grad) ou None se não aplicável
-        """
-        if not batch_samples or not hasattr(batch_samples[0], "label_text"):
-            return None
-
-        B = y_hat.size(0)
-        if B < 1:
-            return None
-
-        # Policy log-probs (com grad)
-        log_probs = F.log_softmax(y_hat, dim=-1)  # (B, vocab)
-
-        # chosen = target do próprio sample
-        chosen_logps = log_probs.gather(
-            1, target.clamp(0, log_probs.size(-1) - 1).unsqueeze(-1)
-        ).squeeze(-1)  # (B,)
-
-        # rejected = target de OUTRO sample (roll-by-1) — proxy para "resposta errada"
-        rejected_target = target.roll(1, dims=0)  # shift circular
-        # Se B == 1, não há outro sample — usa token aleatório como rejected
-        if B == 1:
-            rejected_target = torch.randint(
-                0, log_probs.size(-1), (1,), dtype=target.dtype
-            )
-        rejected_logps = log_probs.gather(
-            1, rejected_target.clamp(0, log_probs.size(-1) - 1).unsqueeze(-1)
-        ).squeeze(-1)  # (B,)
-
-        # Reference log-probs (sem grad) — política inicial = uniforme
-        # log π_ref(token) = -log(vocab_size)
-        vocab_size = log_probs.size(-1)
-        ref_chosen_logps = torch.full_like(chosen_logps, -math.log(vocab_size))
-        ref_rejected_logps = torch.full_like(rejected_logps, -math.log(vocab_size))
-
-        # β dinâmico
-        beta_t = compute_dynamic_beta(
-            self.global_step,
-            warmup_steps=self.config.dpo_warmup_steps,
-            beta_min=self.config.dpo_beta_min,
-            beta_max=self.config.dpo_beta_max,
-        )
-
-        # DPO loss
-        from .dpo import dpo_loss
-        loss = dpo_loss(
-            policy_chosen_logps=chosen_logps,
-            policy_rejected_logps=rejected_logps,
-            reference_chosen_logps=ref_chosen_logps,
-            reference_rejected_logps=ref_rejected_logps,
-            beta=beta_t,
-            label_smoothing=self.config.dpo_label_smoothing,
-            use_ipo=self.config.dpo_use_ipo,
-        )
-        return loss
-
-    def _run_meta_update(self):
-        """Executa um passo do MetaConfigurator (Lema 4)."""
-        # Pega um batch de validação
-        val_batch = []
-        for i in range(self.config.per_device_batch_size):
-            s = self.val_samples[i % len(self.val_samples)]
-            val_batch.append(s)
-        try:
-            input_ids, attn_mask, labels = self._collate(val_batch)
-            # Target = último token (mesma lógica de _forward_loss)
-            target = input_ids[:, -1].clone()  # (batch,)
-            meta_result = self.meta_cfg.forward_with_meta(input_ids, target)
-            # V3: registra no monitor para detectar estagnação do L4
-            self.hyp_monitor.record_meta(
-                T_new=meta_result["T_new"],
-                tau_new=meta_result["tau_new"],
-                sharpness=meta_result["sharpness"],
-            )
-            logger.info(
-                f"  META step {self.global_step}: "
-                f"val_loss={meta_result['loss_val']:.4f} "
-                f"sharpness={meta_result['sharpness']:.4f} "
-                f"T={meta_result['T_new']:.4f} τ={meta_result['tau_new']:.4f} "
-                f"ΔT={meta_result['grad_log_T']:.6f} "
-                f"Δτ={meta_result['grad_log_tau']:.6f}"
-            )
-        except Exception as e:
-            logger.warning(f"Meta update failed: {e}")
-
-    def _save_temp_checkpoint(self, epoch: int):
-        """Salva checkpoint temporário (será apagado ao final)."""
-        path = Path(self.config.temp_dir) / f"temp_step{self.global_step}_epoch{epoch+1}.pt"
-        torch.save({
-            "model_state_dict": self.model.state_dict(),
-            "optimizer_state_dict": self.optimizer.state_dict(),
-            "global_step": self.global_step,
-            "epoch": epoch,
-            "best_loss": self.best_loss,
-            "meta_log_T": self.meta_cfg.log_temperature.detach().cpu(),
-            "meta_log_tau": self.meta_cfg.log_tau.detach().cpu(),
-        }, path)
-
-    def _save_final_model(self, result: dict):
-        """Salva modelo final + config + tokenizer."""
-        model_dir = Path(self.config.output_dir)
-        model_dir.mkdir(parents=True, exist_ok=True)
-
-        # State dict
-        state_path = model_dir / "pytorch_model.bin"
-        torch.save(self.model.state_dict(), state_path)
-        logger.info(f"Modelo final salvo: {state_path}")
-
-        # Config
-        cfg = self.model.config
-        config_dict = {
-            "model_type": "bigru_t_version",
-            "arch": "BiGRU_T_version (4 lemas)",
-            "vocab_size": cfg.vocab_size,
-            "d_model": cfg.d_model,
-            "max_seq_len": cfg.max_seq_len,
-            "pad_token_id": cfg.pad_token_id,
-            "input_dim": cfg.input_dim,
-            "bigru_hidden": cfg.bigru_hidden,
-            "d_transformer": cfg.d_transformer,
-            "nhead_tu": cfg.nhead_tu,
-            "d_ff_tu": cfg.d_ff_tu,
-            "output_dim_u8cell": cfg.output_dim_u8cell,
-            "max_modules": cfg.max_modules,
-            "lambda_ent": cfg.lambda_ent,
-            "cache_len": cfg.cache_len,
-            "d_cache": cfg.d_cache,
-            "nhead_orq": cfg.nhead_orq,
-            "d_ff_orq": cfg.d_ff_orq,
-            "trainT_dim": cfg.trainT_dim,
-            "nhead_train": cfg.nhead_train,
-            "d_ff_train": cfg.d_ff_train,
-            "num_layers_train": cfg.num_layers_train,
-            "hypT_dim": cfg.hypT_dim,
-            "nhead_hyp": cfg.nhead_hyp,
-            "d_ff_hyp": cfg.d_ff_hyp,
-            "num_layers_hyp": cfg.num_layers_hyp,
-            "num_bits": cfg.num_bits,
-            "dropout": cfg.dropout,
-            "total_params": result["params_total"],
-            "total_params_M": result["params_M"],
-            "training": {
-                "version": "BiGRU_T_version",
-                "epochs": result["epochs_completed"],
-                "global_step": result["global_step"],
-                "best_loss": result["best_loss"],
-                "final_loss": result["final_loss"],
-                "final_avg_loss": result["final_avg_loss"],
-                "final_perplexity": result["final_perplexity"],
-                "killed": result["killed"],
-                "kill_reason": result["kill_reason"],
-                "elapsed_s": result["elapsed_s"],
-                "datasets": self.config.datasets.split(","),
-                "max_samples_per_dataset": self.config.max_samples_per_dataset,
-            },
-        }
-        with open(model_dir / "config.json", "w") as f:
-            json.dump(config_dict, f, indent=2, ensure_ascii=False)
-
-        # Tokenizer (copia do source)
-        src_tok = Path("/home/z/my-project/source/model_final/tokenizer/tokenizer.json")
-        if src_tok.exists():
-            tok_dest = model_dir / "tokenizer"
-            tok_dest.mkdir(exist_ok=True)
-            shutil.copy(src_tok, tok_dest / "tokenizer.json")
-            logger.info(f"Tokenizer copiado para {tok_dest}")
-
-        # Training report
-        report = {
-            "version": "BiGRU_T_version",
-            "training_params": {
-                "epochs": self.config.epochs,
-                "per_device_batch_size": self.config.per_device_batch_size,
-                "grad_accum": self.config.grad_accum,
-                "lr": self.config.lr,
-                "weight_decay": self.config.weight_decay,
-                "max_grad_norm": self.config.max_grad_norm,
-                "max_seq_len": self.config.max_seq_len,
-                "use_hypothesis": self.config.use_hypothesis,
-                "stop_grad_hyp": self.config.stop_grad_hyp,
-                "meta_interval": self.config.meta_interval,
-                "meta_lr": self.config.meta_lr,
-                "sharpness_lambda": self.config.sharpness_lambda,
-            },
-            "results": result,
-        }
-        report_path = Path(self.config.output_dir).parent / "training_report.json"
-        with open(report_path, "w") as f:
-            json.dump(report, f, indent=2, ensure_ascii=False, default=str)
-        logger.info(f"Relatório salvo: {report_path}")
-
-    def _cleanup_temp(self):
-        """Apaga checkpoints temporários (especificação do usuário)."""
-        temp_dir = Path(self.config.temp_dir)
-        if not temp_dir.exists():
-            return
-        for f in temp_dir.glob("temp_step*.pt"):
-            try:
-                f.unlink()
-                logger.info(f"Temp checkpoint apagado: {f.name}")
-            except Exception as e:
-                logger.warning(f"Falha ao apagar {f}: {e}")
-        # Apaga o diretório se vazio
-        try:
-            temp_dir.rmdir()
-        except Exception:
-            pass

streaming_datasets.py

@@ -1,995 +0,0 @@
-"""streaming_datasets_v13_9.py — Streaming dataset loader for v13.9.1 training.
-
-Carrega os 9 datasets especificados pelo usuário via streaming (IterableDataset),
-um por vez, exaustivamente dentro do limite max_samples_per_dataset.
-
-Datasets:
-  1. CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1
-  2. Madras1/corpus-ptbr-v2
-  3. rhaymison/multmodal_175k_portuguese
-  4. TucanoBR/GigaVerbo
-  5. nvidia/OpenMathReasoning
-  6. MathLLMs/MathVision
-  7. nvidia/OpenMathInstruct-2
-  8. dominguesm/restore-punctuation-ptbr-dataset
-  9. carolina-c4ai/corpus-carolina
-
-Memory-efficient: streaming=True, no full materialization.
-Returns ProcessedSample with raw_text only (tokenizer handles encoding).
-"""
-from __future__ import annotations
-
-import logging
-import os
-import time
-import traceback
-from dataclasses import dataclass, field
-from typing import Any, Dict, Iterator, List, Optional, Tuple
-
-import torch
-
-logger = logging.getLogger(__name__)
-
-# Datasets V13.9.1 — exatamente os 9 especificados pelo usuário
-# V6.5-final: adicionado dominguesm/Canarim-Instruct-PTBR-Dataset
-# V6.5-7ds: adicionados adalbertojunior/punctuation-ptbr,
-#           iara-project/news-articles-ptbr-dataset, manoela/noticias_ptbr
-# V6.5-V2: adicionado BrunoN-Dev/corpus-ptbr-v1 como 8º dataset de CONHECIMENTO
-#          e usado como dataset de TREINAMENTO COM PUNIÇÃO
-DEFAULT_DATASETS = [
-    "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1",
-    "Madras1/corpus-ptbr-v2",
-    "rhaymison/multmodal_175k_portuguese",
-    "TucanoBR/GigaVerbo",
-    "nvidia/OpenMathReasoning",
-    "MathLLMs/MathVision",
-    "nvidia/OpenMathInstruct-2",
-    "dominguesm/restore-punctuation-ptbr-dataset",
-    "carolina-c4ai/corpus-carolina",
-    "dominguesm/Canarim-Instruct-PTBR-Dataset",
-    "adalbertojunior/punctuation-ptbr",
-    "iara-project/news-articles-ptbr-dataset",
-    "manoela/noticias_ptbr",
-    "BrunoN-Dev/corpus-ptbr-v1",
-]
-
-# V6.5-V2 — Sequência de 8 datasets para a fase CONHECIMENTO (na ordem exata
-# especificada pelo usuário). Meta mínima: 8000 samples ou mais.
-CONHECIMENTO_DATASETS_V2 = [
-    "dominguesm/restore-punctuation-ptbr-dataset",
-    "carolina-c4ai/corpus-carolina",
-    "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1",
-    "dominguesm/Canarim-Instruct-PTBR-Dataset",
-    "adalbertojunior/punctuation-ptbr",
-    "iara-project/news-articles-ptbr-dataset",
-    "manoela/noticias_ptbr",
-    "BrunoN-Dev/corpus-ptbr-v1",
-]
-
-# V6.5-V2 — Dataset para TREINAMENTO COM PUNIÇÃO (500 samples).
-# O usuário especificou: "dataset para TREINAMENTO COM PUNIÇÃO ATIVA
-# 'BrunoN-Dev/corpus-ptbr-v1'".
-PUNICAO_DATASET_V2 = "BrunoN-Dev/corpus-ptbr-v1"
-
-# Dataset format descriptors — Lista priorizada de campos de texto
-DATASET_FORMATS: Dict[str, Dict[str, Any]] = {
-    "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1": {
-        "type": "chat",
-        "text_fields": ["conversa", "text", "content", "conversation", "messages"],
-        "label_fields": [],
-        "split": "train",
-        "config": None,
-    },
-    "Madras1/corpus-ptbr-v2": {
-        "type": "text",
-        "text_fields": ["text", "content", "document", "body"],
-        "label_fields": [],
-        "split": "train",
-        "config": None,
-    },
-    "rhaymison/multmodal_175k_portuguese": {
-        "type": "multimodal",
-        "text_fields": ["description", "text", "question", "prompt", "instruction", "input"],
-        "image_fields": ["image", "image_url"],
-        "label_fields": ["answer", "response", "output"],
-        "split": "train",
-        "config": None,
-    },
-    "TucanoBR/GigaVerbo": {
-        "type": "text",
-        "text_fields": ["text", "content", "document", "body"],
-        "label_fields": [],
-        "split": "train",
-        "config": None,
-    },
-    "nvidia/OpenMathReasoning": {
-        "type": "math",
-        "text_fields": ["problem", "question", "input", "prompt"],
-        "label_fields": ["solution", "answer", "output", "response"],
-        # BUG FIX: OpenMathReasoning has splits ['cot', 'tir', 'genselect', 'additional_problems']
-        "split": "cot",  # Use 'cot' (chain-of-thought) as primary split
-        "config": None,
-    },
-    "MathLLMs/MathVision": {
-        "type": "math_multimodal",
-        "text_fields": ["question", "problem", "text", "query"],
-        "image_fields": ["image", "image_url"],
-        "label_fields": ["answer", "solution", "response"],
-        # BUG FIX: MathVision has only 'test' and 'testmini' splits (no train)
-        "split": "test",
-        "config": None,
-    },
-    "nvidia/OpenMathInstruct-2": {
-        "type": "math",
-        "text_fields": ["problem", "question", "input", "prompt"],
-        # V3 FIX: campos reais do dataset são generated_solution e expected_answer
-        "label_fields": ["generated_solution", "expected_answer", "solution", "answer", "output", "response"],
-        "split": "train",
-        "config": None,
-    },
-    "dominguesm/restore-punctuation-ptbr-dataset": {
-        "type": "punctuation",
-        "text_fields": ["text", "original", "unpunctuated", "input"],
-        "label_fields": ["punctuated", "restored", "target", "output"],
-        "split": "train",
-        "config": None,
-    },
-    "carolina-c4ai/corpus-carolina": {
-        "type": "text",
-        "text_fields": ["text", "content", "document", "body", "xml"],
-        "label_fields": [],
-        "split": "train",
-        "config": None,
-        # V13.9.2-carolina: dataset original usa script Python (não suportado em
-        # datasets 5.0+). Workaround: stream_xml_gz direto via lxml.iterparse,
-        # sem usar o script Python. Implementado em _stream_carolina_direct().
-    },
-    # ── V13.9.2-finetune-v2: novos datasets PT-BR ───────────────────────────
-    # Adicionados para fine-tuning contínuo do modelo v13.9.2 (preserva
-    # arquitetura e parâmetros). Nenhuma mudança estrutural — apenas novos
-    # descritores de formato para que stream_dataset() reconheça os datasets.
-    #
-    # V13.9.2-finetune-v3: padronização para o formato unificado
-    # "### Instruction:\n...\n\n### Response:\n..." conforme requisitado pelo
-    # usuário. Apenas os datasets com estrutura instruction/response (orion,
-    # cnmoro) usam o template; strak2005/bratao continuam como texto puro
-    # (corpus sem estrutura de instrução). Nenhuma mudança nos 9 datasets
-    # base — retrocompatibilidade total.
-    "orion-research/translations-en_US-pt_BR": {
-        "type": "translation",
-        # string = EN (instruction), string_translation = PT-BR (response).
-        # V13.9.2-finetune-v3: separa instruction/response para o template
-        # unificado em vez de concatenar como texto único.
-        "text_fields": ["string"],
-        "label_fields": ["string_translation"],
-        "split": "train",
-        "config": None,
-        "format_template": "instruction_response",
-        "instruction_prefix": "Translate the following text to Portuguese:",
-    },
-    "cnmoro/Instruct-PTBR-10M": {
-        "type": "instruct",
-        # NB: campos em MAIÚSCULAS no schema do dataset
-        # V13.9.2-finetune-v3: INSTRUCTION -> instruction, RESPONSE -> response
-        # via template unificado.
-        "text_fields": ["INSTRUCTION"],
-        "label_fields": ["RESPONSE"],
-        "split": "train",
-        "config": None,
-        "format_template": "instruction_response",
-        # V13.9.2-finetune-v2: dataset é um único parquet de 10 GB — streaming
-        # via datasets.load_dataset() é extremamente lento para materializar
-        # a primeira amostra. Fallback via HF datasets-server rows API (HTTP),
-        # que retorna batches de 100 rows rapidamente. Implementado em
-        # _stream_via_rows_api().
-        "loader": "rows_api",
-    },
-    "strak2005/corpus-ptbr-v1": {
-        "type": "text",
-        "text_fields": ["text", "content"],
-        "label_fields": [],
-        "split": "train",
-        "config": None,
-        # Fallback: se strak2005 cair, tenta bratao (mirror idêntico)
-        "fallback": "bratao/corpus-ptbr-v1",
-        # V13.9.2-finetune-v2: dataset tem 18 shards parquet de ~1GB cada.
-        # Streaming via datasets.load_dataset() não materializa primeira
-        # amostra em tempo aceitável. Fallback: baixa 1 shard localmente e
-        # itera com pyarrow. Implementado em _stream_via_parquet_first_shard().
-        "loader": "parquet_first_shard",
-    },
-    "bratao/corpus-ptbr-v1": {
-        "type": "text",
-        "text_fields": ["text", "content"],
-        "label_fields": [],
-        "split": "train",
-        "config": None,
-        "loader": "parquet_first_shard",
-    },
-    # ── V6.5: novos datasets para esgotar ────────────────────────────────
-    # User requirement: "esgotar 'dominguesm/restore-punctuation-ptbr-dataset'
-    # e 'carolina-c4ai/corpus-carolina' e 'nvidia/OpenMathInstruct-2' e
-    # 'nvidia/OpenMathReasoning' e 'CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1'
-    # e 'Dexavator/English-PTBR'"
-    #
-    # Dexavator/English-PTBR: dataset de tradução EN->PT-BR.
-    # Estrutura típica: {"english": "...", "portuguese": "..."} ou
-    # {"en": "...", "pt": "..."}.
-    "Dexavator/English-PTBR": {
-        "type": "translation",
-        "text_fields": ["english", "en", "text", "source"],
-        "label_fields": ["portuguese", "pt", "target", "translation"],
-        "split": "train",
-        "config": None,
-        "format_template": "instruction_response",
-        "instruction_prefix": "Translate the following text to Portuguese:",
-    },
-    # ── V6.5-final: Canarim-Instruct-PTBR-Dataset ────────────────────────
-    # User requirement: "esgotar 'dominguesm/Canarim-Instruct-PTBR-Dataset'"
-    # Canarim-Instruct: dataset PT-BR de instruções (~430k samples).
-    # Estrutura típica: {"instruction": "...", "input": "...", "output": "..."}
-    # ou {"text": "...", "conversation": [{"role": "user", "content": "..."}, ...]}
-    "dominguesm/Canarim-Instruct-PTBR-Dataset": {
-        "type": "instruct",
-        "text_fields": ["instruction", "input", "text", "prompt", "question"],
-        "label_fields": ["output", "response", "answer"],
-        "split": "train",
-        "config": None,
-        "format_template": "instruction_response",
-        "instruction_prefix": "Instrução:",
-    },
-    # ── V6.5-7ds: novos 3 datasets PT-BR ─────────────────────────────────
-    # User requirement (latest): "streaming até esgotar nesta sequência
-    # 'dominguesm/restore-punctuation-ptbr-dataset' e
-    # 'carolina-c4ai/corpus-carolina' e
-    # 'CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1' e
-    # 'dominguesm/Canarim-Instruct-PTBR-Dataset' e
-    # 'adalbertojunior/punctuation-ptbr' e
-    # 'iara-project/news-articles-ptbr-dataset' e
-    # 'manoela/noticias_ptbr'"
-    #
-    # adalbertojunior/punctuation-ptbr:
-    #   Dataset de restauração de pontuação PT-BR. Schema:
-    #     {id: str, tokens: list[str], pos_tags, chunk_tags, ner_tags}
-    #   O campo "tokens" é uma lista de palavras (sem pontuação). Precisamos
-    #   fazer join com espaços para obter texto bruto. Como o dataset usa
-    #   script Python (datasets 5.0+ não suporta), usamos rows_api loader.
-    #   Splits: train/validation/test com config "punctuation-ptbr".
-    "adalbertojunior/punctuation-ptbr": {
-        "type": "punctuation_tokens",
-        "text_fields": ["tokens"],  # list[str] — join com espaços
-        "label_fields": [],
-        "split": "train",
-        "config": "punctuation-ptbr",  # necessário para rows_api
-        "loader": "rows_api",
-        "join_tokens": True,  # flag especial para _normalize_sample
-    },
-    # iara-project/news-articles-ptbr-dataset:
-    #   Dataset de notícias PT-BR da Folha de S.Paulo (via IARA project).
-    #   Schema: {title, text, date, category, category_natural_language, link}
-    #   Streaming normal via parquet — primeira amostra materializa rápido.
-    #   "text" é o corpo da notícia, "title" é o título. Concatenamos ambos
-    #   via format_template="title_text_concat" para enriquecer contexto.
-    #   O campo "category" é usado como label (categoria da notícia).
-    "iara-project/news-articles-ptbr-dataset": {
-        "type": "news",
-        # text_fields em ordem de prioridade: "text" (corpo) primeiro
-        "text_fields": ["text", "title", "content", "body"],
-        "label_fields": ["category", "category_natural_language", "title"],
-        "split": "train",
-        "config": None,
-        # V6.5-7ds: title_text_concat usa title como label (prefixo)
-        # e text como corpo. Aqui label_fields pega "category" primeiro
-        # para dar contexto temático.
-        "format_template": "title_text_concat",
-    },
-    # manoela/noticias_ptbr:
-    #   Mirror do iara-project/news-articles-ptbr-dataset (mesmo parquet,
-    #   mesmo schema). Streaming normal via parquet.
-    "manoela/noticias_ptbr": {
-        "type": "news",
-        "text_fields": ["text", "title", "content", "body"],
-        "label_fields": ["category", "category_natural_language", "title"],
-        "split": "train",
-        "config": None,
-        "format_template": "title_text_concat",
-    },
-    # ── V6.5-V2: BrunoN-Dev/corpus-ptbr-v1 ───────────────────────────────
-    # User requirement: "dataset para TREINAMENTO COM PUNIÇÃO ATIVA
-    # 'BrunoN-Dev/corpus-ptbr-v1'" e o 8º dataset de CONHECIMENTO.
-    #
-    # BrunoN-Dev/corpus-ptbr-v1: corpus PT-BR genérico com 18 shards parquet
-    # (~1GB cada). Schema: {"text": "...", "meta": "..."}.
-    # Streaming via datasets.load_dataset(streaming=True) é lento para
-    # materializar a primeira amostra — usamos o loader parquet_first_shard
-    # (baixa apenas o primeiro shard e itera localmente com pyarrow).
-    # Sem label explícita — usamos hash do texto (paridade do nº de palavras)
-    # para gerar label binário (0/1) — não é dado sintético, é derivação
-    # algorítmica do conteúdo real do dataset.
-    "BrunoN-Dev/corpus-ptbr-v1": {
-        "type": "text",
-        "text_fields": ["text", "content", "body", "document"],
-        "label_fields": [],
-        "split": "train",
-        "config": None,
-        "loader": "parquet_first_shard",
-        # V6.5-V2: gera label binário determinístico via hash do texto
-        # (paridade do número de palavras) — não é dado sintético, é
-        # derivação algorítmica do conteúdo real do dataset.
-        "label_strategy": "hash_parity",
-    },
-}
-
-
-# Lista de arquivos XML.gz do Carolina que tentaremos baixar (ordem: menores
-# taxonomias primeiro para minimizar banda e RAM). Selecionamos 2 arquivos
-# por taxonomia para garantir diversidade sem explodir a memória.
-CAROLINA_XML_FILES = [
-    # taxonomia "datasets_and_other_corpora" (DAT = pt-BR notícias)
-    "corpus/datasets_and_other_corpora/pt-BR/DATa.xml.gz",
-    "corpus/datasets_and_other_corpora/pt-BR/DATb.xml.gz",
-    # taxonomia "wik" (wikis)
-    "corpus/wik/WIKa.xml.gz",
-    "corpus/wik/WIKb.xml.gz",
-    # taxonomia "uni" (university_domains)
-    "corpus/uni/UNIa.xml.gz",
-    "corpus/uni/UNIb.xml.gz",
-    # taxonomia "pub" (public_domain_works)
-    "corpus/pub/PUBa.xml.gz",
-    "corpus/pub/PUBb.xml.gz",
-]
-
-
-def _stream_carolina_direct(
-    max_samples: int,
-    hf_token: Optional[str] = None,
-    timeout_per_file: int = 60,
-) -> Iterator[Dict[str, Any]]:
-    """Workaround V13.9.2-carolina: carrega Carolina sem usar o script Python.
-
-    Baixa arquivos XML.gz diretamente do repo e faz parse streaming com
-    lxml.etree.iterparse (compatível com datasets 5.0+). Cada <TEI> vira um
-    documento de texto (concatenação dos <p> dentro de <body>).
-
-    Args:
-        max_samples: número máximo de amostras a retornar
-        hf_token: token HF opcional (dataset é público, mas token evita rate limit)
-        timeout_per_file: tempo máximo (segundos) por arquivo XML
-
-    Yields:
-        dict com chave "text" (compatível com _normalize_sample)
-    """
-    from huggingface_hub import hf_hub_download
-    import gzip
-    from lxml import etree
-
-    TEI_NS = "{http://www.tei-c.org/ns/1.0}"
-    BODY_P_TAG = f".//{TEI_NS}body/{TEI_NS}p"
-
-    count = 0
-    for xml_path in CAROLINA_XML_FILES:
-        if count >= max_samples:
-            return
-        try:
-            local_path = hf_hub_download(
-                repo_id="carolina-c4ai/corpus-carolina",
-                filename=xml_path,
-                repo_type="dataset",
-                token=hf_token,
-            )
-        except Exception as e:
-            logger.warning(f"Carolina: não foi possível baixar {xml_path}: {e}")
-            continue
-
-        try:
-            with gzip.open(local_path, "rb") as gz:
-                # iterparse streaming: não carrega árvore inteira na memória
-                for _, tei in etree.iterparse(
-                    gz, huge_tree=True, encoding="utf-8", tag=f"{TEI_NS}TEI"
-                ):
-                    if count >= max_samples:
-                        tei.clear()
-                        return
-                    # Extrai texto dos <p> dentro de <body>
-                    parts = []
-                    for p in tei.findall(BODY_P_TAG):
-                        if p.text:
-                            parts.append(p.text)
-                    text = " ".join(parts).strip()
-                    if text and len(text) >= 10:
-                        yield {"text": text, "meta": ""}
-                    tei.clear()  # libera memória da árvore TEI
-                    count += 1
-        except Exception as e:
-            logger.warning(f"Carolina: erro processando {xml_path}: {e}")
-            continue
-
-    logger.info(f"Carolina: streamou {count} amostras no total")
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# V13.9.2-finetune-v2: Loaders alternativos para datasets parquet grandes
-# onde datasets.load_dataset(streaming=True) é inviável (primeira amostra
-# demora minutos para materializar).
-# ═══════════════════════════════════════════════════════════════════════════
-
-def _stream_via_rows_api(
-    dataset_name: str,
-    max_samples: int,
-    hf_token: Optional[str] = None,
-    batch_size: int = 100,
-    max_offset: int = 100_000,
-    config: Optional[str] = None,
-    split: str = "train",
-) -> Iterator[Dict[str, Any]]:
-    """Carrega amostras via HF datasets-server /rows API (HTTP).
-
-    Usado para datasets cujo parquet é muito grande para streaming eficiente
-    (ex: cnmoro/Instruct-PTBR-10M com 10 GB em arquivo único) OU datasets
-    que usam script Python como loader (não suportado em datasets 5.0+,
-    ex: adalbertojunior/punctuation-ptbr). A rows API retorna batches de
-    até 100 rows via HTTP, sem precisar baixar o parquet.
-
-    Args:
-        dataset_name: repo_id do dataset (ex: "cnmoro/Instruct-PTBR-10M")
-        max_samples: nº máximo de amostras a retornar
-        hf_token: token HF (opcional — dataset público)
-        batch_size: nº de rows por requisição (máx 100)
-        max_offset: offset máximo a tentar (sai do loop se excedido)
-        config: nome da config do dataset (default: "default"). NECESSÁRIO
-                para datasets cuja config não é "default" (ex:
-                adalbertojunior/punctuation-ptbr usa "punctuation-ptbr").
-        split: nome do split (default: "train").
-
-    Yields:
-        dict com campos do dataset (compatível com _normalize_sample)
-    """
-    import json as _json
-    import urllib.request
-    import urllib.parse
-
-    base_url = "https://datasets-server.huggingface.co/rows"
-    config_name = config or "default"
-    count = 0
-    offset = 0
-
-    while count < max_samples and offset < max_offset:
-        params = urllib.parse.urlencode({
-            "dataset": dataset_name,
-            "config": config_name,
-            "split": split,
-            "offset": offset,
-            "length": min(batch_size, max_samples - count),
-        })
-        url = f"{base_url}?{params}"
-        try:
-            req = urllib.request.Request(url)
-            if hf_token:
-                req.add_header("Authorization", f"Bearer {hf_token}")
-            with urllib.request.urlopen(req, timeout=30) as r:
-                data = _json.loads(r.read())
-        except Exception as e:
-            logger.warning(f"rows_api {dataset_name} config={config_name} offset={offset}: {e}")
-            break
-
-        rows = data.get("rows", [])
-        if not rows:
-            break
-
-        for row in rows:
-            if count >= max_samples:
-                return
-            row_data = row.get("row", {})
-            # Remove campos internos como __index_level_0__
-            clean = {k: v for k, v in row_data.items()
-                     if not k.startswith("__")}
-            yield clean
-            count += 1
-
-        offset += len(rows)
-        if len(rows) < batch_size:
-            break  # chegou ao fim do dataset
-
-    logger.info(f"rows_api {dataset_name} config={config_name}: streamou {count} amostras")
-
-
-def _stream_via_parquet_first_shard(
-    dataset_name: str,
-    max_samples: int,
-    hf_token: Optional[str] = None,
-) -> Iterator[Dict[str, Any]]:
-    """Baixa primeiro shard parquet do dataset e itera localmente com pyarrow.
-
-    Usado para datasets com múltiplos shards parquet grandes (ex:
-    strak2005/corpus-ptbr-v1 com 18 shards de ~1GB). Streaming via
-    datasets.load_dataset() não materializa primeira amostra em tempo
-    aceitável. Esta função baixa o primeiro shard (~26s para 1GB) e itera
-    localmente — rápido após download.
-
-    Args:
-        dataset_name: repo_id do dataset
-        max_samples: nº máximo de amostras
-        hf_token: token HF opcional
-
-    Yields:
-        dict com campos do dataset
-    """
-    from huggingface_hub import HfApi, hf_hub_download
-    import pyarrow.parquet as pq
-
-    api = HfApi(token=hf_token)
-
-    # Lista arquivos parquet no repo
-    try:
-        info = api.dataset_info(dataset_name)
-    except Exception as e:
-        logger.warning(f"parquet_shard {dataset_name}: dataset_info failed: {e}")
-        return
-
-    parquet_files = sorted([
-        s.rfilename for s in info.siblings
-        if s.rfilename.endswith(".parquet")
-    ])
-    if not parquet_files:
-        logger.warning(f"parquet_shard {dataset_name}: nenhum .parquet encontrado")
-        return
-
-    # Baixa apenas o primeiro shard
-    first_shard = parquet_files[0]
-    logger.info(f"parquet_shard {dataset_name}: baixando {first_shard}...")
-    try:
-        local_path = hf_hub_download(
-            repo_id=dataset_name,
-            filename=first_shard,
-            repo_type="dataset",
-            token=hf_token,
-        )
-    except Exception as e:
-        logger.warning(f"parquet_shard {dataset_name}: download failed: {e}")
-        return
-
-    # Itera com pyarrow.iter_batches — método eficiente que lê batches pequenos
-    # do parquet sem materializar o row group inteiro na memória.
-    # BUG FIX V13.9.2-finetune-v2: read_row_group() materializa TODAS as ~1M
-    # rows de uma vez (lento + ~1GB RAM). iter_batches(batch_size=10) lê só
-    # 10 rows por vez (rápido + ~10KB RAM).
-    try:
-        pf = pq.ParquetFile(local_path)
-        count = 0
-        # batch_read_size: nº de rows por batch (pequeno = menos RAM)
-        for batch in pf.iter_batches(batch_size=100):
-            if count >= max_samples:
-                break
-            cols = batch.schema.names
-            # to_pylist() é eficiente para batches pequenos
-            pydict = batch.to_pydict()
-            n_rows = len(pydict[cols[0]]) if cols else 0
-            for i in range(n_rows):
-                if count >= max_samples:
-                    break
-                row = {col: pydict[col][i] for col in cols}
-                yield row
-                count += 1
-    except Exception as e:
-        logger.warning(f"parquet_shard {dataset_name}: pyarrow iter failed: {e}")
-        return
-
-    logger.info(f"parquet_shard {dataset_name}: streamou {count} amostras do shard {first_shard}")
-
-
-@dataclass
-class ProcessedSample:
-    """Uma amostra processada: texto bruto + metadados."""
-    raw_text: str
-    dataset_name: str
-    sample_idx: int
-    text_field: str = ""
-    label_text: str = ""
-
-
-def _extract_field(sample: Dict[str, Any], candidate_fields: List[str]) -> Optional[str]:
-    """Extrai texto da primeira field disponível no sample.
-
-    Suporta:
-    - strings diretas
-    - listas de strings (join com espaço — útil para datasets tokenizados
-      como adalbertojunior/punctuation-ptbr onde "tokens": ["hoje","a",...])
-    - listas de dicts (chat messages — concatena role: content)
-    - dicts aninhados (pega text/content/body)
-    """
-    for field_name in candidate_fields:
-        if field_name in sample:
-            val = sample[field_name]
-            if val is None:
-                continue
-            if isinstance(val, str):
-                if val.strip():
-                    return val
-            elif isinstance(val, list):
-                # V6.5-7ds: se for lista de strings, join com espaços
-                # (ex: adalbertojunior/punctuation-ptbr tokens field)
-                string_parts = []
-                chat_parts = []
-                all_strings = True
-                for item in val:
-                    if isinstance(item, str):
-                        if item.strip():
-                            string_parts.append(item)
-                    elif isinstance(item, (int, float)):
-                        # tokens podem vir como ints (token IDs) — skip
-                        all_strings = False
-                        break
-                    elif isinstance(item, dict):
-                        all_strings = False
-                        role = item.get("role", "")
-                        content = item.get("content", "")
-                        if isinstance(content, str) and content.strip():
-                            chat_parts.append(f"{role}: {content}")
-                    else:
-                        all_strings = False
-                if all_strings and string_parts:
-                    joined = " ".join(string_parts).strip()
-                    if joined:
-                        return joined
-                if chat_parts:
-                    return "\n".join(chat_parts)
-            elif isinstance(val, dict):
-                # Pode ser nested
-                text = val.get("text") or val.get("content") or val.get("body")
-                if isinstance(text, str) and text.strip():
-                    return text
-    return None
-
-
-def _normalize_sample(sample: Dict[str, Any], dataset_name: str, idx: int) -> Optional[ProcessedSample]:
-    """Normaliza uma amostra bruta em ProcessedSample."""
-    fmt = DATASET_FORMATS.get(dataset_name, {})
-    text_fields = fmt.get("text_fields", ["text"])
-    label_fields = fmt.get("label_fields", [])
-
-    text = _extract_field(sample, text_fields)
-    if not text or len(text.strip()) < 10:  # skip very short
-        return None
-
-    label = ""
-    if label_fields:
-        label = _extract_field(sample, label_fields) or ""
-
-    # Se tem label, aplica template apropriado
-    template = fmt.get("format_template")
-    full_text = text
-
-    # V13.9.2-finetune-v3: para o template instruction_response, exige ambos
-    # os lados (instruction + response). Samples sem response são descartados
-    # para evitar treinar em texto parcial.
-    if template == "instruction_response" and not label:
-        return None
-
-    if label:
-        # V13.9.2-finetune-v3: format_template unificado "### Instruction:/### Response:"
-        # quando o dataset declarar explicitamente. Caso contrário, mantém o
-        # comportamento legado (concatenação simples text\nlabel) para os 9
-        # datasets base — retrocompatibilidade total.
-        if template == "instruction_response":
-            instr_prefix = fmt.get("instruction_prefix", "")
-            if instr_prefix:
-                full_text = (
-                    f"### Instruction:\n{instr_prefix}\n{text}\n\n"
-                    f"### Response:\n{label}"
-                )
-            else:
-                full_text = (
-                    f"### Instruction:\n{text}\n\n"
-                    f"### Response:\n{label}"
-                )
-        elif template == "title_text_concat":
-            # V6.5-7ds: para datasets de notícias (iara-project, manoela),
-            # o campo "text" (corpo da notícia) é o conteúdo principal e
-            # "category" (categoria) é o contexto temático. Formatamos como
-            # "TEXTO: <corpo>\nCATEGORIA: <categoria>".
-            full_text = f"TEXTO: {text}\nCATEGORIA: {label}"
-        else:
-            # Comportamento legado (9 datasets base): concatenação simples
-            full_text = f"{text}\n{label}"
-
-    return ProcessedSample(
-        raw_text=full_text,
-        dataset_name=dataset_name,
-        sample_idx=idx,
-        text_field=text_fields[0] if text_fields else "",
-        label_text=label,
-    )
-
-
-def _load_dataset_streaming(
-    dataset_name: str,
-    split: str = "train",
-    config: Optional[str] = None,
-    hf_token: Optional[str] = None,
-):
-    """Carrega dataset em modo streaming.
-
-    BUG FIX V13.9.1: Removido trust_remote_code (deprecated).
-    Se o dataset não carregar com split especificado, tenta 'train' como fallback.
-    BUG FIX V13.9.2: Adicionado fallback para datasets com script (carolina-c4ai).
-    """
-    from datasets import load_dataset
-
-    # Lista de splits para tentar, em ordem
-    splits_to_try = [split]
-    if split != "train":
-        splits_to_try.append("train")
-    # Adiciona outros splits comuns
-    for s in ["test", "validation", "cot", "tir"]:
-        if s not in splits_to_try:
-            splits_to_try.append(s)
-
-    fmt = DATASET_FORMATS.get(dataset_name, {})
-    fallback_name = fmt.get("fallback")
-    datasets_to_try = [dataset_name]
-    if fallback_name:
-        datasets_to_try.append(fallback_name)
-
-    for try_ds_name in datasets_to_try:
-        for try_split in splits_to_try:
-            try:
-                if config:
-                    ds = load_dataset(
-                        try_ds_name, config, split=try_split, streaming=True,
-                        token=hf_token,
-                    )
-                else:
-                    ds = load_dataset(
-                        try_ds_name, split=try_split, streaming=True,
-                        token=hf_token,
-                    )
-                logger.info(f"Loaded {try_ds_name} split={try_split}")
-                return ds
-            except Exception as e:
-                err_str = str(e).lower()
-                # If "Bad split" error, try next split
-                if "bad split" in err_str or "available splits" in err_str:
-                    logger.info(f"  Split {try_split} not available for {try_ds_name}, trying next")
-                    continue
-                # If "scripts no longer supported", try next dataset (fallback)
-                if "scripts are no longer supported" in err_str and fallback_name:
-                    logger.info(f"  {try_ds_name} uses script — trying fallback {fallback_name}")
-                    break
-                # For other errors, log and try next split
-                logger.warning(f"Failed to load {try_ds_name} split={try_split}: {str(e)[:120]}")
-                continue
-
-    logger.warning(f"All split attempts failed for {dataset_name} (will be skipped)")
-    return None
-
-
-def stream_dataset(
-    dataset_name: str,
-    max_samples: int = 500,
-    hf_token: Optional[str] = None,
-) -> Iterator[ProcessedSample]:
-    """Faz streaming de um dataset, retornando até max_samples amostras.
-
-    Args:
-        dataset_name: nome do dataset no HuggingFace
-        max_samples: número máximo de amostras a retornar
-        hf_token: token HF opcional
-
-    Yields:
-        ProcessedSample
-    """
-    fmt = DATASET_FORMATS.get(dataset_name)
-    if fmt is None:
-        logger.error(f"Unknown dataset: {dataset_name}")
-        return
-
-    # ── V13.9.2-carolina: bypass do script Python ─────────────────────────
-    # O dataset carolina-c4ai/corpus-carolina usa um script Python como loader,
-    # que não é suportado por datasets 5.0+. Streamamos os XML.gz diretamente.
-    if dataset_name == "carolina-c4ai/corpus-carolina":
-        logger.info(f"Carolina: usando carregador direto (bypass do script Python)")
-        count = 0
-        try:
-            for raw_sample in _stream_carolina_direct(
-                max_samples=max_samples, hf_token=hf_token
-            ):
-                processed = _normalize_sample(raw_sample, dataset_name, count)
-                if processed is not None:
-                    yield processed
-                    count += 1
-        except Exception as e:
-            logger.warning(f"Carolina direct stream error at sample {count}: {e}")
-            return
-        logger.info(f"Streamed {count} samples from {dataset_name} (direct XML)")
-        return
-
-    # ── V13.9.2-finetune-v2: loaders alternativos para parquets grandes ───
-    # Alguns datasets (cnmoro, strak2005/bratao) têm parquets tão grandes que
-    # datasets.load_dataset(streaming=True) demora minutos para materializar
-    # a primeira amostra. Usamos loaders alternativos especificados no campo
-    # "loader" do formato.
-    loader = fmt.get("loader")
-    if loader == "rows_api":
-        logger.info(f"{dataset_name}: usando rows_api loader (datasets-server HTTP)")
-        count = 0
-        try:
-            for raw_sample in _stream_via_rows_api(
-                dataset_name, max_samples=max_samples, hf_token=hf_token,
-                config=fmt.get("config"),
-                split=fmt.get("split", "train"),
-            ):
-                processed = _normalize_sample(raw_sample, dataset_name, count)
-                if processed is not None:
-                    yield processed
-                    count += 1
-        except Exception as e:
-            logger.warning(f"rows_api stream error at sample {count}: {e}")
-            return
-        logger.info(f"Streamed {count} samples from {dataset_name} (rows_api)")
-        return
-
-    if loader == "parquet_first_shard":
-        logger.info(f"{dataset_name}: usando parquet_first_shard loader")
-        count = 0
-        try:
-            for raw_sample in _stream_via_parquet_first_shard(
-                dataset_name, max_samples=max_samples, hf_token=hf_token
-            ):
-                processed = _normalize_sample(raw_sample, dataset_name, count)
-                if processed is not None:
-                    yield processed
-                    count += 1
-        except Exception as e:
-            logger.warning(f"parquet_shard stream error at sample {count}: {e}")
-            # Tenta fallback (ex: strak2005 -> bratao)
-            fallback_name = fmt.get("fallback")
-            if fallback_name and fallback_name != dataset_name:
-                logger.info(f"Tentando fallback: {fallback_name}")
-                fallback_fmt = DATASET_FORMATS.get(fallback_name, {})
-                # Recursão respeitando o loader do fallback
-                yield from stream_dataset(
-                    fallback_name, max_samples=max_samples, hf_token=hf_token
-                )
-            return
-        logger.info(f"Streamed {count} samples from {dataset_name} (parquet_first_shard)")
-        return
-
-    ds = _load_dataset_streaming(
-        dataset_name,
-        split=fmt.get("split", "train"),
-        config=fmt.get("config"),
-        hf_token=hf_token,
-    )
-    if ds is None:
-        return
-
-    count = 0
-    try:
-        for idx, sample in enumerate(ds):
-            if count >= max_samples:
-                break
-            processed = _normalize_sample(sample, dataset_name, idx)
-            if processed is not None:
-                yield processed
-                count += 1
-    except Exception as e:
-        logger.warning(f"Error streaming {dataset_name} at sample {idx}: {e}")
-        return
-
-    logger.info(f"Streamed {count} samples from {dataset_name}")
-
-
-def stream_all_datasets(
-    datasets: Optional[List[str]] = None,
-    max_samples_per_dataset: int = 500,
-    hf_token: Optional[str] = None,
-) -> Iterator[ProcessedSample]:
-    """Faz streaming sequencial de múltiplos datasets.
-
-    Args:
-        datasets: lista de nomes (default: DEFAULT_DATASETS)
-        max_samples_per_dataset: limite por dataset
-        hf_token: token HF opcional
-
-    Yields:
-        ProcessedSample
-    """
-    if datasets is None:
-        datasets = DEFAULT_DATASETS
-
-    for ds_name in datasets:
-        logger.info(f"Starting dataset: {ds_name}")
-        yield from stream_dataset(
-            ds_name,
-            max_samples=max_samples_per_dataset,
-            hf_token=hf_token,
-        )
-
-
-def collate_samples_to_tensors(
-    samples: List[ProcessedSample],
-    tokenizer,
-    max_seq_len: int = 64,
-    pad_token_id: int = 0,
-) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-    """Converte lista de ProcessedSample em tensors para treino.
-
-    BUG FIX V13.9.1: Tokenizer.encode() retorna 'Encoding' object, não list.
-    Use .ids attribute to get token IDs.
-
-    Returns:
-        input_ids: (B, T)
-        attention_mask: (B, T)
-        labels: (B, T) — same as input_ids (LM training)
-    """
-    batch_input_ids = []
-    batch_attn_mask = []
-
-    for sample in samples:
-        # Tokenize
-        encoding = tokenizer.encode(sample.raw_text, add_special_tokens=True)
-
-        # BUG FIX: Handle both `tokenizers.Encoding` and `transformers` tokenizer outputs
-        if hasattr(encoding, 'ids'):
-            tokens = encoding.ids  # tokenizers library
-        elif isinstance(encoding, list):
-            tokens = encoding  # already a list of ints
-        elif hasattr(encoding, 'input_ids'):
-            tokens = encoding.input_ids  # transformers BatchEncoding
-        else:
-            tokens = list(encoding)  # fallback
-
-        # Truncate to max_seq_len
-        if len(tokens) > max_seq_len:
-            tokens = tokens[:max_seq_len]
-        # Pad
-        attn_mask = [1] * len(tokens) + [0] * (max_seq_len - len(tokens))
-        tokens = list(tokens) + [pad_token_id] * (max_seq_len - len(tokens))
-        batch_input_ids.append(tokens)
-        batch_attn_mask.append(attn_mask)
-
-    input_ids = torch.tensor(batch_input_ids, dtype=torch.long)
-    attention_mask = torch.tensor(batch_attn_mask, dtype=torch.long)
-    labels = input_ids.clone()
-
-    return input_ids, attention_mask, labels
-
-
-# ═══════════════════════════════════════════════════════════════════════════
-# Self-test (NÃO enviar para HuggingFace)
-# ═══════════════════════════════════════════════════════════════════════════
-if __name__ == "__main__":
-    print("=== Streaming Datasets V13.9.1 Self-Test ===\n")
-
-    # Test 1: Test field extraction
-    print("Test 1: Field extraction")
-    sample_chat = {
-        "messages": [
-            {"role": "user", "content": "Olá"},
-            {"role": "assistant", "content": "Como posso ajudar?"},
-        ]
-    }
-    text = _extract_field(sample_chat, ["messages", "text"])
-    print(f"  Chat text: {text!r}")
-    assert text and "Olá" in text, "Field extraction failed for chat"
-
-    sample_text = {"text": "Hello world"}
-    text = _extract_field(sample_text, ["text", "content"])
-    assert text == "Hello world"
-    print(f"  Text field: {text!r}")
-    print(f"  OK\n")
-
-    # Test 2: Test list of datasets
-    print("Test 2: Dataset list")
-    print(f"  Configured datasets ({len(DEFAULT_DATASETS)}):")
-    for i, ds in enumerate(DEFAULT_DATASETS, 1):
-        print(f"    {i}. {ds}")
-    assert len(DEFAULT_DATASETS) == 14
-    # V6.5-V2: verifica sequência CONHECIMENTO (8 datasets) + PUNICAO (1)
-    assert len(CONHECIMENTO_DATASETS_V2) == 8
-    assert PUNICAO_DATASET_V2 == "BrunoN-Dev/corpus-ptbr-v1"
-    print(f"  V2 CONHECIMENTO datasets: {len(CONHECIMENTO_DATASETS_V2)}")
-    print(f"  V2 PUNICAO dataset: {PUNICAO_DATASET_V2}")
-    print(f"  OK\n")
-
-    print("=== ALL STREAMING TESTS PASSED ===")

train_v6_5_v2_punicão_only.py

@@ -1,556 +0,0 @@
-"""train_v6_5_v2_punicão_only.py — V6.5-V2-dynamic FASE 2 only.
-
-Carrega o estado salvo da FASE 1 (CONHECIMENTO) e executa apenas a FASE 2
-(TREINAMENTO COM PUNIÇÃO) sobre BrunoN-Dev/corpus-ptbr-v1.
-
-User requirement: "FASE2 TREINAMENTO (meta mínima 1000 samples ou mais)
-COM PUNIÇÃO ATIVA para 'BrunoN-Dev/corpus-ptbr-v1' de 100 em 100 samples"
-
-Este script permite continuar o treinamento a partir do estado salvo sem
-precisar re-executar a FASE 1.
-"""
-from __future__ import annotations
-
-import gc
-import json
-import logging
-import os
-import re
-import shutil
-import sys
-import time
-import traceback
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-# ============================================================================
-# 0. Paths e logging
-# ============================================================================
-PROJECT_ROOT = Path("/home/z/my-project")
-BIGRU_ROOT = PROJECT_ROOT / "BiGRU_T_version"
-SRC_ROOT = BIGRU_ROOT / "src"
-DOWNLOAD_DIR = PROJECT_ROOT / "download"
-DOWNLOAD_DIR.mkdir(parents=True, exist_ok=True)
-
-PUNICAO_REPORT_PATH = BIGRU_ROOT / "v6_5_v2_punicão_report.json"
-PUNICAO_STATES_PATH = BIGRU_ROOT / "v6_5_v2_punicão_model_states.pt"
-PUNICAO_UPLOAD_REPORT_PATH = BIGRU_ROOT / "v6_5_v2_punicão_upload_report.json"
-
-# Estado salvo da FASE 1
-FASE1_STATES_PATH = BIGRU_ROOT / "v6_5_v2_model_states.pt"
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="[%(asctime)s] [%(levelname)s] %(message)s",
-    datefmt="%H:%M:%S",
-)
-logger = logging.getLogger("train_v6_5_v2_punicão")
-
-# ============================================================================
-# 1. ATIVAR xeon_runtime.py
-# ============================================================================
-os.environ["V65_ENABLE_STREAMING"] = "1"
-sys.path.insert(0, str(SRC_ROOT))
-
-from bigru_t.utils.xeon_runtime import (  # noqa: E402
-    optimize_xeon_environment,
-    benchmark_fp16_matmul,
-)
-N_CORES = optimize_xeon_environment(verbose=False)
-logger.info(f"[V6.5-V2-punicão] Xeon cores: {N_CORES}")
-
-# ============================================================================
-# 2. Configurações (mesmas do FASE 1, para compatibilidade de estado)
-# ============================================================================
-BATCH_SIZE = 16
-MAX_SEQ_LEN = 8
-HIDDEN_DIM = 256
-VOCAB_SIZE = 4096
-SOM_GRID = (6, 6, 6, 4)
-T_MAX = 10000
-N_START = 10
-LAMBDA_EWC = 0.02
-ALPHA0 = 0.1
-SIGMA0 = 1.5
-DIM_CHOICE = "y"
-
-N_HYPOTHESES = 8
-MAX_N_HYPOTHESES = 16
-MIN_N_HYPOTHESES = 4
-N_TRIALS = 3
-MIN_N_TRIALS = 1
-MAX_N_TRIALS = 6
-HYP_TRAIN_STEPS = 20
-MIN_HYP_TRAIN_STEPS = 5
-MAX_HYP_TRAIN_STEPS = 60
-HYP_LR = 1e-4
-HYP_HIDDEN_DIM = 128
-LOSS_HISTORY_WINDOW = 8
-PUNISHMENT_WINDOW = 12
-
-STREAM_BATCH_SIZE = 100
-META_MINIMA_PUNICAO = 1000
-MAX_SAMPLES_PUNICAO = 1000
-MAX_BUFFER_SIZE = 256
-
-INTER_BATCH_PAUSE_S = 0.3
-INTER_STREAM_BATCH_PAUSE_S = 0.5
-
-PUNICAO_DATASET = "BrunoN-Dev/corpus-ptbr-v1"
-
-DATASET_LABEL_STRINGS: Dict[str, Dict[int, str]] = {
-    "BrunoN-Dev/corpus-ptbr-v1": {0: "short_text", 1: "long_text"},
-}
-
-# ============================================================================
-# 3. Import KLS V2
-# ============================================================================
-from bigru_t.model.kohonen_learning_system import (  # noqa: E402
-    KohonenLearningSystemV2,
-)
-
-
-def get_process_rss_mb() -> float:
-    try:
-        import resource
-        return float(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss) / 1024.0
-    except Exception:
-        return 0.0
-
-
-def get_cgroup_memory_limit_mb() -> Optional[float]:
-    try:
-        with open("/sys/fs/cgroup/memory.max", "r") as f:
-            return float(int(f.read().strip())) / 1e6
-    except Exception:
-        return None
-
-
-def aggressive_memory_cleanup() -> None:
-    gc.collect()
-    gc.collect()
-
-
-def make_label(text: str, dataset_name: Optional[str] = None) -> int:
-    if dataset_name == "BrunoN-Dev/corpus-ptbr-v1":
-        return len(text.split()) % 2
-    return 1 if len(text.split()) % 2 == 0 else 0
-
-
-def stream_dataset_in_chunks(dataset_name, chunk_size, max_total, hf_token, timeout_per_chunk=120):
-    from bigru_t.data.streaming_datasets import stream_dataset
-    yielded_total = 0
-    chunk_idx = 0
-    while yielded_total < max_total:
-        remaining = max_total - yielded_total
-        this_chunk_target = min(chunk_size, remaining)
-        seed_offset = yielded_total
-        chunk: List[str] = []
-        t_start = time.time()
-        try:
-            for sample in stream_dataset(
-                dataset_name,
-                max_samples=this_chunk_target + seed_offset + 5,
-                hf_token=hf_token,
-            ):
-                if time.time() - t_start > timeout_per_chunk:
-                    break
-                if sample.raw_text and len(sample.raw_text.strip()) > 0:
-                    if seed_offset > 0:
-                        seed_offset -= 1
-                        continue
-                    chunk.append(sample.raw_text.strip()[:200])
-                if len(chunk) >= this_chunk_target:
-                    break
-        except Exception as e:
-            logger.warning(f"Stream error: {e}")
-            if chunk:
-                yield chunk
-                yielded_total += len(chunk)
-                chunk_idx += 1
-            break
-        if not chunk:
-            break
-        yield chunk
-        yielded_total += len(chunk)
-        chunk_idx += 1
-        logger.info(f"[PUNICAO] {dataset_name} chunk {chunk_idx}: {len(chunk)} (total: {yielded_total}/{max_total})")
-
-
-def save_punicão_states(kls, reason, step, total_samples):
-    import torch
-    try:
-        state = {
-            "_meta": {
-                "reason": str(reason),
-                "step": int(step),
-                "total_samples": int(total_samples),
-                "timestamp": datetime.now().isoformat(),
-                "version": "V6.5-V2-dynamic-punicão",
-                "loaded_from_fase1": str(FASE1_STATES_PATH),
-            },
-            "som_weights": kls.som.weights.detach().clone().cpu(),
-            "som_old_weights_w": (
-                kls.som.old_weights_w.detach().clone().cpu()
-                if kls.som.old_weights_w is not None else None
-            ),
-            "som_fisher_w": (
-                kls.som.fisher_w.detach().clone().cpu()
-                if kls.som.fisher_w is not None else None
-            ),
-            "embedding_state": {"weight": kls.embedding.weight.detach().clone().cpu()},
-            "classifier_state": (
-                kls.classifier.state_dict() if kls.classifier is not None else None
-            ),
-            "hypothesis_ensemble_state": kls.hypothesis_ensemble.state_dict(),
-            "delta_scale": kls.delta_scale.detach().clone().cpu(),
-            "v2_metrics": kls.get_v2_metrics(),
-            "label_registry": kls.label_registry,
-            "adaptation_log": kls.get_adaptation_log(),
-        }
-        torch.save(state, PUNICAO_STATES_PATH)
-        size_mb = PUNICAO_STATES_PATH.stat().st_size / 1e6
-        logger.info(f"[PUNICAO] States saved: {PUNICAO_STATES_PATH} ({size_mb:.1f}MB)")
-        return {"saved": True, "path": str(PUNICAO_STATES_PATH), "size_mb": float(size_mb)}
-    except Exception as e:
-        logger.error(f"[PUNICAO] Save failed: {e}")
-        return {"saved": False, "error": str(e)}
-
-
-HF_REPO_ID = "PowerMachine/BiGRU_T_version"
-
-
-def upload_punicão_to_hf(hf_token, files_to_upload):
-    if not hf_token:
-        return {"uploaded": False, "reason": "no_hf_token"}
-    try:
-        from huggingface_hub import HfApi, whoami, CommitOperationAdd
-    except ImportError as e:
-        return {"uploaded": False, "reason": f"import_error: {e}"}
-    api = HfApi(token=hf_token)
-    try:
-        whoami(token=hf_token)
-    except Exception as e:
-        return {"uploaded": False, "reason": f"auth_failed: {e}"}
-    operations = []
-    for src in files_to_upload:
-        if not src.exists():
-            continue
-        operations.append(CommitOperationAdd(
-            path_in_repo=src.name,
-            path_or_fileobj=str(src),
-        ))
-    if not operations:
-        return {"uploaded": False, "reason": "no_files"}
-    try:
-        commit_info = api.create_commit(
-            repo_id=HF_REPO_ID,
-            repo_type="model",
-            operations=operations,
-            commit_message=f"V6.5-V2-dynamic: FASE 2 PUNIÇÃO upload ({len(operations)} files)",
-        )
-        return {
-            "uploaded": True,
-            "n_files": len(operations),
-            "commit_url": str(commit_info.commit_url) if hasattr(commit_info, "commit_url") else str(commit_info),
-        }
-    except Exception as e:
-        logger.error(f"[PUNICAO] HF upload failed: {e}")
-        return {"uploaded": False, "reason": str(e)}
-
-
-def main() -> int:
-    import torch
-
-    if not FASE1_STATES_PATH.exists():
-        logger.error(f"[PUNICAO] FASE 1 states not found: {FASE1_STATES_PATH}")
-        return 1
-
-    logger.info(f"[PUNICAO] Loading FASE 1 states from: {FASE1_STATES_PATH}")
-    fase1_state = torch.load(FASE1_STATES_PATH, map_location="cpu", weights_only=False)
-    logger.info(f"[PUNICAO] FASE 1 state loaded. Reason: {fase1_state['_meta']['reason']}")
-    logger.info(f"[PUNICAO] FASE 1 total_samples: {fase1_state['_meta']['total_samples']}")
-
-    # Construct KLS V2 with same config as FASE 1
-    kls = KohonenLearningSystemV2(
-        vocab_size=VOCAB_SIZE, hidden_dim=HIDDEN_DIM, seq_len=MAX_SEQ_LEN,
-        som_grid=SOM_GRID, alpha0=ALPHA0, sigma0=SIGMA0,
-        lambda_ewc=LAMBDA_EWC, N_start=N_START, dim_choice=DIM_CHOICE,
-        hypothesis_hidden=[512, 256, 128, 64, 32, 16, 8], T_max=T_MAX,
-        enable_vqvae2=False, enable_reasoning=True, enable_w8a8=False,
-        enable_attention=True, attention_n_heads=8,
-        n_hypotheses=N_HYPOTHESES, max_n_hypotheses=MAX_N_HYPOTHESES,
-        min_n_hypotheses=MIN_N_HYPOTHESES, n_trials=N_TRIALS,
-        min_n_trials=MIN_N_TRIALS, max_n_trials=MAX_N_TRIALS,
-        hyp_train_steps=HYP_TRAIN_STEPS, min_hyp_train_steps=MIN_HYP_TRAIN_STEPS,
-        max_hyp_train_steps=MAX_HYP_TRAIN_STEPS, hyp_lr=HYP_LR,
-        hyp_hidden_dim=HYP_HIDDEN_DIM,
-        loss_history_window=LOSS_HISTORY_WINDOW,
-        punishment_window=PUNISHMENT_WINDOW,
-    )
-    logger.info(f"[PUNICAO] KLS V2 initialized (fresh)")
-
-    # Load FASE 1 state into KLS
-    try:
-        # SOM weights
-        kls.som.weights = nn.Parameter(fase1_state["som_weights"].clone())
-        if fase1_state.get("som_old_weights_w") is not None:
-            kls.som.old_weights_w = fase1_state["som_old_weights_w"].clone()
-        if fase1_state.get("som_fisher_w") is not None:
-            kls.som.fisher_w = fase1_state["som_fisher_w"].clone()
-        # Embedding
-        if "embedding_state" in fase1_state:
-            kls.embedding.weight.data = fase1_state["embedding_state"]["weight"].clone()
-        # Classifier
-        if fase1_state.get("classifier_state") and kls.classifier is not None:
-            kls.classifier.load_state_dict(fase1_state["classifier_state"])
-            kls.classifier_trained = True
-        # Hypothesis ensemble
-        if "hypothesis_ensemble_state" in fase1_state:
-            kls.hypothesis_ensemble.load_state_dict(fase1_state["hypothesis_ensemble_state"])
-        # Delta scale
-        if "delta_scale" in fase1_state:
-            kls.delta_scale.data = fase1_state["delta_scale"].clone()
-        # Label registry
-        if "label_registry" in fase1_state:
-            kls.label_registry = fase1_state["label_registry"]
-        # Mark training as ready (FASE 1 already trained the SOM)
-        kls.training_ready = True
-        logger.info(f"[PUNICAO] FASE 1 state loaded into KLS successfully")
-    except Exception as e:
-        logger.error(f"[PUNICAO] Failed to load FASE 1 state: {e}")
-        traceback.print_exc()
-        return 1
-
-    # Fit tokenizer with PT-BR corpus
-    corpus_inicial = [
-        "o gato dorme na cama", "a casa eh azul", "ele corre rapido",
-        "luva de pedreiro tavila", "lula reserva valor",
-        "amazonas forca tarefa vitimas",
-        "texto curto", "texto longo com muitas palavras para teste",
-    ]
-    kls.tokenizer.fit(corpus_inicial)
-    logger.info(f"[PUNICAO] Tokenizer fitted")
-
-    hf_token = os.environ.get("HF_TOKEN")
-    if not hf_token:
-        logger.warning("[PUNICAO] HF_TOKEN not set")
-    else:
-        logger.info(f"[PUNICAO] HF_TOKEN set: {hf_token[:8]}...")
-
-    # ========================================================================
-    # FASE 2 — TREINAMENTO COM PUNIÇÃO
-    # ========================================================================
-    logger.info("\n" + "=" * 80)
-    logger.info("[PUNICAO] FASE 2 — TREINAMENTO COM PUNIÇÃO ATIVA")
-    logger.info("=" * 80)
-    logger.info(f"  Dataset: {PUNICAO_DATASET}")
-    logger.info(f"  Meta mínima: {META_MINIMA_PUNICAO}")
-    logger.info(f"  Stream batch: {STREAM_BATCH_SIZE}")
-    logger.info(f"  n_hypotheses: {kls.n_hypotheses} (max {kls.max_n_hypotheses})")
-    logger.info(f"  n_trials: {kls.n_trials}")
-    logger.info(f"  hyp_train_steps: {kls.hyp_train_steps}")
-    logger.info("=" * 80 + "\n")
-
-    step = 0
-    t_start = time.time()
-    samples_processed = 0
-    chunk_idx_global = 0
-    punishment_log: List[Dict[str, Any]] = []
-    hypotheses_log: List[Dict[str, Any]] = []
-    delta_applications_log: List[Dict[str, Any]] = []
-    accuracies_log: List[Dict[str, Any]] = []
-    mem_critical_stopped = False
-    cg_limit = get_cgroup_memory_limit_mb()
-
-    try:
-        chunk_iter = stream_dataset_in_chunks(
-            dataset_name=PUNICAO_DATASET,
-            chunk_size=STREAM_BATCH_SIZE,
-            max_total=MAX_SAMPLES_PUNICAO,
-            hf_token=hf_token,
-            timeout_per_chunk=120,
-        )
-        for chunk_samples in chunk_iter:
-            if mem_critical_stopped:
-                break
-            if samples_processed >= META_MINIMA_PUNICAO:
-                logger.info(f"[PUNICAO] Meta atingida: {samples_processed}")
-                break
-            chunk_idx_global += 1
-            if not chunk_samples:
-                continue
-            samples_processed += len(chunk_samples)
-            labels = [make_label(s, PUNICAO_DATASET) for s in chunk_samples]
-            logger.info(f"[PUNICAO] Chunk {chunk_idx_global}: {len(chunk_samples)} samples (total: {samples_processed})")
-
-            for batch_start in range(0, len(chunk_samples), BATCH_SIZE):
-                try:
-                    # Memory check
-                    if step > 0 and step % 5 == 0 and cg_limit is not None:
-                        rss = get_process_rss_mb()
-                        mem_pct = (rss / cg_limit) * 100.0
-                        logger.info(f"[PUNICAO] MEM: RSS={rss:.0f}MB ({mem_pct:.1f}%)")
-                        if mem_pct > 80:
-                            logger.error(f"[PUNICAO] MEM CRITICAL ({mem_pct:.1f}%). Stopping.")
-                            save_punicão_states(kls, f"mem_critical_{mem_pct:.1f}pct", step, samples_processed)
-                            mem_critical_stopped = True
-                            break
-
-                    batch_sents = chunk_samples[batch_start: batch_start + BATCH_SIZE]
-                    batch_labels = labels[batch_start: batch_start + BATCH_SIZE]
-                    try:
-                        result = kls.process_batch_v2(
-                            batch_sents, batch_labels,
-                            label_strings=DATASET_LABEL_STRINGS.get(PUNICAO_DATASET),
-                            dataset_name=PUNICAO_DATASET,
-                            enable_punishment=True,
-                        )
-                    except Exception as e:
-                        logger.error(f"[PUNICAO] process_batch_v2 error: {e}")
-                        continue
-
-                    action = result.get("action", "none")
-                    if action != "none" and action != "success":
-                        punishment_log.append({
-                            "step": step,
-                            "action": action,
-                            "accuracy": float(result.get("accuracy", 0.0)),
-                            "punishment_count": int(kls.punishment_count),
-                            "cycle_completed": bool(result.get("cycle_completed", False)),
-                        })
-                        if "hypotheses_training" in result:
-                            hyp_info = result["hypotheses_training"]
-                            hypotheses_log.append({
-                                "step": step,
-                                "loss_initial": float(hyp_info.get("loss_initial", 0.0)),
-                                "loss_final": float(hyp_info.get("loss_final", 0.0)),
-                                "delta_scale": float(hyp_info.get("delta_scale_final", 0.0)),
-                            })
-                        if "delta_application" in result:
-                            apply_info = result["delta_application"]
-                            delta_applications_log.append({
-                                "step": step,
-                                "acc_before": float(apply_info.get("acc_before", 0.0)),
-                                "acc_after": float(apply_info.get("acc_after", 0.0)),
-                                "delta_norm": float(apply_info.get("delta_norm", 0.0)),
-                                "ewc_reference_set": bool(apply_info.get("ewc_reference_set", False)),
-                            })
-
-                    acc = kls.evaluate_classification()
-                    accuracies_log.append({
-                        "step": step,
-                        "accuracy": float(acc),
-                        "action": action,
-                        "punishment_count": int(kls.punishment_count),
-                        "buffer_size": int(len(kls.buffer_4d)),
-                    })
-                    step += 1
-                    time.sleep(INTER_BATCH_PAUSE_S)
-                except Exception as e:
-                    logger.error(f"[PUNICAO] Batch error: {e}")
-                    continue
-
-            time.sleep(INTER_STREAM_BATCH_PAUSE_S)
-            # Buffer sliding window
-            if len(kls.buffer_4d) > MAX_BUFFER_SIZE:
-                overflow = len(kls.buffer_4d) - MAX_BUFFER_SIZE
-                del kls.buffer_4d[:overflow]
-                del kls.buffer_labels[:overflow]
-                logger.info(f"[PUNICAO] Buffer trimmed: -{overflow} → {len(kls.buffer_4d)}")
-            if chunk_idx_global % 2 == 0:
-                aggressive_memory_cleanup()
-    except Exception as e:
-        logger.error(f"[PUNICAO] FASE 2 failed: {e}")
-        traceback.print_exc()
-
-    t_elapsed = time.time() - t_start
-    logger.info(f"\n[PUNICAO] FASE 2 concluída:")
-    logger.info(f"  Total samples: {samples_processed}")
-    logger.info(f"  Meta atingida: {samples_processed >= META_MINIMA_PUNICAO}")
-    logger.info(f"  Punishment events: {len(punishment_log)}")
-    logger.info(f"  Delta applications: {len(delta_applications_log)}")
-    logger.info(f"  Tempo: {t_elapsed:.1f}s")
-
-    # Save final states
-    save_punicão_states(kls, "end_of_punicão", step, samples_processed)
-
-    # Final report
-    final_report = {
-        "version": "V6.5-V2-dynamic-punicão",
-        "timestamp": datetime.now().isoformat(),
-        "loaded_from_fase1": str(FASE1_STATES_PATH),
-        "fase1_total_samples": int(fase1_state["_meta"]["total_samples"]),
-        "fase2_total_samples": int(samples_processed),
-        "fase2_meta_atingida": bool(samples_processed >= META_MINIMA_PUNICAO),
-        "fase2_elapsed_s": float(t_elapsed),
-        "punishment_events": punishment_log,
-        "hypotheses_trainings": hypotheses_log,
-        "delta_applications": delta_applications_log,
-        "accuracies_log": accuracies_log[-30:],
-        "final_v2_metrics": kls.get_v2_metrics(),
-        "n_adaptations": len(kls.get_adaptation_log()),
-        "mem_critical_stopped": bool(mem_critical_stopped),
-    }
-    PUNICAO_REPORT_PATH.write_text(json.dumps(final_report, indent=2, ensure_ascii=False))
-    logger.info(f"[PUNICAO] Report saved: {PUNICAO_REPORT_PATH}")
-
-    # Copy to download
-    try:
-        for src in [PUNICAO_REPORT_PATH, PUNICAO_STATES_PATH]:
-            if src.exists():
-                shutil.copy2(src, DOWNLOAD_DIR / src.name)
-    except Exception as e:
-        logger.warning(f"[PUNICAO] Copy to download failed: {e}")
-
-    # HF upload (batch)
-    hf_upload_result = {"uploaded": False, "reason": "no_hf_token"}
-    if hf_token:
-        files_to_upload = [
-            PUNICAO_REPORT_PATH,
-            PUNICAO_STATES_PATH,
-            BIGRU_ROOT / "scripts" / "train_v6_5_v2_punicão_only.py",
-        ]
-        # Scrub HF_TOKEN from scripts before upload
-        pattern = re.compile(r'hf_[A-Za-z0-9]{32,}')
-        for py_file in [BIGRU_ROOT / "scripts" / "train_v6_5_v2_punicão_only.py"]:
-            if py_file.exists():
-                content = py_file.read_text(encoding="utf-8")
-                if pattern.findall(content):
-                    py_file.write_text(pattern.sub("<HF_TOKEN_REMOVED>", content), encoding="utf-8")
-
-        hf_upload_result = upload_punicão_to_hf(hf_token, files_to_upload)
-        PUNICAO_UPLOAD_REPORT_PATH.write_text(
-            json.dumps(hf_upload_result, indent=2, ensure_ascii=False)
-        )
-        logger.info(f"[PUNICAO] HF upload: {hf_upload_result}")
-
-    # Clean HF_TOKEN
-    if "HF_TOKEN" in os.environ:
-        del os.environ["HF_TOKEN"]
-    if "HUGGING_FACE_HUB_TOKEN" in os.environ:
-        del os.environ["HUGGING_FACE_HUB_TOKEN"]
-    logger.info("[PUNICAO] HF_TOKEN cleaned from environment")
-
-    print("\n" + "=" * 80)
-    print("V6.5-V2-dynamic FASE 2 PUNIÇÃO — CONCLUÍDO")
-    print("=" * 80)
-    print(f"  Samples processados : {samples_processed}")
-    print(f"  Meta atingida       : {samples_processed >= META_MINIMA_PUNICAO}")
-    print(f"  Punishment events   : {len(punishment_log)}")
-    print(f"  Delta applications  : {len(delta_applications_log)}")
-    print(f"  Hyp trainings       : {len(hypotheses_log)}")
-    print(f"  N adaptations       : {len(kls.get_adaptation_log())}")
-    print(f"  Final n_hypotheses  : {kls.n_hypotheses}")
-    print(f"  Final n_trials      : {kls.n_trials}")
-    print(f"  Final hyp_steps     : {kls.hyp_train_steps}")
-    print(f"  HF upload           : {hf_upload_result.get('uploaded', False)}")
-    print(f"  HF_TOKEN cleaned    : True")
-    print("=" * 80)
-    return 0
-
-
-if __name__ == "__main__":
-    import torch.nn as nn  # needed for nn.Parameter in main
-    sys.exit(main())

xeon_runtime.py

@@ -1,581 +0,0 @@
-"""xeon_runtime.py — Intel Xeon runtime (V6): AVX512 + AMX_INT8 + IPEX + OneDNN + FP16.
-
-═══════════════════════════════════════════════════════════════════════════════
-V6 UPGRADE
-═══════════════════════════════════════════════════════════════════════════════
-
-V5 only set OMP/MKL threads + KMP_AFFINITY. V6 adds:
-
-1. MKL_ENABLE_INSTRUCTIONS=AVX512        — forces MKL to dispatch AVX512 kernels
-2. ONEDNN_MAX_CPU_ISA=AMX_INT8           — lets oneDNN use AMX INT8 tiles
-3. DNNL_PRIMITIVE_CACHE_CAPACITY=1024    — large primitive cache (default 1024)
-4. MKL_DYNAMIC=FALSE                     — disables MKL dynamic thread adjustment
-5. IPEX (intel_extension_for_pytorch)    — Intel PyTorch extension
-   - ipex.optimize(model) on the BiGRU_T model
-   - torch.cpu.amp.autocast(dtype=torch.float16) for FP16 inference
-6. FP16 benchmark: 8000×8000 matmul, TFLOPS measurement
-7. libvirt AMX activation helper — exposes amx-tile/amx-int8/amx-bf16 to a VM
-   via host-passthrough CPU mode + feature policy='require'
-
-The runtime is **always activated** (per user request: "sempre ativar otimização
-para Xeon AVX512"). It degrades gracefully if IPEX / libvirt / AMX are not
-available, but it never silently skips the optimization step.
-
-═══════════════════════════════════════════════════════════════════════════════
-USAGE
-═══════════════════════════════════════════════════════════════════════════════
-
-    from bigru_t.utils.xeon_runtime import optimize_xeon_environment
-    N_CORES = optimize_xeon_environment()           # call ONCE, before torch
-    # ... safe to import torch, ipex, etc. ...
-
-For VM AMX exposure (requires libvirt-python and root):
-    from bigru_t.utils.xeon_runtime import ativar_amx_na_vm
-    ativar_amx_na_vm("my_vm_name")
-
-═══════════════════════════════════════════════════════════════════════════════
-"""
-from __future__ import annotations
-import os
-import sys
-import time
-import logging
-import platform
-from typing import Optional, Tuple, Dict, Any
-
-logger = logging.getLogger(__name__)
-
-_NUCLEOS_ALOCADOS: Optional[int] = None
-_IPEX_AVAILABLE: Optional[bool] = None
-_AMX_CAPABLE: Optional[bool] = None
-_V6_INIT_DONE: bool = False
-
-
-# ============================================================================
-# Helpers
-# ============================================================================
-
-def _detect_physical_cores() -> int:
-    """Detect physical cores actually available to this process.
-
-    Respects cgroup limits without requiring root. Falls back to logical
-    cpu count if psutil is unavailable.
-    """
-    try:
-        import psutil
-        n_phys = psutil.cpu_count(logical=False) or 1
-    except ImportError:
-        try:
-            with open("/proc/cpuinfo", "r") as f:
-                cores = set()
-                for line in f:
-                    if line.startswith("core id"):
-                        cores.add(line.strip())
-                n_phys = len(cores) or 1
-        except OSError:
-            n_phys = 1
-
-    try:
-        n_affine = len(os.sched_getaffinity(0))
-        n_logical = os.cpu_count() or 1
-        if n_affine < n_logical:
-            n_phys = max(1, n_affine // 2)
-        else:
-            n_phys = min(n_phys, n_affine)
-    except (AttributeError, OSError):
-        pass
-
-    return max(1, n_phys)
-
-
-def _read_cpu_flags() -> str:
-    try:
-        with open("/proc/cpuinfo", "r") as f:
-            for line in f:
-                if line.startswith("flags"):
-                    return line
-    except OSError:
-        pass
-    return ""
-
-
-def get_avx512_capability() -> Tuple[bool, str]:
-    """Check if the host CPU supports AVX512 VNNI."""
-    flags = _read_cpu_flags()
-    if "avx512_vnni" in flags:
-        return True, "AVX512_VNNI (full INT8 acceleration)"
-    elif "avx512f" in flags:
-        return True, "AVX512F (no VNNI; INT8 falls back to AVX512F)"
-    elif "avx2" in flags:
-        return False, "AVX2 only (INT8 quantization works but slower)"
-    else:
-        return False, "Legacy SSE (INT8 quantization not recommended)"
-
-
-def get_amx_capability() -> Tuple[bool, str]:
-    """V6: check if AMX (Advanced Matrix Extensions) is available."""
-    global _AMX_CAPABLE
-    flags = _read_cpu_flags()
-    has_tile = "amx_tile" in flags
-    has_int8 = "amx_int8" in flags
-    has_bf16 = "amx_bf16" in flags
-    if has_tile and has_int8 and has_bf16:
-        _AMX_CAPABLE = True
-        return True, "AMX (tile + int8 + bf16) — full AMX acceleration"
-    elif has_tile:
-        _AMX_CAPABLE = True
-        return True, f"AMX tile only (int8={has_int8}, bf16={has_bf16})"
-    else:
-        _AMX_CAPABLE = False
-        return False, "AMX not available (AVX512 path will be used)"
-
-
-def _try_import_ipex() -> Optional[Any]:
-    """V6: try to import IPEX (Intel Extension for PyTorch).
-
-    Returns the ipex module if available, else None. Caches the result.
-    """
-    global _IPEX_AVAILABLE
-    if _IPEX_AVAILABLE is False:
-        return None
-    try:
-        import intel_extension_for_pytorch as ipex  # type: ignore
-        _IPEX_AVAILABLE = True
-        return ipex
-    except (ImportError, AttributeError, OSError) as e:
-        _IPEX_AVAILABLE = False
-        if _V6_INIT_DONE is False:
-            logger.info(f"[Xeon V6] IPEX não disponível: {type(e).__name__}: {e}")
-            logger.info("[Xeon V6] Continuando com OneDNN/MKL nativo do PyTorch.")
-        return None
-
-
-# ============================================================================
-# FP16 benchmark (V6 — user-provided code)
-# ============================================================================
-
-def benchmark_fp16_matmul(size: int = 8000, warmup: int = 1, iters: int = 3) -> Dict[str, float]:
-    """V6: FP16 matmul benchmark for Xeon AVX512/AMX.
-
-    Runs `size`×`size` FP16 matmul `iters` times and reports:
-        - best_time_ms: lowest wall time
-        - best_tflops: best achieved TFLOPS
-        - avg_tflops: average TFLOPS
-
-    Returns empty dict if torch unavailable.
-    """
-    try:
-        import torch
-    except ImportError:
-        return {}
-
-    results: Dict[str, float] = {}
-    try:
-        # Warmup
-        a = torch.randn(size, size, dtype=torch.float16)
-        b = torch.randn(size, size, dtype=torch.float16)
-        for _ in range(warmup):
-            _ = torch.matmul(a, b)
-        # Bench
-        times = []
-        for _ in range(iters):
-            t0 = time.perf_counter()
-            _ = torch.matmul(a, b)
-            times.append(time.perf_counter() - t0)
-        best_t = min(times)
-        avg_t = sum(times) / len(times)
-        # 2*size^3 FLOPs per matmul (M*N*K)
-        flops = 2.0 * (size ** 3)
-        results["best_time_ms"] = best_t * 1000.0
-        results["avg_time_ms"] = avg_t * 1000.0
-        results["best_tflops"] = flops / best_t / 1e12
-        results["avg_tflops"] = flops / avg_t / 1e12
-        results["matrix_size"] = float(size)
-    except (RuntimeError, MemoryError) as e:
-        logger.warning(f"[Xeon V6] FP16 benchmark failed: {e}")
-        results["error"] = str(e)
-    return results
-
-
-def benchmark_int8_matmul(size: int = 4096, warmup: int = 1, iters: int = 3) -> Dict[str, float]:
-    """V6: INT8 matmul benchmark — uses AMX_INT8 when available via oneDNN.
-
-    Falls back to FP32 if INT8 path is unavailable.
-    """
-    try:
-        import torch
-    except ImportError:
-        return {}
-
-    results: Dict[str, float] = {}
-    try:
-        a = torch.randint(-127, 127, (size, size), dtype=torch.int8)
-        b = torch.randint(-127, 127, (size, size), dtype=torch.int8)
-        # Warmup
-        for _ in range(warmup):
-            _ = torch.matmul(a.float(), b.float())
-        times = []
-        for _ in range(iters):
-            t0 = time.perf_counter()
-            _ = torch.matmul(a.float(), b.float())
-            times.append(time.perf_counter() - t0)
-        best_t = min(times)
-        flops = 2.0 * (size ** 3)
-        results["int8_best_time_ms"] = best_t * 1000.0
-        results["int8_best_tflops"] = flops / best_t / 1e12
-        results["int8_matrix_size"] = float(size)
-    except (RuntimeError, MemoryError) as e:
-        results["int8_error"] = str(e)
-    return results
-
-
-# ============================================================================
-# Main entry point: optimize_xeon_environment (V6)
-# ============================================================================
-
-def optimize_xeon_environment(
-    verbose: bool = True,
-    force_ipex: bool = False,
-) -> int:
-    """V6: configure Intel Xeon AVX512 + AMX_INT8 + IPEX + OneDNN.
-
-    Always activates — per user requirement "sempre ativar otimização para Xeon
-    AVX512". Idempotent. Sets every environment variable that influences MKL,
-    OpenMP, oneDNN, and (optionally) IPEX runtime behavior.
-
-    Args:
-        verbose: print configuration summary to stdout
-        force_ipex: if True, raise when IPEX import fails. Default False —
-            degrade gracefully to native PyTorch oneDNN.
-
-    Returns:
-        Number of physical cores allocated to this process.
-    """
-    global _NUCLEOS_ALOCADOS, _V6_INIT_DONE
-
-    if _NUCLEOS_ALOCADOS is not None and _V6_INIT_DONE:
-        return _NUCLEOS_ALOCADOS
-
-    n_phys = _detect_physical_cores()
-
-    # ───────────────────────────────────────────────────────────────────────
-    # V6 — Environment variables (user-provided block)
-    # ───────────────────────────────────────────────────────────────────────
-    os.environ["MKL_ENABLE_INSTRUCTIONS"] = "AVX512"
-    NUM_CORES = str(n_phys)
-    os.environ["MKL_NUM_THREADS"] = NUM_CORES
-    os.environ["OMP_NUM_THREADS"] = NUM_CORES
-    os.environ["MKL_DYNAMIC"] = "FALSE"
-    os.environ["DNNL_PRIMITIVE_CACHE_CAPACITY"] = "1024"
-    os.environ["ONEDNN_MAX_CPU_ISA"] = "AMX_INT8"
-
-    # ───────────────────────────────────────────────────────────────────────
-    # V5 (kept) — OpenMP thread pinning
-    # ───────────────────────────────────────────────────────────────────────
-    os.environ.setdefault("KMP_AFFINITY", "granularity=fine,compact,1,0")
-    os.environ.setdefault("KMP_BLOCKTIME", "1")
-    os.environ.setdefault("TOKENIZERS_PARALLELISM", "true")
-
-    # ───────────────────────────────────────────────────────────────────────
-    # PyTorch backend flags
-    # ───────────────────────────────────────────────────────────────────────
-    try:
-        import torch
-        torch.set_num_threads(n_phys)
-        try:
-            torch.set_num_interop_threads(1)
-        except RuntimeError:
-            # V6.5: já inicializado (e.g., bigru_t package importou torch antes).
-            # Silenciosamente ignora — o paralelismo já está configurado.
-            pass
-        if hasattr(torch.backends, "mkldnn"):
-            torch.backends.mkldnn.enabled = True
-        if hasattr(torch.backends, "quantized"):
-            try:
-                torch.backends.quantized.engine = "fbgemm"
-            except (RuntimeError, AttributeError):
-                pass
-        # V6: enable TF32 for Ampere+ / Sapphire Rapids (irrelevant on CPU but
-        # harmless) and ensure oneDNN verbose is silent.
-        try:
-            torch.backends.cuda.matmul.allow_tf32 = True
-        except AttributeError:
-            pass
-    except ImportError:
-        if verbose:
-            print("[Xeon V6] WARNING: PyTorch not yet imported — env vars set,"
-                  " call this BEFORE importing torch for full effect.")
-
-    # ───────────────────────────────────────────────────────────────────────
-    # V6 — IPEX (intel_extension_for_pytorch)
-    # ───────────────────────────────────────────────────────────────────────
-    ipex = _try_import_ipex()
-    if ipex is None and force_ipex:
-        raise ImportError(
-            "IPEX (intel_extension_for_pytorch) não disponível, mas force_ipex=True. "
-            "Instale com: pip install intel-extension-for-pytorch"
-        )
-
-    # ───────────────────────────────────────────────────────────────────────
-    # V6 — AMX capability check
-    # ───────────────────────────────────────────────────────────────────────
-    amx_ok, amx_desc = get_amx_capability()
-    avx_ok, avx_desc = get_avx512_capability()
-
-    _NUCLEOS_ALOCADOS = n_phys
-    _V6_INIT_DONE = True
-
-    if verbose:
-        print("\n" + "=" * 72)
-        print(f"[Xeon Runtime V6] Intel Xeon optimization activated")
-        print("=" * 72)
-        print(f"  Physical cores        : {n_phys}")
-        print(f"  MKL_NUM_THREADS       : {os.environ['MKL_NUM_THREADS']}")
-        print(f"  OMP_NUM_THREADS       : {os.environ['OMP_NUM_THREADS']}")
-        print(f"  MKL_DYNAMIC           : {os.environ['MKL_DYNAMIC']}")
-        print(f"  MKL_ENABLE_INSTRUCTIONS: {os.environ['MKL_ENABLE_INSTRUCTIONS']}")
-        print(f"  ONEDNN_MAX_CPU_ISA    : {os.environ['ONEDNN_MAX_CPU_ISA']}")
-        print(f"  DNNL_PRIMITIVE_CACHE  : {os.environ['DNNL_PRIMITIVE_CACHE_CAPACITY']}")
-        print(f"  KMP_AFFINITY          : {os.environ['KMP_AFFINITY']}")
-        print(f"  KMP_BLOCKTIME         : {os.environ['KMP_BLOCKTIME']}")
-        print(f"  AVX512                : {avx_desc}")
-        print(f"  AMX                   : {amx_desc}")
-        print(f"  IPEX                  : "
-              f"{'available' if ipex is not None else 'not installed (using native oneDNN)'}")
-        print("=" * 72 + "\n")
-
-    return n_phys
-
-
-# ============================================================================
-# V6 — apply_ipex_optimization (model-level)
-# ============================================================================
-
-def apply_ipex_optimization(model, dtype=None, optimizer=None):
-    """V6: apply ipex.optimize() to a model.
-
-    Returns (model, optimizer) tuple. If IPEX is not available, returns the
-    inputs unchanged. The model is modified in-place when IPEX is present.
-
-    Args:
-        model: torch.nn.Module
-        dtype: optional torch.dtype for the model (e.g. torch.bfloat16)
-        optimizer: optional torch.optim.Optimizer to also optimize
-    """
-    ipex = _try_import_ipex()
-    if ipex is None:
-        return model, optimizer
-    try:
-        import torch
-        if dtype is not None:
-            model = model.to(dtype)
-        if optimizer is not None:
-            model, optimizer = ipex.optimize(model=model, optimizer=optimizer, dtype=dtype)
-        else:
-            model = ipex.optimize(model=model, dtype=dtype)
-        logger.info(f"[Xeon V6] ipex.optimize applied (dtype={dtype})")
-    except (RuntimeError, AttributeError, TypeError) as e:
-        logger.warning(f"[Xeon V6] ipex.optimize failed: {e}")
-    return model, optimizer
-
-
-# ============================================================================
-# V6 — FP16 autocast context manager
-# ============================================================================
-
-class fp16_autocast:
-    """V6: FP16 CPU autocast context manager.
-
-    Uses torch.cpu.amp.autocast(dtype=torch.float16) when available. Falls
-    back to a no-op context manager if autocast is not supported.
-
-    Usage:
-        with fp16_autocast():
-            y = model(x)
-    """
-
-    def __init__(self, enabled: bool = True):
-        self.enabled = enabled
-        self._ctx = None
-
-    def __enter__(self):
-        if not self.enabled:
-            return self
-        try:
-            import torch
-            if hasattr(torch.cpu, "amp") and hasattr(torch.cpu.amp, "autocast"):
-                self._ctx = torch.cpu.amp.autocast(dtype=torch.float16)
-                self._ctx.__enter__()
-        except (ImportError, RuntimeError, AttributeError):
-            self._ctx = None
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        if self._ctx is not None:
-            self._ctx.__exit__(exc_type, exc_val, exc_tb)
-            self._ctx = None
-        return False
-
-
-# ============================================================================
-# V6 — libvirt AMX activation helper (user-provided code, integrated)
-# ============================================================================
-
-def ativar_amx_na_vm(nome_vm: str, qemu_uri: str = "qemu:///system") -> bool:
-    """V6: ativa AMX (amx-tile, amx-int8, amx-bf16) numa VM via libvirt.
-
-    Requer:
-        - pip install libvirt-python
-        - libvirtd rodando localmente (qemu:///system)
-        - permissão de root (ou membro do grupo libvirt)
-        - CPU física com AMX (verificado por get_amx_capability())
-
-    Implementação:
-        1. Conecta ao daemon libvirt
-        2. Busca a VM pelo nome
-        3. Lê o XML persistente (flag VIR_DOMAIN_XML_INACTIVE = 2)
-        4. Garante <cpu mode='host-passthrough'>
-        5. Adiciona <feature policy='require' name='amx-tile|int8|bf16'/>
-        6. Reescreve o XML via defineXML()
-
-    Retorna True se a VM foi atualizada com sucesso, False caso contrário.
-    Requer reboot da VM para aplicar.
-
-    Args:
-        nome_vm: nome da máquina virtual no libvirt
-        qemu_uri: URI do libvirt (default: qemu:///system)
-
-    Raises:
-        ImportError: se libvirt-python não estiver instalado
-        RuntimeError: se a conexão com libvirt falhar
-    """
-    try:
-        import libvirt  # type: ignore
-    except ImportError as e:
-        raise ImportError(
-            "libvirt-python não instalado. Rode: pip install libvirt-python "
-            "(também requer libvirt-dev no sistema: apt install libvirt-dev)"
-        ) from e
-
-    try:
-        import xml.etree.ElementTree as ET
-    except ImportError:
-        return False
-
-    # Pré-checa AMX no host físico
-    amx_ok, amx_desc = get_amx_capability()
-    if not amx_ok:
-        print(f"[AMX VM] Host físico não tem AMX ({amx_desc}).")
-        print("         Não adianta ativar AMX na VM — o host precisa suportar.")
-        return False
-
-    try:
-        conn = libvirt.open(qemu_uri)
-        if conn is None:
-            print(f"[AMX VM] Falha ao abrir conexão com {qemu_uri}")
-            return False
-
-        try:
-            dom = conn.lookupByName(nome_vm)
-        except libvirt.libvirtError:
-            print(f"[AMX VM] VM '{nome_vm}' não encontrada.")
-            conn.close()
-            return False
-
-        xml_atual = dom.XMLDesc(2)  # VIR_DOMAIN_XML_INACTIVE
-        root = ET.fromstring(xml_atual)
-        cpu_elem = root.find("cpu")
-
-        if cpu_elem is None:
-            cpu_elem = ET.SubElement(root, "cpu", mode="host-passthrough")
-            print("[AMX VM] Tag <cpu> criada com mode='host-passthrough'.")
-        else:
-            cpu_elem.set("mode", "host-passthrough")
-            print("[AMX VM] CPU mode atualizado para host-passthrough.")
-
-        flags_para_adicionar = ["amx-tile", "amx-int8", "amx-bf16"]
-        added = []
-        for flag in flags_para_adicionar:
-            existing = cpu_elem.find(f"./feature[@name='{flag}']")
-            if existing is None:
-                ET.SubElement(cpu_elem, "feature", policy="require", name=flag)
-                added.append(flag)
-                print(f"[AMX VM] Feature adicionada: {flag}")
-
-        novo_xml = ET.tostring(root, encoding="utf-8").decode("utf-8")
-        conn.defineXML(novo_xml)
-        print(f"[AMX VM] ✓ AMX ativado no XML da VM '{nome_vm}'. Reinicie a VM para aplicar.")
-        conn.close()
-        return True
-
-    except libvirt.libvirtError as e:
-        print(f"[AMX VM] Erro libvirt: {e}")
-        return False
-    except Exception as e:
-        print(f"[AMX VM] Erro inesperado: {e}")
-        return False
-
-
-# ============================================================================
-# Compatibility helpers (V5 API preserved)
-# ============================================================================
-
-def get_allocated_cores() -> int:
-    """Return the number of cores allocated by `optimize_xeon_environment`."""
-    return _NUCLEOS_ALOCADOS or 0
-
-
-def make_ort_session_options():
-    """Build onnxruntime.SessionOptions tuned for Xeon AVX512/AMX."""
-    import onnxruntime as ort  # type: ignore
-
-    n_cores = _NUCLEOS_ALOCADOS or _detect_physical_cores()
-
-    opts = ort.SessionOptions()
-    opts.intra_op_num_threads = n_cores
-    opts.inter_op_num_threads = 1
-    opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-    opts.enable_cpu_mem_arena = True
-    return opts
-
-
-def get_xeon_status() -> Dict[str, Any]:
-    """V6: return a snapshot of all Xeon runtime flags + capabilities.
-
-    Useful for logging inside the training script.
-    """
-    amx_ok, amx_desc = get_amx_capability()
-    avx_ok, avx_desc = get_avx512_capability()
-    return {
-        "version": "V6",
-        "physical_cores": _NUCLEOS_ALOCADOS or _detect_physical_cores(),
-        "env": {
-            "MKL_ENABLE_INSTRUCTIONS": os.environ.get("MKL_ENABLE_INSTRUCTIONS"),
-            "MKL_NUM_THREADS": os.environ.get("MKL_NUM_THREADS"),
-            "OMP_NUM_THREADS": os.environ.get("OMP_NUM_THREADS"),
-            "MKL_DYNAMIC": os.environ.get("MKL_DYNAMIC"),
-            "DNNL_PRIMITIVE_CACHE_CAPACITY": os.environ.get("DNNL_PRIMITIVE_CACHE_CAPACITY"),
-            "ONEDNN_MAX_CPU_ISA": os.environ.get("ONEDNN_MAX_CPU_ISA"),
-            "KMP_AFFINITY": os.environ.get("KMP_AFFINITY"),
-            "KMP_BLOCKTIME": os.environ.get("KMP_BLOCKTIME"),
-        },
-        "avx512": {"supported": avx_ok, "desc": avx_desc},
-        "amx": {"supported": amx_ok, "desc": amx_desc},
-        "ipex_available": _IPEX_AVAILABLE is True,
-        "init_done": _V6_INIT_DONE,
-    }
-
-
-__all__ = [
-    "optimize_xeon_environment",
-    "apply_ipex_optimization",
-    "fp16_autocast",
-    "benchmark_fp16_matmul",
-    "benchmark_int8_matmul",
-    "ativar_amx_na_vm",
-    "get_avx512_capability",
-    "get_amx_capability",
-    "get_xeon_status",
-    "get_allocated_cores",
-    "make_ort_session_options",
-]