cida-plugin 1.0.0__py3-none-any.whl

cida_plugin/translator.py

@@ -0,0 +1,74 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class LatentSemanticTranslator(nn.Module):
+    """
+    Module 3 of Kairos OS: Latent-to-Semantic Translator.
+    Translates CIDA's latent superposition (Prosecutor vs Defender beliefs)
+    into structured semantic concept embeddings that an LLM can understand.
+    """
+    def __init__(self, d_hidden: int = 128, vocab_size: int = 50000, d_model_llm: int = 4096):
+        super().__init__()
+        self.d_hidden = d_hidden
+        self.d_model_llm = d_model_llm
+        
+        # Non-linear projection from CIDA latent space to LLM semantic space
+        self.latent_to_semantic = nn.Sequential(
+            nn.Linear(d_hidden, d_hidden * 4),
+            nn.GELU(),
+            nn.Dropout(0.1),
+            nn.Linear(d_hidden * 4, d_model_llm)
+        )
+        
+        # Attention pooling to summarize evidence
+        self.evidence_attention = nn.MultiheadAttention(embed_dim=d_model_llm, num_heads=8, batch_first=True)
+        
+    def forward(self, superposition_state: dict, class_names: list = None):
+        """
+        Args:
+            superposition_state: Dict containing 'prosecutor_belief' and 'defender_belief'
+                                 Each tensor is of shape (B, num_classes) or (B, d_hidden)
+            class_names: List of class names for semantic grounding
+            
+        Returns:
+            semantic_embeddings: (B, Seq, d_model_llm) ready to be prepended to LLM prompt
+        """
+        if superposition_state is None:
+            return None
+            
+        prosecutor_b = superposition_state.get("prosecutor_belief") # (B, ...)
+        defender_b = superposition_state.get("defender_belief")     # (B, ...)
+        
+        # In a real implementation, b is usually (B, num_classes). 
+        # For the epic pipeline, CIDA needs to output the raw hidden states (B, d_hidden) 
+        # alongside the probabilities. We assume they are d_hidden here for the projection.
+        
+        # Protect against shape mismatch if b is just probabilities (B, num_classes)
+        # We will pad or project it to d_hidden for this skeleton
+        B = prosecutor_b.size(0)
+        
+        if prosecutor_b.size(-1) != self.d_hidden:
+            # Dummy projection if we only received probabilities
+            pad_p = torch.zeros(B, self.d_hidden, device=prosecutor_b.device)
+            pad_p[:, :prosecutor_b.size(-1)] = prosecutor_b
+            prosecutor_b = pad_p
+            
+            pad_d = torch.zeros(B, self.d_hidden, device=defender_b.device)
+            pad_d[:, :defender_b.size(-1)] = defender_b
+            defender_b = pad_d
+
+        # Map to LLM dimension
+        sem_prosecutor = self.latent_to_semantic(prosecutor_b).unsqueeze(1) # (B, 1, d_llm)
+        sem_defender = self.latent_to_semantic(defender_b).unsqueeze(1)     # (B, 1, d_llm)
+        
+        # Combine hypotheses into a sequence
+        semantic_sequence = torch.cat([sem_prosecutor, sem_defender], dim=1) # (B, 2, d_llm)
+        
+        # Self-attention to find conflicts
+        attn_out, _ = self.evidence_attention(semantic_sequence, semantic_sequence, semantic_sequence)
+        
+        # Add residual
+        semantic_sequence = semantic_sequence + attn_out
+        
+        return semantic_sequence

cida_plugin/ttt.py

@@ -0,0 +1,348 @@
+"""
+Test-Time Training (TTT) для CIDA-Plugin.
+
+Концепция (Apple 2024, MIT 2024):
+    Обычно: обучение = оффлайн, инференс = заморожен.
+    TTT: агент делает K шагов градиентного спуска на каждом входе,
+    адаптируясь к конкретному примеру ПЕРЕД ответом.
+
+    θ*_i = θ_i − α · ∇L_self(θ_i, x)   ← K шагов Adam
+    b_i  = Agent_i(x; θ*_i)              ← belief после адаптации
+    θ_i  ← θ_i                           ← восстановление весов
+
+Почему это важно для CIDA:
+    - Первая архитектура где агенты РЕАЛЬНО «думают» о каждом входе
+    - Добавляем вычисление (K шагов), не параметры
+    - Маленькая модель адаптируется как большая
+
+Self-supervised loss:
+    Masked reconstruction — маскируем часть компонент скрытого состояния
+    агента и заставляем его восстанавливать замаскированное.
+    Это заставляет агента «понять» структуру конкретного входа.
+"""
+
+import io
+from contextlib import contextmanager
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from .agent import AgentState
+
+
+class MaskedReconstructionHead(nn.Module):
+    """
+    Вспомогательная голова для self-supervised loss.
+    
+    Принимает замаскированное скрытое состояние агента,
+    предсказывает оригинальные значения замаскированных позиций.
+    
+    Архитектура: 2-layer MLP с bottleneck (d_hidden → d_hidden//2 → d_hidden).
+    Bottleneck предотвращает тривиальное копирование и заставляет
+    модель извлекать семантическую структуру из незамаскированных позиций.
+    """
+
+    def __init__(self, d_hidden: int):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(d_hidden, d_hidden // 2),
+            nn.SiLU(),
+            nn.Linear(d_hidden // 2, d_hidden),
+        )
+
+    def forward(self, masked_states: torch.Tensor) -> torch.Tensor:
+        """
+        masked_states: (B, M, d_hidden) — состояния с замаскированными компонентами.
+        Returns:       (B, M, d_hidden) — предсказание оригинальных значений.
+        """
+        return self.net(masked_states)
+
+
+class TestTimeTrainer(nn.Module):
+    """
+    Test-Time Training для агентов CIDA.
+    
+    При каждом forward-проходе:
+    1. Создаёт маску (mask_ratio компонент обнуляются)
+    2. Пропускает замаскированный вход через AgentUpdater
+    3. Считает reconstruction loss на замаскированных позициях
+    4. Делает K шагов Adam на updater + reconstruction_head
+    5. После deliberation — восстанавливает оригинальные веса
+
+    Параметры
+    ---------
+    d_hidden : int
+        Размерность скрытых состояний агентов.
+    ttt_steps : int
+        Число шагов градиентного спуска (K). По умолчанию 3.
+        Компромисс: больше шагов = лучше адаптация, но дороже.
+    ttt_lr : float
+        Learning rate для inner Adam. По умолчанию 1e-3.
+        Должен быть достаточно большим для быстрой адаптации
+        за K шагов, но не настолько чтобы сломать представления.
+    mask_ratio : float
+        Доля маскируемых компонент. По умолчанию 0.15 (как в BERT).
+    """
+
+    def __init__(
+        self,
+        d_hidden: int,
+        ttt_steps: int = 3,
+        ttt_lr: float = 1e-3,
+        mask_ratio: float = 0.15,
+    ):
+        super().__init__()
+        self.ttt_steps = ttt_steps
+        self.ttt_lr = ttt_lr
+        self.mask_ratio = mask_ratio
+        self.d_hidden = d_hidden
+
+        # Reconstruction head — обучается вместе с основной моделью
+        self.reconstruction_head = MaskedReconstructionHead(d_hidden)
+
+    def _create_mask(self, shape: tuple, device: torch.device) -> torch.Tensor:
+        """
+        Создаёт бинарную маску: 1 = сохранить, 0 = замаскировать.
+        
+        Маска одинаковая для всех агентов в батче (per-example, not per-agent)
+        чтобы все агенты видели одинаковые «пробелы» и были вынуждены
+        договариваться о восстановлении.
+        
+        shape: (B, M, d_hidden)
+        Returns: (B, 1, d_hidden) — broadcast по агентам
+        """
+        B = shape[0]
+        d = shape[2]
+        num_masked = max(1, int(d * self.mask_ratio))
+
+        mask = torch.ones(B, 1, d, device=device)
+        for i in range(B):
+            indices = torch.randperm(d, device=device)[:num_masked]
+            mask[i, 0, indices] = 0.0
+
+        return mask
+
+    def compute_reconstruction_loss(
+        self,
+        updater: nn.Module,
+        masked_states: torch.Tensor,
+        original_states: torch.Tensor,
+        mask: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Self-supervised loss: MSE на замаскированных позициях.
+
+        updater         : nn.Module — AgentUpdater для проброса замаскированных состояний
+        masked_states   : (B, M, d_hidden) — состояния с маской (вход)
+        original_states : (B, M, d_hidden) — оригинальные состояния (target)
+        mask            : (B, 1, d_hidden) — маска (0 = замаскировано)
+
+        Returns: scalar — средний MSE на замаскированных позициях.
+        """
+        B, M, d = masked_states.shape
+        device = masked_states.device
+        
+        # Создаем фиктивные данные для AgentUpdater (ему нужны только s, e, r для forward)
+        dummy_state = AgentState(
+            s=masked_states,
+            b=torch.zeros(B, M, 1, device=device),
+            u=torch.ones(B, M, 1, device=device),
+            p=torch.zeros(B, M, 1, device=device),
+            e=torch.zeros(B, M, d, device=device),
+            alpha=torch.zeros(B, M, 1, device=device)
+        )
+        dummy_r = torch.zeros(B, M, d, device=device)
+        dummy_e = torch.zeros(B, M, d, device=device)
+        
+        # Пропускаем через updater (чтобы его веса получили градиенты!)
+        updated_state = updater(dummy_state, dummy_r, dummy_e)
+        
+        predicted = self.reconstruction_head(updated_state.s)  # (B, M, d)
+        inverted_mask = 1.0 - mask  # 1 = замаскированные позиции
+
+        # MSE только на замаскированных
+        diff = (predicted - original_states) ** 2
+        masked_diff = diff * inverted_mask  # (B, M, d)
+
+        # Средний loss: сумма по маскированным / число маскированных
+        num_masked = inverted_mask.sum().clamp(min=1.0)
+        loss = masked_diff.sum() / num_masked
+
+        return loss
+
+    @contextmanager
+    def adapt_context(
+        self,
+        updater: nn.Module,
+        agent_states: torch.Tensor,
+    ):
+        """
+        Context manager для TTT-адаптации.
+
+        Внутри контекста:
+            - updater имеет адаптированные веса (θ*)
+            - reconstruction_head тоже адаптирован
+        При выходе:
+            - Все веса восстанавливаются к θ
+
+        Использование:
+            with ttt.adapt_context(updater, s_t) as ttt_info:
+                # updater уже адаптирован, запускаем deliberation
+                state_t = updater(state_t, r_t, e_t)
+
+        Возвращает dict с диагностикой:
+            - 'losses': list[float] — losses по шагам
+            - 'param_shift': float — ||θ* - θ||
+            - 'steps_done': int — фактическое число шагов
+        
+        Parameters
+        ----------
+        updater : nn.Module
+            AgentUpdater, чьи веса будут адаптированы.
+        agent_states : torch.Tensor
+            (B, M, d_hidden) — текущие состояния агентов (target для реконструкции).
+        """
+        original_states = agent_states.detach()
+        device = agent_states.device
+
+        # ── Сохраняем оригинальные параметры (BytesIO вместо deepcopy — быстрее) ──
+        saved_updater_state = self._save_to_buffer(updater)
+        saved_head_state = self._save_to_buffer(self.reconstruction_head)
+
+        # ── Создаём маску ───────────────────────────────────────────────
+        mask = self._create_mask(agent_states.shape, device)
+
+        # ── Inner optimization (K шагов Adam) ───────────────────────────
+        # Оптимизируем только updater + reconstruction_head
+        inner_params = list(updater.parameters()) + list(
+            self.reconstruction_head.parameters()
+        )
+        inner_optimizer = torch.optim.Adam(inner_params, lr=self.ttt_lr)
+
+        losses = []
+        for step in range(self.ttt_steps):
+            inner_optimizer.zero_grad()
+
+            # Маскируем состояния
+            masked_states = original_states * mask  # (B, M, d)
+
+            # Reconstruction loss
+            loss = self.compute_reconstruction_loss(
+                updater, masked_states, original_states, mask
+            )
+
+            # FIX v4: retain_graph убран — каждый шаг пересоздаёт граф заново
+            # (original_states уже detached, mask постоянна → retain не нужен)
+            loss.backward()
+            inner_optimizer.step()
+            losses.append(loss.item())
+
+        # ── Вычисляем сдвиг параметров ──────────────────────────────
+        param_shift = 0.0
+        current_state = updater.state_dict()
+        saved_updater_state.seek(0)
+        saved_state_dict = torch.load(saved_updater_state, map_location='cpu', weights_only=True)
+        for key in saved_state_dict:
+            if key in current_state:
+                param_shift += (
+                    current_state[key].float() - saved_state_dict[key].float()
+                ).norm(2).item()
+        saved_updater_state.seek(0)  # reset for potential restore
+
+        ttt_info = {
+            "losses": losses,
+            "param_shift": param_shift,
+            "steps_done": self.ttt_steps,
+        }
+
+        try:
+            yield ttt_info
+        finally:
+            # ── Восстанавливаем оригинальные веса ───────────────────────
+            self._load_from_buffer(updater, saved_updater_state)
+            self._load_from_buffer(self.reconstruction_head, saved_head_state)
+
+    def adapt_and_get_info(
+        self,
+        updater: nn.Module,
+        agent_states: torch.Tensor,
+    ) -> dict:
+        """
+        Неконтекстная версия: адаптирует updater и возвращает диагностику.
+        Веса НЕ восстанавливаются — вызывающий код должен позаботиться.
+
+        Полезно когда нужно fine-grained контроль или когда контекст
+        менеджер неудобен (например внутри ODE-solver).
+
+        Returns: dict с 'losses', 'param_shift', 'steps_done',
+                 'saved_updater_state', 'saved_head_state'.
+        """
+        original_states = agent_states.detach()
+        device = agent_states.device
+
+        saved_updater_state = self._save_to_buffer(updater)
+        saved_head_state = self._save_to_buffer(self.reconstruction_head)
+
+        mask = self._create_mask(agent_states.shape, device)
+
+        inner_params = list(updater.parameters()) + list(
+            self.reconstruction_head.parameters()
+        )
+        inner_optimizer = torch.optim.Adam(inner_params, lr=self.ttt_lr)
+
+        losses = []
+        for step in range(self.ttt_steps):
+            inner_optimizer.zero_grad()
+            masked_states = original_states * mask
+            loss = self.compute_reconstruction_loss(
+                updater, masked_states, original_states, mask
+            )
+            # FIX v4: retain_graph убран — пересоздаём граф на каждом шаге
+            loss.backward()
+            inner_optimizer.step()
+            losses.append(loss.item())
+
+        param_shift = 0.0
+        current_state = updater.state_dict()
+        saved_updater_state.seek(0)
+        saved_state_dict = torch.load(saved_updater_state, map_location='cpu', weights_only=True)
+        for key in saved_state_dict:
+            if key in current_state:
+                param_shift += (
+                    current_state[key].float() - saved_state_dict[key].float()
+                ).norm(2).item()
+        saved_updater_state.seek(0)  # reset for potential restore
+
+        return {
+            "losses": losses,
+            "param_shift": param_shift,
+            "steps_done": self.ttt_steps,
+            "saved_updater_state": saved_updater_state,
+            "saved_head_state": saved_head_state,
+        }
+
+    def restore_weights(
+        self,
+        updater: nn.Module,
+        saved_updater_state,
+        saved_head_state,
+    ):
+        """Восстановить оригинальные веса после TTT-адаптации."""
+        self._load_from_buffer(updater, saved_updater_state)
+        self._load_from_buffer(self.reconstruction_head, saved_head_state)
+
+    @staticmethod
+    def _save_to_buffer(module: nn.Module) -> io.BytesIO:
+        """Сохраняет state_dict в memory buffer (быстрее чем copy.deepcopy)."""
+        buf = io.BytesIO()
+        torch.save(module.state_dict(), buf)
+        buf.seek(0)
+        return buf
+
+    @staticmethod
+    def _load_from_buffer(module: nn.Module, buf: io.BytesIO):
+        """Восстанавливает state_dict из memory buffer."""
+        buf.seek(0)
+        state = torch.load(buf, map_location='cpu', weights_only=True)
+        module.load_state_dict(state)

cida_plugin/vision_backbone.py

@@ -0,0 +1,43 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+from torchvision.models.feature_extraction import create_feature_extractor
+
+class VisionFeatureExtractor(nn.Module):
+    """
+    Extracts both pooled and spatial features from a Vision Backbone (ResNet50).
+    Pooled features: (B, 2048)
+    Spatial features: (B, 49, 2048) - where 49 = 7x7 grid
+    """
+    def __init__(self, model_name="resnet50", pretrained=True):
+        super().__init__()
+        if model_name == "resnet50":
+            base_model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1 if pretrained else None)
+            # We want the layer before global avg pool
+            return_nodes = {
+                'layer4': 'spatial_features',
+                'avgpool': 'pooled_features'
+            }
+            self.feature_extractor = create_feature_extractor(base_model, return_nodes=return_nodes)
+            self.d_output = 2048
+        else:
+            raise ValueError(f"Unsupported model: {model_name}")
+
+    def forward(self, x):
+        """
+        x: (B, 3, H, W)
+        Returns:
+            pooled: (B, d_output)
+            spatial: (B, L, d_output) where L is spatial grid size
+        """
+        features = self.feature_extractor(x)
+        
+        # Pooled features come as (B, 2048, 1, 1) -> (B, 2048)
+        pooled = features['pooled_features'].flatten(1)
+        
+        # Spatial features come as (B, 2048, 7, 7) -> (B, 49, 2048)
+        spatial = features['spatial_features']
+        B, C, H, W = spatial.shape
+        spatial = spatial.view(B, C, -1).transpose(1, 2) # (B, 49, 2048)
+        
+        return pooled, spatial

cida_plugin-1.0.0.dist-info/METADATA

@@ -0,0 +1,167 @@
+Metadata-Version: 2.4
+Name: cida-plugin
+Version: 1.0.0
+Summary: Universal Evidence-Grounded Multi-Agent Deliberation Layer for any encoder
+Author-email: Kairat Zhaksylykov <zhaksylykov.k06@gmail.com>
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/Kairatzh/CIDA-plugin
+Project-URL: Repository, https://github.com/Kairatzh/CIDA-plugin.git
+Project-URL: Documentation, https://github.com/Kairatzh/CIDA-plugin#readme
+Project-URL: Issues, https://github.com/Kairatzh/CIDA-plugin/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: torch>=2.1
+Requires-Dist: transformers>=4.0
+Requires-Dist: huggingface_hub>=0.14.0
+Requires-Dist: torchdiffeq>=0.2.3
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Dynamic: license-file
+
+# CIDA-Plugin v3: Universal Evidence-Grounded Multi-Agent Deliberation Layer
+
+> *"What if a neural network could argue with itself — and reach a better answer?"*
+
+**CIDA-Plugin** is a drop-in architectural layer that can be added on top of **any** pre-trained Transformer encoder (BERT, DistilBERT, RoBERTa, etc.) or Vision Backbone (ResNet, DenseNet, etc.). Instead of a simple Linear Head, CIDA-Plugin introduces a **Multi-Agent Deliberation Protocol**.
+
+It forces the model to form independent perspectives (agents), exchange arguments, and reach a consensus weighted by each agent's uncertainty.
+
+**Result:** Massive reductions in Expected Calibration Error (ECE), robust uncertainty estimation, and better-reasoned predictions without relying on post-hoc calibration methods like Temperature Scaling.
+
+---
+
+## ⚡ What's New in v3 (Simplified Architecture)
+We transitioned from a highly complex, statistical embedding-based formulation (v2) to a streamlined, theoretically grounded Bayesian-inspired architecture (v3):
+
+*   **Bayesian Role Priors**: Removed the hyperparameter-heavy `debate_loss`, role-specific serialization losses, and learnable `RoleEmbeddings`. Instead, agents are assigned fixed, mathematically guaranteed prior beliefs (Prosecutor, Defender, Skeptic, Integrator). This enforces structural disagreement at all times, preventing agent representation collapse.
+*   **Weighted Mean Consensus**: Replaced the Product of Experts (PoE) aggregator, which incorrectly assumed agent independence and amplified shared bias (causing overconfidence). We now aggregate beliefs via a Weighted Mean, which is mathematically sound for correlated variables.
+*   **Disagreement-as-Uncertainty**: Replaced the circular and unstable `ReliabilityTracker` with an observable, non-learned uncertainty quantification based on the variance (standard deviation) between expert beliefs: $U = f(\text{std}(b))$.
+*   **3-Component Loss System**: Reduced the loss system from 11 components to 3 core components: Task Loss (CE/BCE), Calibration Loss (Brier Score), and Anti-Collapse Loss (used only as a safety net).
+
+---
+
+## ⚡ Comparison: Legacy vs. v3 Simplified
+
+| Feature | Legacy CIDA (v2/Omega) | CIDA v3 (Simplified) |
+| :--- | :--- | :--- |
+| **Agent Diversity** | Additive embeddings + `debate_loss` | Fixed Role Priors + `anti_collapse_loss` |
+| **Consensus Mech** | Product of Experts (PoE) | Weighted Mean (Correlation-Aware) |
+| **Reliability/Uncertainty** | Learned EMA Reliability Tracker | Observed Disagreement ($std(b)$) |
+| **Loss System** | 11 components (hard to tune) | 3 components (extremely stable) |
+| **Hyperparameters** | 11 (lambda schedules, temp, etc.) | 2 (lambda_cal, lambda_ac) |
+
+---
+
+## 📦 Installation
+
+```bash
+pip install .
+```
+
+---
+
+## ⚡ Quickstart
+
+CIDA-Plugin is designed to be as easy to use as a standard Hugging Face model.
+
+### 1. Training with any Encoder
+```python
+import torch
+from transformers import AutoModel
+from cida_plugin import CIDAPlugin, CIDAPluginConfig, CIDALoss
+
+# 1. Load any frozen encoder
+encoder = AutoModel.from_pretrained("distilbert-base-uncased")
+d_model = encoder.config.hidden_size
+
+# 2. Initialize the plugin config
+config = CIDAPluginConfig(
+    d_input=d_model,     # Match encoder output dimension
+    d_hidden=128,        # Internal plugin dimension
+    num_classes=2,
+    max_rounds=3,        # Deliberation rounds
+    early_stop_threshold=0.90
+)
+plugin = CIDAPlugin(config)
+loss_fn = CIDALoss(lambda_cal=0.4, lambda_ac=0.2)
+
+# 3. Forward pass
+input_ids = torch.randint(0, 1000, (4, 128))
+out = encoder(input_ids)
+pooled = out.last_hidden_state[:, 0, :]
+
+# The plugin takes the pooled representation and deliberates
+plugin_out = plugin(pooled, seq_output=out.last_hidden_state)
+
+logits = plugin_out["p_final"] # (Batch, Num_Classes)
+loss, loss_components = loss_fn(logits, targets, plugin_out["b_all"])
+```
+
+### 2. Saving and Loading (Hugging Face style)
+```python
+# Save to disk
+plugin.save_pretrained("./my-cida-plugin")
+
+# Load from disk
+loaded_plugin = CIDAPlugin.from_pretrained("./my-cida-plugin")
+```
+
+---
+
+## 🛠️ Architecture Overview
+
+The plugin takes the output of your encoder and processes it through the following steps:
+
+1. **Input Projection:** Maps the arbitrary `d_input` of the encoder to the internal `d_hidden` of the agents.
+2. **Agent Initialization:** Creates $M$ distinct agents initialized with the pooled representation.
+3. **Deliberation Loop ($R$ rounds):**
+   - **Evidence Extraction:** Agents attend to the input sequence to gather distinct evidence.
+   - **Message Formulation:** Agents compress their beliefs and evidence into theses.
+   - **Cross-Attention Communication:** Agents listen to others, explicitly weighting disagreement.
+   - **Gated Update:** Agents update their internal states.
+   - **Role Prior Blending:** Enforces structural roles (Prosecutor, Defender, Skeptic, Integrator) on updated beliefs.
+4. **Consensus Aggregation:** A final Weighted Mean consensus calculation.
+
+---
+
+## 🧪 Liquid Dynamics & TTT (v5 Additions)
+*   **Liquid Neural ODE**: Set `use_liquid_dynamics=True` to replace the discrete iteration loop with continuous-time deliberation solver ($ds/dt = -s/\tau(x) + F(s,r,e)$).
+*   **Test-Time Training (TTT)**: Set `use_ttt=True` to allow agents to adapt their weights to a specific input using self-supervised masked state reconstruction steps before answering.
+
+---
+
+## 🎮 Interactive Demo (Hugging Face Spaces)
+
+See how 4 agents deliberate before answering — with agent vote charts and uncertainty gauges.
+
+```bash
+# Train demo checkpoints (~5 min on CPU)
+python demo/train_demo.py
+
+# Launch Gradio locally
+python demo/app.py
+```
+
+Deploy to [Hugging Face Spaces](https://huggingface.co/spaces): create a Gradio Space pointing to the `demo/` folder (see `demo/README.md`).
+
+---
+
+## ⚡ Running Tests
+To verify the installation and execution:
+```bash
+pytest tests/ -v
+```

cida_plugin-1.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+cida_plugin/__init__.py,sha256=2tKyADKoGtZ_mkm9pBBoJ-0XlNxeN9zLTRVpsGUmXww,1801
+cida_plugin/agent.py,sha256=YVEFLIGBiM-w2hEMmz1oE7C_M8_hvXWxZAkvKQMLZMM,8537
+cida_plugin/config.py,sha256=7_YALMO3vDu6E7Ah1ODgcmPdK2DO_VIHqMBUz3hPzQE,11156
+cida_plugin/consensus.py,sha256=WDokEu5Ybr4j5l6cMOddM8Y7eTkdV_4v3iaeybl_-R8,8832
+cida_plugin/core.py,sha256=9oNih5KXtuJcGhj7oBDF_0tJvx01cSfxoEJEHCfcQHQ,20143
+cida_plugin/deliberation.py,sha256=ABedI-Le0BFjP4GGEpfzYMZ-4A469yx-vUwM-xsUAYY,18470
+cida_plugin/diagnostics.py,sha256=PeMjHMnihO_Qu1nTG-PFTphAL8b8h44Sl-wjlbC8VnA,5242
+cida_plugin/hf.py,sha256=hn5AOxVNFlOB73kQyZfpStZ3a7-nJe6AoqdCerIL3aw,7929
+cida_plugin/liquid_dynamics.py,sha256=iLFV6bPllhDW4wimTtIXd7n-_S9FgCpen-ct56DExSw,10489
+cida_plugin/losses.py,sha256=F6Cj-uQfKMJbP1O_pJ9C8H-XRXGBuG6gNU-_09s6Irs,8493
+cida_plugin/translator.py,sha256=3ZHzOM1B7_xnqNSwUmf_dKgnETV62X0YWhZMlB5yO2I,3296
+cida_plugin/ttt.py,sha256=ILE8NxzKo5bT1OgS-ro18RouOeopmcWTzbrLthPDRSk,15449
+cida_plugin/vision_backbone.py,sha256=T4GdlZTFlh2xCBnvYJBgmZmIh6MoDQ8JUS30UGemlZo,1649
+cida_plugin-1.0.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+cida_plugin-1.0.0.dist-info/METADATA,sha256=MB0rqdFaAZMyoFmW0I3CLIA95z6QGCBAYBJXuIr4b6Y,7543
+cida_plugin-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+cida_plugin-1.0.0.dist-info/top_level.txt,sha256=IsOo3gdhzBYnw_n7e2zwHEUL0cQAq9GYrR4v9ubjqy4,12
+cida_plugin-1.0.0.dist-info/RECORD,,

cida_plugin-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+