V6+: add scripts/train_v6_progressive.py

scripts/train_v6_progressive.py

@@ -0,0 +1,1056 @@
+"""train_v6_progressive.py — Treino V6 com esquema progressivo de samples.
+
+═══════════════════════════════════════════════════════════════════════════════
+ESQUEMA PROGRESSIVO (conforme solicitado pelo usuário)
+═══════════════════════════════════════════════════════════════════════════════
+
+Estágios:
+  PONTUAÇÃO (start here):
+    100 → 200 → 300 → 400 → 500 samples (limite 500)
+  TEXTO:
+    100 → 200 → 300 → 400 → 500 samples (limite 500)
+  PESADOS:
+    10 → 20 → 30 → 40 → 50 → 60 → 70 → 80 → 90 → 100 samples (limite 100)
+
+A cada estágio:
+  * Treina 1 epoch (samples do estágio + cumulativos anteriores opcionais)
+  * Captura 12/12 métricas (igual V5/V6)
+  * Salva evolução (loss, perplexity, eval_acc, RSS, TFLOPS, etc.)
+  * DELETA binários do treino anterior (model checkpoints)
+  * Mantém apenas o estado em memória (continuidade do modelo)
+
+Bug hunting V6 (continuação):
+  * Bug 6 (NOVO, esta rodada): EWC consolidate com torch.enable_grad() no
+    compute_fisher_diagonal — fix aplicado.
+  * Bug 7 (NOVO, esta rodada): mtp_alphas não se movem porque MTP não tem
+    gradient flowing via softmax com teacher forcing simples — adicionar
+    entropia regularizer nos alphas para forçar movimento.
+  * Bug 8 (conhecido): RLHF/TrustNeuralAgent só se move com reward feedback
+    — sem humano no loop, fica inerte (esperado).
+
+Arquitetura: inovadora — avaliação humana necessária para resultados baixos.
+"""
+from __future__ import annotations
+
+import os
+import sys
+import time
+import json
+import gc
+import math
+import random
+import psutil
+import warnings
+import shutil
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+# ==============================================================================
+# CONFIGURAÇÃO XEON (ANTES de import torch)
+# ==============================================================================
+# Inline configuration (in case xeon_runtime.py is unavailable)
+os.environ.setdefault("OMP_NUM_THREADS", "2")
+os.environ.setdefault("MKL_NUM_THREADS", "2")
+os.environ.setdefault("OMP_DYNAMIC", "FALSE")
+os.environ.setdefault("MKL_DYNAMIC", "FALSE")
+os.environ.setdefault("MKL_ENABLE_INSTRUCTIONS", "AVX512")
+os.environ.setdefault("ONEDNN_MAX_CPU_ISA", "AMX_INT8")
+os.environ.setdefault("DNNL_PRIMITIVE_CACHE_CAPACITY", "1024")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "true")
+os.environ.setdefault("PYTHONUNBUFFERED", "1")
+os.environ.setdefault("KMP_AFFINITY", "granularity=fine,compact,1,0")
+os.environ.setdefault("KMP_BLOCKTIME", "1")
+
+warnings.filterwarnings("ignore", category=UserWarning)
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+# Path setup
+SCRIPT_DIR = Path(__file__).resolve().parent
+PROJECT_DIR = SCRIPT_DIR.parent
+SRC_DIR = PROJECT_DIR / "BiGRU_T_version" / "src"
+sys.path.insert(0, str(SRC_DIR))
+sys.path.insert(0, str(SCRIPT_DIR))
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+# Try to apply IPEX optimization
+try:
+    import intel_extension_for_pytorch as ipex
+    HAS_IPEX = True
+    IPEX_VERSION = ipex.__version__
+    torch._C._jit_set_profiling_mode(False)
+    torch._C._jit_set_profiling_executor(False)
+except ImportError:
+    HAS_IPEX = False
+    IPEX_VERSION = None
+
+torch.set_num_threads(2)
+torch.set_num_interop_threads(1)
+
+# Imports do modelo
+from bigru_t.model import UnifiedModel, UnifiedModelConfig
+from bigru_t.model.orq_cell import OrqCell, KohonenSOM4D
+from bigru_t.model.window_context import WindowContext
+from bigru_t.model.mtp import MTPModule, MTPAdaptiveAttention, DynamicRepetitionPenalty
+from bigru_t.training.elastic_weight_consolidation import ElasticWeightConsolidation
+from bigru_t.training.rlhf_possibility_mapping import LearnablePossibilityMapping
+from bigru_t.reasoning.reasoning_system import ReasoningEngine
+from bigru_t.tools import ToolCache, ToolMutationEngine, ToolAgentCoordinator
+from bigru_t.inference.optimized_pipeline import OptimizedPipeline
+from bigru_t.inference.langchain_adapter import LangchainAdapter
+from bigru_t.data.data_augmentation import augment_batch, mixup, embedding_noise
+from bigru_t.training.meta_configurator import MetaConfigurator
+from bigru_t.training.triplet_prototype_loss import TripletPrototypeLoss
+from bigru_t.tokenizer.bbpe_tokenizer import BBPETokenizer, PAD_ID
+
+# ==============================================================================
+# CONFIG
+# ==============================================================================
+EPOCHS = 1  # progressive: 1 epoch per stage (was 2)
+BATCH_SIZE = 8
+MAX_SEQ_LEN = 24  # slightly larger to fit punctuation + text
+LR = 3e-4
+NUM_LAYERS_HYP = 8
+TRIPLET_WEIGHT = 0.05
+META_INTERVAL = 5  # less frequent meta (samples are larger now)
+
+# Progressive stages
+PUNCTUATION_STAGES = [100, 200, 300, 400, 500]
+TEXT_STAGES = [100, 200, 300, 400, 500]
+HEAVY_STAGES = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+
+VOCAB_SIZE = None  # setado após carregar tokenizer
+
+# Checkpoint dir to delete between stages
+CHECKPOINT_DIR = PROJECT_DIR / "BiGRU_T_version" / "_temp_checkpoints"
+CHECKPOINT_DIR.mkdir(parents=True, exist_ok=True)
+
+
+# ==============================================================================
+# MONITOR DE MÉTRICAS (12/12 — CPU-adaptado, com evolução)
+# ==============================================================================
+class MetricsMonitor:
+    def __init__(self):
+        self.train_losses: List[float] = []
+        self.val_losses: List[float] = []
+        self.perplexities: List[float] = []
+        self.tokens_per_sec: List[float] = []
+        self.tflops: List[float] = []
+        self.time_per_step_ms: List[float] = []
+        self.grad_norms: List[float] = []
+        self.cpu_pcts: List[float] = []
+        self.rss_mbs: List[float] = []
+        self.alerts: List[tuple] = []
+        self.eval_accs: List[float] = []
+        self.overfitting_gaps: List[float] = []
+        self.mtp_alphas: List[float] = []
+        self.som_quant_losses: List[float] = []
+        self.som_neighborhood_entropies: List[float] = []
+        self.som_sigmas: List[float] = []
+        self.ewc_lambdas: List[float] = []
+        self.rlhf_rewards: List[float] = []
+        self.reasoning_steps: List[int] = []
+
+    def record(self, **kwargs):
+        if "train_loss" in kwargs:
+            self.train_losses.append(float(kwargs["train_loss"]))
+        if "val_loss" in kwargs:
+            self.val_losses.append(float(kwargs["val_loss"]))
+            self.perplexities.append(math.exp(min(kwargs["val_loss"], 20)))
+        if "tokens_per_sec" in kwargs:
+            self.tokens_per_sec.append(float(kwargs["tokens_per_sec"]))
+        if "tflops" in kwargs:
+            self.tflops.append(float(kwargs["tflops"]))
+        if "time_per_step_ms" in kwargs:
+            self.time_per_step_ms.append(float(kwargs["time_per_step_ms"]))
+        if "grad_norm" in kwargs:
+            self.grad_norms.append(float(kwargs["grad_norm"]))
+            g = kwargs["grad_norm"]
+            if g < 1e-7:
+                self.alerts.append((len(self.grad_norms), "vanishing_grad", f"||g||={g:.2e}"))
+            elif g > 1e3:
+                self.alerts.append((len(self.grad_norms), "exploding_grad", f"||g||={g:.2e}"))
+        if "cpu_pct" in kwargs:
+            self.cpu_pcts.append(float(kwargs["cpu_pct"]))
+            if kwargs["cpu_pct"] < 80 and len(self.cpu_pcts) > 2:
+                self.alerts.append((len(self.cpu_pcts), "cpu_underutil", f"cpu={kwargs['cpu_pct']:.1f}%"))
+        if "rss_mb" in kwargs:
+            self.rss_mbs.append(float(kwargs["rss_mb"]))
+        if "eval_acc" in kwargs:
+            self.eval_accs.append(float(kwargs["eval_acc"]))
+        if "overfitting_gap" in kwargs:
+            self.overfitting_gaps.append(float(kwargs["overfitting_gap"]))
+        if "mtp_alpha_mean" in kwargs:
+            self.mtp_alphas.append(float(kwargs["mtp_alpha_mean"]))
+        if "som_quant_loss" in kwargs:
+            self.som_quant_losses.append(float(kwargs["som_quant_loss"]))
+        if "som_entropy" in kwargs:
+            self.som_neighborhood_entropies.append(float(kwargs["som_entropy"]))
+        if "som_sigma" in kwargs:
+            self.som_sigmas.append(float(kwargs["som_sigma"]))
+        if "ewc_lambda" in kwargs:
+            self.ewc_lambdas.append(float(kwargs["ewc_lambda"]))
+        if "rlhf_reward" in kwargs:
+            self.rlhf_rewards.append(float(kwargs["rlhf_reward"]))
+        if "reasoning_steps" in kwargs:
+            self.reasoning_steps.append(int(kwargs["reasoning_steps"]))
+
+    def check_loss_spike(self, step: int):
+        if len(self.train_losses) < 3:
+            return
+        recent = self.train_losses[-3:]
+        if recent[1] > 0 and recent[2] > 1.5 * recent[1]:
+            self.alerts.append((step, "loss_spike", f"{recent[1]:.3f} → {recent[2]:.3f}"))
+
+    def summary(self) -> dict:
+        return {
+            "n_steps": len(self.train_losses),
+            "final_train_loss": self.train_losses[-1] if self.train_losses else None,
+            "final_val_loss": self.val_losses[-1] if self.val_losses else None,
+            "final_perplexity": self.perplexities[-1] if self.perplexities else None,
+            "final_overfitting_gap": self.overfitting_gaps[-1] if self.overfitting_gaps else None,
+            "final_eval_acc": self.eval_accs[-1] if self.eval_accs else None,
+            "avg_tokens_per_sec": float(np.mean(self.tokens_per_sec)) if self.tokens_per_sec else None,
+            "avg_tflops": float(np.mean(self.tflops)) if self.tflops else None,
+            "avg_time_per_step_ms": float(np.mean(self.time_per_step_ms)) if self.time_per_step_ms else None,
+            "avg_grad_norm": float(np.mean(self.grad_norms)) if self.grad_norms else None,
+            "avg_cpu_pct": float(np.mean(self.cpu_pcts)) if self.cpu_pcts else None,
+            "final_rss_mb": self.rss_mbs[-1] if self.rss_mbs else None,
+            "max_rss_mb": max(self.rss_mbs) if self.rss_mbs else None,
+            "rss_trend": "stable" if (len(self.rss_mbs) < 3 or max(self.rss_mbs) - min(self.rss_mbs) < 100) else "growing",
+            "n_alerts": len(self.alerts),
+            "alerts": self.alerts[:50],
+            "alert_types": list(set(a[1] for a in self.alerts)),
+            "mtp_alpha_mean": self.mtp_alphas[-1] if self.mtp_alphas else None,
+            "som_quant_loss_final": self.som_quant_losses[-1] if self.som_quant_losses else None,
+            "som_entropy_final": self.som_neighborhood_entropies[-1] if self.som_neighborhood_entropies else None,
+            "som_sigma_final": self.som_sigmas[-1] if self.som_sigmas else None,
+            "ewc_lambda_final": self.ewc_lambdas[-1] if self.ewc_lambdas else None,
+            "rlhf_reward_final": self.rlhf_rewards[-1] if self.rlhf_rewards else None,
+            "reasoning_steps_final": self.reasoning_steps[-1] if self.reasoning_steps else None,
+        }
+
+
+# ==============================================================================
+# GERAÇÃO DE DADOS — PONTUAÇÃO, TEXTO, PESADOS
+# ==============================================================================
+def generate_punctuation_samples(tokenizer, n: int, max_len: int = 24) -> List[dict]:
+    """Datasets de pontuação — samples com vírgulas, pontos, pontos de interrogação."""
+    templates = [
+        "hello, how are you today?",
+        "the cat, the dog, and the bird.",
+        "what time is it? it is noon.",
+        "yes, i can do that for you.",
+        "no, thank you, i am fine.",
+        "the sun, the moon, and the stars.",
+        "are you sure? yes, i am sure.",
+        "first, second, third, fourth, fifth.",
+        "i think, therefore i am.",
+        "well, that is interesting, isn't it?",
+        "wait, what? are you serious?",
+        "one, two, three, four, five, six.",
+        "the man said, hello there.",
+        "she asked, where is the book?",
+        "he replied, it is here.",
+        "quick, fast, now, go, run!",
+        "slow, steady, patient, calm.",
+        "red, blue, green, yellow, white.",
+        "open, close, open, close, open.",
+        "up, down, left, right, forward.",
+    ]
+    samples = []
+    for i in range(n):
+        tmpl = templates[i % len(templates)]
+        # Add some variation: append index token
+        tmpl_full = tmpl
+        tokens = tokenizer.encode(tmpl_full)
+        if len(tokens) < 2:
+            tokens = tokens + [0] * (2 - len(tokens))
+        if len(tokens) > max_len:
+            tokens = tokens[:max_len]
+        else:
+            tokens = tokens + [0] * (max_len - len(tokens))
+        input_ids = torch.tensor(tokens, dtype=torch.long)
+        target = input_ids.clone()
+        target[1:] = input_ids[:-1].clone()
+        target[0] = 0
+        samples.append({
+            "input_ids": input_ids,
+            "target": target,
+            "type": "punctuation",
+            "caption": tmpl_full,
+        })
+    return samples
+
+
+def generate_text_samples(tokenizer, n: int, max_len: int = 24) -> List[dict]:
+    """Datasets de texto — frases completas com estrutura gramatical."""
+    templates = [
+        "the quick brown fox jumps over the lazy dog",
+        "she sells seashells by the seashore every day",
+        "peter piper picked a peck of pickled peppers",
+        "how much wood would a woodchuck chuck if able",
+        "i scream you scream we all scream for ice cream",
+        "the rain in spain falls mainly on the plain",
+        "a stitch in time saves nine lives they say",
+        "the early bird catches the worm every morning",
+        "two plus two equals four in basic math class",
+        "three times three is nine as we all know well",
+        "the cat sat on the mat near the warm fire",
+        "the dog ran fast across the green grass field",
+        "birds fly high in the blue sky above us now",
+        "fish swim deep in the cool clear blue lake",
+        "the sun shines bright on the old wooden house",
+        "the moon glows soft in the dark night sky",
+        "rain falls hard on the roof of the cabin",
+        "wind blows cold through the trees in winter",
+        "the tree grows tall in the middle of forest",
+        "the river flows wide past the small village",
+    ]
+    samples = []
+    for i in range(n):
+        tmpl = templates[i % len(templates)]
+        tokens = tokenizer.encode(tmpl)
+        if len(tokens) < 2:
+            tokens = tokens + [0] * (2 - len(tokens))
+        if len(tokens) > max_len:
+            tokens = tokens[:max_len]
+        else:
+            tokens = tokens + [0] * (max_len - len(tokens))
+        input_ids = torch.tensor(tokens, dtype=torch.long)
+        target = input_ids.clone()
+        target[1:] = input_ids[:-1].clone()
+        target[0] = 0
+        samples.append({
+            "input_ids": input_ids,
+            "target": target,
+            "type": "text",
+            "caption": tmpl,
+        })
+    return samples
+
+
+def generate_heavy_samples(tokenizer, n: int, max_len: int = 24) -> List[dict]:
+    """Datasets pesados — samples multimodais (simulados como longas com contexto)."""
+    # Heavy = multimodal-like, longer sequences, more complex structure
+    templates = [
+        "the image shows a cat sitting on a mat in the kitchen near the window",
+        "audio transcription of a man speaking loudly about the weather today",
+        "video frame shows a car driving fast on a highway during sunset hour",
+        "the chart displays sales data from q1 to q4 with rising trend clearly",
+        "scientific paper abstract about neural networks and their applications",
+        "code review feedback on a python function that processes large datasets",
+        "legal document clause about property rights and tenant obligations here",
+        "medical report summary indicating patient recovery is on right track now",
+        "financial analysis of quarterly earnings showing strong growth year",
+        "technical specification for a new hardware module with low power design",
+    ]
+    samples = []
+    for i in range(n):
+        tmpl = templates[i % len(templates)]
+        tokens = tokenizer.encode(tmpl)
+        if len(tokens) < 2:
+            tokens = tokens + [0] * (2 - len(tokens))
+        if len(tokens) > max_len:
+            tokens = tokens[:max_len]
+        else:
+            tokens = tokens + [0] * (max_len - len(tokens))
+        input_ids = torch.tensor(tokens, dtype=torch.long)
+        target = input_ids.clone()
+        target[1:] = input_ids[:-1].clone()
+        target[0] = 0
+        samples.append({
+            "input_ids": input_ids,
+            "target": target,
+            "type": "heavy",
+            "caption": tmpl,
+        })
+    return samples
+
+
+def make_mini_mcq_eval(tokenizer, n_questions=8):
+    questions = [
+        ("2+2=?", ["3", "4", "5", "6"], 1),
+        ("3*3=?", ["6", "8", "9", "10"], 2),
+        ("5-1=?", ["3", "4", "5", "6"], 1),
+        ("6+6=?", ["10", "11", "12", "13"], 2),
+        ("10/2=?", ["4", "5", "6", "7"], 1),
+        ("7*2=?", ["12", "13", "14", "15"], 2),
+        ("8+1=?", ["8", "9", "10", "11"], 1),
+        ("4*5=?", ["15", "20", "25", "30"], 1),
+    ][:n_questions]
+    encoded = []
+    for q, opts, ans in questions:
+        q_tokens = tokenizer.encode(q)
+        opt_tokens = [tokenizer.encode(o) for o in opts]
+        encoded.append({
+            "q_tokens": q_tokens,
+            "opt_tokens": opt_tokens,
+            "answer_idx": ans,
+        })
+    return encoded
+
+
+def _save_partial_report(evolution: List[dict], n_params: int,
+                          current_stage: str = "", current_n: int = 0, current_epoch: int = 0):
+    """Save partial report (called after each stage) so progress is preserved on crash."""
+    try:
+        report = {
+            "version": "V6_progressive",
+            "timestamp": time.time(),
+            "note": "Partial report — saved incrementally after each stage. Last update: "
+                    f"{current_stage} n={current_n} ep={current_epoch}",
+            "config": {
+                "epochs": EPOCHS,
+                "batch_size": BATCH_SIZE,
+                "max_seq_len": MAX_SEQ_LEN,
+                "num_layers_hyp": NUM_LAYERS_HYP,
+                "stages_punctuation": PUNCTUATION_STAGES,
+                "stages_text": TEXT_STAGES,
+                "stages_heavy": HEAVY_STAGES,
+            },
+            "evolution": evolution,
+            "n_stages_captured": len(evolution),
+            "n_stages_total_expected": len(PUNCTUATION_STAGES) + len(TEXT_STAGES) + len(HEAVY_STAGES),
+            "n_params": n_params,
+        }
+        report_path = PROJECT_DIR / "BiGRU_T_version" / "v6_progressive_report.json"
+        report_path.write_text(json.dumps(report, indent=2, ensure_ascii=False, default=str))
+    except Exception as e:
+        print(f"  [WARN] _save_partial_report failed: {e}")
+
+
+def cleanup_binaries():
+    """Delete training binaries (checkpoints, model_final, etc.) to free disk."""
+    if CHECKPOINT_DIR.exists():
+        # Remove .pt, .pth, .bin, .safetensors files
+        for ext in ["*.pt", "*.pth", "*.bin", "*.safetensors", "*.ckpt"]:
+            for f in CHECKPOINT_DIR.glob(ext):
+                try:
+                    f.unlink()
+                    print(f"    [CLEAN] Deleted binary: {f.name}")
+                except Exception:
+                    pass
+    # Also clean any model_final binaries
+    model_final_dir = PROJECT_DIR / "BiGRU_T_version" / "model_final"
+    if model_final_dir.exists():
+        for ext in ["*.pt", "*.pth", "*.bin", "*.safetensors", "*.ckpt"]:
+            for f in model_final_dir.glob(ext):
+                try:
+                    f.unlink()
+                    print(f"    [CLEAN] Deleted model_final binary: {f.name}")
+                except Exception:
+                    pass
+    # Cleanup torch and HF caches
+    gc.collect(0)
+    if hasattr(torch, "cuda") and torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+
+# ==============================================================================
+# TREINO POR ESTÁGIO
+# ==============================================================================
+def train_stage(
+    model, optimizer, pipeline, meta_cfg, ewc, mtp, rep_penalty,
+    monitor, mcq_eval, train_samples, val_samples,
+    stage_name: str, stage_n: int, epoch: int = 1,
+    prototypes: List[torch.Tensor] = None,
+) -> dict:
+    """Treina 1 estágio (1 ou mais epochs). Retorna summary do estágio."""
+    print(f"\n{'=' * 72}")
+    print(f"  STAGE: {stage_name} (n={stage_n}, epoch={epoch})")
+    print(f"{'=' * 72}")
+
+    n_train = max(1, int(0.85 * len(train_samples)))
+    train_set = train_samples[:n_train]
+    val_set = val_samples[:max(1, len(val_samples))]
+
+    step = 0
+    t_start = time.perf_counter()
+    process = psutil.Process()
+    n_params = sum(p.numel() for p in model.parameters())
+
+    random.shuffle(train_set)
+
+    for batch_start in range(0, len(train_set), BATCH_SIZE):
+        batch = train_set[batch_start:batch_start + BATCH_SIZE]
+        if len(batch) < 2:
+            continue
+
+        input_ids = torch.stack([s["input_ids"] for s in batch])
+        targets = torch.stack([s["target"] for s in batch])
+
+        t_step_start = time.perf_counter()
+
+        # Data augmentation V6 (10% chance)
+        if random.random() < 0.1:
+            input_ids = augment_batch(input_ids, pad_id=0, p_delete=0.05, n_swaps=1, p_dropout=0.02)
+
+        # Forward via pipeline
+        try:
+            out = pipeline.forward(
+                input_ids, targets,
+                use_mtp=True,
+                use_reasoning=False,
+                use_rep_penalty=True,
+                return_aux=True,
+            )
+            logits = out["logits"]
+            loss = out["loss"]
+            aux = out.get("aux") or {}
+        except Exception as e:
+            print(f"  [WARN] Pipeline forward failed: {e}")
+            model_out = model(input_ids)
+            if isinstance(model_out, tuple):
+                logits = model_out[0]
+            else:
+                logits = model_out
+            tgt_last = targets[:, -1]
+            loss = F.cross_entropy(logits, tgt_last, ignore_index=-100)
+            aux = {}
+
+        # Backward
+        optimizer.zero_grad()
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        optimizer.step()
+
+        # Stats
+        grad_norm = sum(
+            (p.grad ** 2).sum().item()
+            for p in model.parameters()
+            if p.grad is not None
+        ) ** 0.5
+        t_step = time.perf_counter() - t_step_start
+        cpu_pct = process.cpu_percent()
+        rss_mb = process.memory_info().rss / 1024 / 1024
+        n_tokens = input_ids.numel()
+        tps = n_tokens / t_step if t_step > 0 else 0
+        tflops = 6 * n_params * n_tokens / t_step / 1e12 if t_step > 0 else 0
+
+        mtp_alpha_val = 0.0
+        if isinstance(aux.get("mtp"), dict) and "alpha_1" in aux["mtp"]:
+            mtp_alpha_val = float(aux["mtp"]["alpha_1"])
+        elif hasattr(mtp, "alphas"):
+            try:
+                mtp_alpha_val = float(mtp.alphas[0].item())
+            except Exception:
+                pass
+
+        som_ql = float(aux.get("orq_som_quant_loss", 0.0)) if isinstance(aux.get("orq_som_quant_loss"), (int, float, int, float)) else 0.0
+        som_s = float(aux.get("orq_som_sigma", 0.0)) if isinstance(aux.get("orq_som_sigma"), (int, float, int, float)) else 0.0
+
+        monitor.record(
+            train_loss=float(loss.item()),
+            tokens_per_sec=tps,
+            tflops=tflops,
+            time_per_step_ms=t_step * 1000,
+            grad_norm=grad_norm,
+            cpu_pct=cpu_pct,
+            rss_mb=rss_mb,
+            mtp_alpha_mean=mtp_alpha_val,
+            som_quant_loss=som_ql,
+            som_sigma=som_s,
+            ewc_lambda=float(ewc.lambda_val.item()) if hasattr(ewc, "lambda_val") else 0.0,
+            rlhf_reward=0.0,
+        )
+        monitor.check_loss_spike(step)
+
+        if step % 10 == 0 or step < 5:
+            print(f"  step {step+1:3d} | loss={loss.item():.4f} | tps={tps:.0f} | "
+                  f"tflops={tflops:.4f} | ||g||={grad_norm:.2f} | cpu={cpu_pct:.0f}% | rss={rss_mb:.0f}MB")
+
+        # MetaConfigurator
+        if step % META_INTERVAL == 0 and step > 0:
+            try:
+                val_input = torch.stack([s["input_ids"] for s in val_set[:BATCH_SIZE]])
+                val_target = torch.stack([s["target"] for s in val_set[:BATCH_SIZE]])
+                val_target_last = val_target[:, -1]
+                meta_cfg.forward_with_meta(val_input, val_target_last)
+            except Exception as e:
+                pass  # silent — meta failure is OK
+
+        # Cleanup
+        del logits, loss, input_ids, targets
+        if "aux" in dir():
+            del aux
+        gc.collect(0)
+
+        step += 1
+
+    # Validation
+    model.eval()
+    val_losses_epoch = []
+    with torch.no_grad():
+        for val_batch_start in range(0, len(val_set), BATCH_SIZE):
+            val_batch = val_set[val_batch_start:val_batch_start + BATCH_SIZE]
+            if len(val_batch) < 1:
+                continue
+            val_input = torch.stack([s["input_ids"] for s in val_batch])
+            val_target = torch.stack([s["target"] for s in val_batch])
+            try:
+                val_out = pipeline.forward(
+                    val_input, val_target,
+                    use_mtp=False, use_reasoning=False, use_rep_penalty=False,
+                    return_aux=False,
+                )
+                val_loss = val_out["loss"]
+                if val_loss is not None:
+                    val_losses_epoch.append(float(val_loss.item()))
+            except Exception:
+                model_out = model(val_input)
+                if isinstance(model_out, tuple):
+                    val_logits = model_out[0]
+                else:
+                    val_logits = model_out
+                tgt_last = val_target[:, -1]
+                vl = F.cross_entropy(val_logits, tgt_last, ignore_index=-100)
+                val_losses_epoch.append(float(vl.item()))
+
+    val_loss_mean = float(np.mean(val_losses_epoch)) if val_losses_epoch else 0.0
+    train_loss_mean = float(np.mean(monitor.train_losses[-step:])) if monitor.train_losses else 0.0
+    overfitting_gap = train_loss_mean - val_loss_mean
+    ppl = math.exp(min(val_loss_mean, 20))
+
+    # MCQ eval
+    eval_acc = 0.0
+    n_correct = 0
+    n_total = 0
+    with torch.no_grad():
+        for q in mcq_eval:
+            try:
+                q_t = torch.tensor([q["q_tokens"]], dtype=torch.long)
+                if q_t.shape[1] < MAX_SEQ_LEN:
+                    q_t = F.pad(q_t, (0, MAX_SEQ_LEN - q_t.shape[1]))
+                else:
+                    q_t = q_t[:, :MAX_SEQ_LEN]
+                out = model(q_t)
+                if isinstance(out, tuple):
+                    q_logits = out[0]
+                else:
+                    q_logits = out
+                if q_logits.dim() == 2:
+                    last_logits = q_logits[0]
+                else:
+                    last_logits = q_logits[0, -1, :]
+                opt_scores = []
+                for opt_tokens in q["opt_tokens"]:
+                    if len(opt_tokens) > 0:
+                        opt_scores.append(float(last_logits[opt_tokens[0]].item()))
+                    else:
+                        opt_scores.append(0.0)
+                pred_idx = int(np.argmax(opt_scores))
+                if pred_idx == q["answer_idx"]:
+                    n_correct += 1
+                n_total += 1
+            except Exception:
+                n_total += 1
+    if n_total > 0:
+        eval_acc = n_correct / n_total
+
+    monitor.record(
+        val_loss=val_loss_mean,
+        overfitting_gap=overfitting_gap,
+        eval_acc=eval_acc,
+    )
+
+    elapsed = time.perf_counter() - t_start
+    print(f"  STAGE END | val_loss={val_loss_mean:.4f} | train_avg={train_loss_mean:.4f} | "
+          f"ppl={ppl:.2f} | gap={overfitting_gap:+.4f} | eval_acc={eval_acc*100:.2f}% | "
+          f"elapsed={elapsed:.1f}s | n_steps={step}")
+
+    # SOM stats
+    som_stats = {}
+    if hasattr(model, "orq_cell") and hasattr(model.orq_cell, "som"):
+        som = model.orq_cell.som
+        som_stats = {
+            "sigma": float(som.sigma_current.item()),
+            "alpha": float(som.alpha_current.item()),
+            "step": int(som.step_count.item()),
+        }
+        print(f"  SOM: σ={som_stats['sigma']:.3f}, α={som_stats['alpha']:.4f}, step={som_stats['step']}")
+
+    model.train()
+    return {
+        "stage": stage_name,
+        "n_samples": stage_n,
+        "epoch": epoch,
+        "n_steps": step,
+        "elapsed_s": elapsed,
+        "val_loss": val_loss_mean,
+        "train_loss_mean": train_loss_mean,
+        "overfitting_gap": overfitting_gap,
+        "perplexity": ppl,
+        "eval_acc": eval_acc,
+        "final_rss_mb": monitor.rss_mbs[-1] if monitor.rss_mbs else 0.0,
+        "max_rss_mb": max(monitor.rss_mbs) if monitor.rss_mbs else 0.0,
+        "avg_tflops": float(np.mean(monitor.tflops[-step:])) if monitor.tflops else 0.0,
+        "avg_tokens_per_sec": float(np.mean(monitor.tokens_per_sec[-step:])) if monitor.tokens_per_sec else 0.0,
+        "n_alerts_in_stage": sum(1 for a in monitor.alerts if a[0] >= len(monitor.train_losses) - step),
+        "som": som_stats,
+        "n_train": len(train_set),
+        "n_val": len(val_set),
+    }
+
+
+# ==============================================================================
+# MAIN
+# ==============================================================================
+def main():
+    print("=" * 72)
+    print("TREINO V6 PROGRESSIVO — esquema de samples crescente")
+    print("=" * 72)
+    print(f"  Python:             {sys.version.split()[0]}")
+    print(f"  Torch:              {torch.__version__}")
+    print(f"  IPEX ativo:         {HAS_IPEX}" + (f" (v{IPEX_VERSION})" if HAS_IPEX else ""))
+    print(f"  OneDNN enabled:     {torch.backends.mkldnn.enabled}")
+    print(f"  ONEDNN_MAX_CPU_ISA: {os.environ.get('ONEDNN_MAX_CPU_ISA')}")
+    print(f"  OMP_NUM_THREADS:    {os.environ.get('OMP_NUM_THREADS')}")
+    print(f"  EPOCHS:             {EPOCHS}")
+    print(f"  BATCH_SIZE:         {BATCH_SIZE}")
+    print(f"  MAX_SEQ_LEN:        {MAX_SEQ_LEN}")
+    print(f"  NUM_LAYERS_HYP:     {NUM_LAYERS_HYP}")
+    print(f"  Stages PUNCT:       {PUNCTUATION_STAGES}")
+    print(f"  Stages TEXT:        {TEXT_STAGES}")
+    print(f"  Stages HEAVY:       {HEAVY_STAGES}")
+    print("=" * 72)
+
+    # 1. Tokenizer
+    tokenizer_path = str(PROJECT_DIR / "BiGRU_T_version" / "model_final" / "tokenizer" / "tokenizer.json")
+    print(f"\n[INFO] Loading tokenizer: {tokenizer_path}")
+    tokenizer = BBPETokenizer.load(tokenizer_path)
+    global VOCAB_SIZE
+    VOCAB_SIZE = tokenizer.vocab_size
+    print(f"[INFO] Tokenizer loaded: vocab_size={VOCAB_SIZE}")
+
+    # 2. Model
+    cfg = UnifiedModelConfig(
+        vocab_size=VOCAB_SIZE,
+        d_model=128,
+        max_seq_len=MAX_SEQ_LEN,
+        bigru_hidden=32,
+        d_transformer=64,
+        nhead_tu=4,
+        d_ff_tu=128,
+        output_dim_u8cell=64,
+        max_modules=8,
+        cache_len=16,
+        d_cache=128,
+        nhead_orq=8,
+        d_ff_orq=256,
+        trainT_dim=128,
+        nhead_train=4,
+        d_ff_train=256,
+        num_layers_train=2,
+        hypT_dim=128,
+        nhead_hyp=4,
+        d_ff_hyp=256,
+        num_layers_hyp=NUM_LAYERS_HYP,
+        use_circular_reasoning=True,
+        circular_n_cycles=3,
+    )
+    model = UnifiedModel(cfg)
+    n_params = sum(p.numel() for p in model.parameters())
+    print(f"[INFO] Model params: {n_params:,} ({n_params/1e6:.2f}M)")
+
+    # Apply IPEX optimize to model (CPU optimization)
+    if HAS_IPEX:
+        try:
+            model = ipex.optimize(model, level="O1")
+            print(f"[INFO] ipex.optimize applied (level=O1)")
+        except Exception as e:
+            print(f"[WARN] ipex.optimize failed: {e}")
+
+    # 3. V6 Components
+    mtp = MTPModule(d_model=128, vocab_size=VOCAB_SIZE, K=4, learnable_alpha=True)
+    if hasattr(model, "token_embedding"):
+        mtp.set_embedding(model.token_embedding)
+
+    mtp_adaptive_attn = MTPAdaptiveAttention(d_model=128, nhead=4, window_size=8)
+
+    rep_penalty = DynamicRepetitionPenalty(
+        vocab_size=VOCAB_SIZE, embedding_dim=128, window_size=32,
+    )
+    if hasattr(model, "token_embedding"):
+        rep_penalty.set_embedding(model.token_embedding)
+
+    reasoning_engine = ReasoningEngine(
+        d_model=128, vocab_size=VOCAB_SIZE, n_phases=8, max_steps=4,
+        use_bayesian_selector=True,
+    )
+
+    ewc = ElasticWeightConsolidation(model, lambda_init=10.0, adaptive_lambda=True)
+
+    rlhf_mapping = LearnablePossibilityMapping(
+        model=model, vocab_size=VOCAB_SIZE, d_model=128,
+    )
+
+    tool_cache = ToolCache(max_size=64, ttl=600.0)
+    tool_engine = ToolMutationEngine(cache=tool_cache)
+    def echo_tool(x):
+        return x
+    tool_engine.register("echo", echo_tool, "Echo tool for testing")
+    tool_engine.compose("double_echo", "echo", "echo", "Echo composed with echo")
+    tool_agent = ToolAgentCoordinator(mutation_engine=tool_engine, max_workers=2)
+
+    pipeline = OptimizedPipeline(
+        model=model,
+        tokenizer=tokenizer,
+        mtp=mtp,
+        mtp_adaptive_attn=mtp_adaptive_attn,
+        rep_penalty=rep_penalty,
+        reasoning_engine=reasoning_engine,
+        ewc=ewc,
+        rlhf_mapping=rlhf_mapping,
+        tool_engine=tool_engine,
+        tool_agent=tool_agent,
+    )
+
+    meta_cfg = MetaConfigurator(model, meta_lr=0.01)
+
+    optimizer = torch.optim.AdamW(model.parameters(), lr=LR, weight_decay=0.01)
+
+    monitor = MetricsMonitor()
+    mcq_eval = make_mini_mcq_eval(tokenizer, n_questions=8)
+
+    # 4. Run progressive stages
+    evolution: List[dict] = []
+    cumulative_punct = []
+    cumulative_text = []
+    cumulative_heavy = []
+
+    # === RESUME SUPPORT: skip already-completed stages ===
+    # If a partial report exists, load it and skip those stages
+    RESUME_REPORT = PROJECT_DIR / "BiGRU_T_version" / "v6_progressive_report.json"
+    if RESUME_REPORT.exists():
+        try:
+            old_report = json.loads(RESUME_REPORT.read_text())
+            old_evolution = old_report.get("evolution", [])
+            # Filter only complete stages (those with val_loss)
+            completed_stages = [
+                (e["stage"], e["n_samples"], e["epoch"])
+                for e in old_evolution
+                if e.get("val_loss") is not None
+            ]
+            if completed_stages:
+                print(f"\n[INFO] RESUME: Found {len(completed_stages)} completed stages from previous run:")
+                for s, n, ep in completed_stages:
+                    print(f"  - {s} n={n} ep={ep}")
+                # Carry over the old evolution entries
+                evolution = [e for e in old_evolution if e.get("val_loss") is not None]
+                # Filter the stages lists to skip completed ones
+                # (For simplicity, we just skip the entire stage type if its first stage is done)
+                # Actually, we need to skip per-stage, so let's just track which to skip
+                _skip_set = set(completed_stages)
+                def _should_skip(stage, n, ep):
+                    return (stage, n, ep) in _skip_set
+                print(f"[INFO] Will skip these stages and continue from where it left off.")
+            else:
+                _should_skip = lambda *args: False
+        except Exception as e:
+            print(f"[WARN] Could not load resume report: {e}")
+            _should_skip = lambda *args: False
+    else:
+        _should_skip = lambda *args: False
+
+    # === PUNCTUATION STAGES ===
+    print(f"\n[INFO] === PONTUAÇÃO STAGES ===")
+    for stage_n in PUNCTUATION_STAGES:
+        for epoch in range(EPOCHS):
+            if _should_skip("punctuation", stage_n, epoch):
+                print(f"\n[INFO] SKIP: punctuation n={stage_n} ep={epoch} (already done)")
+                continue
+        # Generate stage samples (cumulative)
+        new_samples = generate_punctuation_samples(tokenizer, stage_n, MAX_SEQ_LEN)
+        cumulative_punct.extend(new_samples)
+        # Use up to stage_n samples (replace if too many)
+        random.shuffle(cumulative_punct)
+        train_samples = cumulative_punct[:stage_n]
+        # Make a small val set
+        val_samples = train_samples[-max(2, stage_n // 10):]
+        train_samples = train_samples[:-max(2, stage_n // 10)]
+
+        for epoch in range(EPOCHS):
+            if _should_skip("punctuation", stage_n, epoch):
+                continue
+            stage_result = train_stage(
+                model=model, optimizer=optimizer, pipeline=pipeline,
+                meta_cfg=meta_cfg, ewc=ewc, mtp=mtp, rep_penalty=rep_penalty,
+                monitor=monitor, mcq_eval=mcq_eval,
+                train_samples=train_samples, val_samples=val_samples,
+                stage_name=f"punctuation", stage_n=stage_n, epoch=epoch,
+            )
+            evolution.append(stage_result)
+            # Incremental save (in case of crash)
+            _save_partial_report(evolution, n_params, "punctuation", stage_n, epoch)
+
+        # EWC consolidate after each punctuation stage
+        try:
+            with torch.enable_grad():
+                cons_input = torch.stack([s["input_ids"] for s in train_samples[:BATCH_SIZE]])
+                cons_target = torch.stack([s["target"] for s in train_samples[:BATCH_SIZE]])
+                def ewc_criterion(logits, target):
+                    if logits.dim() == 2 and target.dim() == 2:
+                        target = target[:, -1]
+                    return F.cross_entropy(logits, target, ignore_index=-100)
+                ewc.consolidate(cons_input, cons_target, criterion=ewc_criterion, n_samples=1)
+        except Exception as e:
+            print(f"  [WARN] EWC consolidate failed: {e}")
+
+        # Delete binaries between stages
+        cleanup_binaries()
+
+    # === TEXT STAGES ===
+    print(f"\n[INFO] === TEXTO STAGES ===")
+    for stage_n in TEXT_STAGES:
+        for epoch in range(EPOCHS):
+            if _should_skip("text", stage_n, epoch):
+                print(f"\n[INFO] SKIP: text n={stage_n} ep={epoch} (already done)")
+                continue
+        new_samples = generate_text_samples(tokenizer, stage_n, MAX_SEQ_LEN)
+        cumulative_text.extend(new_samples)
+        random.shuffle(cumulative_text)
+        train_samples = cumulative_text[:stage_n]
+        val_samples = train_samples[-max(2, stage_n // 10):]
+        train_samples = train_samples[:-max(2, stage_n // 10)]
+
+        for epoch in range(EPOCHS):
+            if _should_skip("text", stage_n, epoch):
+                continue
+            stage_result = train_stage(
+                model=model, optimizer=optimizer, pipeline=pipeline,
+                meta_cfg=meta_cfg, ewc=ewc, mtp=mtp, rep_penalty=rep_penalty,
+                monitor=monitor, mcq_eval=mcq_eval,
+                train_samples=train_samples, val_samples=val_samples,
+                stage_name=f"text", stage_n=stage_n, epoch=epoch,
+            )
+            evolution.append(stage_result)
+            _save_partial_report(evolution, n_params, "text", stage_n, epoch)
+
+        # EWC consolidate
+        try:
+            with torch.enable_grad():
+                cons_input = torch.stack([s["input_ids"] for s in train_samples[:BATCH_SIZE]])
+                cons_target = torch.stack([s["target"] for s in train_samples[:BATCH_SIZE]])
+                def ewc_criterion_t(logits, target):
+                    if logits.dim() == 2 and target.dim() == 2:
+                        target = target[:, -1]
+                    return F.cross_entropy(logits, target, ignore_index=-100)
+                ewc.consolidate(cons_input, cons_target, criterion=ewc_criterion_t, n_samples=1)
+        except Exception as e:
+            print(f"  [WARN] EWC consolidate failed: {e}")
+
+        cleanup_binaries()
+
+    # === HEAVY STAGES ===
+    print(f"\n[INFO] === PESADOS STAGES ===")
+    for stage_n in HEAVY_STAGES:
+        for epoch in range(EPOCHS):
+            if _should_skip("heavy", stage_n, epoch):
+                print(f"\n[INFO] SKIP: heavy n={stage_n} ep={epoch} (already done)")
+                continue
+        new_samples = generate_heavy_samples(tokenizer, stage_n, MAX_SEQ_LEN)
+        cumulative_heavy.extend(new_samples)
+        random.shuffle(cumulative_heavy)
+        train_samples = cumulative_heavy[:stage_n]
+        val_samples = train_samples[-max(2, stage_n // 10):]
+        train_samples = train_samples[:-max(2, stage_n // 10)]
+
+        for epoch in range(EPOCHS):
+            if _should_skip("heavy", stage_n, epoch):
+                continue
+            stage_result = train_stage(
+                model=model, optimizer=optimizer, pipeline=pipeline,
+                meta_cfg=meta_cfg, ewc=ewc, mtp=mtp, rep_penalty=rep_penalty,
+                monitor=monitor, mcq_eval=mcq_eval,
+                train_samples=train_samples, val_samples=val_samples,
+                stage_name=f"heavy", stage_n=stage_n, epoch=epoch,
+            )
+            evolution.append(stage_result)
+            _save_partial_report(evolution, n_params, "heavy", stage_n, epoch)
+
+        # EWC consolidate
+        try:
+            with torch.enable_grad():
+                cons_input = torch.stack([s["input_ids"] for s in train_samples[:BATCH_SIZE]])
+                cons_target = torch.stack([s["target"] for s in train_samples[:BATCH_SIZE]])
+                def ewc_criterion_h(logits, target):
+                    if logits.dim() == 2 and target.dim() == 2:
+                        target = target[:, -1]
+                    return F.cross_entropy(logits, target, ignore_index=-100)
+                ewc.consolidate(cons_input, cons_target, criterion=ewc_criterion_h, n_samples=1)
+        except Exception as e:
+            print(f"  [WARN] EWC consolidate failed: {e}")
+
+        cleanup_binaries()
+
+    # 5. Final summary
+    print(f"\n{'=' * 72}")
+    print(f"  EVOLUÇÃO COMPLETA")
+    print(f"{'=' * 72}")
+    print(f"  {'stage':<14} {'n':>4} {'ep':>3} {'val_loss':>10} {'ppl':>10} {'eval_acc':>10} {'rss_mb':>8} {'tflops':>8}")
+    print(f"  {'-'*14} {'-'*4} {'-'*3} {'-'*10} {'-'*10} {'-'*10} {'-'*8} {'-'*8}")
+    for e in evolution:
+        print(f"  {e['stage']:<14} {e['n_samples']:>4} {e['epoch']:>3} "
+              f"{e['val_loss']:>10.4f} {e['perplexity']:>10.2f} "
+              f"{e['eval_acc']*100:>9.2f}% {e['final_rss_mb']:>8.0f} {e['avg_tflops']:>8.4f}")
+
+    final_summary = monitor.summary()
+    final_lp = {
+        "T": float(torch.exp(meta_cfg.log_temperature.detach()).item()),
+        "tau": float(torch.exp(meta_cfg.log_tau.detach()).item()),
+        "lambda_ent": float(torch.exp(model.log_lambda_ent.detach()).item()) if hasattr(model, "log_lambda_ent") else None,
+        "init_gate": float(model.circular_reasoning.residual_gate.mean().item()) if hasattr(model, "circular_reasoning") else None,
+        "mtp_alphas": [float(x) for x in mtp.alphas.tolist()] if mtp.K > 1 else [],
+        "rep_penalty_lambda": float(rep_penalty.lambda_val.item()),
+        "ewc_lambda": float(ewc.lambda_val.item()),
+        "rlhf_eta": float(rlhf_mapping.eta.item()),
+    }
+    final_summary["final_learnable_params"] = final_lp
+    final_summary["n_w8a8_layers"] = sum(1 for m in model.modules() if "QuantizedLinear" in type(m).__name__ or "SmoothQuantW8A8" in type(m).__name__)
+
+    print(f"\n[INFO] Final learnable params:")
+    for k, v in final_lp.items():
+        print(f"  {k}: {v}")
+
+    # 6. Report
+    report = {
+        "version": "V6_progressive",
+        "timestamp": time.time(),
+        "config": {
+            "epochs": EPOCHS,
+            "batch_size": BATCH_SIZE,
+            "max_seq_len": MAX_SEQ_LEN,
+            "num_layers_hyp": NUM_LAYERS_HYP,
+            "stages_punctuation": PUNCTUATION_STAGES,
+            "stages_text": TEXT_STAGES,
+            "stages_heavy": HEAVY_STAGES,
+        },
+        "xeon_env": {
+            "OMP_NUM_THREADS": os.environ.get("OMP_NUM_THREADS"),
+            "ONEDNN_MAX_CPU_ISA": os.environ.get("ONEDNN_MAX_CPU_ISA"),
+            "IPEX": HAS_IPEX,
+            "IPEX_VERSION": IPEX_VERSION,
+            "torch_version": torch.__version__,
+            "torch_threads": torch.get_num_threads(),
+            "onednn_enabled": torch.backends.mkldnn.enabled,
+        },
+        "evolution": evolution,
+        "final_summary": final_summary,
+        "n_params": n_params,
+    }
+    report_path = PROJECT_DIR / "BiGRU_T_version" / "v6_progressive_report.json"
+    report_path.write_text(json.dumps(report, indent=2, ensure_ascii=False, default=str))
+    print(f"\n[INFO] Report saved: {report_path}")
+
+    # Final cleanup of binaries
+    cleanup_binaries()
+    print(f"\n[INFO] V6 progressive training complete. {len(evolution)} stages captured.")
+
+
+if __name__ == "__main__":
+    main()