V6.5-7ds cleanup: remove legacy scripts/train_v6_2.py

scripts/train_v6_2.py

@@ -1,1461 +0,0 @@
-"""train_v6_2.py — Treino V6.2 BiGRU_T_version.
-
-V6.2 — PGVECTOR LOOKUP NO NÍVEL DE HIPÓTESE + BATCH_SIZE=16 + 5 datasets × 50
-═══════════════════════════════════════════════════════════════════════════
-
-Diferenças vs V6.1:
-
-1. PGVector lookup no nível de HIPÓTESE (hyp_t.py): antes de aplicar a
-   punição (correção delta), a HypT consulta o mapa SOM via
-   pgvector_lookup_before_punishment(). Se status == COMPLETE (info
-   consolidada no SOM), a punição é DESATIVADA — o modelo confia em y_hat.
-   Se INCOMPLETE/MISSING, a punição é aplicada normalmente.
-
-   User requirement: "ative pgvector_lookup no nível de hipótese (hyp_t.py)
-   para que ele também consulte o mapa antes de aplicar punição".
-
-   Hipótese: se o SOM já tem a info (COMPLETE), o delta se torna redundante —
-   aplicar a correção introduziria ruído desnecessário. A consulta prévia
-   evita esse overhead.
-
-2. BATCH_SIZE = 16 (era 4) — User requirement: "BATCH_SIZE = 16".
-
-3. 5 datasets × 50 samples = 250 total (era 50). User requirement:
-   "capturar métricas no re-treino streaming de 5 datasets (pip install
-   datasets) 50 em 50 samples diversos (streaming_datasets.py)".
-
-4. datasets library instalada (pip install datasets) — streaming real.
-
-5. Xeon V6 sempre ativo (AVX512 + AMX_INT8 + IPEX + OneDNN + FP16).
-
-6. Monitoramento 12/12 + Kohonen + MTP + EWC + PGVector (treino) +
-   PGVector no nível de hipótese (skip_rate, n_complete_skip,
-   n_incomplete_apply, n_missing_apply).
-
-7. Apagar binários ao final (user requirement).
-"""
-from __future__ import annotations
-
-import os
-import sys
-import gc
-import json
-import time
-import psutil
-import math
-import shutil
-import glob
-import random
-from pathlib import Path
-from typing import Optional, Dict, List, Any, Tuple
-
-# ==============================================================================
-# 1. XEON RUNTIME V6 — ATIVAR ANTES DE QUALQUER IMPORT IA
-# ==============================================================================
-os.environ.setdefault("PYTHONUNBUFFERED", "1")
-os.environ.setdefault("TOKENIZERS_PARALLELISM", "true")
-
-sys.path.insert(0, "/home/z/my-project/BiGRU_T_version/src")
-sys.path.insert(0, "/home/z/my-project/scripts")
-
-from bigru_t.utils.xeon_runtime import (  # noqa: E402
-    optimize_xeon_environment,
-    get_xeon_status,
-    fp16_autocast,
-    benchmark_fp16_matmul,
-)
-# V6.1: sempre ativa o Xeon (user requirement: "ativar xeon_runtime.py")
-N_CORES = optimize_xeon_environment(verbose=True)
-XEON_STATUS = get_xeon_status()
-# V6.1: roda benchmark FP16 uma vez para registrar TFLOPS no report
-FP16_BENCH = benchmark_fp16_matmul(size=2000, iters=2)
-
-import torch  # noqa: E402
-import torch.nn as nn  # noqa: E402
-import torch.nn.functional as F  # noqa: E402
-import numpy as np  # noqa: E402
-
-# ==============================================================================
-# 2. IMPORTS DO PROJETO (V6 + V6.1)
-# ==============================================================================
-from bigru_t.model import UnifiedModel, UnifiedModelConfig  # noqa: E402
-from bigru_t.model.orq_cell import OrqCell as OrqCellV6, Kohonen4DConfig  # noqa: E402
-from bigru_t.tokenizer.bbpe_tokenizer import BBPETokenizer, PAD_ID  # noqa: E402
-from bigru_t.training import (  # noqa: E402
-    TripletPrototypeLoss,
-)
-from bigru_t.training.meta_configurator import MetaConfigurator  # noqa: E402
-from bigru_t.training.ewc import EWCV6, EWCConfigV6  # noqa: E402
-from bigru_t.training.mtp import MTPHead, mtp_loss  # noqa: E402
-from bigru_t.training.dynamic_repetition_penalty import DynamicRepetitionPenalty  # noqa: E402
-from bigru_t.training.data_augmentation import DataAugmenter, AugmentationConfig  # noqa: E402
-from bigru_t.training.rlhf_mapping import RLHFMapping  # noqa: E402
-from bigru_t.attention.window_context import WindowContext, WindowContextConfig  # noqa: E402
-from bigru_t.reasoning.thinking import ThinkingSystem, ThinkingConfig  # noqa: E402
-from bigru_t.tools.tool_mutation import ToolMutator  # noqa: E402
-from bigru_t.tools.tool_cache import ToolCache  # noqa: E402
-from bigru_t.utils.memory_cleanup import aggressive_cleanup, get_rss_mb  # noqa: E402
-
-# V6.1: streaming datasets (5 datasets × 10 samples)
-from bigru_t.data.streaming_datasets import (  # noqa: E402
-    stream_dataset,
-    DEFAULT_DATASETS,
-    ProcessedSample,
-)
-
-import logging  # noqa: E402
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [%(levelname)s] %(message)s",
-    datefmt="%H:%M:%S",
-)
-logger = logging.getLogger("train_v6_2")
-
-# ==============================================================================
-# 3. PARÂMETROS V6.1
-# ==============================================================================
-# 5 datasets × 50 samples = 250 total (user requirement V6.2)
-V62_DATASETS = [
-    "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1",
-    "Madras1/corpus-ptbr-v2",
-    "TucanoBR/GigaVerbo",
-    "nvidia/OpenMathInstruct-2",
-    "dominguesm/restore-punctuation-ptbr-dataset",
-]
-N_PER_DATASET = 50  # V6.2: 50 samples por dataset (era 10)
-FALLBACK_SYNTHETIC_PER_DS = 50  # fallback se streaming falhar
-
-EPOCHS = 2
-BATCH_SIZE = 16  # V6.2: era 4 (user requirement)
-MAX_SEQ_LEN = 16
-NUM_LAYERS_HYP = 8
-TRIPLET_WEIGHT = 0.05
-META_INTERVAL = 3
-CLEANUP_INTERVAL = 1
-TRIPLET_EMA_ALPHA = 0.1
-
-# V6 features (mantidas)
-USE_MTP = True
-USE_EWC = True  # V6.1: EWC ATIVADO (skip mask previne NaN)
-USE_KOHONEN_ORQ = True
-MTP_K = 4
-MTP_ENTROPY_BETA = 0.01
-EWC_LAMBDA = 0.0   # V6.1: classic Fisher desativado (causa NaN quando ativado)
-                    # A inovação V6.1 é a skip mask no Fisher Kohonen per-neuron
-                    # (quando todos os neurônios estão filled, EWC contribution = 0)
-EWC_LAMBDA_TOPO = 0.05
-MTP_LOSS_WEIGHT = 0.1
-
-# V6.1 — PGVector thresholds (orq_cell defaults, repeated here for report)
-PGV_COMPLETE_THR = 0.6
-PGV_MISSING_THR = 0.2
-
-REPORT_PATH = "/home/z/my-project/BiGRU_T_version/v6_2_report.json"
-
-
-# ==============================================================================
-# 4. MONITOR V6.2 — 12/12 + Kohonen + MTP + EWC + PGVector + Hyp PGVector
-# ==============================================================================
-class MetricsMonitorV62:
-    """Monitor V6.2: 12/12 + Kohonen SOM + MTP + EWC + PGVector lookup
-    (treino level) + PGVector no nível de hipótese (hyp skip_rate)."""
-
-    def __init__(self):
-        self.history = {
-            # 12/12 metrics
-            "train_loss": [], "val_loss": [], "perplexity": [],
-            "overfitting_gap": [], "eval_benchmark": [],
-            "tokens_per_sec": [], "tflops_per_cpu": [], "mbu_gbps": [],
-            "time_per_step_ms": [], "comm_overhead_ms": [],
-            "grad_norm": [], "cpu_pct": [], "rss_mb": [],
-            "alerts": [], "meta_history": [],
-            # V6 Kohonen
-            "sigma_t": [], "alpha_t": [], "bmu_diversity": [],
-            "map_entropy": [], "neighborhood_spread": [],
-            "bmu_id_mean": [], "update_magnitude": [], "bmu_drift": [],
-            "n_filled": [], "filled_ratio": [],
-            # V6 MTP
-            "mtp_train_loss": [], "mtp_val_loss": [],
-            "mtp_entropy_reg": [], "mtp_alphas": [],
-            # V6 EWC
-            "ewc_penalty": [], "ewc_classic_pen": [],
-            "ewc_kohonen_pen": [], "ewc_topo_pen": [],
-            "n_masked_som_neurons": [],
-            # V6.1 PGVector (treino level)
-            "pgv_status": [],         # str: COMPLETE | INCOMPLETE | MISSING
-            "pgv_coverage": [],       # float: fração de neurônios com sim ≥ missing_thr
-            "pgv_best_sim": [],       # float: similaridade máxima
-            "pgv_n_filled": [],       # int: neurônios filled no mapa
-            "pgv_filled_ratio": [],   # float
-            # V6.2 PGVector no nível de hipótese
-            "hyp_pgv_status": [],              # str: COMPLETE | INCOMPLETE | MISSING | NO_PUNISHMENT
-            "hyp_pgv_apply_punishment": [],    # bool: se True, aplicou delta
-            "hyp_pgv_skipped": [],             # bool: se True, skip pgvector
-            "hyp_pgv_best_sim": [],            # float
-            "hyp_pgv_coverage": [],            # float
-            "hyp_pgv_n_complete_skip": [],     # int: contador acumulado
-            "hyp_pgv_n_incomplete_apply": [],  # int: contador acumulado
-            "hyp_pgv_n_missing_apply": [],     # int: contador acumulado
-            "hyp_pgv_skip_rate": [],           # float: n_complete_skip / n_decided
-            # V6.1 dataset tracking
-            "dataset_source": [],     # str: nome do dataset da sample
-        }
-        self.prev_loss = None
-        self.process = psutil.Process(os.getpid())
-
-    def record_step(self, step, train_loss, n_tokens, elapsed_s, grad_norm,
-                    flops_estimate=0.0, kohonen_aux=None, mtp_metrics=None,
-                    ewc_metrics=None, pgv_metrics=None, hyp_pgv_metrics=None,
-                    dataset_name=None):
-        tps = n_tokens / max(elapsed_s, 1e-6)
-        tflops = flops_estimate / max(elapsed_s, 1e-6) / 1e12
-        tps_ms = elapsed_s * 1000.0
-        cpu_pct = self.process.cpu_percent(interval=None)
-        rss_mb = get_rss_mb()
-
-        spike_alert = False
-        if self.prev_loss is not None and self.prev_loss > 0:
-            delta_pct = abs(train_loss - self.prev_loss) / self.prev_loss
-            if delta_pct > 0.5:
-                spike_alert = True
-                self.history["alerts"].append({"step": step, "type": "loss_spike", "delta_pct": delta_pct})
-        self.prev_loss = train_loss
-
-        grad_alert = None
-        if grad_norm < 1e-7:
-            grad_alert = "vanishing"
-        elif grad_norm > 1e3:
-            grad_alert = "exploding"
-        if grad_alert:
-            self.history["alerts"].append({"step": step, "type": f"grad_{grad_alert}"})
-
-        if cpu_pct < 80.0 and step > 1:
-            self.history["alerts"].append({"step": step, "type": "cpu_underutilization", "cpu_pct": cpu_pct})
-
-        if len(self.history["alerts"]) > 50:
-            self.history["alerts"] = self.history["alerts"][-50:]
-
-        self.history["train_loss"].append(train_loss)
-        self.history["tokens_per_sec"].append(tps)
-        self.history["tflops_per_cpu"].append(tflops)
-        self.history["mbu_gbps"].append(0.0)
-        self.history["time_per_step_ms"].append(tps_ms)
-        self.history["comm_overhead_ms"].append(0.0)
-        self.history["grad_norm"].append(grad_norm)
-        self.history["cpu_pct"].append(cpu_pct)
-        self.history["rss_mb"].append(rss_mb)
-
-        if kohonen_aux:
-            for k in ["sigma_t", "alpha_t", "bmu_diversity", "map_entropy",
-                      "neighborhood_spread", "bmu_id_mean",
-                      "update_magnitude", "bmu_drift",
-                      "n_filled", "filled_ratio"]:
-                self.history[k].append(kohonen_aux.get(k, 0))
-        if mtp_metrics:
-            self.history["mtp_train_loss"].append(mtp_metrics.get("total_loss", 0))
-            self.history["mtp_entropy_reg"].append(mtp_metrics.get("entropy_reg", 0))
-            self.history["mtp_alphas"].append(mtp_metrics.get("alphas", []))
-        if ewc_metrics:
-            self.history["ewc_penalty"].append(ewc_metrics.get("total_pen", 0))
-            self.history["ewc_classic_pen"].append(ewc_metrics.get("classic_pen", 0))
-            self.history["ewc_kohonen_pen"].append(ewc_metrics.get("kohonen_pen", 0))
-            self.history["ewc_topo_pen"].append(ewc_metrics.get("topo_pen", 0))
-            self.history["n_masked_som_neurons"].append(ewc_metrics.get("n_masked_som_neurons", 0))
-        if pgv_metrics:
-            self.history["pgv_status"].append(pgv_metrics.get("status", "UNKNOWN"))
-            self.history["pgv_coverage"].append(pgv_metrics.get("coverage_ratio", 0))
-            self.history["pgv_best_sim"].append(pgv_metrics.get("best_sim", 0))
-            self.history["pgv_n_filled"].append(pgv_metrics.get("n_filled", 0))
-            self.history["pgv_filled_ratio"].append(pgv_metrics.get("filled_ratio", 0))
-        # V6.2: Hyp PGVector (nível de hipótese)
-        if hyp_pgv_metrics is not None:
-            self.history["hyp_pgv_status"].append(hyp_pgv_metrics.get("status", "UNKNOWN"))
-            self.history["hyp_pgv_apply_punishment"].append(
-                1 if hyp_pgv_metrics.get("apply_punishment", False) else 0)
-            self.history["hyp_pgv_skipped"].append(
-                1 if hyp_pgv_metrics.get("skipped_by_pgvector", False) else 0)
-            self.history["hyp_pgv_best_sim"].append(hyp_pgv_metrics.get("best_sim", 0))
-            self.history["hyp_pgv_coverage"].append(hyp_pgv_metrics.get("coverage", 0))
-            # Contadores acumulados do HypT
-            stats = hyp_pgv_metrics.get("hyp_stats", {})
-            self.history["hyp_pgv_n_complete_skip"].append(stats.get("n_complete_skip", 0))
-            self.history["hyp_pgv_n_incomplete_apply"].append(stats.get("n_incomplete_apply", 0))
-            self.history["hyp_pgv_n_missing_apply"].append(stats.get("n_missing_apply", 0))
-            self.history["hyp_pgv_skip_rate"].append(stats.get("skip_rate", 0))
-        if dataset_name:
-            self.history["dataset_source"].append(dataset_name)
-
-        if step % 5 == 0 or step == 1 or spike_alert or grad_alert:
-            kohonen_str = ""
-            if kohonen_aux:
-                kohonen_str = (f" σ={kohonen_aux.get('sigma_t', 0):.3f}"
-                               f" α={kohonen_aux.get('alpha_t', 0):.3f}"
-                               f" BMUdiv={kohonen_aux.get('bmu_diversity', 0)}"
-                               f" filled={kohonen_aux.get('n_filled', 0)}/8")
-            pgv_str = ""
-            if pgv_metrics:
-                pgv_str = f" PGV={pgv_metrics.get('status', '?')[:4]} cov={pgv_metrics.get('coverage_ratio', 0):.2f}"
-            # V6.2: Hyp PGVector
-            hyp_pgv_str = ""
-            if hyp_pgv_metrics is not None:
-                h_status = hyp_pgv_metrics.get("status", "?")[:4]
-                h_apply = "Δ" if hyp_pgv_metrics.get("apply_punishment", False) else "—"
-                hyp_pgv_str = f" HYP={h_status}{h_apply}"
-            logger.info(
-                f"  step {step:3d} | loss={train_loss:.4f} | tps={tps:.0f} | "
-                f"step_ms={tps_ms:.0f} | ||g||={grad_norm:.2f} | cpu%={cpu_pct:.0f} | "
-                f"rss={rss_mb:.0f}MB" + kohonen_str + pgv_str + hyp_pgv_str
-                + (" ⚠️SPIKE" if spike_alert else "")
-                + (f" ⚠️GRAD_{grad_alert}" if grad_alert else "")
-            )
-
-    def record_epoch(self, epoch, val_loss, train_loss_avg, eval_acc, mtp_val_loss=None):
-        ppl = math.exp(min(val_loss, 20.0))
-        gap = train_loss_avg - val_loss
-        self.history["val_loss"].append(val_loss)
-        self.history["perplexity"].append(ppl)
-        self.history["overfitting_gap"].append(gap)
-        self.history["eval_benchmark"].append(eval_acc)
-        if mtp_val_loss is not None:
-            self.history["mtp_val_loss"].append(mtp_val_loss)
-        logger.info(
-            f"  EPOCH {epoch} | val_loss={val_loss:.4f} | train_avg={train_loss_avg:.4f} | "
-            f"ppl={ppl:.2f} | gap={gap:+.4f} | eval_acc={eval_acc:.2%}"
-            + (f" | mtp_val={mtp_val_loss:.4f}" if mtp_val_loss is not None else "")
-        )
-
-    def record_meta(self, meta_result):
-        self.history["meta_history"].append({
-            "T": meta_result.get("T_new", 0),
-            "tau": meta_result.get("tau_new", 0),
-            "lambda_ent": meta_result.get("lambda_ent_new", 0),
-            "init_gate": meta_result.get("init_gate_new", 0),
-            "meta_loss": meta_result.get("meta_loss", 0),
-            "sharpness": meta_result.get("sharpness", 0),
-        })
-
-    def summary(self):
-        h = self.history
-        rss_trend = "stable"
-        if len(h["rss_mb"]) >= 3:
-            if h["rss_mb"][-1] > h["rss_mb"][0] * 1.5:
-                rss_trend = "growing"
-            elif h["rss_mb"][-1] < h["rss_mb"][0] * 0.8:
-                rss_trend = "shrinking"
-        # V6.1 — PGVector status distribution
-        pgv_status_counts = {"COMPLETE": 0, "INCOMPLETE": 0, "MISSING": 0}
-        for s in h["pgv_status"]:
-            pgv_status_counts[s] = pgv_status_counts.get(s, 0) + 1
-        # V6.2 — Hyp PGVector status distribution (nível de hipótese)
-        hyp_pgv_status_counts = {
-            "COMPLETE": 0, "INCOMPLETE": 0, "MISSING": 0, "NO_PUNISHMENT": 0,
-        }
-        for s in h["hyp_pgv_status"]:
-            hyp_pgv_status_counts[s] = hyp_pgv_status_counts.get(s, 0) + 1
-        # V6.1 — Dataset distribution
-        ds_counts: Dict[str, int] = {}
-        for d in h["dataset_source"]:
-            ds_counts[d] = ds_counts.get(d, 0) + 1
-        return {
-            "n_steps": len(h["train_loss"]),
-            "n_epochs": len(h["val_loss"]),
-            "final_train_loss": h["train_loss"][-1] if h["train_loss"] else None,
-            "final_val_loss": h["val_loss"][-1] if h["val_loss"] else None,
-            "final_perplexity": h["perplexity"][-1] if h["perplexity"] else None,
-            "final_overfitting_gap": h["overfitting_gap"][-1] if h["overfitting_gap"] else None,
-            "final_eval_benchmark": h["eval_benchmark"][-1] if h["eval_benchmark"] else None,
-            "avg_tokens_per_sec": sum(h["tokens_per_sec"]) / max(1, len(h["tokens_per_sec"])),
-            "avg_tflops_per_cpu": sum(h["tflops_per_cpu"]) / max(1, len(h["tflops_per_cpu"])),
-            "avg_time_per_step_ms": sum(h["time_per_step_ms"]) / max(1, len(h["time_per_step_ms"])),
-            "avg_grad_norm": sum(h["grad_norm"]) / max(1, len(h["grad_norm"])),
-            "avg_cpu_pct": sum(h["cpu_pct"]) / max(1, len(h["cpu_pct"])),
-            "final_rss_mb": h["rss_mb"][-1] if h["rss_mb"] else None,
-            "max_rss_mb": max(h["rss_mb"]) if h["rss_mb"] else None,
-            "rss_trend": rss_trend,
-            "n_alerts": len(h["alerts"]),
-            "alerts": h["alerts"][:20],
-            "alert_types": list({a["type"] for a in h["alerts"]}),
-            "meta_history": h["meta_history"],
-            "kohonen_evolution": {
-                "sigma_t": h["sigma_t"],
-                "alpha_t": h["alpha_t"],
-                "bmu_diversity": h["bmu_diversity"],
-                "map_entropy": h["map_entropy"],
-                "neighborhood_spread": h["neighborhood_spread"],
-                "update_magnitude": h["update_magnitude"],
-                "bmu_drift": h["bmu_drift"],
-                "n_filled": h["n_filled"],
-                "filled_ratio": h["filled_ratio"],
-                "final_sigma_t": h["sigma_t"][-1] if h["sigma_t"] else None,
-                "final_alpha_t": h["alpha_t"][-1] if h["alpha_t"] else None,
-                "sigma_decay": (h["sigma_t"][0] - h["sigma_t"][-1]) if len(h["sigma_t"]) >= 2 else 0,
-                "alpha_decay": (h["alpha_t"][0] - h["alpha_t"][-1]) if len(h["alpha_t"]) >= 2 else 0,
-                "final_n_filled": h["n_filled"][-1] if h["n_filled"] else 0,
-                "final_filled_ratio": h["filled_ratio"][-1] if h["filled_ratio"] else 0,
-            },
-            "mtp_evolution": {
-                "train_loss": h["mtp_train_loss"],
-                "val_loss": h["mtp_val_loss"],
-                "entropy_reg": h["mtp_entropy_reg"],
-                "final_alphas": h["mtp_alphas"][-1] if h["mtp_alphas"] else None,
-            },
-            "ewc_evolution": {
-                "total_penalty": h["ewc_penalty"],
-                "classic_pen": h["ewc_classic_pen"],
-                "kohonen_pen": h["ewc_kohonen_pen"],
-                "topo_pen": h["ewc_topo_pen"],
-                "n_masked_som_neurons": h["n_masked_som_neurons"],
-            },
-            # V6.1 — PGVector evolution
-            "pgvector_evolution": {
-                "status_per_step": h["pgv_status"],
-                "status_counts": pgv_status_counts,
-                "coverage_ratio": h["pgv_coverage"],
-                "best_sim": h["pgv_best_sim"],
-                "n_filled": h["pgv_n_filled"],
-                "filled_ratio": h["pgv_filled_ratio"],
-                "final_coverage": h["pgv_coverage"][-1] if h["pgv_coverage"] else None,
-                "final_best_sim": h["pgv_best_sim"][-1] if h["pgv_best_sim"] else None,
-                "final_n_filled": h["pgv_n_filled"][-1] if h["pgv_n_filled"] else 0,
-                "final_filled_ratio": h["pgv_filled_ratio"][-1] if h["pgv_filled_ratio"] else 0,
-            },
-            # V6.2 — Hyp PGVector evolution (nível de hipótese)
-            "hyp_pgvector_evolution": {
-                "status_per_step": h["hyp_pgv_status"],
-                "status_counts": hyp_pgv_status_counts,
-                "apply_punishment_per_step": h["hyp_pgv_apply_punishment"],
-                "skipped_per_step": h["hyp_pgv_skipped"],
-                "best_sim": h["hyp_pgv_best_sim"],
-                "coverage": h["hyp_pgv_coverage"],
-                "n_complete_skip": h["hyp_pgv_n_complete_skip"],
-                "n_incomplete_apply": h["hyp_pgv_n_incomplete_apply"],
-                "n_missing_apply": h["hyp_pgv_n_missing_apply"],
-                "skip_rate": h["hyp_pgv_skip_rate"],
-                "final_n_complete_skip": h["hyp_pgv_n_complete_skip"][-1] if h["hyp_pgv_n_complete_skip"] else 0,
-                "final_n_incomplete_apply": h["hyp_pgv_n_incomplete_apply"][-1] if h["hyp_pgv_n_incomplete_apply"] else 0,
-                "final_n_missing_apply": h["hyp_pgv_n_missing_apply"][-1] if h["hyp_pgv_n_missing_apply"] else 0,
-                "final_skip_rate": h["hyp_pgv_skip_rate"][-1] if h["hyp_pgv_skip_rate"] else 0,
-                "final_best_sim": h["hyp_pgv_best_sim"][-1] if h["hyp_pgv_best_sim"] else 0,
-                "final_coverage": h["hyp_pgv_coverage"][-1] if h["hyp_pgv_coverage"] else 0,
-            },
-            # V6.1 — Dataset tracking
-            "dataset_distribution": ds_counts,
-        }
-
-
-# ==============================================================================
-# 5. LOAD 5 DATASETS × 50 SAMPLES (com fallback sintético expandido)
-# ==============================================================================
-def _generate_synth_samples(ds_name: str, n: int) -> List[str]:
-    """Gera n samples sintéticos diversos para um dataset.
-
-    V6.2: agora gera até 50 samples por dataset usando templates
-    variados + fatores aleatórios (rng com seed por dataset para
-    reprodutibilidade).
-    """
-    rng = random.Random(hash(ds_name) & 0xFFFFFFFF)
-
-    # Templates base por categoria (cada template tem placeholders {n}, {word})
-    templates_by_ds = {
-        "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1": [
-            "Olá, como você está hoje?",
-            "Bom dia! Posso ajudar com algo?",
-            "Qual é a capital do Brasil?",
-            "Me conte uma curiosidade sobre o espaço.",
-            "Como funciona o aprendizado de máquina?",
-            "Traduza '{word}' para português.",
-            "Escreva um poema curto sobre o mar.",
-            "Quem foi Machado de Assis?",
-            "Explique a teoria da relatividade.",
-            "Liste {n} benefícios do exercício físico.",
-            "Qual a diferença entre CPU e GPU?",
-            "Me ajude a escrever um email formal.",
-            "Receita de bolo de chocolate simples.",
-            "Como declarar imposto de renda?",
-            "Melhores livros de ficção científica.",
-        ],
-        "Madras1/corpus-ptbr-v2": [
-            "A literatura brasileira é riquíssima e diversa.",
-            "O café é uma das bebidas mais consumidas no mundo.",
-            "A Amazônia abriga milhões de espécies.",
-            "São Paulo é a maior cidade do Brasil.",
-            "O carnaval é uma festa tradicional brasileira.",
-            "A música popular brasileira tem raízes africanas.",
-            "O futebol é o esporte mais popular do país.",
-            "A culinária regional varia muito entre estados.",
-            "A língua portuguesa tem origem no latim vulgar.",
-            "A história do Brasil começou em 1500.",
-            "O Pantanal é a maior planície alagada do mundo.",
-            "A bossa nova influenciou a música mundial.",
-            "A arquitetura colonial brasileira é patrimônio.",
-            "O Jabuti é um personagem do folclore brasileiro.",
-            "A capoeira mistura dança e marciais.",
-        ],
-        "TucanoBR/GigaVerbo": [
-            "O verbo é a palavra que indica ação.",
-            "Conjugue o verbo '{word}' no presente.",
-            "Os verbos irregulares merecem atenção especial.",
-            "O infinitivo é a forma nominal do verbo.",
-            "O gerúndio termina em -ndo em português.",
-            "O particípio é usado nos tempos compostos.",
-            "Verbos transitivos exigem objeto direto.",
-            "Verbos intransitivos não exigem objeto.",
-            "A voz passiva transforma o sujeito em paciente.",
-            "O imperativo é usado para dar ordens.",
-            "Verbos auxiliares formam tempos compostos.",
-            "Conjunção coordena orações independentes.",
-            "O subjuntivo expressa desejo ou hipótese.",
-            "A crase ocorre em fusão de preposição e artigo.",
-            "Advérbios modificam verbos, adjetivos ou advérbios.",
-        ],
-        "nvidia/OpenMathInstruct-2": [
-            "Problema: calcule {a} × {b}. Solução: {prod}.",
-            "Problema: qual é a raiz de {sq}? Solução: {sqrt}.",
-            "Problema: some {a} + {b}. Solução: {sum}.",
-            "Problema: divida {a} por {b}. Solução: {div}.",
-            "Problema: calcule {a}² + {b}². Solução: {ssq}.",
-            "Problema: qual é o MDC de {a} e {b}? Solução: {mdc}.",
-            "Problema: converta 1/{b} para decimal. Solução: {dec}.",
-            "Problema: calcule {pct}% de {a}. Solução: {res}.",
-            "Problema: perímetro de quadrado {a}×{a}? Solução: {per}.",
-            "Problema: resolva {a}x + {b} = {c}. Solução: x = {x}.",
-            "Problema: área do triângulo base {a} altura {b}? Solução: {area}.",
-            "Problema: {a}! = ? Solução: {fat}.",
-            "Problema: log10({a}) = ? Solução: {log}.",
-            "Problema: {a} mod {b} = ? Solução: {mod}.",
-            "Problema: potência {a}^{b} = ? Solução: {pot}.",
-        ],
-        "dominguesm/restore-punctuation-ptbr-dataset": [
-            "o gato subiu no telhado",
-            "a chuva caiu a noite toda",
-            "são paulo é uma cidade grande",
-            "joão e maria foram passear",
-            "o livro está sobre a mesa",
-            "amanhã vou ao mercado comprar pão",
-            "o sol nasce no leste",
-            "ela canta muito bem",
-            "o carro parou no sinal vermelho",
-            "os alunos estudaram para a prova",
-            "a professora explicou a matéria",
-            "o cachorro latiu para o carteiro",
-            "as flores floresceram na primavera",
-            "o trem chegou na estação",
-            "as crianças brincam no parque",
-        ],
-    }
-    word_pool = ["hello", "world", "goodbye", "friend", "love", "happy",
-                 "morning", "night", "music", "book", "water", "sun",
-                 "moon", "star", "rain", "wind", "fire", "earth", "sky",
-                 "tree", "flower", "bird", "fish", "house", "door"]
-    templates = templates_by_ds.get(ds_name, [f"sample {i} para {ds_name}" for i in range(n)])
-
-    out = []
-    for i in range(n):
-        t = templates[i % len(templates)]
-        # Substitui placeholders
-        a = rng.randint(2, 30)
-        b = rng.randint(2, 12)
-        try:
-            text = t.format(
-                n=rng.randint(2, 5),
-                word=rng.choice(word_pool),
-                a=a, b=b,
-                prod=a * b,
-                sq=a * a,
-                sqrt=int(math.isqrt(a * a)),
-                sum=a + b,
-                div=a / b,
-                ssq=a * a + b * b,
-                mdc=math.gcd(a, b),
-                dec=round(1 / b, 4),
-                pct=rng.randint(10, 50),
-                res=int(a * rng.randint(10, 50) / 100),
-                per=a * 4,
-                c=a * 2 + b,
-                x=2,
-                area=int(a * b / 2),
-                fat=int(math.factorial(min(a, 6))),
-                log=round(math.log10(max(a, 2)), 3),
-                mod=a % b,
-                pot=a ** min(b, 4),
-            )
-        except (KeyError, ValueError):
-            text = t
-        out.append(text)
-    return out
-
-
-def load_v62_samples(tokenizer, max_seq_len, hf_token=None):
-    """Carrega 5 datasets × 50 samples do streaming_datasets.py (V6.2).
-
-    Para cada dataset, tenta 50 samples reais via stream_dataset().
-    Se o streaming falhar (rede, auth, etc.), usa 50 samples sintéticos
-    da categoria equivalente (mantém o tracking de dataset_name).
-
-    V6.2: datasets library agora instalada (pip install datasets).
-    """
-    samples = []
-    rng = random.Random(42)
-
-    # V6.2: per-dataset timeout (segundos) — streaming pode ser lento,
-    # então limitamos o tempo por dataset. Se o timeout expirar, usamos
-    # o que foi coletado + completamos com sintéticos.
-    PER_DS_TIMEOUT_S = 90  # 90s por dataset (5 datasets × 90s = 7.5min max)
-    # V6.2: flag para bypass streaming — em ambientes com rede lenta,
-    # usar apenas sintéticos (valida toda a arquitetura V6.2 sem depender
-    # de download de datasets). Caso True, N_PER_DATASET sintéticos por ds.
-    BYPASS_STREAMING = True  # streaming lento no env → sintéticos diversos
-
-    for ds_name in V62_DATASETS:
-        if BYPASS_STREAMING:
-            logger.info(f"  [SYNTH] {ds_name} (BYPASS_STREAMING=True, {N_PER_DATASET} samples sintéticos)")
-            synth_texts = _generate_synth_samples(ds_name, N_PER_DATASET)
-            for text in synth_texts[:N_PER_DATASET]:
-                ids = tokenizer.encode(text)
-                if len(ids) > max_seq_len:
-                    ids = ids[:max_seq_len]
-                else:
-                    ids = ids + [PAD_ID] * (max_seq_len - len(ids))
-                first_word = text.split()[0] if text.split() else "ok"
-                label_ids = tokenizer.encode(first_word)
-                if len(label_ids) > max_seq_len:
-                    label_ids = label_ids[:max_seq_len]
-                else:
-                    label_ids = label_ids + [PAD_ID] * (max_seq_len - len(label_ids))
-                samples.append({
-                    "input_ids": torch.tensor(ids, dtype=torch.long),
-                    "label_ids": torch.tensor(label_ids, dtype=torch.long),
-                    "label_text": first_word,
-                    "type": "synthetic_bypass",
-                    "answer": "",
-                    "dataset": ds_name,
-                })
-            continue
-        logger.info(f"  [STREAM] Loading {ds_name} (max {N_PER_DATASET} samples, timeout={PER_DS_TIMEOUT_S}s)...")
-        ds_samples = []
-        ds_t0 = time.perf_counter()
-        try:
-            count = 0
-            for sample in stream_dataset(
-                ds_name,
-                max_samples=N_PER_DATASET,
-                hf_token=hf_token,
-            ):
-                if count >= N_PER_DATASET:
-                    break
-                # V6.2: timeout check
-                if (time.perf_counter() - ds_t0) > PER_DS_TIMEOUT_S:
-                    logger.info(f"    ⏱ timeout {PER_DS_TIMEOUT_S}s atingido com {count}/{N_PER_DATASET} samples")
-                    break
-                text = sample.raw_text[:200] if sample.raw_text else None
-                if not text or len(text) < 5:
-                    continue
-                ids = tokenizer.encode(text)
-                if len(ids) > max_seq_len:
-                    ids = ids[:max_seq_len]
-                else:
-                    ids = ids + [PAD_ID] * (max_seq_len - len(ids))
-                # label = primeira palavra
-                first_word = text.split()[0] if text.split() else "ok"
-                label_ids = tokenizer.encode(first_word)
-                if len(label_ids) > max_seq_len:
-                    label_ids = label_ids[:max_seq_len]
-                else:
-                    label_ids = label_ids + [PAD_ID] * (max_seq_len - len(label_ids))
-                ds_samples.append({
-                    "input_ids": torch.tensor(ids, dtype=torch.long),
-                    "label_ids": torch.tensor(label_ids, dtype=torch.long),
-                    "label_text": first_word,
-                    "type": "streaming",
-                    "answer": "",
-                    "dataset": ds_name,
-                })
-                count += 1
-            if count > 0:
-                logger.info(f"    ✓ {count} samples reais carregados de {ds_name}")
-                samples.extend(ds_samples)
-                if count < N_PER_DATASET:
-                    # Completa com sintéticos se streaming retornou menos
-                    needed = N_PER_DATASET - count
-                    logger.info(f"    + {needed} samples sintéticos para completar {ds_name}")
-                    synth_texts = _generate_synth_samples(ds_name, needed)
-                    for text in synth_texts[:needed]:
-                        ids = tokenizer.encode(text)
-                        if len(ids) > max_seq_len:
-                            ids = ids[:max_seq_len]
-                        else:
-                            ids = ids + [PAD_ID] * (max_seq_len - len(ids))
-                        first_word = text.split()[0] if text.split() else "ok"
-                        label_ids = tokenizer.encode(first_word)
-                        if len(label_ids) > max_seq_len:
-                            label_ids = label_ids[:max_seq_len]
-                        else:
-                            label_ids = label_ids + [PAD_ID] * (max_seq_len - len(label_ids))
-                        samples.append({
-                            "input_ids": torch.tensor(ids, dtype=torch.long),
-                            "label_ids": torch.tensor(label_ids, dtype=torch.long),
-                            "label_text": first_word,
-                            "type": "synthetic_complement",
-                            "answer": "",
-                            "dataset": ds_name,
-                        })
-                continue
-            else:
-                logger.warning(f"    ⚠ nenhuma sample de {ds_name}, usando fallback sintético")
-        except Exception as e:
-            logger.warning(f"    ⚠ streaming falhou para {ds_name}: {type(e).__name__}: {str(e)[:80]}")
-            logger.warning(f"    usando fallback sintético")
-
-        # Fallback sintético — 50 samples por dataset (V6.2)
-        synth_texts = _generate_synth_samples(ds_name, N_PER_DATASET)
-        for text in synth_texts[:N_PER_DATASET]:
-            ids = tokenizer.encode(text)
-            if len(ids) > max_seq_len:
-                ids = ids[:max_seq_len]
-            else:
-                ids = ids + [PAD_ID] * (max_seq_len - len(ids))
-            first_word = text.split()[0] if text.split() else "ok"
-            label_ids = tokenizer.encode(first_word)
-            if len(label_ids) > max_seq_len:
-                label_ids = label_ids[:max_seq_len]
-            else:
-                label_ids = label_ids + [PAD_ID] * (max_seq_len - len(label_ids))
-            samples.append({
-                "input_ids": torch.tensor(ids, dtype=torch.long),
-                "label_ids": torch.tensor(label_ids, dtype=torch.long),
-                "label_text": first_word,
-                "type": "synthetic_fallback",
-                "answer": "",
-                "dataset": ds_name,
-            })
-
-    logger.info(f"  Total samples: {len(samples)} ({len(V62_DATASETS)} datasets × até {N_PER_DATASET} samples)")
-    return samples
-
-
-# ==============================================================================
-# 6. MCQ EVAL (igual V6)
-# ==============================================================================
-def make_mini_mcq(n_questions: int = 8):
-    questions = []
-    for i in range(n_questions):
-        a, b = i + 1, (i * 2) % 10 + 1
-        correct = a + b
-        question = f"What is {a} + {b}?"
-        options = [correct, correct + 1, correct - 1, correct + 2]
-        rng = random.Random(i)
-        rng.shuffle(options)
-        correct_idx = options.index(correct)
-        questions.append({
-            "question": question,
-            "options": [str(o) for o in options],
-            "correct_idx": correct_idx,
-        })
-    return questions
-
-
-def evaluate_mcq(model, tokenizer, mcq):
-    model.eval()
-    correct = 0
-    with torch.no_grad():
-        for q in mcq:
-            q_ids = tokenizer.encode(q["question"])
-            if len(q_ids) < MAX_SEQ_LEN:
-                q_ids = q_ids + [PAD_ID] * (MAX_SEQ_LEN - len(q_ids))
-            else:
-                q_ids = q_ids[:MAX_SEQ_LEN]
-            x = torch.tensor(q_ids, dtype=torch.long).unsqueeze(0)
-            try:
-                y_hat, delta = model(x, use_hypothesis=True)
-                logprobs = F.log_softmax((y_hat + delta)[0], dim=-1)
-                option_scores = []
-                for opt in q["options"]:
-                    opt_ids = tokenizer.encode(opt)
-                    if len(opt_ids) == 0:
-                        opt_ids = [PAD_ID]
-                    score = logprobs[opt_ids[0]].item()
-                    option_scores.append(score)
-                pred = int(np.argmax(option_scores))
-                if pred == q["correct_idx"]:
-                    correct += 1
-            except (RuntimeError, IndexError):
-                continue
-    model.train()
-    return correct / max(1, len(mcq))
-
-
-# ==============================================================================
-# 7. DELETE BINARIES
-# ==============================================================================
-def delete_training_binaries():
-    """Deleta binários do treinamento."""
-    deleted = []
-    patterns = [
-        "/home/z/my-project/BiGRU_T_version/model_final/*.bin",
-        "/home/z/my-project/BiGRU_T_version/model_final/*.pt",
-        "/home/z/my-project/BiGRU_T_version/model_final/*.pth",
-        "/home/z/my-project/BiGRU_T_version/model_final/*.safetensors",
-        "/home/z/my-project/BiGRU_T_version/**/*.bin",
-        "/home/z/my-project/BiGRU_T_version/**/*.pt",
-    ]
-    for pattern in patterns:
-        for filepath in glob.glob(pattern, recursive=True):
-            try:
-                os.remove(filepath)
-                deleted.append(filepath)
-                logger.info(f"  [BIN DELETE] {filepath}")
-            except OSError:
-                pass
-    return deleted
-
-
-# ==============================================================================
-# 8. MAIN
-# ==============================================================================
-def main():
-    logger.info("=" * 72)
-    logger.info("TRAIN V6.2 — BiGRU_T_version")
-    logger.info("PGVector-like lookup + EWC math upgrade + 5 datasets × 10 samples")
-    logger.info("=" * 72)
-
-    logger.info(f"Xeon V6: cores={XEON_STATUS['physical_cores']}, "
-                f"AMX={XEON_STATUS['amx']['supported']}, "
-                f"IPEX={XEON_STATUS['ipex_available']}")
-    logger.info(f"FP16 benchmark: best_tflops={FP16_BENCH.get('best_tflops', 'N/A')}")
-
-    # Tokenizer
-    tokenizer_path = "/home/z/my-project/BiGRU_T_version/model_final/tokenizer/tokenizer.json"
-    if os.path.exists(tokenizer_path):
-        try:
-            tokenizer = BBPETokenizer.load(tokenizer_path)
-            logger.info(f"Tokenizer loaded (vocab={tokenizer.vocab_size})")
-        except Exception as e:
-            logger.warning(f"Failed to load tokenizer ({e}), fitting inline")
-            tokenizer = BBPETokenizer(vocab_size=256)
-            tokenizer.fit_on_texts(["hello world", "machine learning"])
-    else:
-        tokenizer = BBPETokenizer(vocab_size=256)
-        tokenizer.fit_on_texts(["hello world", "machine learning"])
-        logger.info(f"Tokenizer fitted inline (vocab={tokenizer.vocab_size})")
-
-    # Build model
-    logger.info("\n[1] Building UnifiedModel...")
-    cfg = UnifiedModelConfig(
-        vocab_size=tokenizer.vocab_size,
-        d_model=128,
-        max_modules=8,
-        num_layers_hyp=NUM_LAYERS_HYP,
-        max_seq_len=MAX_SEQ_LEN,
-    )
-    model = UnifiedModel(cfg)
-    n_params = sum(p.numel() for p in model.parameters())
-    logger.info(f"  Model params: {n_params/1e6:.2f}M")
-
-    # V6.1: REPLACE model.orq_cell with V6 Kohonen 4D SOM
-    if USE_KOHONEN_ORQ:
-        logger.info("\n[2] Replacing OrqCell with V6.1 Kohonen 4D SOM (PGVector-ready)...")
-        orq_v6 = OrqCellV6(Kohonen4DConfig(
-            d_cache=cfg.d_cache,
-            d_model_in=cfg.output_dim_u8cell,
-            nhead=cfg.nhead_orq,
-            d_ff=cfg.d_ff_orq,
-            total_steps=100,
-            pgvector_complete_thr=PGV_COMPLETE_THR,
-            pgvector_missing_thr=PGV_MISSING_THR,
-        ))
-        device = next(model.parameters()).device
-        orq_v6 = orq_v6.to(device)
-        old_orq = model.orq_cell
-        model.orq_cell = orq_v6
-        del old_orq
-        logger.info(f"  OrqCell V6.1 installed: "
-                    f"n_neurons={orq_v6.cfg.n_neurons}, "
-                    f"grid={orq_v6.cfg.grid_shape}, "
-                    f"PGV thresholds: complete≥{PGV_COMPLETE_THR}, missing<{PGV_MISSING_THR}")
-
-    # V6 MTP head
-    mtp_head = None
-    if USE_MTP:
-        mtp_head = MTPHead(
-            hidden_size=cfg.d_cache,
-            vocab_size=tokenizer.vocab_size,
-            K=MTP_K,
-        )
-        mtp_head = mtp_head.to(device)
-        logger.info(f"  MTP head initialized: K={MTP_K}")
-
-    # V6 Data augmenter
-    augmenter = DataAugmenter(AugmentationConfig(
-        vocab_size=tokenizer.vocab_size,
-        p_token_dropout=0.05,
-        p_cutout=0.03,
-    ))
-
-    # V6 Tool system (smoke test)
-    cache = ToolCache(max_size=128)
-    mutator = ToolMutator(mutation_rate=0.1, max_variants=2)
-    mutator.register("encoder_layer", nn.Linear(cfg.d_model, cfg.d_model))
-
-    # V6.1 EWC — inicializado após epoch 1
-    ewc = None
-
-    # Optimizer
-    optimizer = torch.optim.AdamW(
-        list(model.parameters()) + list(mtp_head.parameters() if mtp_head is not None else []),
-        lr=3e-4, weight_decay=0.01,
-    )
-
-    # TripletPrototypeLoss
-    triplet_loss = TripletPrototypeLoss(margin=0.3, lambda_triplet=TRIPLET_WEIGHT)
-    prototypes = torch.zeros(cfg.max_modules, cfg.d_cache, requires_grad=False)
-
-    # MetaConfigurator
-    meta_cfg = MetaConfigurator(model)
-
-    # Monitor V6.1
-    monitor = MetricsMonitorV62()
-
-    # =====================================================================
-    # LOAD 5 DATASETS × 10 SAMPLES
-    # =====================================================================
-    logger.info("\n[3] Loading 5 datasets × 10 samples (streaming + synthetic fallback)...")
-    hf_token = os.environ.get("HF_TOKEN")
-    samples = load_v62_samples(tokenizer, MAX_SEQ_LEN, hf_token=hf_token)
-    n_total = len(samples)
-    n_train = int(0.8 * n_total)
-    train_samples = samples[:n_train]
-    val_samples = samples[n_train:]
-    logger.info(f"  Train: {len(train_samples)} | Val: {len(val_samples)}")
-    # Report datasets distribution
-    ds_dist: Dict[str, int] = {}
-    for s in samples:
-        ds_dist[s["dataset"]] = ds_dist.get(s["dataset"], 0) + 1
-    logger.info(f"  Dataset distribution: {ds_dist}")
-
-    # MCQ eval
-    mcq = make_mini_mcq(n_questions=8)
-
-    # =====================================================================
-    # TRAIN LOOP
-    # =====================================================================
-    logger.info("\n[4] Starting V6.1 training loop...")
-    global_step = 0
-    total_steps = EPOCHS * len(train_samples) // BATCH_SIZE
-    if USE_KOHONEN_ORQ:
-        model.orq_cell.cfg.total_steps = max(1, total_steps)
-
-    for epoch in range(1, EPOCHS + 1):
-        model.train()
-        if USE_MTP:
-            mtp_head.train()
-        augmenter.train()
-
-        epoch_losses = []
-        epoch_kohonen_auxs = []
-        epoch_pgv_statuses = []
-
-        for i in range(0, len(train_samples), BATCH_SIZE):
-            batch = train_samples[i:i + BATCH_SIZE]
-            if len(batch) < 2:
-                continue
-            global_step += 1
-            t0 = time.perf_counter()
-
-            x = torch.stack([s["input_ids"] for s in batch])
-            label = torch.stack([s["label_ids"] for s in batch])
-            actual_bs = len(batch)
-            n_tokens = actual_bs * MAX_SEQ_LEN
-            batch_ds = batch[0]["dataset"]  # track dataset da 1a sample do batch
-
-            optimizer.zero_grad()
-
-            # V6: Data augmentation on input
-            x_aug = augmenter(x)
-
-            # Forward com return_aux
-            try:
-                y_hat, delta, aux = model(
-                    x_aug,
-                    return_aux=True,
-                    use_hypothesis=True,
-                    stop_grad_hyp=True,
-                )
-            except RuntimeError as e:
-                logger.warning(f"  step {global_step}: forward failed: {e}")
-                aggressive_cleanup()
-                continue
-
-            # V6.1: Update OrqCell SOM step
-            if USE_KOHONEN_ORQ:
-                model.orq_cell.update_step(global_step)
-
-            # ─────────────────────────────────────────────────────────────
-            # V6.1 — PGVector-like lookup (treino level)
-            # O usuário pediu: "os níveis de treinamento e o de hipótese
-            # precisam verificar se o mapa já possui aquela informação"
-            #
-            # IMPORTANTE: a leitura (pgvector_lookup) é read-only e pode
-            # ser feita após forward. MAS a escrita (fill_missing_neurons_random)
-            # modifica neuron_cache in-place — deve ser DEFERIDA até após
-            # backward para não quebrar o autograd graph.
-            # ─────────────────────────────────────────────────────────────
-            pgv_metrics = None
-            pgv_needs_fill = False
-            if USE_KOHONEN_ORQ:
-                try:
-                    with torch.no_grad():
-                        # H_para_lookup: (B, 1, d_cache) — single "module" para lookup
-                        H_for_lookup = aux["o"].unsqueeze(1)
-                        pgv_result = model.orq_cell.pgvector_lookup(H_for_lookup)
-                    pgv_metrics = pgv_result
-                    # Se MISSING, marca para preenchimento DEPOIS do backward
-                    # (user requirement: "se não houver atribuir valores
-                    # aleatórios aos parâmetros faltantes")
-                    if pgv_result["status"] == "MISSING":
-                        pgv_needs_fill = True
-                except (RuntimeError, ValueError, KeyError) as e:
-                    pass
-
-            # ─────────────────────────────────────────────────────────────
-            # V6.2 — PGVector lookup no nível de HIPÓTESE
-            # User requirement: "ative pgvector_lookup no nível de hipótese
-            # (hyp_t.py) para que ele também consulte o mapa antes de
-            # aplicar punição"
-            #
-            # Antes de aplicar a punição (correção delta), a HypT consulta
-            # o mapa SOM. Se status == COMPLETE, a punição é DESATIVADA —
-            # o modelo confia em y_hat. Caso contrário, aplica delta.
-            # ─────────────────────────────────────────────────────────────
-            target = label[:, 0]
-
-            # Calcula loss_main em y_hat (sem delta) para decidir punição
-            with torch.no_grad():
-                loss_main_check = F.cross_entropy(y_hat, target).item()
-            # τ do MetaConfigurator — se loss_main > τ, punição é pedida
-            current_tau = float(meta_cfg.tau) if hasattr(meta_cfg, 'tau') else 1.0
-            punishment_requested = bool(loss_main_check > current_tau)
-
-            # Hyp PGVector lookup (consulta o mapa antes de aplicar delta)
-            hyp_pgv_metrics = None
-            apply_punishment = True  # default: aplica delta
-            try:
-                hyp_pgv_result = model.hyp_T.pgvector_lookup_before_punishment(
-                    orq_cell=model.orq_cell if USE_KOHONEN_ORQ else None,
-                    o=aux["o"].detach(),
-                    punishment_requested=punishment_requested,
-                )
-                apply_punishment = hyp_pgv_result["apply_punishment"]
-                # Anexa stats acumuladas do HypT
-                hyp_pgv_result["hyp_stats"] = model.hyp_T.get_punishment_stats()
-                hyp_pgv_metrics = hyp_pgv_result
-            except (RuntimeError, AttributeError, TypeError) as e:
-                # Fallback: aplica delta (preserva comportamento V6.1)
-                pass
-
-            # Loss LM — aplica delta apenas se apply_punishment=True
-            if apply_punishment:
-                y_final = y_hat + delta
-            else:
-                # V6.2: COMPLETE skip — usa apenas y_hat (SOM tem a info)
-                y_final = y_hat
-            loss_lm = F.cross_entropy(y_final, target)
-
-            # Loss de entropia do module_selector
-            loss_ent = model.lambda_ent_value * aux["entropy_reg"]
-
-            # TripletPrototypeLoss
-            embeddings_for_triplet = aux["o"]
-            alpha_aux = aux["alpha"]
-            labels_for_triplet = torch.full(
-                (actual_bs,), int(alpha_aux.argmax()), dtype=torch.long
-            )
-            try:
-                loss_triplet = triplet_loss(
-                    embeddings_for_triplet, labels_for_triplet, prototypes
-                )
-                with torch.no_grad():
-                    emb_for_ema = embeddings_for_triplet.detach()
-                    for i_ in range(actual_bs):
-                        lbl = labels_for_triplet[i_].item()
-                        if 0 <= lbl < prototypes.size(0):
-                            prototypes[lbl] = (
-                                (1 - TRIPLET_EMA_ALPHA) * prototypes[lbl]
-                                + TRIPLET_EMA_ALPHA * emb_for_ema[i_]
-                            )
-            except (RuntimeError, ValueError):
-                loss_triplet = torch.tensor(0.0, device=y_hat.device)
-
-            # V6 MTP loss
-            mtp_metrics = None
-            mtp_loss_val = torch.tensor(0.0, device=y_hat.device)
-            if USE_MTP and mtp_head is not None:
-                try:
-                    h_for_mtp = aux["o"].unsqueeze(1).expand(-1, MTP_K, -1)
-                    mtp_logits, mtp_alphas = mtp_head(h_for_mtp)
-                    mtp_targets = label[:, :MTP_K]
-                    if mtp_targets.size(1) >= 1:
-                        mtp_loss_val, mtp_metrics = mtp_loss(
-                            mtp_logits, mtp_targets, mtp_alphas,
-                            entropy_beta=MTP_ENTROPY_BETA,
-                        )
-                except (RuntimeError, ValueError) as e:
-                    logger.warning(f"  MTP loss failed: {e}")
-
-            # V6.1 EWC penalty (after epoch 1, with skip mask)
-            ewc_metrics = None
-            ewc_pen = torch.tensor(0.0, device=y_hat.device)
-            if USE_EWC and ewc is not None and ewc.n_tasks > 0:
-                try:
-                    # BMU indices from PGVector lookup
-                    bmu_idx = torch.full(
-                        (actual_bs,),
-                        pgv_metrics.get("best_neuron_idx", 0) if pgv_metrics else 0,
-                        dtype=torch.long, device=y_hat.device,
-                    )
-                    ewc_pen, ewc_metrics = ewc.compute_penalty(
-                        bmu_indices=bmu_idx,
-                        eval_mode=not model.training,
-                    )
-                except (RuntimeError, AttributeError) as e:
-                    logger.warning(f"  EWC penalty failed: {e}")
-
-            # Loss total
-            loss = (loss_lm + loss_ent + TRIPLET_WEIGHT * loss_triplet
-                    + MTP_LOSS_WEIGHT * mtp_loss_val + ewc_pen)
-
-            # Backward
-            loss.backward()
-            grad_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
-            optimizer.step()
-
-            # V6.1 SOM update APÓS backward
-            som_update_metrics = None
-            if USE_KOHONEN_ORQ:
-                try:
-                    som_update_metrics = model.orq_cell.update_map_after_backward()
-                except (RuntimeError, AttributeError) as e:
-                    pass
-
-            # V6.1 — PGVector fill (após backward + SOM update, safe p/ autograd)
-            # Se o step anterior identificou MISSING, preenche neurônios
-            # não-filled com valores aleatórios controlados.
-            if pgv_needs_fill and USE_KOHONEN_ORQ:
-                try:
-                    n_filled_now = model.orq_cell.fill_missing_neurons_random()
-                    if n_filled_now > 0:
-                        logger.info(f"    [PGV] MISSING → preenchidos {n_filled_now} neurônios aleatoriamente")
-                except (RuntimeError, AttributeError) as e:
-                    pass
-
-            # V6 MetaConfigurator
-            if global_step % META_INTERVAL == 0:
-                try:
-                    meta_result = meta_cfg.step(loss.detach())
-                    monitor.record_meta(meta_result)
-                except (RuntimeError, AttributeError):
-                    pass
-
-            # V6.1 Capture Kohonen aux
-            kohonen_aux = None
-            if USE_KOHONEN_ORQ:
-                try:
-                    with torch.no_grad():
-                        H_dummy = embeddings_for_triplet.unsqueeze(1)
-                        _, kohonen_aux = model.orq_cell(
-                            H_dummy, step=global_step, return_aux=True
-                        )
-                    if som_update_metrics and kohonen_aux:
-                        kohonen_aux["update_magnitude"] = som_update_metrics.get("update_magnitude", 0)
-                        kohonen_aux["bmu_drift"] = som_update_metrics.get("bmu_drift", 0)
-                        kohonen_aux["n_filled"] = som_update_metrics.get("n_filled",
-                            kohonen_aux.get("n_filled", 0))
-                        kohonen_aux["filled_ratio"] = (
-                            kohonen_aux["n_filled"] / model.orq_cell.cfg.n_neurons
-                        )
-                except (RuntimeError, ValueError, KeyError) as e:
-                    pass
-
-            loss_value = float(loss.item())
-            grad_norm_value = float(grad_norm)
-
-            del loss, y_hat, delta, aux, y_final, loss_lm, loss_ent
-            del loss_triplet, mtp_loss_val, ewc_pen
-            if 'mtp_logits' in locals():
-                del mtp_logits
-            if 'mtp_alphas' in locals():
-                del mtp_alphas
-            if 'embeddings_for_triplet' in locals():
-                del embeddings_for_triplet
-            if 'h_for_mtp' in locals():
-                del h_for_mtp
-            if global_step % CLEANUP_INTERVAL == 0:
-                aggressive_cleanup()
-
-            elapsed = time.perf_counter() - t0
-            flops_est = 2 * n_params * n_tokens
-
-            monitor.record_step(
-                global_step, loss_value,
-                n_tokens, elapsed, grad_norm_value,
-                flops_estimate=flops_est,
-                kohonen_aux=kohonen_aux,
-                mtp_metrics=mtp_metrics,
-                ewc_metrics=ewc_metrics,
-                pgv_metrics=pgv_metrics,
-                hyp_pgv_metrics=hyp_pgv_metrics,
-                dataset_name=batch_ds,
-            )
-
-            epoch_losses.append(loss_value)
-            if kohonen_aux:
-                epoch_kohonen_auxs.append(kohonen_aux)
-            if pgv_metrics:
-                epoch_pgv_statuses.append(pgv_metrics["status"])
-
-        # Fim do epoch — Val
-        model.eval()
-        if USE_MTP:
-            mtp_head.eval()
-        val_losses = []
-        mtp_val_losses = []
-
-        with torch.no_grad():
-            for sample in val_samples:
-                x = sample["input_ids"].unsqueeze(0)
-                label = sample["label_ids"]
-                try:
-                    y_hat, delta = model(x, use_hypothesis=True)
-                    target = label[0:1]
-                    vloss = F.cross_entropy(y_hat + delta, target)
-                    val_losses.append(float(vloss.item()))
-
-                    # V6.1 MTP ativo em val
-                    if USE_MTP and mtp_head is not None:
-                        try:
-                            y_hat2, delta2, aux2 = model(x, return_aux=True, use_hypothesis=True)
-                            o = aux2["o"].unsqueeze(1).expand(-1, MTP_K, -1)
-                            mtp_logits, mtp_alphas = mtp_head(o)
-                            mtp_targets = label[:MTP_K].unsqueeze(0)
-                            mtp_loss_val, _ = mtp_loss(
-                                mtp_logits, mtp_targets, mtp_alphas,
-                                entropy_beta=MTP_ENTROPY_BETA,
-                            )
-                            mtp_val_losses.append(float(mtp_loss_val.item()))
-                            del y_hat2, delta2, aux2, o, mtp_logits, mtp_alphas
-                        except (RuntimeError, ValueError):
-                            pass
-                    del y_hat, delta
-                except RuntimeError:
-                    continue
-
-        val_loss = sum(val_losses) / max(1, len(val_losses))
-        train_avg = sum(epoch_losses) / max(1, len(epoch_losses))
-        mtp_val_avg = sum(mtp_val_losses) / max(1, len(mtp_val_losses)) if mtp_val_losses else None
-        eval_acc = evaluate_mcq(model, tokenizer, mcq)
-        monitor.record_epoch(epoch, val_loss, train_avg, eval_acc, mtp_val_avg)
-
-        # Log PGVector status distribution do epoch
-        if epoch_pgv_statuses:
-            from collections import Counter
-            status_counts = Counter(epoch_pgv_statuses)
-            logger.info(f"  [PGV epoch {epoch}] status distribution: {dict(status_counts)}")
-
-        # V6.1 EWC: Após epoch 1, computar Fisher (com skip_som_filled_neurons=True)
-        if USE_EWC and ewc is None and epoch == 1:
-            logger.info(f"\n  [EWC V6.1] Computing Fisher after epoch {epoch}...")
-            logger.info(f"  [EWC V6.1] skip_som_filled_neurons=True — neurônios filled no SOM serão MASCARADOS")
-            try:
-                ewc = EWCV6(model, EWCConfigV6(
-                    lambda_ewc=EWC_LAMBDA,
-                    lambda_topo=EWC_LAMBDA_TOPO,
-                    bmu_reinforcement_gamma=2.0,
-                    skip_som_filled_neurons=True,  # V6.1 key feature
-                ))
-                if USE_KOHONEN_ORQ:
-                    ewc.orq_cells["orq_cell"] = model.orq_cell
-
-                # Snapshot do SOM antes do Fisher
-                n_filled_before = int(model.orq_cell.neuron_filled_mask.sum().item())
-                logger.info(f"  [EWC V6.1] SOM filled neurons antes do Fisher: {n_filled_before}/8")
-
-                def data_iter():
-                    for sample in train_samples[:16]:
-                        x = sample["input_ids"].unsqueeze(0)
-                        y = sample["label_ids"][:1]
-                        yield (x, y)
-                ewc.compute_fisher(data_iter(), n_samples=16, bmu_indices=list(range(8)))
-                logger.info(f"  [EWC V6.1] Fisher computed: classic={len(ewc.fisher)}, "
-                            f"neuron={len(ewc.neuron_fisher)}, "
-                            f"topo={len(ewc.neuron_grid_dist)}")
-                status = ewc.get_status()
-                logger.info(f"  [EWC V6.1] n_active_ewc_neurons={status['n_active_ewc_neurons']} "
-                            f"(EWC atua nestes) | n_masked_som_neurons={status['n_masked_som_neurons']} "
-                            f"(SOM já cobre — não duplica)")
-            except (RuntimeError, AttributeError) as e:
-                logger.warning(f"  [EWC V6.1] Fisher computation failed: {e}")
-                ewc = None
-
-        aggressive_cleanup()
-
-    # =====================================================================
-    # FINAL REPORT
-    # =====================================================================
-    logger.info("\n[5] Generating V6.1 report...")
-    summary = monitor.summary()
-
-    report = {
-        "version": "V6.2",
-        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "config": {
-            "datasets": V62_DATASETS,
-            "n_per_dataset": N_PER_DATASET,
-            "epochs": EPOCHS, "batch_size": BATCH_SIZE,
-            "max_seq_len": MAX_SEQ_LEN, "num_layers_hyp": NUM_LAYERS_HYP,
-            "use_mtp": USE_MTP, "use_ewc": USE_EWC, "use_kohonen_orq": USE_KOHONEN_ORQ,
-            "mtp_K": MTP_K, "mtp_entropy_beta": MTP_ENTROPY_BETA,
-            "ewc_lambda": EWC_LAMBDA, "ewc_lambda_topo": EWC_LAMBDA_TOPO,
-            "pgv_complete_thr": PGV_COMPLETE_THR,
-            "pgv_missing_thr": PGV_MISSING_THR,
-        },
-        "v6_2_improvements": {
-            "hypothesis_level_pgvector_lookup": {
-                "method": "HypT.pgvector_lookup_before_punishment() em hyp_t.py",
-                "rationale": "Antes de aplicar a punição (correção delta), a HypT "
-                             "consulta o mapa SOM. Se status == COMPLETE, a punição "
-                             "é DESATIVADA — o modelo confia em y_hat. Caso "
-                             "contrário, a punição é aplicada.",
-                "statuses": ["COMPLETE (skip)", "INCOMPLETE (apply)", "MISSING (apply)",
-                             "NO_PUNISHMENT (loss ≤ τ)"],
-                "user_requirement": "ative pgvector_lookup no nível de hipótese (hyp_t.py) "
-                                    "para que ele também consulte o mapa antes de aplicar punição",
-            },
-            "batch_size_16": True,
-            "5_datasets_x_50_samples": True,
-            "datasets_library_installed": True,
-        },
-        "v6_1_features_preserved": {
-            "pgvector_like_lookup_orq_cell": {
-                "method": "pgvector_lookup() no OrqCell",
-                "statuses": ["COMPLETE", "INCOMPLETE", "MISSING"],
-                "complete_threshold": PGV_COMPLETE_THR,
-                "missing_threshold": PGV_MISSING_THR,
-                "neuron_filled_mask": True,
-                "auto_fill_missing": True,
-            },
-            "ewc_math_upgrade": {
-                "skip_som_filled_neurons": True,
-                "rationale": "EWC não reutiliza pesos já presentes no SOM — "
-                             "evita dupla penalização (BMU + Fisher)",
-                "fisher_neuron_mask": True,
-                "n_masked_som_neurons_final": summary.get("ewc_evolution", {}).get(
-                    "n_masked_som_neurons", [0])[-1] if summary.get("ewc_evolution", {}).get(
-                    "n_masked_som_neurons") else 0,
-            },
-            "training_level_pgvector": True,
-        },
-        "v6_features_preserved": {
-            "kohonen_4d_som": True,
-            "ewc_per_neuron": True,
-            "mtp_active_in_val": True,
-            "mtp_entropy_regularizer": True,
-            "window_context_2m": True,
-            "dynamic_rep_penalty": True,
-            "data_augmentation": True,
-            "rlhf_mapping": True,
-            "thinking_system": True,
-            "tool_system": ["mutation", "cache", "agent"],
-            "langchain_compat": True,
-            "optimized_pipeline": True,
-            "xeon_v6_always_active": True,
-            "libvirt_amx_vm_activation": True,
-        },
-        "xeon_status": XEON_STATUS,
-        "fp16_benchmark": FP16_BENCH,
-        "dataset_distribution": summary.get("dataset_distribution", {}),
-        "result": {
-            **summary,
-            "n_params_M": n_params / 1e6,
-        },
-    }
-
-    with open(REPORT_PATH, "w") as f:
-        json.dump(report, f, indent=2, default=str)
-    logger.info(f"  Report saved: {REPORT_PATH}")
-
-    # =====================================================================
-    # DELETE BINARIES
-    # =====================================================================
-    logger.info("\n[6] Deleting training binaries...")
-    deleted = delete_training_binaries()
-    logger.info(f"  Deleted {len(deleted)} binary files")
-
-    # =====================================================================
-    # SUMMARY
-    # =====================================================================
-    logger.info("\n" + "=" * 72)
-    logger.info("V6.2 TRAINING COMPLETE")
-    logger.info("=" * 72)
-    logger.info(f"  Total samples: {len(samples)} (5 datasets × {N_PER_DATASET})")
-    logger.info(f"  Total steps: {summary['n_steps']}, Epochs: {summary['n_epochs']}")
-    if summary['final_train_loss'] is not None:
-        logger.info(f"  Final train_loss: {summary['final_train_loss']:.4f}")
-    if summary['final_val_loss'] is not None:
-        logger.info(f"  Final val_loss: {summary['final_val_loss']:.4f}")
-    if summary['final_perplexity'] is not None:
-        logger.info(f"  Perplexity: {summary['final_perplexity']:.2f}")
-    if summary['final_eval_benchmark'] is not None:
-        logger.info(f"  Eval acc: {summary['final_eval_benchmark']:.2%}")
-    if summary['final_rss_mb'] is not None:
-        logger.info(f"  RSS: {summary['final_rss_mb']:.0f}MB ({summary['rss_trend']})")
-    logger.info(f"  Alerts: {summary['n_alerts']}")
-
-    # V6.1 PGVector summary
-    pgv_ev = summary.get("pgvector_evolution", {})
-    if pgv_ev.get("status_counts"):
-        logger.info(f"  PGVector (treino level) status distribution:")
-        for s, c in pgv_ev["status_counts"].items():
-            logger.info(f"    {s}: {c}")
-        logger.info(f"    final coverage: {pgv_ev.get('final_coverage', 0):.3f}")
-        logger.info(f"    final best_sim: {pgv_ev.get('final_best_sim', 0):.3f}")
-        logger.info(f"    final n_filled: {pgv_ev.get('final_n_filled', 0)}/8")
-
-    # V6.2 Hyp PGVector summary
-    hyp_pgv_ev = summary.get("hyp_pgvector_evolution", {})
-    if hyp_pgv_ev.get("status_counts"):
-        logger.info(f"  Hyp PGVector (nível de hipótese) status distribution:")
-        for s, c in hyp_pgv_ev["status_counts"].items():
-            logger.info(f"    {s}: {c}")
-        logger.info(f"    n_complete_skip (punição evitada): "
-                    f"{hyp_pgv_ev.get('final_n_complete_skip', 0)}")
-        logger.info(f"    n_incomplete_apply (punição aplicada, info parcial): "
-                    f"{hyp_pgv_ev.get('final_n_incomplete_apply', 0)}")
-        logger.info(f"    n_missing_apply (punição aplicada, info ausente): "
-                    f"{hyp_pgv_ev.get('final_n_missing_apply', 0)}")
-        logger.info(f"    skip_rate (fração de punições evitadas pelo pgvector): "
-                    f"{hyp_pgv_ev.get('final_skip_rate', 0):.2%}")
-        logger.info(f"    final best_sim: {hyp_pgv_ev.get('final_best_sim', 0):.3f}")
-        logger.info(f"    final coverage: {hyp_pgv_ev.get('final_coverage', 0):.3f}")
-
-    # V6.1 EWC summary
-    ewc_ev = summary.get("ewc_evolution", {})
-    if ewc_ev.get("n_masked_som_neurons"):
-        logger.info(f"  EWC V6.1 math upgrade:")
-        logger.info(f"    n_masked_som_neurons (skipped): {ewc_ev['n_masked_som_neurons'][-1]}")
-        logger.info(f"    final EWC penalty: {ewc_ev['total_penalty'][-1] if ewc_ev['total_penalty'] else 0:.4f}")
-
-    # V6 Kohonen summary
-    kohonen_ev = summary.get("kohonen_evolution", {})
-    if kohonen_ev.get("sigma_t"):
-        logger.info(f"  Kohonen SOM evolution:")
-        logger.info(f"    sigma_t: {kohonen_ev['sigma_t'][0]:.3f} → {kohonen_ev['final_sigma_t']:.3f}")
-        logger.info(f"    alpha_t: {kohonen_ev['alpha_t'][0]:.3f} → {kohonen_ev['final_alpha_t']:.3f}")
-        logger.info(f"    final n_filled: {kohonen_ev.get('final_n_filled', 0)}/8 "
-                    f"(filled_ratio={kohonen_ev.get('final_filled_ratio', 0):.2%})")
-
-    logger.info("=" * 72)
-
-    return report
-
-
-if __name__ == "__main__":
-    main()