dual-loop-controller 2.0.0a1__tar.gz → 2.0.0a2__tar.gz

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dual-loop-controller
-Version: 2.0.0a1
+Version: 2.0.0a2
 Summary: A hardware-aligned, manifold-preserving latent deliberation framework for Transformers
 Author: Ch3nOff
 License-Expression: MIT
@@ -30,6 +30,7 @@ Dynamic: license-file
 # Dual-Loop Cognitive Controller v2.0
 > **A Hardware-Aligned Latent Deliberation Framework for Transformers: Architecture & Empirical Analysis**
 
+[![PyPI](https://img.shields.io/pypi/v/dual-loop-controller.svg)](https://pypi.org/project/dual-loop-controller/)
 [![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](tests/)
 [![PyTorch](https://img.shields.io/badge/PyTorch-2.14%2B-ee4c2c.svg)](https://pytorch.org/)
 [![Status](https://img.shields.io/badge/status-empirical--audit-orange.svg)](#empirical-findings)
@@ -118,22 +119,38 @@ Despite the scaling limits at small model regimes, the repository provides clean
 
 ### 1. Installation
 ```bash
+# Install officially from PyPI:
+pip install --pre dual-loop-controller
+# or exact version: pip install dual-loop-controller==2.0.0a2
+
+# Or install direct from GitHub release tag:
+pip install git+https://github.com/Ch3nOff/dual-loop-controller.git@v2.0.0a2
+
+# Or clone locally and install in editable mode:
 git clone https://github.com/Ch3nOff/dual-loop-controller.git
 cd dual-loop-controller
-python -m pip install torch numpy
+pip install -e .
 ```
 
+> [!NOTE]
+> **Pretrained Weights Bundled**: A 225K parameter trained reference checkpoint (~912 KB) is bundled directly in `dual_loop/checkpoints/checkpoint_trained_dualloop.pt`. Fresh clones and pip installs run inference and audits out-of-the-box without requiring a training step first.
+
 ### 2. Running Component Tests (Verifying Shapes & Gradients)
 ```bash
 python -m unittest discover -s tests -p "test_*.py"
 ```
 
-### 3. Running the Honest Benchmark Suite (Live Tensor Computations)
+### 3. Verifying Dynamic Halting & Pareto Calibration
+```bash
+python verify_dynamic_inference.py
+```
+
+### 4. Running the Honest Benchmark Suite (Live Tensor Computations)
 ```bash
 python -m dual_loop.benchmarks.comprehensive_suite
 ```
 
-### 4. Re-Training from Scratch
+### 5. Re-Training from Scratch
 ```bash
 python train.py --epochs 35 --hops 3 --k_steps 3 --d_model 64
 ```

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/README.md

@@ -1,6 +1,7 @@
 # Dual-Loop Cognitive Controller v2.0
 > **A Hardware-Aligned Latent Deliberation Framework for Transformers: Architecture & Empirical Analysis**
 
+[![PyPI](https://img.shields.io/pypi/v/dual-loop-controller.svg)](https://pypi.org/project/dual-loop-controller/)
 [![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](tests/)
 [![PyTorch](https://img.shields.io/badge/PyTorch-2.14%2B-ee4c2c.svg)](https://pytorch.org/)
 [![Status](https://img.shields.io/badge/status-empirical--audit-orange.svg)](#empirical-findings)
@@ -89,22 +90,38 @@ Despite the scaling limits at small model regimes, the repository provides clean
 
 ### 1. Installation
 ```bash
+# Install officially from PyPI:
+pip install --pre dual-loop-controller
+# or exact version: pip install dual-loop-controller==2.0.0a2
+
+# Or install direct from GitHub release tag:
+pip install git+https://github.com/Ch3nOff/dual-loop-controller.git@v2.0.0a2
+
+# Or clone locally and install in editable mode:
 git clone https://github.com/Ch3nOff/dual-loop-controller.git
 cd dual-loop-controller
-python -m pip install torch numpy
+pip install -e .
 ```
 
+> [!NOTE]
+> **Pretrained Weights Bundled**: A 225K parameter trained reference checkpoint (~912 KB) is bundled directly in `dual_loop/checkpoints/checkpoint_trained_dualloop.pt`. Fresh clones and pip installs run inference and audits out-of-the-box without requiring a training step first.
+
 ### 2. Running Component Tests (Verifying Shapes & Gradients)
 ```bash
 python -m unittest discover -s tests -p "test_*.py"
 ```
 
-### 3. Running the Honest Benchmark Suite (Live Tensor Computations)
+### 3. Verifying Dynamic Halting & Pareto Calibration
+```bash
+python verify_dynamic_inference.py
+```
+
+### 4. Running the Honest Benchmark Suite (Live Tensor Computations)
 ```bash
 python -m dual_loop.benchmarks.comprehensive_suite
 ```
 
-### 4. Re-Training from Scratch
+### 5. Re-Training from Scratch
 ```bash
 python train.py --epochs 35 --hops 3 --k_steps 3 --d_model 64
 ```

dual_loop_controller-2.0.0a2/dual_loop/__init__.py

@@ -0,0 +1,66 @@
+"""
+Dual-Loop Cognitive Controller v2.0
+===================================
+A hardware-aligned, manifold-preserving latent reasoning framework
+for Transformer architectures.
+"""
+
+from .memory import CognitiveWorkingMemory
+from .halting import EntropyHaltingUnit
+from .controller import RecurrentLatentController, TopKCapacityCrossAttention
+from .decoder import DualLoopTransformer
+from .adapters.latent_adapter import LatentDeliberationAdapter
+
+import os
+import torch
+from typing import Optional
+
+__version__ = "2.0.0a2"
+
+def get_default_checkpoint_path() -> Optional[str]:
+    """
+    Resolves the pre-trained reference checkpoint path by checking:
+    1. Local working directory: './checkpoint_trained_dualloop.pt'
+    2. Bundled package data: 'dual_loop/checkpoints/checkpoint_trained_dualloop.pt'
+    """
+    local_path = "checkpoint_trained_dualloop.pt"
+    if os.path.exists(local_path):
+        return os.path.abspath(local_path)
+    
+    pkg_path = os.path.join(os.path.dirname(__file__), "checkpoints", "checkpoint_trained_dualloop.pt")
+    if os.path.exists(pkg_path):
+        return os.path.abspath(pkg_path)
+
+    return None
+
+def load_trained_checkpoint(model: Optional[DualLoopTransformer] = None, checkpoint_path: Optional[str] = None):
+    """
+    Loads pre-trained weights into the DualLoopTransformer model, automatically falling back
+    to the bundled package checkpoint if no path is provided.
+    """
+    resolved_path = checkpoint_path or get_default_checkpoint_path()
+    if resolved_path is None or not os.path.exists(resolved_path):
+        raise FileNotFoundError(
+            "Pretrained checkpoint not found in local directory or bundled package data.\n"
+            "To train the model from scratch, execute:\n"
+            "  python train.py --epochs 35 --hops 3 --k_steps 3\n"
+            "or run:\n"
+            "  python evaluate_real_behavior.py"
+        )
+
+    state_dict = torch.load(resolved_path, map_location="cpu", weights_only=True)
+    if model is not None:
+        model.load_state_dict(state_dict, strict=False)
+        return model, resolved_path
+    return state_dict
+
+__all__ = [
+    "CognitiveWorkingMemory",
+    "EntropyHaltingUnit",
+    "RecurrentLatentController",
+    "TopKCapacityCrossAttention",
+    "DualLoopTransformer",
+    "LatentDeliberationAdapter",
+    "get_default_checkpoint_path",
+    "load_trained_checkpoint",
+]

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/dual_loop/benchmarks/comprehensive_suite.py

@@ -13,13 +13,15 @@ Evaluations Performed:
 
 import os
 import time
+import random
+import numpy as np
 import torch
 import torch.nn.functional as F
 
-from dual_loop import DualLoopTransformer
+from dual_loop import DualLoopTransformer, load_trained_checkpoint
 from dual_loop.benchmarks import MultiHopGraphDataset
 
-def load_or_instantiate_model(checkpoint_path="checkpoint_trained_dualloop.pt", num_nodes=16):
+def load_or_instantiate_model(checkpoint_path=None, num_nodes=16):
     vocab_size = num_nodes + 3
     model = DualLoopTransformer(
         vocab_size=vocab_size,
@@ -30,19 +32,33 @@ def load_or_instantiate_model(checkpoint_path="checkpoint_trained_dualloop.pt",
         num_cwm_slots=12,
         max_ponder_steps=3,
         capacity_factor=0.5,
-        entropy_threshold=1.30
+        entropy_threshold=1.35
     )
-    if os.path.exists(checkpoint_path):
-        state_dict = torch.load(checkpoint_path, map_location="cpu", weights_only=True)
-        model.load_state_dict(state_dict, strict=False)
-        print(f"[Model Loader] Loaded weights from '{checkpoint_path}'.")
-    else:
-        print("[Model Loader] Warning: Checkpoint not found; running with initialized weights.")
+    try:
+        _, loaded_path = load_trained_checkpoint(model, checkpoint_path)
+        print(f"[Model Loader] Successfully loaded weights from '{loaded_path}'.")
+    except FileNotFoundError as e:
+        print("\n" + "!" * 80)
+        print("CRITICAL WARNING: TRAINED CHECKPOINT NOT FOUND!")
+        print("The benchmark suite is currently executing on UNTRAINED (random) weights.")
+        print("Reported metrics will reflect random baseline (~6.25%).")
+        print("To evaluate true model capabilities (29-34% accuracy), generate weights with:")
+        print("    python train.py --epochs 35 --hops 3 --k_steps 3")
+        print("or:")
+        print("    python evaluate_real_behavior.py")
+        print("!" * 80 + "\n")
+
     model.eval()
     return model
 
 def run_suite():
+    # Deterministic Seeding for 100% Reproducibility
+    random.seed(42)
+    np.random.seed(42)
     torch.manual_seed(42)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(42)
+
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     num_nodes = 16
     chance_baseline = 100.0 / num_nodes # 6.25%
@@ -61,8 +77,8 @@ def run_suite():
     hop_results = {}
     with torch.no_grad():
         for h in [1, 2, 3]:
-            ds = MultiHopGraphDataset(num_samples=400, num_nodes=num_nodes, num_edges=6, hops=h)
-            x, y_all = ds.get_batch(400)
+            ds = MultiHopGraphDataset(num_samples=400, num_nodes=num_nodes, num_edges=6, hops=h, seed=100 + h)
+            x, y_all = ds.get_batch(400, shuffle=False)
             x, y = x.to(device), y_all[:, -1].to(device)
             logits, _ = model(x, k_steps=h)
             acc = (logits.argmax(dim=-1) == y).float().mean().item() * 100.0
@@ -76,8 +92,8 @@ def run_suite():
     distractor_results = {}
     with torch.no_grad():
         for e in [6, 8, 12, 16]:
-            ds_e = MultiHopGraphDataset(num_samples=300, num_nodes=num_nodes, num_edges=e, hops=3)
-            x_e, y_e_all = ds_e.get_batch(300)
+            ds_e = MultiHopGraphDataset(num_samples=300, num_nodes=num_nodes, num_edges=e, hops=3, seed=200 + e)
+            x_e, y_e_all = ds_e.get_batch(300, shuffle=False)
             x_e, y_e = x_e.to(device), y_e_all[:, -1].to(device)
             logits_e, _ = model(x_e, k_steps=3)
             acc_e = (logits_e.argmax(dim=-1) == y_e).float().mean().item() * 100.0
@@ -85,11 +101,11 @@ def run_suite():
             print(f"  {e:2d} Total Edges -> Test Accuracy (Computed from Logits): {acc_e:5.1f}%")
 
     # -------------------------------------------------------------------------
-    # BENCHMARK 3: Unvarnished Test-Time Compute Scaling (K = 0 .. 5)
+    # BENCHMARK 3: UnvarnISHED TEST-TIME COMPUTE SCALING (K = 0 .. 5)
     # -------------------------------------------------------------------------
     print("\n[BENCHMARK 3: UNVARNISHED TEST-TIME COMPUTE SCALING (K = 0 .. 5)]")
-    ds_scale = MultiHopGraphDataset(num_samples=500, num_nodes=num_nodes, num_edges=6, hops=3)
-    xs, ys_all = ds_scale.get_batch(500)
+    ds_scale = MultiHopGraphDataset(num_samples=500, num_nodes=num_nodes, num_edges=6, hops=3, seed=42)
+    xs, ys_all = ds_scale.get_batch(500, shuffle=False)
     xs, ys = xs.to(device), ys_all[:, -1].to(device)
     scale_results = {}
     with torch.no_grad():
@@ -107,6 +123,13 @@ def run_suite():
     print("\n[BENCHMARK 4: PER-SAMPLE DYNAMIC HALTING & PARETO FRONTIER]")
     print("Evaluating individual sample halting without artificial batch-mean collapsing:")
     with torch.no_grad():
+        opt_thresh = model.calibrate_halting(xs, target_labels=ys, verbose=False)
+        logits_dyn, info_dyn = model(xs, dynamic_halting=True)
+        acc_dyn = (logits_dyn.argmax(-1) == ys).float().mean().item() * 100.0
+        st = info_dyn['steps_taken']
+        print(f"  Direct Inference: Calibrated Threshold={opt_thresh:.3f} nats | Accuracy={acc_dyn:.1f}% | Effective K={info_dyn['effective_k']:.2f} steps")
+        print(f"  Steps Taken: K=1: {(st==1).float().mean()*100:.1f}%, K=2: {(st==2).float().mean()*100:.1f}%, K=3: {(st==3).float().mean()*100:.1f}%\n")
+
         logits_k1, _ = model(xs, k_steps=1)
         logits_k2, _ = model(xs, k_steps=2)
         logits_k3, _ = model(xs, k_steps=3)

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/dual_loop/benchmarks/graph_reasoning.py

@@ -1,17 +1,27 @@
 import random
 import torch
-from typing import List, Tuple
+from typing import List, Tuple, Optional
 
 class MultiHopGraphDataset:
     """
     Synthetic Multi-Hop Graph Reasoning Benchmark.
     Generates directed pointer chains with random distractor edges.
+    Supports isolated deterministic seeding for 100% reproducible benchmarks.
     """
-    def __init__(self, num_samples: int = 2000, num_nodes: int = 20, num_edges: int = 8, hops: int = 3):
+    def __init__(
+        self,
+        num_samples: int = 2000,
+        num_nodes: int = 20,
+        num_edges: int = 8,
+        hops: int = 3,
+        seed: Optional[int] = None
+    ):
         self.num_samples = num_samples
         self.num_nodes = num_nodes
         self.num_edges = num_edges
         self.hops = hops
+        self.seed = seed
+        self.rng = random.Random(seed) if seed is not None else random.Random()
         
         self.ARROW = num_nodes
         self.SEP = num_nodes + 1
@@ -23,7 +33,7 @@ class MultiHopGraphDataset:
         samples = []
         for _ in range(self.num_samples):
             nodes = list(range(self.num_nodes))
-            random.shuffle(nodes)
+            self.rng.shuffle(nodes)
             
             chain = nodes[:self.hops + 1]
             edges = []
@@ -31,12 +41,12 @@ class MultiHopGraphDataset:
                 edges.append((chain[i], chain[i+1]))
             
             while len(edges) < self.num_edges:
-                u = random.choice(nodes)
-                v = random.choice([n for n in nodes if n != u])
+                u = self.rng.choice(nodes)
+                v = self.rng.choice([n for n in nodes if n != u])
                 if (u, v) not in edges:
                     edges.append((u, v))
             
-            random.shuffle(edges)
+            self.rng.shuffle(edges)
             
             seq = []
             for u, v in edges:
@@ -52,8 +62,20 @@ class MultiHopGraphDataset:
             ))
         return samples
 
-    def get_batch(self, batch_size: int = 64) -> Tuple[torch.Tensor, torch.Tensor]:
-        indices = random.sample(range(self.num_samples), batch_size)
+    def get_batch(
+        self,
+        batch_size: int = 64,
+        shuffle: bool = True,
+        seed: Optional[int] = None
+    ) -> Tuple[torch.Tensor, torch.Tensor]:
+        if not shuffle:
+            indices = list(range(min(batch_size, self.num_samples)))
+        elif seed is not None:
+            batch_rng = random.Random(seed)
+            indices = batch_rng.sample(range(self.num_samples), batch_size)
+        else:
+            indices = self.rng.sample(range(self.num_samples), batch_size)
+
         seqs = [self.data[i][0] for i in indices]
         targets = torch.stack([self.data[i][1] for i in indices])
         inputs = torch.stack(seqs)

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/dual_loop/benchmarks/halting_audit.py

@@ -10,14 +10,19 @@ import torch
 import torch.nn.functional as F
 import numpy as np
 
-from dual_loop import DualLoopTransformer
+from dual_loop import DualLoopTransformer, load_trained_checkpoint
 from dual_loop.benchmarks import MultiHopGraphDataset
 
 def audit_halting_pareto():
+    import random
+    random.seed(42)
+    np.random.seed(42)
     torch.manual_seed(42)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(42)
+
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     num_nodes = 16
-    checkpoint_path = "checkpoint_trained_dualloop.pt"
 
     model = DualLoopTransformer(
         vocab_size=num_nodes + 3,
@@ -30,15 +35,11 @@ def audit_halting_pareto():
         capacity_factor=0.5
     ).to(device)
 
-    if os.path.exists(checkpoint_path):
-        state_dict = torch.load(checkpoint_path, map_location="cpu", weights_only=True)
-        model.load_state_dict(state_dict, strict=False)
-    else:
-        raise FileNotFoundError("Checkpoint not found.")
-
+    load_trained_checkpoint(model)
     model.eval()
-    dataset = MultiHopGraphDataset(num_samples=500, num_nodes=num_nodes, num_edges=6, hops=3)
-    x_test, y_test_all = dataset.get_batch(500)
+
+    dataset = MultiHopGraphDataset(num_samples=500, num_nodes=num_nodes, num_edges=6, hops=3, seed=42)
+    x_test, y_test_all = dataset.get_batch(500, shuffle=False)
     x_test, y_test = x_test.to(device), y_test_all[:, -1].to(device)
 
     # 1. Measure raw step-by-step entropy distribution

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/dual_loop/decoder.py

@@ -60,18 +60,66 @@ class DualLoopTransformer(nn.Module):
         self.inner_decoder = nn.TransformerEncoder(dec_layer, num_layers=num_decoder_layers)
         self.lm_head = nn.Linear(d_model, vocab_size)
 
-    def calibrate_halting(self, sample_inputs: torch.Tensor, percentile: float = 35.0):
+    def calibrate_halting(
+        self,
+        sample_inputs: torch.Tensor,
+        target_labels: Optional[torch.Tensor] = None,
+        percentile: Optional[float] = None,
+        candidate_percentiles: Tuple[float, ...] = (25.0, 35.0, 50.0, 65.0, 75.0, 85.0),
+        verbose: bool = False
+    ) -> float:
         """
         Dynamically calibrates the halting threshold against the model's actual
-        decoder entropy distribution on step 1 of validation samples.
+        decoder predictive entropy distribution on validation samples.
+
+        Modes:
+        1. Fixed Quantile (default: 75th percentile / upper quartile):
+           If `percentile` is specified (or when `target_labels is None`), sets the threshold
+           directly to the specified quantile of step-1 predictive entropy.
+        2. Automated Pareto Grid-Search:
+           If `target_labels` is provided and `percentile is None`, sweeps across candidate
+           percentiles to find the Pareto-optimal threshold balancing high accuracy with reduced
+           pondering steps (effective K).
         """
         self.eval()
         with torch.no_grad():
             logits_k1, _ = self.forward(sample_inputs, k_steps=1, dynamic_halting=False)
             ent_k1 = self.outer_loop.halting_unit.calculate_entropy(logits_k1)
-            calibrated = torch.quantile(ent_k1, percentile / 100.0).item()
-            self.outer_loop.halting_unit.entropy_threshold = calibrated
-            return calibrated
+
+            if target_labels is not None and percentile is None:
+                best_score = -float('inf')
+                best_thresh = None
+                best_p = 75.0
+
+                for p in candidate_percentiles:
+                    cand_thresh = torch.quantile(ent_k1, p / 100.0).item()
+                    self.outer_loop.halting_unit.entropy_threshold = cand_thresh
+                    logits_dyn, info = self.forward(sample_inputs, dynamic_halting=True)
+                    acc = (logits_dyn.argmax(dim=-1) == target_labels).float().mean().item() * 100.0
+                    eff_k = info["effective_k"]
+
+                    # Pareto scoring: maximize accuracy, reward compute savings
+                    max_k = float(self.outer_loop.max_ponder_steps)
+                    compute_saving = (max_k - eff_k) / max_k if max_k > 0 else 0.0
+                    score = acc + (compute_saving * 5.0)
+
+                    if verbose:
+                        print(f"[Calibration Search] P={p:4.1f}% -> Thresh={cand_thresh:.3f} | Acc={acc:5.1f}% | Avg K={eff_k:.2f} | Score={score:.2f}")
+
+                    if score > best_score:
+                        best_score = score
+                        best_thresh = cand_thresh
+                        best_p = p
+
+                self.outer_loop.halting_unit.entropy_threshold = best_thresh
+                if verbose:
+                    print(f"[Calibration Search] Selected Pareto-optimal Percentile={best_p}% (Threshold={best_thresh:.3f} nats)")
+                return best_thresh
+            else:
+                p = 75.0 if percentile is None else percentile
+                calibrated = torch.quantile(ent_k1, p / 100.0).item()
+                self.outer_loop.halting_unit.entropy_threshold = calibrated
+                return calibrated
 
     def forward(
         self,

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/dual_loop/halting.py

@@ -33,10 +33,10 @@ class EntropyHaltingUnit(nn.Module):
         entropy = -torch.sum(probs * log_probs, dim=-1)
         return entropy
 
-    def calibrate_threshold(self, sample_logits: torch.Tensor, percentile: float = 50.0):
+    def calibrate_threshold(self, sample_logits: torch.Tensor, percentile: float = 75.0):
         """
         Calibrates the entropy threshold to match the model's actual empirical
-        predictive distribution (e.g. median / 50th percentile of validation entropy).
+        predictive distribution (defaults to 75th percentile / upper quartile of validation entropy).
         """
         with torch.no_grad():
             entropies = self.calculate_entropy(sample_logits)

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/dual_loop_controller.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dual-loop-controller
-Version: 2.0.0a1
+Version: 2.0.0a2
 Summary: A hardware-aligned, manifold-preserving latent deliberation framework for Transformers
 Author: Ch3nOff
 License-Expression: MIT
@@ -30,6 +30,7 @@ Dynamic: license-file
 # Dual-Loop Cognitive Controller v2.0
 > **A Hardware-Aligned Latent Deliberation Framework for Transformers: Architecture & Empirical Analysis**
 
+[![PyPI](https://img.shields.io/pypi/v/dual-loop-controller.svg)](https://pypi.org/project/dual-loop-controller/)
 [![Tests](https://img.shields.io/badge/tests-passing-brightgreen.svg)](tests/)
 [![PyTorch](https://img.shields.io/badge/PyTorch-2.14%2B-ee4c2c.svg)](https://pytorch.org/)
 [![Status](https://img.shields.io/badge/status-empirical--audit-orange.svg)](#empirical-findings)
@@ -118,22 +119,38 @@ Despite the scaling limits at small model regimes, the repository provides clean
 
 ### 1. Installation
 ```bash
+# Install officially from PyPI:
+pip install --pre dual-loop-controller
+# or exact version: pip install dual-loop-controller==2.0.0a2
+
+# Or install direct from GitHub release tag:
+pip install git+https://github.com/Ch3nOff/dual-loop-controller.git@v2.0.0a2
+
+# Or clone locally and install in editable mode:
 git clone https://github.com/Ch3nOff/dual-loop-controller.git
 cd dual-loop-controller
-python -m pip install torch numpy
+pip install -e .
 ```
 
+> [!NOTE]
+> **Pretrained Weights Bundled**: A 225K parameter trained reference checkpoint (~912 KB) is bundled directly in `dual_loop/checkpoints/checkpoint_trained_dualloop.pt`. Fresh clones and pip installs run inference and audits out-of-the-box without requiring a training step first.
+
 ### 2. Running Component Tests (Verifying Shapes & Gradients)
 ```bash
 python -m unittest discover -s tests -p "test_*.py"
 ```
 
-### 3. Running the Honest Benchmark Suite (Live Tensor Computations)
+### 3. Verifying Dynamic Halting & Pareto Calibration
+```bash
+python verify_dynamic_inference.py
+```
+
+### 4. Running the Honest Benchmark Suite (Live Tensor Computations)
 ```bash
 python -m dual_loop.benchmarks.comprehensive_suite
 ```
 
-### 4. Re-Training from Scratch
+### 5. Re-Training from Scratch
 ```bash
 python train.py --epochs 35 --hops 3 --k_steps 3 --d_model 64
 ```

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/dual_loop_controller.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ dual_loop/benchmarks/comprehensive_suite.py
 dual_loop/benchmarks/graph_reasoning.py
 dual_loop/benchmarks/halting_audit.py
 dual_loop/benchmarks/initiative_benchmark.py
+dual_loop/checkpoints/checkpoint_trained_dualloop.pt
 dual_loop_controller.egg-info/PKG-INFO
 dual_loop_controller.egg-info/SOURCES.txt
 dual_loop_controller.egg-info/dependency_links.txt

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dual-loop-controller"
-version = "2.0.0a1"
+version = "2.0.0a2"
 description = "A hardware-aligned, manifold-preserving latent deliberation framework for Transformers"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -51,3 +51,6 @@ Repository = "https://github.com/Ch3nOff/dual-loop-controller.git"
 where = ["."]
 include = ["dual_loop*"]
 exclude = ["tests*", "dist*", "build*"]
+
+[tool.setuptools.package-data]
+dual_loop = ["checkpoints/*.pt"]

{dual_loop_controller-2.0.0a1 → dual_loop_controller-2.0.0a2}/tests/test_dual_loop.py

@@ -106,5 +106,46 @@ class TestDualLoopComponents(unittest.TestCase):
         self.assertIsNotNone(model.outer_loop.query_projector[0].weight.grad)
         self.assertGreater(model.outer_loop.query_projector[0].weight.grad.norm().item(), 0.0)
 
+    def test_calibrate_halting_default_and_search(self):
+        model = DualLoopTransformer(
+            vocab_size=self.vocab_size,
+            d_model=self.D,
+            max_ponder_steps=3
+        )
+        sample_inputs = torch.randint(0, self.vocab_size, (16, self.N))
+        
+        # Test 1: Default percentile (75.0)
+        calib_thresh = model.calibrate_halting(sample_inputs)
+        self.assertIsInstance(calib_thresh, float)
+        self.assertEqual(model.outer_loop.halting_unit.entropy_threshold, calib_thresh)
+
+        # Test 2: Automated Grid-Search with target_labels
+        target_labels = torch.randint(0, self.vocab_size, (16,))
+        best_thresh = model.calibrate_halting(sample_inputs, target_labels=target_labels)
+        self.assertIsInstance(best_thresh, float)
+        self.assertEqual(model.outer_loop.halting_unit.entropy_threshold, best_thresh)
+
+    def test_load_trained_checkpoint(self):
+        from dual_loop import load_trained_checkpoint
+        model = DualLoopTransformer(vocab_size=19, d_model=64, num_cwm_slots=12, max_ponder_steps=3)
+        loaded_model, loaded_path = load_trained_checkpoint(model)
+        self.assertIsNotNone(loaded_model)
+        self.assertTrue(len(loaded_path) > 0)
+
+    def test_multihop_graph_dataset_reproducibility(self):
+        from dual_loop.benchmarks import MultiHopGraphDataset
+        ds1 = MultiHopGraphDataset(num_samples=50, num_nodes=16, num_edges=6, hops=3, seed=123)
+        ds2 = MultiHopGraphDataset(num_samples=50, num_nodes=16, num_edges=6, hops=3, seed=123)
+        
+        # Check first sequence and targets match exactly
+        self.assertTrue(torch.equal(ds1.data[0][0], ds2.data[0][0]))
+        self.assertTrue(torch.equal(ds1.data[0][1], ds2.data[0][1]))
+
+        # Check get_batch matches
+        b1_x, b1_y = ds1.get_batch(20, shuffle=False)
+        b2_x, b2_y = ds2.get_batch(20, shuffle=False)
+        self.assertTrue(torch.equal(b1_x, b2_x))
+        self.assertTrue(torch.equal(b1_y, b2_y))
+
 if __name__ == "__main__":
     unittest.main()

dual_loop_controller-2.0.0a1/dual_loop/__init__.py

@@ -1,22 +0,0 @@
-"""
-Dual-Loop Cognitive Controller v2.0
-===================================
-A hardware-aligned, manifold-preserving latent reasoning framework
-for Transformer architectures.
-"""
-
-from .memory import CognitiveWorkingMemory
-from .halting import EntropyHaltingUnit
-from .controller import RecurrentLatentController, TopKCapacityCrossAttention
-from .decoder import DualLoopTransformer
-from .adapters.latent_adapter import LatentDeliberationAdapter
-
-__version__ = "2.0.0a1"
-__all__ = [
-    "CognitiveWorkingMemory",
-    "EntropyHaltingUnit",
-    "RecurrentLatentController",
-    "TopKCapacityCrossAttention",
-    "DualLoopTransformer",
-    "LatentDeliberationAdapter",
-]