V6.5-V2-dynamic: FASE 2 PUNIÇÃO upload (3 files)

train_v6_5_v2_punicão_only.py

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

v6_5_v2_punicão_model_states.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2dee50dc8d2407917195d7b76b11ceba69b82f5caf3dac649dfc055004b7bc51
+size 43416469

v6_5_v2_punicão_report.json

@@ -0,0 +1,1199 @@
+{
+  "version": "V6.5-V2-dynamic-punicão",
+  "timestamp": "2026-08-08T21:32:29.242618",
+  "loaded_from_fase1": "/home/z/my-project/BiGRU_T_version/v6_5_v2_model_states.pt",
+  "fase1_total_samples": 3300,
+  "fase2_total_samples": 1000,
+  "fase2_meta_atingida": true,
+  "fase2_elapsed_s": 135.41348695755005,
+  "punishment_events": [
+    {
+      "step": 0,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 1,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.625,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 2,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5416666666666666,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 3,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.546875,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 4,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5625,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 5,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5520833333333334,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 7,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5517241379310345,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 8,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5454545454545454,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 9,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5337837837837838,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 10,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5426829268292683,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 11,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5388888888888889,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 12,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5204081632653061,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 14,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5092592592592593,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 15,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5043103448275862,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 16,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5080645161290323,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 17,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 18,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5183823529411765,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 19,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5173611111111112,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 21,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5110294117647058,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 22,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5138888888888888,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 23,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5036764705882353,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 24,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4930555555555556,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 25,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.4889705882352941,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 26,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4756944444444444,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 28,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.47794117647058826,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 29,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4895833333333333,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 30,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.4742647058823529,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 31,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4826388888888889,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 32,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5073529411764706,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 33,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5138888888888888,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 35,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5110294117647058,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 36,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5104166666666666,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 37,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.47794117647058826,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 38,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4791666666666667,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 39,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.47058823529411764,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 40,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4930555555555556,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 42,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.4889705882352941,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 43,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4965277777777778,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 44,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5110294117647058,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 45,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5138888888888888,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 46,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5367647058823529,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 47,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5208333333333334,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 49,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5110294117647058,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 50,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5208333333333334,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 51,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5183823529411765,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 52,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5173611111111112,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 53,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5073529411764706,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 54,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5104166666666666,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 56,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5110294117647058,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 57,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4965277777777778,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 58,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.5147058823529411,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 59,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.5104166666666666,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 60,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.4963235294117647,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 61,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4895833333333333,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 63,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.46691176470588236,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 64,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4722222222222222,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 65,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.45588235294117646,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 66,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4583333333333333,
+      "punishment_count": 0,
+      "cycle_completed": true
+    },
+    {
+      "step": 67,
+      "action": "train_hypotheses_and_activate",
+      "accuracy": 0.4632352941176471,
+      "punishment_count": 1,
+      "cycle_completed": false
+    },
+    {
+      "step": 68,
+      "action": "apply_best_delta_and_consolidate",
+      "accuracy": 0.4722222222222222,
+      "punishment_count": 0,
+      "cycle_completed": true
+    }
+  ],
+  "hypotheses_trainings": [
+    {
+      "step": 0,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.008179070428013802
+    },
+    {
+      "step": 2,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.00668971985578537
+    },
+    {
+      "step": 4,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.005471568554639816
+    },
+    {
+      "step": 7,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.00447523407638073
+    },
+    {
+      "step": 9,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.003660326125100255
+    },
+    {
+      "step": 11,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0029938064981251955
+    },
+    {
+      "step": 14,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.002448655664920807
+    },
+    {
+      "step": 16,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0020027728751301765
+    },
+    {
+      "step": 18,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0016380823217332363
+    },
+    {
+      "step": 21,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0013397991424426436
+    },
+    {
+      "step": 23,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010958312777802348
+    },
+    {
+      "step": 25,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 28,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 30,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 32,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 35,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 37,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 39,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 42,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 44,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 46,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 49,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 51,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 53,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 56,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 58,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 60,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 63,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 65,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    },
+    {
+      "step": 67,
+      "loss_initial": NaN,
+      "loss_final": NaN,
+      "delta_scale": 0.0010000000474974513
+    }
+  ],
+  "delta_applications": [
+    {
+      "step": 1,
+      "acc_before": 0.625,
+      "acc_after": 0.625,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 3,
+      "acc_before": 0.546875,
+      "acc_after": 0.546875,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 5,
+      "acc_before": 0.5520833333333334,
+      "acc_after": 0.5520833333333334,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 8,
+      "acc_before": 0.5454545454545454,
+      "acc_after": 0.5454545454545454,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 10,
+      "acc_before": 0.5426829268292683,
+      "acc_after": 0.5426829268292683,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 12,
+      "acc_before": 0.5204081632653061,
+      "acc_after": 0.5204081632653061,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 15,
+      "acc_before": 0.5043103448275862,
+      "acc_after": 0.5043103448275862,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 17,
+      "acc_before": 0.5,
+      "acc_after": 0.5,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 19,
+      "acc_before": 0.5173611111111112,
+      "acc_after": 0.5173611111111112,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 22,
+      "acc_before": 0.5138888888888888,
+      "acc_after": 0.5138888888888888,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 24,
+      "acc_before": 0.4930555555555556,
+      "acc_after": 0.4930555555555556,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 26,
+      "acc_before": 0.4756944444444444,
+      "acc_after": 0.4756944444444444,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 29,
+      "acc_before": 0.4895833333333333,
+      "acc_after": 0.4895833333333333,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 31,
+      "acc_before": 0.4826388888888889,
+      "acc_after": 0.4826388888888889,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 33,
+      "acc_before": 0.5138888888888888,
+      "acc_after": 0.5138888888888888,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 36,
+      "acc_before": 0.5104166666666666,
+      "acc_after": 0.5104166666666666,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 38,
+      "acc_before": 0.4791666666666667,
+      "acc_after": 0.4791666666666667,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 40,
+      "acc_before": 0.4930555555555556,
+      "acc_after": 0.4930555555555556,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 43,
+      "acc_before": 0.4965277777777778,
+      "acc_after": 0.4965277777777778,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 45,
+      "acc_before": 0.5138888888888888,
+      "acc_after": 0.5138888888888888,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 47,
+      "acc_before": 0.5208333333333334,
+      "acc_after": 0.5208333333333334,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 50,
+      "acc_before": 0.5208333333333334,
+      "acc_after": 0.5208333333333334,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 52,
+      "acc_before": 0.5173611111111112,
+      "acc_after": 0.5173611111111112,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 54,
+      "acc_before": 0.5104166666666666,
+      "acc_after": 0.5104166666666666,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 57,
+      "acc_before": 0.4965277777777778,
+      "acc_after": 0.4965277777777778,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 59,
+      "acc_before": 0.5104166666666666,
+      "acc_after": 0.5104166666666666,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 61,
+      "acc_before": 0.4895833333333333,
+      "acc_after": 0.4895833333333333,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 64,
+      "acc_before": 0.4722222222222222,
+      "acc_after": 0.4722222222222222,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 66,
+      "acc_before": 0.4583333333333333,
+      "acc_after": 0.4583333333333333,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    },
+    {
+      "step": 68,
+      "acc_before": 0.4722222222222222,
+      "acc_after": 0.4722222222222222,
+      "delta_norm": NaN,
+      "ewc_reference_set": true
+    }
+  ],
+  "accuracies_log": [
+    {
+      "step": 40,
+      "accuracy": 0.48046875,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 41,
+      "accuracy": 0.4807692307692308,
+      "action": "none",
+      "punishment_count": 0,
+      "buffer_size": 260
+    },
+    {
+      "step": 42,
+      "accuracy": 0.4889705882352941,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 43,
+      "accuracy": 0.5,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 44,
+      "accuracy": 0.5110294117647058,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 45,
+      "accuracy": 0.53515625,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 46,
+      "accuracy": 0.5367647058823529,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 47,
+      "accuracy": 0.51171875,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 48,
+      "accuracy": 0.5076923076923077,
+      "action": "none",
+      "punishment_count": 0,
+      "buffer_size": 260
+    },
+    {
+      "step": 49,
+      "accuracy": 0.5110294117647058,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 50,
+      "accuracy": 0.515625,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 51,
+      "accuracy": 0.5183823529411765,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 52,
+      "accuracy": 0.51953125,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 53,
+      "accuracy": 0.5073529411764706,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 54,
+      "accuracy": 0.5234375,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 55,
+      "accuracy": 0.5230769230769231,
+      "action": "none",
+      "punishment_count": 0,
+      "buffer_size": 260
+    },
+    {
+      "step": 56,
+      "accuracy": 0.5110294117647058,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 57,
+      "accuracy": 0.51171875,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 58,
+      "accuracy": 0.5147058823529411,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 59,
+      "accuracy": 0.5,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 60,
+      "accuracy": 0.4963235294117647,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 61,
+      "accuracy": 0.45703125,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 62,
+      "accuracy": 0.4576923076923077,
+      "action": "none",
+      "punishment_count": 0,
+      "buffer_size": 260
+    },
+    {
+      "step": 63,
+      "accuracy": 0.46691176470588236,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 64,
+      "accuracy": 0.46484375,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 65,
+      "accuracy": 0.45588235294117646,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 66,
+      "accuracy": 0.4609375,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 67,
+      "accuracy": 0.4632352941176471,
+      "action": "train_hypotheses_and_activate",
+      "punishment_count": 1,
+      "buffer_size": 272
+    },
+    {
+      "step": 68,
+      "accuracy": 0.46484375,
+      "action": "apply_best_delta_and_consolidate",
+      "punishment_count": 0,
+      "buffer_size": 256
+    },
+    {
+      "step": 69,
+      "accuracy": 0.4653846153846154,
+      "action": "none",
+      "punishment_count": 0,
+      "buffer_size": 260
+    }
+  ],
+  "final_v2_metrics": {
+    "version": "V2-dynamic",
+    "n_hypotheses": 8,
+    "n_hypotheses_active": 8,
+    "max_n_hypotheses": 16,
+    "n_trials": 6,
+    "hyp_train_steps": 20,
+    "hyp_lr": 0.0001,
+    "delta_scale": 0.0010000000474974513,
+    "n_generators": 16,
+    "punishment_count": 0,
+    "success_count": 0,
+    "training_ready": false,
+    "classifier_trained": true,
+    "ewc_reference_set": true,
+    "buffer_size": 256,
+    "dynamic_adaptation": {
+      "loss_history_len": 8,
+      "loss_stats": {
+        "slope": NaN,
+        "volatility": NaN,
+        "mean": NaN,
+        "std": NaN,
+        "n": 8
+      },
+      "punishment_rate": 1.0,
+      "punishment_window_size": 12,
+      "n_adaptations": 60,
+      "limits": {
+        "min_n_hypotheses": 4,
+        "max_n_hypotheses": 16,
+        "min_n_trials": 1,
+        "max_n_trials": 6,
+        "min_hyp_train_steps": 5,
+        "max_hyp_train_steps": 60
+      },
+      "last_5_adaptations": [
+        {
+          "trigger": "punishment",
+          "step": 55,
+          "before": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "after": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "adapted": false,
+          "rules_fired": [],
+          "loss_stats": {
+            "slope": NaN,
+            "volatility": NaN,
+            "mean": NaN,
+            "std": NaN,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "auto",
+          "step": 56,
+          "before": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "after": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "adapted": false,
+          "rules_fired": [],
+          "loss_stats": {
+            "slope": NaN,
+            "volatility": NaN,
+            "mean": NaN,
+            "std": NaN,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "punishment",
+          "step": 57,
+          "before": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "after": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "adapted": false,
+          "rules_fired": [],
+          "loss_stats": {
+            "slope": NaN,
+            "volatility": NaN,
+            "mean": NaN,
+            "std": NaN,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "auto",
+          "step": 58,
+          "before": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "after": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "adapted": false,
+          "rules_fired": [],
+          "loss_stats": {
+            "slope": NaN,
+            "volatility": NaN,
+            "mean": NaN,
+            "std": NaN,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        },
+        {
+          "trigger": "punishment",
+          "step": 59,
+          "before": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "after": {
+            "n_hypotheses": 8,
+            "n_trials": 6,
+            "hyp_train_steps": 20
+          },
+          "adapted": false,
+          "rules_fired": [],
+          "loss_stats": {
+            "slope": NaN,
+            "volatility": NaN,
+            "mean": NaN,
+            "std": NaN,
+            "n": 8
+          },
+          "punishment_rate": 1.0
+        }
+      ]
+    }
+  },
+  "n_adaptations": 60,
+  "mem_critical_stopped": false
+}