deepparallel 0.3.1__tar.gz → 0.4.0__tar.gz

{deepparallel-0.3.1 → deepparallel-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.3.1
+Version: 0.4.0
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0
@@ -19,6 +19,8 @@ Requires-Dist: cryptography>=42.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"
+Provides-Extra: research
+Requires-Dist: numpy>=1.24; extra == "research"
 
 # DeepParallel
 
@@ -67,6 +69,7 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel run --yes "..."        # auto-approve tool actions
     deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
     deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+    deepparallel research conduit       # latent-relay research demo (needs [research] extra)
 
 ## Supply-chain gate
 

{deepparallel-0.3.1 → deepparallel-0.4.0}/README.md

@@ -45,6 +45,7 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel run --yes "..."        # auto-approve tool actions
     deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
     deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+    deepparallel research conduit       # latent-relay research demo (needs [research] extra)
 
 ## Supply-chain gate
 

{deepparallel-0.3.1 → deepparallel-0.4.0}/deepparallel/__init__.py

@@ -1,3 +1,3 @@
 """DeepParallel CLI package."""
 
-__version__ = "0.3.1"
+__version__ = "0.4.0"

{deepparallel-0.3.1 → deepparallel-0.4.0}/deepparallel/cli.py

@@ -546,6 +546,52 @@ def audit(ctx: click.Context, path: str) -> None:
     sys.exit(0)
 
 
+@main.group()
+def research() -> None:
+    """Runnable demonstrators of the ideas behind DeepParallel."""
+
+
+@research.command("conduit")
+def research_conduit() -> None:
+    """Conduit: relay a thought between models as a hidden state vs. as a word.
+
+    Frozen synthetic models relay a continuous meaning down a chain of agents two
+    ways and we measure how much survives each hop. The latent channel holds the
+    meaning; the word channel (one emitted token per hop) collapses. The same
+    result on real open-weight models: crowelogic.com/research/conduit
+    """
+    try:
+        from deepparallel.research import conduit as _conduit
+    except ImportError:
+        branding.error(
+            "this demo needs numpy. Install it with: pip install 'deepparallel[research]'"
+        )
+        sys.exit(3)
+    console.print(f"[{branding.DIM}]running the latent relay (frozen synthetic models)...[/]")
+    r = _conduit.demonstrate()
+    console.print(
+        f"\n[bold]Conduit[/] · meaning retained after K relay hops "
+        f"[{branding.DIM}](cosine; 1.0 = perfect)[/]"
+    )
+    console.print(
+        f"[{branding.DIM}]  meaning = {r['meaning_dim']}-dim continuous   "
+        f"word channel = 1 token of {r['vocab']}[/]\n"
+    )
+    console.print(
+        f"  [{branding.DIM}]{'hops':>5}   {'latent relay':>13}   {'word relay':>11}   {'gain':>6}[/]"
+    )
+    for K in r["hops"]:
+        lat, wrd = r["latent"][K], r["word"][K]
+        console.print(
+            f"  {K:>5}   [{branding.GREEN_HEX}]{lat:>13.3f}[/]   "
+            f"[{branding.DIM}]{wrd:>11.3f}[/]   [{branding.AMBER_HEX}]{lat - wrd:>+6.3f}[/]"
+        )
+    console.print(
+        f"\n[{branding.DIM}]  the full hidden state relays more meaning than the single word "
+        f"the model would have said.[/]"
+    )
+
+
 @main.command(name="tools")
 def tools_cmd() -> None:
     """List the agent tools available to DeepParallel."""

deepparallel-0.4.0/deepparallel/research/__init__.py

@@ -0,0 +1,6 @@
+"""DeepParallel research demonstrators.
+
+Self-contained, runnable illustrations of the ideas behind DeepParallel's
+multi-model approach. These are optional and depend on numpy; install with
+`pip install deepparallel[research]`.
+"""

deepparallel-0.4.0/deepparallel/research/conduit.py

@@ -0,0 +1,156 @@
+"""Conduit: latent-state relay between frozen models (runnable demonstrator).
+
+The idea behind DeepParallel's multi-model approach, made concrete. When agents
+collaborate by writing words and reading them back, every hand-off squeezes a
+continuous thought through a single emitted token (~log2(vocab) bits). Conduit
+relays the model's hidden state directly through a tiny connector instead.
+
+This is a dependency-light demonstration of the mechanism and the information
+loss it avoids: two FROZEN synthetic transformers of different hidden sizes (so
+the connector is genuinely required) relay a continuous meaning vector down a
+chain of agents two ways, and we measure how much meaning survives each hop:
+
+    latent : h_i -> connector(W) -> next model    (continuous)
+    word   : h_i -> argmax token -> re-embed       (one discrete symbol)
+
+Needs numpy (`pip install deepparallel[research]`). The full research, including
+the same result on real open-weight models, is at crowelogic.com/research/conduit.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def _gelu(x):
+    return 0.5 * x * (1.0 + np.tanh(0.7978845608 * (x + 0.044715 * x**3)))
+
+
+def _ln(x):
+    return (x - x.mean(-1, keepdims=True)) / (x.std(-1, keepdims=True) + 1e-5)
+
+
+def _softmax(x):
+    e = np.exp(x - x.max(-1, keepdims=True))
+    return e / e.sum(-1, keepdims=True)
+
+
+class _FrozenLM:
+    """A tiny frozen decoder-only transformer with its own hidden size + vocab."""
+
+    def __init__(self, vocab, d, n_layers, seed):
+        self.vocab, self.d = vocab, d
+        rng = np.random.default_rng(seed)
+        s = 1.0 / np.sqrt(d)
+        self.E = rng.standard_normal((vocab, d)) * 0.02
+        self.U = rng.standard_normal((d, vocab)) * s
+        self.layers = [
+            {
+                "Wq": rng.standard_normal((d, d)) * s,
+                "Wk": rng.standard_normal((d, d)) * s,
+                "Wv": rng.standard_normal((d, d)) * s,
+                "Wo": rng.standard_normal((d, d)) * s,
+                "W1": rng.standard_normal((d, 4 * d)) * s,
+                "W2": rng.standard_normal((4 * d, d)) * s,
+            }
+            for _ in range(n_layers)
+        ]
+
+    def _forward(self, x):
+        T = x.shape[0]
+        mask = np.triu(np.full((T, T), -1e9), k=1)
+        for p in self.layers:
+            h = _ln(x)
+            q, k, v = h @ p["Wq"], h @ p["Wk"], h @ p["Wv"]
+            att = _softmax(q @ k.T / np.sqrt(self.d) + mask)
+            x = x + (att @ v) @ p["Wo"]
+            x = x + _gelu(_ln(x) @ p["W1"]) @ p["W2"]
+        return x
+
+    def hidden_at(self, in_embed):
+        return self._forward(in_embed.reshape(1, self.d))[-1]
+
+    def next_token(self, hidden):
+        return int(np.argmax(hidden @ self.U))
+
+
+def _ridge(X, Y, lam=1e-2):
+    Xb = np.hstack([X, np.ones((X.shape[0], 1))])
+    return np.linalg.solve(Xb.T @ Xb + lam * np.eye(Xb.shape[1]), Xb.T @ Y)
+
+
+def _affine(W, x):
+    return np.hstack([x, np.ones((x.shape[0], 1))]) @ W
+
+
+class _Conduit:
+    def __init__(self, d_meaning, dims, vocab, seed=7):
+        self.dm = d_meaning
+        rng = np.random.default_rng(seed)
+        self.models = [
+            _FrozenLM(vocab, dims[0], 2, seed + 1),
+            _FrozenLM(vocab, dims[1], 2, seed + 2),
+        ]
+        self.P = [rng.standard_normal((d_meaning, m.d)) * 0.5 for m in self.models]
+        self.conn, self.readout = {}, {}
+
+    def _encode(self, mi, z):
+        return self.models[mi].hidden_at(z @ self.P[mi])
+
+    def _relay(self, z, K, path):
+        mi = 0
+        h = self._encode(mi, z)
+        for hop in range(1, K + 1):
+            mj = hop % len(self.models)
+            if path == "latent":
+                in_embed = _affine(self.conn[(mi, mj)], h.reshape(1, -1))[0]
+            else:
+                tok = self.models[mi].next_token(h)
+                in_embed = self.models[mj].E[tok]
+            h = self.models[mj].hidden_at(in_embed)
+            mi = mj
+        return h, mi
+
+    def fit(self, n_train, fit_hops, seed=0):
+        rng = np.random.default_rng(seed)
+        Z = rng.standard_normal((n_train, self.dm))
+        n = len(self.models)
+        for i in range(n):
+            Hi = np.array([self._encode(i, z) for z in Z])
+            for j in range(n):
+                self.conn[(i, j)] = _ridge(Hi, Z @ self.P[j])
+        for path in ("latent", "word"):
+            finals = {0: [], 1: []}
+            targets = {0: [], 1: []}
+            for K in fit_hops:
+                for z in Z:
+                    h, m = self._relay(z, K, path)
+                    finals[m].append(h)
+                    targets[m].append(z)
+            for m in finals:
+                if finals[m]:
+                    self.readout[(path, m)] = _ridge(np.array(finals[m]), np.array(targets[m]))
+
+    def recover(self, z, K, path):
+        h, m = self._relay(z, K, path)
+        return _affine(self.readout[(path, m)], h.reshape(1, -1))[0]
+
+
+def _cos(a, b):
+    return float(a @ b / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-9))
+
+
+def demonstrate(hops=(1, 2, 4, 6, 8)) -> dict:
+    """Run the relay both ways and return meaning retained per hop count."""
+    d_meaning, vocab = 16, 256
+    link = _Conduit(d_meaning, dims=[32, 48], vocab=vocab)
+    link.fit(n_train=800, fit_hops=hops)
+    rng = np.random.default_rng(123)
+    test = rng.standard_normal((300, d_meaning))
+    out = {"latent": {}, "word": {}, "meaning_dim": d_meaning, "vocab": vocab, "hops": list(hops)}
+    for path in ("latent", "word"):
+        for K in hops:
+            out[path][K] = round(
+                float(np.mean([_cos(z, link.recover(z, K, path)) for z in test])), 3
+            )
+    return out

{deepparallel-0.3.1 → deepparallel-0.4.0}/deepparallel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepparallel
-Version: 0.3.1
+Version: 0.4.0
 Summary: DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic.
 Author-email: Michael Crowe <michael@crowelogic.com>
 License: Apache-2.0
@@ -19,6 +19,8 @@ Requires-Dist: cryptography>=42.0.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: ruff>=0.6.0; extra == "dev"
+Provides-Extra: research
+Requires-Dist: numpy>=1.24; extra == "research"
 
 # DeepParallel
 
@@ -67,6 +69,7 @@ Set the backend env vars (a `.env` file in the working directory is loaded autom
     deepparallel run --yes "..."        # auto-approve tool actions
     deepparallel review <file|--diff>   # cross-model review as a CI gate (Pro)
     deepparallel audit <file>           # supply-chain gate: catch hallucinated deps (Pro)
+    deepparallel research conduit       # latent-relay research demo (needs [research] extra)
 
 ## Supply-chain gate
 

{deepparallel-0.3.1 → deepparallel-0.4.0}/deepparallel.egg-info/SOURCES.txt

@@ -18,6 +18,8 @@ deepparallel.egg-info/dependency_links.txt
 deepparallel.egg-info/entry_points.txt
 deepparallel.egg-info/requires.txt
 deepparallel.egg-info/top_level.txt
+deepparallel/research/__init__.py
+deepparallel/research/conduit.py
 deepparallel/tools/__init__.py
 deepparallel/tools/codeast.py
 deepparallel/tools/edit.py
@@ -39,6 +41,7 @@ tests/test_fusion.py
 tests/test_issuer_signer.py
 tests/test_licensing.py
 tests/test_renderer.py
+tests/test_research.py
 tests/test_supply_chain.py
 tests/test_tool_registry.py
 tests/test_tools_codeast.py

{deepparallel-0.3.1 → deepparallel-0.4.0}/deepparallel.egg-info/requires.txt

@@ -10,3 +10,6 @@ cryptography>=42.0.0
 [dev]
 pytest>=8.0.0
 ruff>=0.6.0
+
+[research]
+numpy>=1.24

{deepparallel-0.3.1 → deepparallel-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "deepparallel"
-version = "0.3.1"
+version = "0.4.0"
 description = "DeepParallel - a multi-model agentic coding CLI with cross-model Guardian review, served via Crowe Logic."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -26,6 +26,7 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = ["pytest>=8.0.0", "ruff>=0.6.0"]
+research = ["numpy>=1.24"]
 
 [project.urls]
 Homepage = "https://crowelogic.com"

deepparallel-0.4.0/tests/test_research.py

@@ -0,0 +1,27 @@
+import pytest
+from click.testing import CliRunner
+
+from deepparallel.cli import main
+
+np = pytest.importorskip("numpy")  # research demos are an optional extra
+
+from deepparallel.research import conduit  # noqa: E402
+
+
+def test_demonstrate_latent_beats_word_at_every_hop():
+    r = conduit.demonstrate(hops=(1, 4, 8))
+    for k in (1, 4, 8):
+        assert r["latent"][k] > r["word"][k], f"latent should beat word at hop {k}"
+    assert r["latent"][1] > 0.7  # strong signal retained at one hop
+
+
+def test_demonstrate_word_channel_does_not_improve_with_depth():
+    r = conduit.demonstrate(hops=(1, 6))
+    assert r["word"][6] <= r["word"][1] + 0.05  # lossy re-serialization, no gain
+
+
+def test_research_conduit_command_runs_and_prints_table():
+    result = CliRunner().invoke(main, ["research", "conduit"])
+    assert result.exit_code == 0
+    assert "Conduit" in result.output
+    assert "latent relay" in result.output