Upload folder using huggingface_hub

scripts/smoke_test.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""smoke_test.py — Smoke test do pipeline BiGRU_T_version.
+
+Verifica:
+1. Importação de todos os módulos
+2. Criação do UnifiedModel
+3. Forward pass sem erro
+4. Backward pass sem erro
+5. QuantizedLinear funcionando (W8A8 fake quant)
+6. ModuleSelector produzindo alpha + entropy_reg
+7. apply_gradient_surgery sem erro
+8. MetaConfigurator sem erro
+9. KillSwitch detectando condições de kill
+10. Multimodal encoders importáveis
+
+NÃO treina — apenas valida que o pipeline está íntegro.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+os.environ.setdefault("OMP_NUM_THREADS", "2")
+os.environ.setdefault("MKL_NUM_THREADS", "2")
+
+import torch
+torch.set_num_threads(2)
+
+
+def test_imports():
+    """Testa importação de todos os módulos."""
+    print("=== Test 1: Imports ===")
+    try:
+        from bigru_t import (
+            UnifiedModel, UnifiedModelConfig, create_unified_model,
+            u8cell_T, BiGRU4, TransformerUnit, OrqCell, TrainT, HypT,
+            ModuleSelector,
+            QuantizedLinear, quantize_tensor, apply_w8a8,
+            apply_gradient_surgery, orthogonalize_gradient,
+            MetaConfigurator,
+            KillSwitch, KillSwitchState,
+            BiGRU_T_Trainer, TrainerConfig,
+        )
+        print("  OK: all imports successful")
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        import traceback; traceback.print_exc()
+        return False
+
+
+def test_model_forward():
+    """Testa forward pass do UnifiedModel."""
+    print("\n=== Test 2: Model forward ===")
+    try:
+        from bigru_t import create_unified_model, UnifiedModelConfig
+        config = UnifiedModelConfig(
+            vocab_size=1000,
+            d_model=32,
+            max_seq_len=16,
+            pad_token_id=1,
+            max_modules=2,  # pequeno para teste rápido
+            bigru_hidden=8,
+            d_transformer=16,
+            nhead_tu=2,
+            d_ff_tu=32,
+            output_dim_u8cell=16,
+            cache_len=4,
+            d_cache=32,
+            nhead_orq=2,
+            d_ff_orq=64,
+            trainT_dim=32,
+            nhead_train=2,
+            d_ff_train=64,
+            num_layers_train=1,
+            hypT_dim=32,
+            nhead_hyp=2,
+            d_ff_hyp=64,
+            num_layers_hyp=1,
+        )
+        model, _ = create_unified_model(config)
+        params = model.count_parameters()
+        print(f"  params: {params['total']:,} ({params['total_M']:.3f}M)")
+
+        # Forward com token IDs
+        x = torch.randint(0, 1000, (2, 16))  # (batch=2, T=16)
+        y_hat, delta = model(x, temperature=1.0, use_hypothesis=False)
+        assert y_hat.shape == (2, 1000), f"y_hat shape {y_hat.shape} != (2, 1000)"
+        assert delta.shape == (2, 1000), f"delta shape {delta.shape} != (2, 1000)"
+        print(f"  OK: forward y_hat {y_hat.shape}, delta {delta.shape}")
+
+        # Forward com hipótese
+        y_hat, delta = model(x, temperature=1.0, use_hypothesis=True, stop_grad_hyp=True)
+        assert y_hat.shape == (2, 1000)
+        assert delta.shape == (2, 1000)
+        print(f"  OK: forward with hypothesis")
+
+        # Forward com return_aux
+        y_hat, delta, aux = model(x, temperature=1.0, use_hypothesis=False, return_aux=True)
+        assert "entropy_reg" in aux
+        assert "alpha" in aux
+        assert aux["alpha"].shape == (2,)
+        print(f"  OK: return_aux entropy_reg={aux['entropy_reg'].item():.4f}, alpha={aux['alpha'].tolist()}")
+
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        import traceback; traceback.print_exc()
+        return False
+
+
+def test_backward():
+    """Testa backward pass."""
+    print("\n=== Test 3: Backward ===")
+    try:
+        from bigru_t import create_unified_model, UnifiedModelConfig
+        import torch.nn.functional as F
+        config = UnifiedModelConfig(
+            vocab_size=100, d_model=16, max_seq_len=8, pad_token_id=1,
+            max_modules=2, bigru_hidden=4, d_transformer=8, nhead_tu=2, d_ff_tu=16,
+            output_dim_u8cell=8, cache_len=4, d_cache=16, nhead_orq=2, d_ff_orq=32,
+            trainT_dim=16, nhead_train=2, d_ff_train=32, num_layers_train=1,
+            hypT_dim=16, nhead_hyp=2, d_ff_hyp=32, num_layers_hyp=1,
+        )
+        model, _ = create_unified_model(config)
+        x = torch.randint(0, 100, (2, 8))
+        target = torch.randint(0, 100, (2,))
+        y_hat, _ = model(x, use_hypothesis=False)
+        loss = F.cross_entropy(y_hat, target)
+        loss.backward()
+        # Verifica que gradientes foram computados
+        n_with_grad = sum(1 for p in model.parameters() if p.grad is not None and p.grad.abs().sum() > 0)
+        n_total = sum(1 for p in model.parameters() if p.requires_grad)
+        print(f"  OK: backward done, loss={loss.item():.4f}, {n_with_grad}/{n_total} params have grad")
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        import traceback; traceback.print_exc()
+        return False
+
+
+def test_quantized_linear():
+    """Testa QuantizedLinear (Lema 3)."""
+    print("\n=== Test 4: QuantizedLinear (W8A8) ===")
+    try:
+        from bigru_t.quantization.quantized_linear import QuantizedLinear, quantize_tensor
+        # Test quantize_tensor
+        x = torch.randn(100)
+        x_q = quantize_tensor(x, num_bits=8)
+        err = (x - x_q).abs().max().item()
+        print(f"  quantize_tensor max err: {err:.4f}")
+
+        # Test QuantizedLinear
+        ql = QuantizedLinear(10, 5)
+        x = torch.randn(2, 10)
+        y = ql(x)
+        assert y.shape == (2, 5)
+        print(f"  OK: QuantizedLinear forward {y.shape}")
+
+        # Backward
+        y.sum().backward()
+        assert ql.weight.grad is not None
+        print(f"  OK: QuantizedLinear backward, grad norm {ql.weight.grad.norm().item():.4f}")
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        return False
+
+
+def test_gradient_surgery():
+    """Testa apply_gradient_surgery (Lema 2)."""
+    print("\n=== Test 5: Gradient surgery ===")
+    try:
+        from bigru_t.training.gradient_surgery import orthogonalize_gradient, apply_gradient_surgery
+        from bigru_t import create_unified_model, UnifiedModelConfig
+        import torch.nn.functional as F
+
+        # Test orthogonalize_gradient — caso conflitante
+        g_main = torch.tensor([1.0, 0.0])
+        g_hyp = torch.tensor([-1.0, 0.0])  # conflitante (dot = -1 < 0)
+        g_orth = orthogonalize_gradient(g_main, g_hyp)
+        # Projeção: g_hyp - (dot/norm_sq) * g_main = (-1, 0) - (-1/1) * (1, 0) = (0, 0)
+        assert torch.allclose(g_orth, torch.zeros(2), atol=1e-6), f"Expected (0,0), got {g_orth}"
+        print(f"  OK: orthogonalize conflitante → {g_orth.tolist()} (should be [0, 0])")
+
+        # Test orthogonalize_gradient — caso alinhado
+        g_main = torch.tensor([1.0, 0.0])
+        g_hyp = torch.tensor([0.5, 0.0])  # alinhado (dot = 0.5 > 0)
+        g_orth = orthogonalize_gradient(g_main, g_hyp)
+        # Sem projeção: g_hyp permanece
+        assert torch.allclose(g_orth, g_hyp), f"Expected {g_hyp}, got {g_orth}"
+        print(f"  OK: orthogonalize alinhado → {g_orth.tolist()} (should be [0.5, 0.0])")
+
+        # Test apply_gradient_surgery end-to-end
+        config = UnifiedModelConfig(
+            vocab_size=50, d_model=8, max_seq_len=4, pad_token_id=1,
+            max_modules=2, bigru_hidden=2, d_transformer=4, nhead_tu=2, d_ff_tu=8,
+            output_dim_u8cell=4, cache_len=2, d_cache=8, nhead_orq=2, d_ff_orq=16,
+            trainT_dim=8, nhead_train=2, d_ff_train=16, num_layers_train=1,
+            hypT_dim=8, nhead_hyp=2, d_ff_hyp=16, num_layers_hyp=1,
+        )
+        model, _ = create_unified_model(config)
+        x = torch.randint(0, 50, (2, 4))
+        target = torch.randint(0, 50, (2,))
+        y_hat_main, delta = model(x, use_hypothesis=True, stop_grad_hyp=True)
+        loss_main = F.cross_entropy(y_hat_main, target)
+        loss_hyp = F.cross_entropy(y_hat_main + delta, target)
+        apply_gradient_surgery(model, loss_main, loss_hyp)
+        n_with_grad = sum(1 for p in model.parameters() if p.grad is not None)
+        print(f"  OK: apply_gradient_surgery, {n_with_grad} params have .grad")
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        import traceback; traceback.print_exc()
+        return False
+
+
+def test_meta_configurator():
+    """Testa MetaConfigurator (Lema 4)."""
+    print("\n=== Test 6: MetaConfigurator ===")
+    try:
+        from bigru_t import create_unified_model, UnifiedModelConfig
+        from bigru_t.training.meta_configurator import MetaConfigurator
+
+        config = UnifiedModelConfig(
+            vocab_size=50, d_model=8, max_seq_len=4, pad_token_id=1,
+            max_modules=2, bigru_hidden=2, d_transformer=4, nhead_tu=2, d_ff_tu=8,
+            output_dim_u8cell=4, cache_len=2, d_cache=8, nhead_orq=2, d_ff_orq=16,
+            trainT_dim=8, nhead_train=2, d_ff_train=16, num_layers_train=1,
+            hypT_dim=8, nhead_hyp=2, d_ff_hyp=16, num_layers_hyp=1,
+        )
+        model, _ = create_unified_model(config)
+        meta = MetaConfigurator(model, meta_lr=0.01, sharpness_lambda=0.01)
+
+        # Initial T and tau
+        print(f"  Initial: T={meta.temperature:.4f}, tau={meta.tau:.4f}")
+
+        # Run one meta step
+        x = torch.randint(0, 50, (2, 4))
+        target = torch.randint(0, 50, (2,))
+        result = meta.forward_with_meta(x, target)
+        print(f"  After 1 step: T={result['T_new']:.4f}, tau={result['tau_new']:.4f}, "
+              f"loss_val={result['loss_val']:.4f}, sharpness={result['sharpness']:.4f}")
+
+        # Check tau was synced to model
+        assert model.tau.item() == result["tau_new"], f"model.tau {model.tau.item()} != {result['tau_new']}"
+        print(f"  OK: MetaConfigurator synced model.tau = {model.tau.item():.4f}")
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        import traceback; traceback.print_exc()
+        return False
+
+
+def test_kill_switch():
+    """Testa KillSwitch."""
+    print("\n=== Test 7: KillSwitch ===")
+    try:
+        from bigru_t.training.kill_switch import KillSwitch
+        ks = KillSwitch(loss_patience=3, ram_threshold_pct=99.9, disk_min_free_gb=0.001)
+
+        # Simula 5 steps com loss não decrescente
+        for i in range(5):
+            state = ks.check(i, loss=10.0, active_modules=2)
+        assert state.reason is not None, "Expected kill after patience exhausted"
+        print(f"  OK: kill triggered after {state.step} steps: {state.reason}")
+
+        # Resumo
+        summary = ks.summary()
+        print(f"  OK: summary keys: {list(summary.keys())}")
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        return False
+
+
+def test_multimodal_imports():
+    """Testa importação dos encoders multimodais (reaproveitados)."""
+    print("\n=== Test 8: Multimodal imports ===")
+    try:
+        # Não importa os módulos diretamente (podem ter dependências pesadas)
+        # Apenas verifica que os arquivos existem
+        multimodal_dir = Path(__file__).parent.parent / "src" / "bigru_t" / "multimodal"
+        expected = ["text_encoder.py", "image_encoder.py", "audio_encoder.py", "video_encoder.py", "modal_router.py", "fusion_layer.py"]
+        for f in expected:
+            assert (multimodal_dir / f).exists(), f"Missing {f}"
+        print(f"  OK: {len(expected)} multimodal modules present")
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        return False
+
+
+def test_utils_reused():
+    """Verifica que módulos utilitários reaproveitados estão presentes."""
+    print("\n=== Test 9: Reused utility modules ===")
+    try:
+        utils_dir = Path(__file__).parent.parent / "src" / "bigru_t" / "utils"
+        expected = ["hardware_detector.py", "xeon_runtime.py", "oom_guard.py", "memory_monitor.py", "tensor_ops.py", "validators.py", "logging_utils.py"]
+        for f in expected:
+            assert (utils_dir / f).exists(), f"Missing {f}"
+        print(f"  OK: {len(expected)} utility modules present")
+
+        # Test xeon_runtime import
+        try:
+            from bigru_t.utils.xeon_runtime import optimize_xeon_environment
+            optimize_xeon_environment()
+            print(f"  OK: optimize_xeon_environment() called")
+        except Exception as e:
+            print(f"  WARN: xeon_runtime optimize failed: {e}")
+        return True
+    except Exception as e:
+        print(f"  FAIL: {e}")
+        return False
+
+
+def main():
+    print("=" * 60)
+    print("BiGRU_T_version — Smoke Test")
+    print("=" * 60)
+
+    tests = [
+        test_imports,
+        test_model_forward,
+        test_backward,
+        test_quantized_linear,
+        test_gradient_surgery,
+        test_meta_configurator,
+        test_kill_switch,
+        test_multimodal_imports,
+        test_utils_reused,
+    ]
+    results = []
+    for t in tests:
+        try:
+            r = t()
+            results.append(r)
+        except Exception as e:
+            print(f"  CRASH: {e}")
+            results.append(False)
+
+    print("\n" + "=" * 60)
+    passed = sum(results)
+    total = len(results)
+    print(f"Smoke test: {passed}/{total} passed")
+    print("=" * 60)
+    sys.exit(0 if passed == total else 1)
+
+
+if __name__ == "__main__":
+    main()

scripts/train.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""train.py — Treino de bug-detection para BiGRU_T_version (2 épocas).
+
+Especificações do usuário atendidas:
+- 2 épocas fixas (não mudar sem permissão)
+- Sem dados inventados (apenas datasets do repo + HF públicos)
+- Monitorar RAM, disco, loss, perplexidade
+- Kill-switch: matar se loss não diminuir ou RAM explodir
+- Estados temporários salvos durante treino e APAGADOS ao final
+- Parâmetros do modelo aprendidos automaticamente (sem inserção manual)
+- Ambiente otimizado para Xeon (AVX512, OpenMP, MKL)
+- HF_TOKEN apagado ao final (se usado para datasets privados)
+
+Uso:
+    export HF_TOKEN="hf_xxx"  # opcional para datasets públicos
+    python scripts/train.py \\
+        --datasets CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1,Madras1/corpus-ptbr-v2 \\
+        --max-samples 30 \\
+        --epochs 2
+"""
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+# Adiciona src/ ao path
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+# Otimização Xeon (deve vir ANTES de importar torch)
+os.environ.setdefault("OMP_NUM_THREADS", "2")
+os.environ.setdefault("MKL_NUM_THREADS", "2")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+os.environ.setdefault("TORCH_NUM_THREADS", "2")
+
+import torch
+torch.set_num_threads(2)
+
+# Tenta otimizar ambiente Xeon (do módulo reaproveitado)
+try:
+    from bigru_t.utils.xeon_runtime import optimize_xeon_environment
+    optimize_xeon_environment()
+except Exception as e:
+    logging.warning(f"Could not apply Xeon optimization: {e}")
+
+from bigru_t import (
+    UnifiedModel, UnifiedModelConfig, create_unified_model,
+    BiGRU_T_Trainer, TrainerConfig,
+)
+from bigru_t.data.streaming_datasets import stream_dataset
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%H:%M:%S",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+
+def load_tokenizer(path: str):
+    """Carrega tokenizer BBPE 16K."""
+    from tokenizers import Tokenizer
+    return Tokenizer.from_file(path)
+
+
+def load_samples(
+    datasets: str,
+    max_samples_per_dataset: int,
+    hf_token: str | None,
+) -> list:
+    """Carrega amostras via streaming (reaproveita streaming_datasets_v13_9)."""
+    samples = []
+    datasets_list = [d.strip() for d in datasets.split(",") if d.strip()]
+    logger.info(f"Loading samples from {len(datasets_list)} datasets...")
+    for ds_name in datasets_list:
+        ds_start = time.time()
+        ds_count = 0
+        try:
+            for sample in stream_dataset(
+                ds_name,
+                max_samples=max_samples_per_dataset,
+                hf_token=hf_token,
+            ):
+                samples.append(sample)
+                ds_count += 1
+                if ds_count >= max_samples_per_dataset:
+                    break
+                if time.time() - ds_start > 300:
+                    logger.warning(f"  timeout em {ds_name} após {ds_count} amostras")
+                    break
+        except Exception as e:
+            logger.error(f"Erro carregando {ds_name}: {e}")
+            continue
+        logger.info(f"  {ds_name}: {ds_count} amostras em {time.time()-ds_start:.1f}s")
+    return samples
+
+
+def main():
+    parser = argparse.ArgumentParser(description="BiGRU_T_version — Bug-detection training (2 epochs)")
+    parser.add_argument(
+        "--datasets",
+        type=str,
+        default="CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1,Madras1/corpus-ptbr-v2,dominguesm/restore-punctuation-ptbr-dataset",
+        help="Lista separada por vírgulas de datasets HF",
+    )
+    parser.add_argument("--max-samples", type=int, default=30, help="Amostras POR dataset (default 30)")
+    parser.add_argument("--epochs", type=int, default=2, help="Nº de épocas (default 2)")
+    parser.add_argument("--batch-size", type=int, default=1)
+    parser.add_argument("--grad-accum", type=int, default=4)
+    parser.add_argument("--lr", type=float, default=1e-3)
+    parser.add_argument("--max-seq-len", type=int, default=64)
+    parser.add_argument("--output-dir", type=str, default="/home/z/my-project/BiGRU_T_version/model_final")
+    parser.add_argument("--temp-dir", type=str, default="/home/z/my-project/BiGRU_T_version/_temp_checkpoints")
+    parser.add_argument(
+        "--tokenizer-path",
+        type=str,
+        default="/home/z/my-project/source/model_final/tokenizer/tokenizer.json",
+    )
+    parser.add_argument("--no-hypothesis", action="store_true", help="Desativar hipótese (Lema 3)")
+    parser.add_argument("--keep-temp", action="store_true", help="Manter checkpoints temporários")
+    parser.add_argument("--smoke-test", action="store_true", help="Smoke test: 5 samples, 1 epoch")
+    args = parser.parse_args()
+
+    if args.smoke_test:
+        logger.info("SMOKE TEST MODE — 5 samples/dataset, 1 epoch")
+        args.max_samples = 5
+        args.epochs = 1
+        args.grad_accum = 2
+        args.datasets = "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1"
+
+    # HF token (opcional para datasets públicos)
+    hf_token = os.environ.get("HF_TOKEN") or None
+
+    # Configuração do modelo
+    model_config = UnifiedModelConfig(
+        vocab_size=16384,
+        d_model=128,
+        max_seq_len=args.max_seq_len,
+        # input_dim é automaticamente = d_model via __post_init__
+        # Para bug-detection, reduzimos max_modules (64 é caro)
+        max_modules=8,  # 8 módulos em vez de 64
+        bigru_hidden=32,
+        d_transformer=64,
+        nhead_tu=4,
+        d_ff_tu=128,
+        output_dim_u8cell=64,
+        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=2,
+        num_bits=8,
+        dropout=0.1,
+    )
+
+    # Cria modelo
+    logger.info("Criando UnifiedModel...")
+    model, _ = create_unified_model(model_config)
+    params = model.count_parameters()
+    logger.info(f"  params: {params['total']:,} ({params['total_M']:.2f}M)")
+
+    # Carrega tokenizer
+    tokenizer = load_tokenizer(args.tokenizer_path)
+
+    # Carrega datasets
+    samples = load_samples(args.datasets, args.max_samples, hf_token)
+    n = len(samples)
+    if n == 0:
+        logger.error("Nenhuma amostra carregada — abortando")
+        sys.exit(1)
+    logger.info(f"Total: {n} amostras carregadas")
+
+    # Split 90/10 treino/val
+    import random
+    random.seed(42)
+    random.shuffle(samples)
+    split = max(1, int(0.9 * n))
+    train_samples = samples[:split]
+    val_samples = samples[split:] or samples[:1]  # fallback: 1 amostra
+    logger.info(f"  train: {len(train_samples)} | val: {len(val_samples)}")
+
+    # Configuração do trainer
+    trainer_config = TrainerConfig(
+        epochs=args.epochs,
+        datasets=args.datasets,
+        max_samples_per_dataset=args.max_samples,
+        max_seq_len=args.max_seq_len,
+        per_device_batch_size=args.batch_size,
+        grad_accum=args.grad_accum,
+        lr=args.lr,
+        use_hypothesis=not args.no_hypothesis,
+        output_dir=args.output_dir,
+        temp_dir=args.temp_dir,
+        keep_temp=args.keep_temp,
+    )
+
+    # Trainer
+    trainer = BiGRU_T_Trainer(
+        model=model,
+        tokenizer=tokenizer,
+        config=trainer_config,
+        train_samples=train_samples,
+        val_samples=val_samples,
+    )
+
+    # Treina
+    result = trainer.train()
+
+    # Print resultado
+    import json
+    print("\n=== Resultado Final ===")
+    print(json.dumps(result, indent=2, default=str))
+
+    # Apaga HF token do ambiente (especificação do usuário)
+    if "HF_TOKEN" in os.environ:
+        del os.environ["HF_TOKEN"]
+        logger.info("HF_TOKEN apagado do ambiente")
+
+    # Exit code: 0 se OK, 1 se morto pelo kill-switch
+    sys.exit(0 if not result.get("killed") else 1)
+
+
+if __name__ == "__main__":
+    main()

scripts/train_fast.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""train_fast.py — Treino rápido de bug-detection (2 épocas, modelo pequeno).
+
+Versão otimizada para rodar em < 5 minutos no ambiente Xeon 2-core:
+- max_modules=4 (em vez de 8)
+- bigru_hidden=16 (em vez de 32)
+- d_transformer=32 (em vez de 64)
+- num_layers_train=1, num_layers_hyp=1
+- max_samples=8 por dataset
+- 1 dataset (CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1)
+
+Valida todos os 4 lemas sem pretender produzir modelo SOTA.
+"""
+from __future__ import annotations
+
+import os
+import sys
+import time
+import json
+import logging
+from pathlib import Path
+
+# Adiciona src/ ao path
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+# Otimização Xeon
+os.environ.setdefault("OMP_NUM_THREADS", "2")
+os.environ.setdefault("MKL_NUM_THREADS", "2")
+os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
+
+import torch
+torch.set_num_threads(2)
+
+try:
+    from bigru_t.utils.xeon_runtime import optimize_xeon_environment
+    optimize_xeon_environment()
+except Exception as e:
+    logging.warning(f"Could not apply Xeon optimization: {e}")
+
+from bigru_t import (
+    UnifiedModel, UnifiedModelConfig, create_unified_model,
+    BiGRU_T_Trainer, TrainerConfig,
+)
+from bigru_t.data.streaming_datasets import stream_dataset
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%H:%M:%S",
+    handlers=[logging.StreamHandler()],
+)
+logger = logging.getLogger(__name__)
+
+
+def main():
+    # HF token
+    hf_token = os.environ.get("HF_TOKEN") or None
+
+    # Modelo pequeno para bug-detection rápido
+    model_config = UnifiedModelConfig(
+        vocab_size=16384,
+        d_model=64,
+        max_seq_len=32,
+        pad_token_id=1,
+        max_modules=4,           # 4 módulos em vez de 8
+        bigru_hidden=16,         # 16 em vez de 32
+        d_transformer=32,        # 32 em vez de 64
+        nhead_tu=2,              # 2 em vez de 4 (32/2=16 ok)
+        d_ff_tu=64,              # 64 em vez de 128
+        output_dim_u8cell=32,    # 32 em vez de 64
+        cache_len=8,             # 8 em vez de 16
+        d_cache=64,              # 64 em vez de 128
+        nhead_orq=2,             # 2 em vez de 8 (64/2=32 ok)
+        d_ff_orq=128,            # 128 em vez de 256
+        trainT_dim=64,
+        nhead_train=2,
+        d_ff_train=128,
+        num_layers_train=1,      # 1 em vez de 2
+        hypT_dim=64,
+        nhead_hyp=2,
+        d_ff_hyp=128,
+        num_layers_hyp=1,        # 1 em vez de 2
+        num_bits=8,
+        dropout=0.1,
+    )
+
+    logger.info("Criando UnifiedModel (small config)...")
+    model, _ = create_unified_model(model_config)
+    params = model.count_parameters()
+    logger.info(f"  params: {params['total']:,} ({params['total_M']:.2f}M)")
+
+    # Tokenizer
+    from tokenizers import Tokenizer
+    tok_path = "/home/z/my-project/source/model_final/tokenizer/tokenizer.json"
+    tokenizer = Tokenizer.from_file(tok_path)
+
+    # Carrega 1 dataset
+    ds_name = "CEIA-POSITIVO/ultrachat_br_clustred_balanced_v1"
+    max_samples = 8
+    logger.info(f"Loading {max_samples} samples from {ds_name}...")
+    samples = []
+    t0 = time.time()
+    for sample in stream_dataset(ds_name, max_samples=max_samples, hf_token=hf_token):
+        samples.append(sample)
+        if len(samples) >= max_samples:
+            break
+        if time.time() - t0 > 120:
+            logger.warning(f"Timeout após {len(samples)} amostras")
+            break
+    logger.info(f"Loaded {len(samples)} samples in {time.time()-t0:.1f}s")
+
+    if not samples:
+        logger.error("Nenhuma amostra carregada")
+        sys.exit(1)
+
+    # Split 90/10
+    import random
+    random.seed(42)
+    random.shuffle(samples)
+    split = max(1, int(0.9 * len(samples)))
+    train_samples = samples[:split]
+    val_samples = samples[split:] or samples[:1]
+    logger.info(f"  train: {len(train_samples)} | val: {len(val_samples)}")
+
+    # Trainer config
+    trainer_config = TrainerConfig(
+        epochs=2,
+        datasets=ds_name,
+        max_samples_per_dataset=max_samples,
+        max_seq_len=32,
+        per_device_batch_size=1,
+        grad_accum=2,
+        lr=1e-3,
+        use_hypothesis=True,
+        meta_interval=5,
+        log_every=1,
+        save_temp_every=100,  # não salvar temp (modelo pequeno)
+        output_dir="/home/z/my-project/BiGRU_T_version/model_final",
+        temp_dir="/home/z/my-project/BiGRU_T_version/_temp_checkpoints",
+        keep_temp=False,
+    )
+
+    trainer = BiGRU_T_Trainer(
+        model=model,
+        tokenizer=tokenizer,
+        config=trainer_config,
+        train_samples=train_samples,
+        val_samples=val_samples,
+    )
+
+    result = trainer.train()
+
+    print("\n=== Resultado Final ===")
+    print(json.dumps(result, indent=2, default=str))
+
+    # Apaga HF token
+    if "HF_TOKEN" in os.environ:
+        del os.environ["HF_TOKEN"]
+        logger.info("HF_TOKEN apagado do ambiente")
+
+    sys.exit(0 if not result.get("killed") else 1)
+
+
+if __name__ == "__main__":
+    main()

scripts/upload_to_hf.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""upload_to_hf.py — Upload do BiGRU_T_version para HuggingFace Hub.
+
+Faz upload de:
+- model_final/pytorch_model.bin
+- model_final/config.json
+- model_final/tokenizer/tokenizer.json
+- training_report.json
+- README.md
+- src/ (código fonte)
+- scripts/ (scripts de treino/smoke test)
+- docs/ (análise matemática)
+
+Repositório destino: PowerMachine/BiGRU_T_version (public)
+
+Uso:
+    export HF_TOKEN="hf_xxx"
+    python scripts/upload_to_hf.py
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from huggingface_hub import HfApi, create_repo
+
+
+def main():
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        print("ERROR: HF_TOKEN not set")
+        sys.exit(1)
+
+    repo_id = "PowerMachine/BiGRU_T_version"
+    project_dir = Path("/home/z/my-project/BiGRU_T_version")
+
+    print(f"Uploading to {repo_id} (public)...")
+
+    api = HfApi(token=token)
+
+    # Cria repo (idempotente)
+    try:
+        create_repo(repo_id, repo_type="model", token=token, private=False, exist_ok=True)
+        print(f"  Repo created/exists: {repo_id}")
+    except Exception as e:
+        print(f"  Warning creating repo: {e}")
+
+    # Upload de arquivos individuais
+    files_to_upload = [
+        ("README.md", "README.md"),
+        ("requirements.txt", "requirements.txt"),
+        ("training_report.json", "training_report.json"),
+        ("model_final/config.json", "config.json"),
+        ("model_final/pytorch_model.bin", "pytorch_model.bin"),
+        ("model_final/tokenizer/tokenizer.json", "tokenizer/tokenizer.json"),
+        ("docs/analysis.md", "docs/analysis.md"),
+    ]
+
+    for src, dst in files_to_upload:
+        src_path = project_dir / src
+        if not src_path.exists():
+            print(f"  SKIP (not found): {src}")
+            continue
+        print(f"  Uploading {src} → {dst}...")
+        try:
+            api.upload_file(
+                path_or_fileobj=str(src_path),
+                path_in_repo=dst,
+                repo_id=repo_id,
+                repo_type="model",
+                token=token,
+            )
+            print(f"    OK")
+        except Exception as e:
+            print(f"    FAIL: {e}")
+
+    # Upload de diretórios como pastas
+    dirs_to_upload = [
+        ("src", "src"),
+        ("scripts", "scripts"),
+    ]
+
+    for src_dir, dst_dir in dirs_to_upload:
+        src_path = project_dir / src_dir
+        if not src_path.exists():
+            print(f"  SKIP (not found): {src_dir}/")
+            continue
+        print(f"  Uploading {src_dir}/ → {dst_dir}/ ...")
+        try:
+            api.upload_folder(
+                folder_path=str(src_path),
+                path_in_repo=dst_dir,
+                repo_id=repo_id,
+                repo_type="model",
+                token=token,
+                ignore_patterns=["__pycache__", "*.pyc", ".pytest_cache", "_temp_checkpoints"],
+            )
+            print(f"    OK")
+        except Exception as e:
+            print(f"    FAIL: {e}")
+
+    print(f"\nUpload complete: https://huggingface.co/{repo_id}")
+
+    # Apaga token do ambiente (especificação do usuário)
+    del os.environ["HF_TOKEN"]
+    print("HF_TOKEN apagado do ambiente")
+
+
+if __name__ == "__main__":
+    main()