dsh-biocore 0.1.2 → 0.1.4

package/python/mindbase/connectome_prior.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict
+
+from .digital_prior import FlyPrior
+
+
+@dataclass(frozen=True)
+class ConnectomePrior(FlyPrior):
+    """Compressed structural prior from digital-fly connectomics.
+
+    cell_types from MaleCNS 2026; MBON/DAN counts are approximate and used only
+    as a scale, not as an exact reconstruction.
+    """
+    cell_types: int = 11_710
+    mb_compartments: int = 15
+    mbon_count: int = 34
+    dan_count: int = 130
+
+    def summary(self) -> Dict[str, object]:
+        base = super().summary()
+        base.update(
+            {
+                "cell_types": self.cell_types,
+                "mb_compartments": self.mb_compartments,
+                "mbon_count": self.mbon_count,
+                "dan_count": self.dan_count,
+                "note": "MBON/DAN counts are approximate, used as scale only",
+            }
+        )
+        return base
+
+
+CONNECTOME = ConnectomePrior()

package/python/mindbase/connectome_world.py

@@ -0,0 +1,158 @@
+"""Connectome-constrained world model prototype.
+
+A sparse recurrent reservoir (connectome-like wiring prior) + self-supervised
+linear readout: predict the next sensory/state vector.  This is a small,
+honest prototype, not a whole-brain emulation.
+"""
+from __future__ import annotations
+
+import random
+from typing import Dict, List, Sequence
+
+import numpy as np
+
+
+class ConnectomeWorldModel:
+    def __init__(self, n_neurons: int = 128, n_input: int = 6,
+                 sparsity: float = 0.08, spectral_radius: float = 0.9,
+                 seed: int = 1, n_action: int = 6,
+                 use_action_effects: bool = False):
+        self.n = int(n_neurons)
+        self.n_input = int(n_input)
+        self.n_action = int(n_action)
+        self.use_action_effects = bool(use_action_effects)
+        self.action_dim = self.n_input if self.use_action_effects else self.n_action
+        self.action_effects = np.zeros((self.n_action, self.n_input))
+        self.rng = np.random.default_rng(int(seed))
+        w = self.rng.normal(0.0, 1.0, size=(self.n, self.n))
+        mask = self.rng.random((self.n, self.n)) < float(sparsity)
+        w = w * mask
+        # scale spectral radius for stable echo-state dynamics
+        try:
+            vals = np.linalg.eigvals(w)
+            radius = float(np.max(np.abs(vals))) if len(vals) else 1.0
+            w = w * (float(spectral_radius) / max(1e-9, radius))
+        except Exception:
+            w = w / max(1e-9, np.linalg.norm(w, 2))
+        self.W = w
+        self.B = self.rng.normal(0.0, 0.2, size=(self.n, self.n_input + self.action_dim))
+        self.C = np.zeros((self.n, self.n_input))
+        self.h = np.zeros(self.n)
+
+    def _step(self, sensory: np.ndarray, action: int | None = None) -> np.ndarray:
+        s = np.asarray(sensory, dtype=float).reshape(-1)
+        if s.shape[0] != self.n_input:
+            s = np.resize(s, self.n_input)
+        a = np.zeros(self.action_dim)
+        if action is not None:
+            ai = int(action) % self.n_action
+            if self.use_action_effects:
+                a = self.action_effects[ai].copy()
+            else:
+                a[ai] = 1.0
+        inp = np.concatenate([s, a])
+        self.h = np.tanh(self.W @ self.h + self.B @ inp)
+        return self.h
+
+    def predict_next(self, sensory: np.ndarray, action: int | None = None) -> np.ndarray:
+        h = self._step(sensory, action)
+        return np.asarray(sensory, dtype=float).reshape(-1)[:self.n_input] + h @ self.C
+
+    def fit(self, sequences: Sequence[Sequence[np.ndarray]], ridge: float = 1e-3) -> Dict[str, float]:
+        X: List[np.ndarray] = []
+        Y: List[np.ndarray] = []
+        for seq in sequences:
+            self.h = np.zeros(self.n)
+            prev = None
+            for s in seq:
+                s = np.asarray(s, dtype=float)
+                if prev is not None:
+                    X.append(self.h.copy())
+                    Y.append(s - prev)
+                self._step(s)
+                prev = s
+        if not X:
+            return {"n": 0, "train_mse": 0.0}
+        Xm = np.asarray(X)
+        Ym = np.asarray(Y)
+        # ridge: C^T = (X^T X + λI)^-1 X^T Y
+        A = Xm.T @ Xm + float(ridge) * np.eye(self.n)
+        self.C = np.linalg.solve(A, Xm.T @ Ym)
+        pred = Xm @ self.C
+        return {"n": int(len(X)), "train_mse": round(float(np.mean((pred - Ym) ** 2)), 6)}
+
+    def evaluate(self, sequences: Sequence[Sequence[np.ndarray]]) -> Dict[str, float]:
+        errs = []
+        base = []
+        for seq in sequences:
+            self.h = np.zeros(self.n)
+            prev = None
+            for s in seq:
+                s = np.asarray(s, dtype=float)
+                if prev is not None:
+                    pred = prev + (self.h @ self.C)
+                    errs.append(float(np.mean((pred - s) ** 2)))
+                    base.append(float(np.mean((prev - s) ** 2)))
+                self._step(s)
+                prev = s
+        return {"n": len(errs),
+                "model_mse": round(float(np.mean(errs)) if errs else 0.0, 6),
+                "persistence_mse": round(float(np.mean(base)) if base else 0.0, 6)}
+
+
+    def fit_action(self, sequences: Sequence[Sequence[tuple]], ridge: float = 1e-3) -> Dict[str, float]:
+        if self.use_action_effects:
+            sums = np.zeros((self.n_action, self.n_input))
+            counts = np.zeros(self.n_action)
+            for seq in sequences:
+                for (s0, action), (s1, _a1) in zip(seq[:-1], seq[1:]):
+                    ai = int(action) % self.n_action
+                    sums[ai] += np.asarray(s1, dtype=float) - np.asarray(s0, dtype=float)
+                    counts[ai] += 1
+            for i in range(self.n_action):
+                if counts[i] > 0:
+                    self.action_effects[i] = sums[i] / counts[i]
+        X: List[np.ndarray] = []
+        Y: List[np.ndarray] = []
+        for seq in sequences:
+            self.h = np.zeros(self.n)
+            for (s, action), nxt in zip(seq[:-1], seq[1:]):
+                s_arr = np.asarray(s, dtype=float)
+                X.append(self.h.copy())
+                Y.append(np.asarray(nxt[0], dtype=float) - s_arr)
+                self._step(s_arr, int(action))
+        if not X:
+            return {"n": 0, "train_mse": 0.0}
+        Xm = np.asarray(X)
+        Ym = np.asarray(Y)
+        A = Xm.T @ Xm + float(ridge) * np.eye(self.n)
+        self.C = np.linalg.solve(A, Xm.T @ Ym)
+        pred = Xm @ self.C
+        return {"n": int(len(X)), "train_mse": round(float(np.mean((pred - Ym) ** 2)), 6)}
+
+    def evaluate_action(self, sequences: Sequence[Sequence[tuple]]) -> Dict[str, float]:
+        errs = []
+        base = []
+        for seq in sequences:
+            self.h = np.zeros(self.n)
+            for (s, action), nxt in zip(seq[:-1], seq[1:]):
+                s_arr = np.asarray(s, dtype=float)
+                nxt_arr = np.asarray(nxt[0], dtype=float)
+                pred = s_arr + (self.h @ self.C)
+                errs.append(float(np.mean((pred - nxt_arr) ** 2)))
+                base.append(float(np.mean((s_arr - nxt_arr) ** 2)))
+                self._step(s_arr, int(action))
+        return {"n": len(errs),
+                "model_mse": round(float(np.mean(errs)) if errs else 0.0, 6),
+                "persistence_mse": round(float(np.mean(base)) if base else 0.0, 6)}
+
+
+def sequences_from_rows(rows: Sequence[Dict[str, object]], n_input: int = 6) -> List[np.ndarray]:
+    out = []
+    for r in rows:
+        need = float((r.get("needs") or 0.0))
+        vec = [float(r.get("energy", 0.0)), float(r.get("social", 0.0)),
+               float(r.get("stress", 0.0)), float(r.get("damage", 0.0)),
+               float(r.get("viability", 1.0)), need]
+        out.append(np.asarray(vec[:n_input], dtype=float))
+    return out

package/python/mindbase/constructs.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Dict, Optional, Tuple
+
+from .noise import clip
+
+DEFAULT_PATH = Path(__file__).with_name("constructs.json")
+
+BOUNDS: Dict[str, Tuple[float, float]] = {
+    "O": (0.0, 1.0),
+    "C": (0.0, 1.0),
+    "E": (0.0, 1.0),
+    "A": (0.0, 1.0),
+    "N": (0.0, 1.0),
+    "baseline_v": (-1.0, 1.0),
+    "baseline_a": (0.0, 1.0),
+    "stress_reactivity": (0.0, 1.0),
+    "recovery_rate": (0.0, 1.0),
+    "social_baseline": (0.0, 1.0),
+    "energy_baseline": (0.0, 1.0),
+    "curiosity_baseline": (0.0, 1.0),
+    "safety_baseline": (0.0, 1.0),
+    "da_baseline": (0.0, 1.0),
+    "oa_baseline": (0.0, 1.0),
+    "ht_baseline": (0.0, 1.0),
+    "autonomy_gain": (0.0, 1.5),
+    "learning_rate": (0.01, 0.12),
+    "circadian_phase": (-0.10, 0.10),
+}
+
+
+class ConstructRegistry:
+    """Declarative construct -> numeric deltas.
+
+    Definitions are data (JSON), not if/else branches. Register a new construct
+    at runtime without touching the engine.
+    """
+
+    def __init__(self, path: Optional[Path] = None, definitions: Optional[Dict[str, dict]] = None):
+        self.constructs: Dict[str, dict] = {}
+        target = path or DEFAULT_PATH
+        if target.exists():
+            self.load(target)
+        if definitions:
+            self.register_many(definitions)
+
+    def load(self, path: Path) -> None:
+        data = json.loads(Path(path).read_text(encoding="utf-8"))
+        self.register_many(data)
+
+    def register(self, name: str, definition: dict) -> None:
+        if "deltas" not in definition or not isinstance(definition["deltas"], dict):
+            raise ValueError(f"construct {name} needs a deltas dict")
+        self.constructs[name] = dict(definition)
+
+    def register_many(self, definitions: Dict[str, dict]) -> None:
+        for name, definition in definitions.items():
+            self.register(name, definition)
+
+    def has(self, name: str) -> bool:
+        return name in self.constructs
+
+    def apply(self, numbers: Dict[str, float], scores: Dict[str, float]) -> Tuple[Dict[str, float], Dict[str, float]]:
+        out = dict(numbers)
+        extra: Dict[str, float] = {}
+        for name, raw_score in scores.items():
+            definition = self.constructs.get(name)
+            if definition is None:
+                continue
+            score = clip(float(raw_score), 0.0, 1.0)
+            for target, delta in definition["deltas"].items():
+                amount = score * float(delta)
+                if target.startswith("extra."):
+                    key = target.split(".", 1)[1]
+                    extra[key] = extra.get(key, 0.5) + amount
+                elif target in out:
+                    out[target] = out[target] + amount
+        for key, (lo, hi) in BOUNDS.items():
+            if key in out:
+                out[key] = clip(float(out[key]), lo, hi)
+        for key in list(extra):
+            extra[key] = clip(extra[key], 0.0, 1.0)
+        return out, extra
+
+    def snapshot(self) -> Dict[str, dict]:
+        return {name: {"label": d.get("label", name), "description": d.get("description", "")} for name, d in self.constructs.items()}

package/python/mindbase/context_builder.py

@@ -0,0 +1,58 @@
+"""Prioritized context blocks and a numeric reflection trigger.
+
+MemGPT/Letta-style core blocks + Generative-Agents-style reflection threshold.
+No LLM call in the decision; the LLM is only used when the trigger fires.
+"""
+from __future__ import annotations
+
+
+class ContextBuilder:
+    def __init__(self, max_chars: int = 1400):
+        self.max_chars = int(max_chars)
+        self.last_blocks = {}
+
+    def build(self, facts=None, loops=None, recent: str = "") -> str:
+        facts = [str(x).strip() for x in (facts or []) if str(x).strip()]
+        loops = [str(x).strip() for x in (loops or []) if str(x).strip()]
+        blocks = []
+        used = 0
+        def add(label, items):
+            nonlocal used
+            if not items:
+                return
+            body = "；".join(dict.fromkeys(items))
+            text = label + "：" + body
+            if used + len(text) > self.max_chars:
+                remain = max(0, self.max_chars - used)
+                if remain < 20:
+                    return
+                text = text[:remain]
+            blocks.append(text)
+            used += len(text)
+        add("稳定事实", facts)
+        add("未闭环", loops)
+        if recent:
+            add("近期", [recent])
+        self.last_blocks = {"facts": len(facts), "loops": len(loops), "chars": used}
+        return "\n".join(blocks)
+
+
+class ReflectionTrigger:
+    def __init__(self, threshold: float = 8.0, min_interval_s: float = 1800.0):
+        self.threshold = float(threshold)
+        self.min_interval_s = float(min_interval_s)
+        self.accum = 0.0
+        self.last_at = 0.0
+
+    def note(self, importance: float) -> None:
+        try:
+            self.accum += max(0.0, min(1.0, float(importance)))
+        except Exception:
+            pass
+
+    def due(self, now: float) -> bool:
+        return self.accum >= self.threshold and (float(now) - self.last_at) >= self.min_interval_s
+
+    def consume(self, now: float) -> None:
+        self.accum = 0.0
+        self.last_at = float(now)

package/python/mindbase/critical.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import numpy as np
+
+
+class CriticalDynamics:
+    """Recurrent dynamics near the edge of chaos (spectral radius ~= 1)."""
+
+    def __init__(self, seed: int = 1, n: int = 64):
+        self.rng = np.random.default_rng(seed)
+        self.n = n
+        self.w = self.rng.normal(0, 1.0 / np.sqrt(n), (n, n))
+        radius = max(1e-6, float(np.max(np.abs(np.linalg.eigvals(self.w)))))
+        self.w *= 1.0 / radius
+        self.x = self.rng.normal(0, 0.1, n)
+        self.history = []
+
+    def step(self, external: float = 0.0) -> dict:
+        noise = self.rng.normal(0, 0.01, self.n)
+        self.x = np.tanh(self.w @ self.x + 0.4 * float(external) + noise)
+        self.history.append(float(np.mean(self.x)))
+        self.history = self.history[-200:]
+        self.metastability = float(np.std(self.history)) if len(self.history) > 5 else 0.0
+        return {
+            "mean": round(float(np.mean(self.x)), 4),
+            "variance": round(float(np.var(self.x)), 4),
+            "metastability": round(float(np.std(self.history)), 4) if len(self.history) > 5 else 0.0,
+            "saturation": round(float(np.mean(np.abs(self.x) > 0.95)), 4),
+        }
+
+    def flexibility(self) -> float:
+        # metastability normalized for downstream use
+        return round(min(1.0, max(0.0, float(self.step.__self__.history and 0 or 0))), 4) if False else round(min(1.0, abs(float(getattr(self, "metastability", 0.0)))), 4)
+
+    def spectral_radius(self) -> float:
+        return round(float(np.max(np.abs(np.linalg.eigvals(self.w)))), 4)

package/python/mindbase/criticality.py

@@ -0,0 +1,123 @@
+"""Criticality meters and controllers for endogenous noise.
+
+Operational proxies only: branching ratio, avalanche distribution, metastability.
+These are *not* claims of consciousness; they measure structured spontaneous activity.
+"""
+from __future__ import annotations
+
+import math
+from collections import deque
+from typing import Deque, Dict, List, Optional
+
+
+class BranchingRatio:
+    """Estimate sigma = E[n_{t+1} / n_t] for active steps (n_t > 0)."""
+
+    def __init__(self, window: int = 256):
+        self.window = max(8, int(window))
+        self.history: Deque[float] = deque(maxlen=self.window)
+        self.prev = 0
+
+    def reset(self) -> None:
+        self.history.clear()
+        self.prev = 0
+
+    def update(self, activity: int) -> float:
+        n = max(0, int(activity))
+        if self.prev > 0:
+            self.history.append(float(n) / float(self.prev))
+        self.prev = n
+        return self.sigma
+
+    @property
+    def sigma(self) -> float:
+        if not self.history:
+            return 0.0
+        return float(sum(self.history) / len(self.history))
+
+    def score(self, target: float = 1.0) -> float:
+        if not self.history:
+            return 0.0
+        return max(0.0, 1.0 - min(1.0, abs(self.sigma - float(target))))
+
+
+class AvalancheMeter:
+    """Collect activity counts and fit a crude power-law slope on log bins."""
+
+    def __init__(self, capacity: int = 2048):
+        self.counts: Deque[int] = deque(maxlen=max(32, int(capacity)))
+
+    def reset(self) -> None:
+        self.counts.clear()
+
+    def update(self, activity: int) -> None:
+        self.counts.append(max(0, int(activity)))
+
+    def exponent(self) -> float:
+        vals = [x for x in self.counts if x > 0]
+        if len(vals) < 16:
+            return 0.0
+        # coarse log bins
+        bins: Dict[int, int] = {}
+        for x in vals:
+            b = int(math.floor(math.log2(max(1, x))))
+            bins[b] = bins.get(b, 0) + 1
+        xs: List[float] = []
+        ys: List[float] = []
+        for b, c in sorted(bins.items()):
+            if c > 0:
+                xs.append(math.log(max(1.0, float(2 ** b))))
+                ys.append(math.log(float(c)))
+        if len(xs) < 3:
+            return 0.0
+        mx = sum(xs) / len(xs)
+        my = sum(ys) / len(ys)
+        den = sum((x - mx) ** 2 for x in xs)
+        if den <= 1e-9:
+            return 0.0
+        return float(sum((x - mx) * (y - my) for x, y in zip(xs, ys)) / den)
+
+    def score(self) -> float:
+        # target slope ~ -1.5 (classic avalanche exponent)
+        return max(0.0, 1.0 - min(1.0, abs(self.exponent() + 1.5) / 1.5))
+
+
+class CriticalityController:
+    """Homeostatic controller: adjust a gate toward a target branching ratio."""
+
+    def __init__(self, target: float = 1.0, lr: float = 0.02, gate: float = 1.0):
+        self.target = float(target)
+        self.lr = float(lr)
+        self.gate = float(gate)
+        self.last_sigma = 0.0
+
+    def update(self, sigma: float) -> float:
+        self.last_sigma = float(sigma)
+        if self.last_sigma > 0.0:
+            self.gate += self.lr * (self.last_sigma - self.target)
+            self.gate = max(0.2, min(3.0, self.gate))
+        return self.gate
+
+
+class MetastabilityMeter:
+    """Cheap state-switching / dwell-time proxy."""
+
+    def __init__(self, window: int = 256):
+        self.values: Deque[float] = deque(maxlen=max(16, int(window)))
+
+    def update(self, value: float) -> None:
+        self.values.append(float(value))
+
+    def autocorrelation(self, lag: int = 1) -> float:
+        xs = list(self.values)
+        if len(xs) <= lag + 2:
+            return 0.0
+        a = xs[:-lag]
+        b = xs[lag:]
+        ma = sum(a) / len(a)
+        mb = sum(b) / len(b)
+        va = sum((x - ma) ** 2 for x in a)
+        vb = sum((x - mb) ** 2 for x in b)
+        if va <= 1e-12 or vb <= 1e-12:
+            return 0.0
+        return float(sum((x - ma) * (y - mb) for x, y in zip(a, b)) / math.sqrt(va * vb))

package/python/mindbase/defaults.py

@@ -0,0 +1,27 @@
+"""Reference defaults from digital-fly literature.
+
+These are documented starting points, not laws. Runtime knobs live in
+MindConfig; changing a default should be a deliberate design change.
+"""
+
+# Digital fly (FlyWire / MaleCNS)
+NEURONS = 139_255
+SYNAPSES = 50_000_000
+CELL_TYPES = 11_710
+MB_COMPARTMENTS = 15
+
+# Mushroom body compression
+KC_COUNT = 2_000
+KC_SPARSITY = 0.05
+KC_SLOTS = 256
+KC_ACTIVE = max(1, round(KC_SLOTS * KC_SPARSITY))  # 13
+
+# Approximate scale only (used for comments / coarse priors)
+MBON_COUNT = 34
+DAN_COUNT = 130
+
+# Runtime contract
+MAX_WM_SLOTS = 5
+MEMORY_CAPACITY = 256
+MAX_GOALS = 3
+MAX_LLM_CALLS_PER_STEP = 1