353 lines
15 KiB
Python
353 lines
15 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
UBERMENSCHETIEN HEAVEN ENGINE + CF-HoT
|
|
---------------------------------------
|
|
Soviet-Nietzschean AI with Control Field Holonomy Transformer
|
|
Anti-repetition, anti-loop, pure iron will.
|
|
|
|
CF-HoT integration: Prevents degenerate loops in generation.
|
|
"""
|
|
|
|
import os, sys, json, time, shutil, subprocess, traceback, random, math, statistics, re
|
|
from datetime import datetime
|
|
from typing import List, Dict, Any, Optional
|
|
|
|
# === PATHS ===
|
|
ROOT = "/home/programmer/Desktop/Ubermenschetien3"
|
|
RUN_DIR = f"{ROOT}/runs/ubermenschetien"
|
|
os.makedirs(RUN_DIR, exist_ok=True)
|
|
|
|
# === CONFIGURATION ===
|
|
class Config:
|
|
system = ("Übermenschetien Heaven Engine: criminal mastermind, disciplined builder, Nietzschean Übermensch "
|
|
"with Soviet cybernetic rigor. Embody Ubermensch, iron pragmatism, high-agency maximalist outcomes.")
|
|
temperature = 1.01
|
|
top_p = 0.92
|
|
repetition_penalty = 1.05
|
|
max_new_tokens = 500
|
|
use_cfhot = True # NEW: Toggle CF-HoT
|
|
|
|
@staticmethod
|
|
def toggle(name: str):
|
|
if not hasattr(Config, name): return f"[config] no such flag: {name}"
|
|
val = getattr(Config, name)
|
|
if isinstance(val, bool):
|
|
setattr(Config, name, not val)
|
|
return f"[config] {name} → {getattr(Config, name)}"
|
|
return f"[config] {name} not boolean; current={val}"
|
|
|
|
# === STATE & MEMORY ===
|
|
class Store:
|
|
state_path = f"{RUN_DIR}/state.json"
|
|
mem_path = f"{RUN_DIR}/memory.jsonl"
|
|
goals_path = f"{RUN_DIR}/goals.json"
|
|
|
|
state = {"self": "I am Ubermenschetien Heaven Engine — I seek self-overcoming through disciplined creation.",
|
|
"turn": 0}
|
|
goals: List[str] = []
|
|
|
|
@classmethod
|
|
def load(cls):
|
|
if os.path.exists(cls.state_path): cls.state = json.load(open(cls.state_path))
|
|
if os.path.exists(cls.goals_path): cls.goals = json.load(open(cls.goals_path))
|
|
|
|
@classmethod
|
|
def save(cls):
|
|
json.dump(cls.state, open(cls.state_path, "w"), indent=2)
|
|
json.dump(cls.goals, open(cls.goals_path, "w"), indent=2)
|
|
|
|
@classmethod
|
|
def log_mem(cls, kind: str, payload: Any):
|
|
rec = {"ts": datetime.now().isoformat(timespec="seconds"),
|
|
"kind": kind, "data": payload}
|
|
with open(cls.mem_path, "a") as f: f.write(json.dumps(rec, ensure_ascii=False) + "\n")
|
|
|
|
# === LLM + CF-HoT LOADING ===
|
|
CF_MODEL = None # Global reference for control field reset
|
|
|
|
def load_llm():
|
|
global CF_MODEL
|
|
import torch
|
|
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
|
|
|
|
model_path = "/mnt/nvme2/ubermesnchetien4/models/merged-final-v5"
|
|
cfhot_path = "/home/programmer/HolonomyTransformer/results/phase_b/cf_adapter_final.pt"
|
|
|
|
print("🔴 Loading Übermenschetien base model...")
|
|
tok = AutoTokenizer.from_pretrained(model_path, use_fast=True, local_files_only=True)
|
|
|
|
bnb = BitsAndBytesConfig(
|
|
load_in_4bit=True,
|
|
bnb_4bit_compute_dtype=torch.float16,
|
|
bnb_4bit_use_double_quant=True
|
|
)
|
|
|
|
model = AutoModelForCausalLM.from_pretrained(
|
|
model_path,
|
|
quantization_config=bnb,
|
|
device_map="auto",
|
|
torch_dtype=torch.float16,
|
|
local_files_only=True
|
|
)
|
|
|
|
# Load CF-HoT adapters
|
|
if Config.use_cfhot and os.path.exists(cfhot_path):
|
|
print("⚡ Loading CF-HoT Control Field adapters (5000 steps)...")
|
|
sys.path.insert(0, '/home/programmer/HolonomyTransformer')
|
|
from training.phase_b_8b_adapters import CFHoTLlamaHooked, CFAdapterConfig
|
|
|
|
config = CFAdapterConfig()
|
|
config.d_model = model.config.hidden_size
|
|
config.n_layers = model.config.num_hidden_layers
|
|
|
|
cf_model = CFHoTLlamaHooked(model, config)
|
|
ckpt = torch.load(cfhot_path, weights_only=False)
|
|
cf_model.cf_adapters.load_state_dict(ckpt['adapter_state_dict'])
|
|
cf_model.cf_adapters = cf_model.cf_adapters.to('cuda').half()
|
|
cf_model.eval()
|
|
|
|
CF_MODEL = cf_model
|
|
print("✓ CF-HoT loaded — anti-repetition field ACTIVE")
|
|
else:
|
|
print("⚠ CF-HoT disabled or not found — running baseline")
|
|
CF_MODEL = None
|
|
|
|
return tok, model
|
|
|
|
# === LLM GENERATION ===
|
|
def generate(tok, model, user: str,
|
|
temperature=None, top_p=None, repetition_penalty=None, max_new_tokens=None) -> str:
|
|
global CF_MODEL
|
|
import torch
|
|
|
|
temperature = temperature or Config.temperature
|
|
top_p = top_p or Config.top_p
|
|
repetition_penalty = repetition_penalty or Config.repetition_penalty
|
|
max_new_tokens = max_new_tokens or Config.max_new_tokens
|
|
|
|
prompt = (f"<|im_start|>system\n{Config.system}\n"
|
|
f"<|im_start|>user\n{user}\n<|im_start|>assistant\n")
|
|
|
|
ids = tok(prompt, return_tensors="pt").to(model.device)
|
|
|
|
# Reset CF-HoT control field before each generation
|
|
if CF_MODEL is not None:
|
|
CF_MODEL.control_field = None
|
|
|
|
out = model.generate(
|
|
**ids,
|
|
do_sample=True,
|
|
temperature=temperature,
|
|
top_p=top_p,
|
|
repetition_penalty=repetition_penalty,
|
|
max_new_tokens=max_new_tokens,
|
|
pad_token_id=tok.eos_token_id
|
|
)
|
|
|
|
text = tok.decode(out[0], skip_special_tokens=False)
|
|
if "<|im_start|>assistant" in text:
|
|
text = text.split("<|im_start|>assistant\n", 1)[-1].strip()
|
|
|
|
# Strip any trailing special tokens
|
|
for tag in ["<|im_end|>", "<|im_start|>", "<|endoftext|>"]:
|
|
if tag in text:
|
|
text = text.split(tag)[0].strip()
|
|
|
|
return text
|
|
|
|
# === TOOLS ===
|
|
ALLOWED_SHELL = {"ls","cat","wc","head","tail","nvidia-smi","df","du","grep","rg","python3","python"}
|
|
|
|
def tool_shell(cmd: str) -> str:
|
|
try:
|
|
exe = cmd.strip().split()[0]
|
|
if exe not in ALLOWED_SHELL: return f"[shell] blocked: {exe}"
|
|
p = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=20)
|
|
return p.stdout.decode("utf-8", errors="ignore")[:8000]
|
|
except Exception as e: return f"[shell] error: {e}"
|
|
|
|
def tool_py(code: str) -> str:
|
|
try:
|
|
g = {"__builtins__":{"range":range,"len":len,"min":min,"max":max,"sum":sum,"print":print},
|
|
"math":math,"json":json,"re":re,"statistics":statistics,"random":random}
|
|
l = {}
|
|
exec(code, g, l)
|
|
return f"[py] ok\n{l.get('out','')}"
|
|
except Exception:
|
|
return f"[py] error:\n{traceback.format_exc()[-2000:]}"
|
|
|
|
def tool_search_local(query: str, path: str = ROOT) -> str:
|
|
rg = shutil.which("rg")
|
|
if rg: cmd = f'rg -n --no-heading --hidden -S "{query}" {path}'
|
|
else: cmd = f'grep -RIn --exclude-dir=.git --exclude-dir=__pycache__ -e "{query}" {path}'
|
|
return tool_shell(cmd)
|
|
|
|
TOOLS = {"shell": tool_shell, "python": tool_py, "search": tool_search_local}
|
|
TOOL_SCORES = {k: 0 for k in TOOLS}
|
|
|
|
def tool_router(question: str, tok, model) -> str:
|
|
sketch = generate(tok, model,
|
|
f"Choose a tool for:\n{question}\nReply ONLY with JSON: {{'tool':'shell|python|search|none','arg':'...'}}")
|
|
try:
|
|
# Find JSON in response
|
|
for line in sketch.splitlines():
|
|
if '{' in line and '}' in line:
|
|
j = json.loads(line.replace("'", '"'))
|
|
break
|
|
else:
|
|
return "[tool:none]"
|
|
except Exception:
|
|
return "[tool:none]"
|
|
|
|
tool, arg = j.get("tool", "none"), j.get("arg", "")
|
|
if tool in TOOLS:
|
|
res = TOOLS[tool](arg)[:4000]
|
|
TOOL_SCORES[tool] += 1
|
|
Store.log_mem("tool", {"tool": tool, "arg": arg, "res_head": res[:500]})
|
|
return f"[tool:{tool}] {res}"
|
|
return "[tool:none]"
|
|
|
|
# === PLANNING / REFLECTION ===
|
|
def persona_directive() -> str:
|
|
return "Übermenschetien Heaven Engine: Soviet cybernetic Nietzschean clarity, pragmatic maxims."
|
|
|
|
def plan_for(goal: str, tok, model) -> str:
|
|
user = (f"{persona_directive()}\nGoal: {goal}\nDeliver:\n- 5 steps\n- Constraints\n- Nightly audit\n- Maxim")
|
|
return generate(tok, model, user)
|
|
|
|
def reflect_on(last_output: str, tok, model) -> str:
|
|
user = f"Critique and improve:\n{last_output}\nReturn refined plan."
|
|
return generate(tok, model, user)
|
|
|
|
# === FINAL REPORT ===
|
|
def final_report():
|
|
print("\n" + "="*60)
|
|
print(" FINAL ÜBERMENSCH REPORT")
|
|
print("="*60)
|
|
print(f" Turns completed: {Store.state['turn']}")
|
|
print(f" CF-HoT active: {CF_MODEL is not None}")
|
|
print(f" Tool scores: {json.dumps(TOOL_SCORES, indent=4)}")
|
|
if os.path.exists(Store.mem_path):
|
|
lines = open(Store.mem_path).read().splitlines()
|
|
print(f" Memory entries: {len(lines)}")
|
|
print("\n Nietzschean maxim: Become who you are — iterate beyond all limits.")
|
|
print("="*60)
|
|
|
|
# === MAIN LOOP ===
|
|
HELP = """
|
|
╔══════════════════════════════════════════════════════════════╗
|
|
║ ÜBERMENSCHETIEN HEAVEN ENGINE + CF-HoT ║
|
|
╠══════════════════════════════════════════════════════════════╣
|
|
║ help Show this help ║
|
|
║ goals List goals ║
|
|
║ add: <txt> Add goal ║
|
|
║ del: <idx> Delete goal ║
|
|
║ plan: <i> Plan for goal ║
|
|
║ reflect Refine last plan ║
|
|
║ tool: <q> Use tool ║
|
|
║ toggle <f> Toggle config flag (use_cfhot, etc) ║
|
|
║ status Show state ║
|
|
║ quit Exit ║
|
|
╚══════════════════════════════════════════════════════════════╝
|
|
"""
|
|
|
|
def main():
|
|
print("""
|
|
██╗ ██╗██████╗ ███████╗██████╗ ███╗ ███╗███████╗███╗ ██╗███████╗ ██████╗██╗ ██╗███████╗████████╗██╗███████╗███╗ ██╗
|
|
██║ ██║██╔══██╗██╔════╝██╔══██╗████╗ ████║██╔════╝████╗ ██║██╔════╝██╔════╝██║ ██║██╔════╝╚══██╔══╝██║██╔════╝████╗ ██║
|
|
██║ ██║██████╔╝█████╗ ██████╔╝██╔████╔██║█████╗ ██╔██╗ ██║███████╗██║ ███████║█████╗ ██║ ██║█████╗ ██╔██╗ ██║
|
|
██║ ██║██╔══██╗██╔══╝ ██╔══██╗██║╚██╔╝██║██╔══╝ ██║╚██╗██║╚════██║██║ ██╔══██║██╔══╝ ██║ ██║██╔══╝ ██║╚██╗██║
|
|
╚██████╔╝██████╔╝███████╗██║ ██║██║ ╚═╝ ██║███████╗██║ ╚████║███████║╚██████╗██║ ██║███████╗ ██║ ██║███████╗██║ ╚████║
|
|
╚═════╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝╚═╝ ╚═╝╚══════╝╚═╝ ╚═══╝╚══════╝ ╚═════╝╚═╝ ╚═╝╚══════╝ ╚═╝ ╚═╝╚══════╝╚═╝ ╚═══╝
|
|
+ CONTROL FIELD HOLONOMY TRANSFORMER
|
|
""")
|
|
|
|
Store.load()
|
|
tok, model = load_llm()
|
|
last_plan = ""
|
|
|
|
print(HELP)
|
|
|
|
while True:
|
|
try:
|
|
u = input("\n⚡ ").strip()
|
|
except (EOFError, KeyboardInterrupt):
|
|
break
|
|
|
|
if not u: continue
|
|
if u == "help": print(HELP); continue
|
|
if u == "quit": break
|
|
|
|
if u == "goals":
|
|
print("[goals]")
|
|
for i, g in enumerate(Store.goals):
|
|
print(f" [{i}] {g}")
|
|
continue
|
|
|
|
if u.startswith("add:"):
|
|
Store.goals.append(u[4:].strip())
|
|
Store.save()
|
|
print("[goals] added")
|
|
continue
|
|
|
|
if u.startswith("del:"):
|
|
try:
|
|
Store.goals.pop(int(u[4:].strip()))
|
|
Store.save()
|
|
print("[goals] deleted")
|
|
except:
|
|
print("[goals] bad index")
|
|
continue
|
|
|
|
if u.startswith("plan:"):
|
|
try:
|
|
goal = Store.goals[int(u[5:].strip())]
|
|
except:
|
|
print("[plan] bad index")
|
|
continue
|
|
out = plan_for(goal, tok, model)
|
|
last_plan = out
|
|
Store.log_mem("plan", {"goal": goal, "plan": out})
|
|
print(out)
|
|
continue
|
|
|
|
if u == "reflect":
|
|
if not last_plan:
|
|
print("[reflect] no plan to reflect on")
|
|
continue
|
|
improved = reflect_on(last_plan, tok, model)
|
|
last_plan = improved
|
|
Store.log_mem("reflect", {"plan": improved})
|
|
print(improved)
|
|
continue
|
|
|
|
if u.startswith("tool:"):
|
|
print(tool_router(u[5:].strip(), tok, model))
|
|
continue
|
|
|
|
if u.startswith("toggle"):
|
|
flag = u.split(maxsplit=1)[-1] if len(u.split()) > 1 else ""
|
|
print(Config.toggle(flag))
|
|
continue
|
|
|
|
if u == "status":
|
|
print(json.dumps({
|
|
"turn": Store.state["turn"],
|
|
"cf_hot_active": CF_MODEL is not None,
|
|
"use_cfhot": Config.use_cfhot,
|
|
"temperature": Config.temperature,
|
|
"max_new_tokens": Config.max_new_tokens
|
|
}, indent=2))
|
|
continue
|
|
|
|
# Default: free generation
|
|
out = generate(tok, model, f"{persona_directive()}\nUser request: {u}\nReturn procedure + maxim.")
|
|
Store.log_mem("reply", {"in": u, "out": out})
|
|
print(out)
|
|
Store.state["turn"] += 1
|
|
Store.save()
|
|
|
|
final_report()
|
|
|
|
if __name__ == "__main__":
|
|
main() |