Add files via upload

Author: Freeky7819

scripts/meta_state_logger.py

@@ -0,0 +1,92 @@
+# meta_state_logger.py
+import argparse, time, os, datetime as dt
+
+def tail_last_line(path):
+    try:
+        with open(path, 'rb') as f:
+            f.seek(0, os.SEEK_END)
+            size = f.tell()
+            if size == 0:
+                return None
+            back = min(4096, size)
+            f.seek(-back, os.SEEK_END)
+            chunk = f.read().decode('utf-8', errors='ignore')
+            lines = [ln for ln in chunk.splitlines() if ln.strip()]
+            return lines[-1] if lines else None
+    except FileNotFoundError:
+        return None
+
+def parse_metrics(line):
+    if not line: return None
+    parts = [p.strip() for p in line.split(',')]
+    try:
+        return dict(
+            cycle=int(parts[0]),
+            alpha=float(parts[1]),
+            omega=float(parts[2]),
+            sigma=float(parts[3]),
+            drift=float(parts[4]),
+            confidence=float(parts[5]),
+            entropy=float(parts[6]),
+        )
+    except Exception:
+        # robust fallback
+        vals=[]
+        for p in parts:
+            try: vals.append(float(p))
+            except: pass
+        if len(vals) >= 5:
+            return dict(cycle=int(vals[0]), alpha=float('nan'), omega=float('nan'),
+                        sigma=vals[-4], drift=vals[-3], confidence=vals[-2], entropy=vals[-1])
+        return None
+
+def classify_state(entropy, drift, confidence):
+    if entropy > 0.05 or confidence < 0.95: return "CONFUSED"
+    if drift   > 0.02: return "DRIFTING"
+    if entropy > 0.02: return "WANDERING"
+    return "STABLE"
+
+def advice(state):
+    return {
+        "STABLE":   "All good. Maintain parameters.",
+        "WANDERING":"Gently reduce temperature/top_p. Add brief anchor.",
+        "DRIFTING": "Lower top_p, increase repeat_penalty. Re-center on the task.",
+        "CONFUSED": "Strong reset: anchor + lower temperature; consider re-prompt.",
+        "REALIGNING":"Stabilizing… keep parameters conservative for a bit.",
+    }.get(state, "Observe and adapt conservatively.")
+
+def main():
+    ap = argparse.ArgumentParser(description="Human-readable state logger from RLang CSV.")
+    ap.add_argument("--csv", default="out.csv")
+    ap.add_argument("--out", default="meta_state.txt")
+    ap.add_argument("--interval", type=float, default=2.0)
+    args = ap.parse_args()
+
+    last_written_cycle = None
+    print(f"[meta] watching {args.csv} → {args.out}")
+    while True:
+        line = tail_last_line(args.csv)
+        m = parse_metrics(line)
+        if m and m.get('cycle') != last_written_cycle:
+            state = classify_state(m['entropy'], m['drift'], m['confidence'])
+            now = dt.datetime.utcnow().strftime("%Y-%m-%d %H:%M:%SZ")
+            with open(args.out, 'w', encoding='utf-8') as f:
+                f.write(
+f"""# ResonantBridge — Meta State
+time: {now} UTC
+cycle: {m['cycle']}
+sigma: {m['sigma']:.5f}
+entropy: {m['entropy']:.5f}
+drift: {m['drift']:.5f}
+confidence: {m['confidence']:.5f}
+state: {state}
+
+advice: {advice(state)}
+"""
+                )
+            last_written_cycle = m['cycle']
+            print(f"[meta] cycle {m['cycle']} → {state}")
+        time.sleep(args.interval)
+
+if __name__ == "__main__":
+    main()

scripts/ollama_sigma_feed.py

@@ -0,0 +1,93 @@
+"""
+ollama_sigma_feed.py
+--------------------
+Streams tokens from a local Ollama model and writes a rolling "sigma" proxy
+to a text file for the Rlang autopoietic bridge to read.
+
+Requirements:
+  - Python 3.9+
+  - `requests` library
+  - Ollama running locally (default http://localhost:11434)
+
+Usage:
+  python ollama_sigma_feed.py --model llama3:8b --prompt "Explain resonance in one paragraph."                                   --sigma-file sigma_feed.txt --window 64
+
+Sigma proxy (no logprobs mode):
+  We compute a rolling token-distribution entropy H over the last N tokens.
+  Then map H into a bounded coherence measure sigma ~= 1 + k*(H0 - H),
+  where H0 is a reference entropy (approx upper bound for your model/tokenizer window).
+
+If your Ollama build exposes token logprobs in the stream, you can enable
+`--use-logprobs` and we will compute proper entropy from probabilities.
+"""
+import argparse, time, json, collections, math, requests
+
+def rolling_entropy_from_tokens(tokens):
+    # Simple character-level fallback: frequency of initial char of token text
+    # (works acceptably on common tokenizers for a quick proxy without logprobs).
+    freq = collections.Counter(t[:1] for t in tokens if t)
+    total = sum(freq.values()) or 1
+    p = [c/total for c in freq.values()]
+    H = -sum(pi*math.log(max(pi,1e-12)) for pi in p)  # nats
+    return H
+
+def map_entropy_to_sigma(H, H_ref=2.0, k=0.25):
+    # sigma ~ 1 when H == H_ref; >1 if H < H_ref (more coherent); <1 if H > H_ref
+    return 1.0 + k*(H_ref - H)
+
+def stream_ollama(model, prompt, host="http://localhost:11434", use_logprobs=False):
+    url = f"{host}/api/generate"
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "stream": True,
+        # You may set options here if desired:
+        # "options": {"temperature": 0.8, "top_p": 0.9}
+    }
+    with requests.post(url, json=payload, stream=True) as r:
+        r.raise_for_status()
+        for line in r.iter_lines():
+            if not line:
+                continue
+            try:
+                data = json.loads(line.decode("utf-8"))
+            except Exception:
+                continue
+            yield data
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", default="llama3:8b")
+    ap.add_argument("--prompt", default="Explain resonance as breathing of a system.")
+    ap.add_argument("--sigma-file", default="sigma_feed.txt")
+    ap.add_argument("--window", type=int, default=64, help="rolling window (tokens)")
+    ap.add_argument("--host", default="http://localhost:11434")
+    ap.add_argument("--use-logprobs", action="store_true", help="if available in your Ollama stream")
+    args = ap.parse_args()
+
+    tokens = collections.deque(maxlen=args.window)
+    # Try a rough upper reference entropy; adjust if your tokenizer is different
+    H_ref = 2.0
+    with open(args.sigma_file, "w", encoding="utf-8") as sf:
+        sf.write("1.00\n")  # initial neutral value
+
+    print(f"[ollama_sigma_feed] connecting to {args.host}, model={args.model}")
+    for msg in stream_ollama(args.model, args.prompt, args.host, args.use_logprobs):
+        if msg.get("done"):
+            break
+        tok_text = msg.get("response", "")
+        if not tok_text:
+            continue
+        # Split coarse to capture sub-tokens quickly
+        for ch in tok_text.split():
+            tokens.append(ch)
+            H = rolling_entropy_from_tokens(tokens)
+            sigma = map_entropy_to_sigma(H, H_ref=H_ref, k=0.25)
+            # clamp to reasonable living range [0.5, 1.5]
+            sigma = max(0.5, min(1.5, sigma))
+            with open(args.sigma_file, "w", encoding="utf-8") as sf:
+                sf.write(f"{sigma:.4f}\n")
+    print("[ollama_sigma_feed] stream complete; final sigma written.")
+
+if __name__ == "__main__":
+    main()

scripts/ollama_sigma_feed_live.py

@@ -0,0 +1,51 @@
+# ollama_sigma_feed_live.py
+import argparse, subprocess, time, sys, os
+
+def main():
+    ap = argparse.ArgumentParser(description="Keep σ(t) fresh by repeatedly calling ollama_sigma_feed.py.")
+    ap.add_argument("--model", required=True, help='e.g. "llama3.1:8b"')
+    ap.add_argument("--prompt", default="Explain resonance as breathing of a system.")
+    ap.add_argument("--sigma-file", default="sigma_feed.txt")
+    ap.add_argument("--window", type=int, default=64)
+    ap.add_argument("--host", default="http://127.0.0.1:11434")
+    ap.add_argument("--interval", type=float, default=1.0, help="seconds to wait between runs")
+    ap.add_argument("--use-logprobs", action="store_true")
+    ap.add_argument("--max-runs", type=int, default=0, help="0 = infinite; otherwise run this many times and exit")
+    args = ap.parse_args()
+
+    script = os.path.join(os.path.dirname(__file__), "ollama_sigma_feed.py")
+    if not os.path.isfile(script):
+        print("[live] ERROR: ollama_sigma_feed.py not found next to this script.", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"[live] starting σ loop → model={args.model} host={args.host} window={args.window} interval={args.interval}s")
+    print(f"[live] writing to: {args.sigma_file}  (Ctrl+C to stop)")
+    runs = 0
+    try:
+        while True:
+            cmd = [
+                sys.executable, script,
+                "--model", args.model,
+                "--prompt", args.prompt,
+                "--sigma-file", args.sigma_file,
+                "--window", str(args.window),
+                "--host", args.host,
+            ]
+            if args.use_logprobs:
+                cmd.append("--use-logprobs")
+
+            proc = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+            out = (proc.stdout or "").strip().splitlines()
+            if out:
+                print("[live] " + out[-1])
+
+            runs += 1
+            if args.max_runs and runs >= args.max_runs:
+                break
+
+            time.sleep(args.interval)
+    except KeyboardInterrupt:
+        print("\n[live] stopped by user.")
+
+if __name__ == "__main__":
+    main()