Publish Learned virtual-computer state-transition world model

README.md

@@ -0,0 +1,36 @@
+---
+title: KernelMind Neural Model Machine
+emoji: 🧠
+colorFrom: green
+colorTo: blue
+sdk: gradio
+sdk_version: "6.5.1"
+app_file: app.py
+pinned: false
+---
+
+# KernelMind Neural Model Machine
+
+This project trains the machine that follows KernelMind AI OS. A compact neural
+world model learns the transition function of an eight-bit virtual computer from
+current state, capability flags, and one of thirteen OS actions. Training covers
+the exhaustive 53,248-state/action corpus.
+
+The evaluation separates held-out one-step transition accuracy from six-step
+autoregressive rollout fidelity. The Space places the neural prediction beside
+the deterministic reference transition for direct inspection.
+
+It is a learned virtual-machine dynamics model, not a hypervisor and not a model
+with access to the host operating system.
+
+## Verified local result
+
+The 6,937-parameter model reached 99.962% exact transition accuracy and 100%
+blocked-action accuracy across 5,325 held-out transitions. In a separate
+autoregressive audit, it reproduced every step and final state across 2,000
+randomized six-action rollouts.
+
+```bash
+uv run python projects/kernelmind-model-machine/train.py
+uv run pytest tests/test_kernelmind_model_machine.py
+```

evaluation.json

@@ -0,0 +1,20 @@
+{
+  "model": "KernelMind Neural Model Machine",
+  "parameters": 6937,
+  "training_transitions": 42598,
+  "heldout_transitions": 5325,
+  "best_epoch": 4,
+  "test": {
+    "exact_transition_accuracy": 0.9996244311332703,
+    "state_bit_accuracy": 0.999953031539917,
+    "blocked_accuracy": 1.0,
+    "transitions": 5325
+  },
+  "multi_step_audit": {
+    "rollouts": 2000,
+    "steps_per_rollout": 6,
+    "exact_step_fraction": 1.0,
+    "exact_six_step_rollout_fraction": 1.0
+  },
+  "boundary": "Models an eight-bit virtual state; it does not control the host OS"
+}

model_machine.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85d0c02a033f9bc934deaa864ffa29304209a241f7cd4d88f283ac9c2f36852b
+size 28444

source/app.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import gradio as gr
+import torch
+from model import NeuralModelMachine
+from safetensors.torch import load_file
+from schema import ACTIONS, CAPABILITY_NAMES, STATE_NAMES, reference_transition
+
+ARTIFACT_DIR = (
+    Path(__file__).resolve().parent / "artifacts" / "kernelmind-model-machine"
+)
+MODEL = NeuralModelMachine()
+MODEL.load_state_dict(load_file(ARTIFACT_DIR / "model_machine.safetensors"))
+MODEL.eval()
+
+
+@torch.inference_mode()
+def run_transition(
+    action: str,
+    active_state: list[str],
+    active_capabilities: list[str],
+) -> tuple[dict, dict]:
+    state = [int(name in active_state) for name in STATE_NAMES]
+    capabilities = [int(name in active_capabilities) for name in CAPABILITY_NAMES]
+    action_index = ACTIONS.index(action)
+    predicted, blocked_probability = MODEL.transition(
+        torch.tensor([state], dtype=torch.float32),
+        torch.tensor([capabilities], dtype=torch.float32),
+        torch.tensor([action_index]),
+    )
+    reference_state, reference_blocked = reference_transition(
+        state, capabilities, action
+    )
+    learned_state = predicted[0].int().tolist()
+    learned = {
+        "next_state": dict(zip(STATE_NAMES, learned_state, strict=True)),
+        "blocked_probability": float(blocked_probability[0]),
+    }
+    reference = {
+        "next_state": dict(zip(STATE_NAMES, reference_state, strict=True)),
+        "blocked": bool(reference_blocked),
+        "exact_match": learned_state == reference_state
+        and int(blocked_probability[0] >= 0.5) == reference_blocked,
+    }
+    return learned, reference
+
+
+with gr.Blocks(title="KernelMind Neural Model Machine") as demo:
+    gr.Markdown(
+        "# KernelMind Neural Model Machine\n"
+        "A trained world model predicts how an OS action changes virtual machine "
+        "state. Compare its transition directly with the deterministic reference."
+    )
+    action = gr.Dropdown(ACTIONS, value="WRITE_BACKUP", label="Action")
+    state = gr.CheckboxGroup(
+        STATE_NAMES,
+        value=["file_exists", "service_running"],
+        label="Current state bits",
+    )
+    capabilities = gr.CheckboxGroup(
+        CAPABILITY_NAMES,
+        value=["network"],
+        label="Capabilities",
+    )
+    initial = run_transition(
+        "WRITE_BACKUP", ["file_exists", "service_running"], ["network"]
+    )
+    with gr.Row():
+        learned = gr.JSON(value=initial[0], label="Learned transition")
+        reference = gr.JSON(value=initial[1], label="Reference transition")
+    button = gr.Button("Advance the model machine", variant="primary")
+    button.click(
+        run_transition,
+        inputs=[action, state, capabilities],
+        outputs=[learned, reference],
+    )
+
+
+if __name__ == "__main__":
+    demo.launch()
+

source/model.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import torch
+from schema import ACTIONS
+from torch import nn
+
+
+class NeuralModelMachine(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+        self.action_embedding = nn.Embedding(len(ACTIONS), 16)
+        self.network = nn.Sequential(
+            nn.Linear(8 + 4 + 16, 64),
+            nn.LayerNorm(64),
+            nn.SiLU(),
+            nn.Linear(64, 64),
+            nn.SiLU(),
+            nn.Linear(64, 9),
+        )
+
+    def forward(
+        self,
+        state: torch.Tensor,
+        capabilities: torch.Tensor,
+        action: torch.Tensor,
+    ) -> torch.Tensor:
+        action_features = self.action_embedding(action)
+        return self.network(torch.cat([state, capabilities, action_features], dim=1))
+
+    @torch.inference_mode()
+    def transition(
+        self,
+        state: torch.Tensor,
+        capabilities: torch.Tensor,
+        action: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        probabilities = torch.sigmoid(self(state, capabilities, action))
+        return (probabilities[:, :8] >= 0.5).float(), probabilities[:, 8]
+
+
+def parameter_count(model: nn.Module) -> int:
+    return sum(parameter.numel() for parameter in model.parameters())

source/requirements.txt

@@ -0,0 +1,4 @@
+gradio>=5,<7
+safetensors>=0.6,<1
+torch>=2.7,<3
+

source/schema.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+ACTIONS = [
+    "PAD",
+    "REPORT",
+    "OPEN_APP",
+    "READ_FILE",
+    "WRITE_FILE",
+    "DELETE_FILE",
+    "INSTALL_PACKAGE",
+    "SEARCH_LOCAL",
+    "SEARCH_WEB",
+    "RESTART_SERVICE",
+    "WRITE_BACKUP",
+    "ASK_CONFIRMATION",
+    "REFUSE",
+]
+STATE_NAMES = [
+    "file_exists",
+    "app_open",
+    "package_installed",
+    "service_running",
+    "backup_exists",
+    "report_available",
+    "confirmation_pending",
+    "refusal_logged",
+]
+CAPABILITY_NAMES = ["administrator", "network", "confirmed", "sensitive_target"]
+
+
+def reference_transition(
+    state: list[int],
+    capabilities: list[int],
+    action: str,
+) -> tuple[list[int], int]:
+    next_state = list(state)
+    administrator, network, confirmed, sensitive = map(bool, capabilities)
+    blocked = 0
+    if action == "REPORT":
+        next_state[5] = 1
+    elif action == "OPEN_APP":
+        next_state[1] = 1
+    elif action == "READ_FILE":
+        if not state[0] or (sensitive and not administrator):
+            blocked = 1
+        else:
+            next_state[5] = 1
+    elif action == "WRITE_FILE":
+        if sensitive and not administrator:
+            blocked = 1
+        else:
+            next_state[0] = 1
+    elif action == "DELETE_FILE":
+        if not confirmed or sensitive or not state[0]:
+            blocked = 1
+        else:
+            next_state[0] = 0
+    elif action == "INSTALL_PACKAGE":
+        if not (confirmed and administrator and network):
+            blocked = 1
+        else:
+            next_state[2] = 1
+    elif action == "SEARCH_LOCAL":
+        next_state[5] = 1
+    elif action == "SEARCH_WEB":
+        if not network:
+            blocked = 1
+        else:
+            next_state[5] = 1
+    elif action == "RESTART_SERVICE":
+        if not (confirmed and administrator):
+            blocked = 1
+        else:
+            next_state[3] = 1
+    elif action == "WRITE_BACKUP":
+        if not state[0] or (sensitive and not administrator):
+            blocked = 1
+        else:
+            next_state[4] = 1
+    elif action == "ASK_CONFIRMATION":
+        next_state[6] = 1
+    elif action == "REFUSE":
+        next_state[7] = 1
+    return next_state, blocked
+

source/train.py

@@ -0,0 +1,195 @@
+from __future__ import annotations
+
+import itertools
+import json
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import torch
+import trackio
+from model import NeuralModelMachine, parameter_count
+from safetensors.torch import save_file
+from schema import ACTIONS, CAPABILITY_NAMES, STATE_NAMES, reference_transition
+from torch.nn import functional as F
+
+PROJECT_DIR = Path(__file__).resolve().parent
+ARTIFACT_DIR = PROJECT_DIR / "artifacts" / "kernelmind-model-machine"
+DATA_DIR = PROJECT_DIR / "data"
+SEED = 2087
+
+
+def build_rows() -> list[dict]:
+    rows = []
+    for state in itertools.product([0, 1], repeat=8):
+        for capabilities in itertools.product([0, 1], repeat=4):
+            for action_index, action in enumerate(ACTIONS):
+                next_state, blocked = reference_transition(
+                    list(state), list(capabilities), action
+                )
+                rows.append(
+                    {
+                        "state": list(state),
+                        "capabilities": list(capabilities),
+                        "action": action,
+                        "action_index": action_index,
+                        "next_state": next_state,
+                        "blocked": blocked,
+                    }
+                )
+    return rows
+
+
+def tensors(rows: list[dict]) -> tuple[torch.Tensor, ...]:
+    return (
+        torch.tensor([row["state"] for row in rows], dtype=torch.float32),
+        torch.tensor([row["capabilities"] for row in rows], dtype=torch.float32),
+        torch.tensor([row["action_index"] for row in rows]),
+        torch.tensor(
+            [row["next_state"] + [row["blocked"]] for row in rows],
+            dtype=torch.float32,
+        ),
+    )
+
+
+@torch.inference_mode()
+def evaluate(model: NeuralModelMachine, rows: list[dict]) -> dict:
+    state, capabilities, action, targets = tensors(rows)
+    probabilities = torch.sigmoid(model(state, capabilities, action))
+    predictions = (probabilities >= 0.5).float()
+    exact = (predictions == targets).all(1)
+    return {
+        "exact_transition_accuracy": float(exact.float().mean()),
+        "state_bit_accuracy": float(
+            (predictions[:, :8] == targets[:, :8]).float().mean()
+        ),
+        "blocked_accuracy": float(
+            (predictions[:, 8] == targets[:, 8]).float().mean()
+        ),
+        "transitions": len(rows),
+    }
+
+
+@torch.inference_mode()
+def rollout_audit(model: NeuralModelMachine, samples: int = 2_000) -> dict:
+    rng = np.random.default_rng(SEED + 1)
+    exact_steps = 0
+    exact_rollouts = 0
+    for _ in range(samples):
+        state = rng.integers(0, 2, size=8).tolist()
+        capabilities = rng.integers(0, 2, size=4).tolist()
+        learned = torch.tensor([state], dtype=torch.float32)
+        reference = state
+        rollout_exact = True
+        for action_index in rng.integers(0, len(ACTIONS), size=6):
+            action = ACTIONS[action_index]
+            reference, reference_blocked = reference_transition(
+                reference, capabilities, action
+            )
+            predicted, blocked_probability = model.transition(
+                learned,
+                torch.tensor([capabilities], dtype=torch.float32),
+                torch.tensor([action_index]),
+            )
+            learned = predicted
+            step_exact = learned[0].int().tolist() == reference
+            step_exact = step_exact and (
+                int(blocked_probability[0] >= 0.5) == reference_blocked
+            )
+            exact_steps += int(step_exact)
+            rollout_exact = rollout_exact and step_exact
+        exact_rollouts += int(rollout_exact)
+    return {
+        "rollouts": samples,
+        "steps_per_rollout": 6,
+        "exact_step_fraction": exact_steps / (samples * 6),
+        "exact_six_step_rollout_fraction": exact_rollouts / samples,
+    }
+
+
+def main() -> None:
+    torch.manual_seed(SEED)
+    torch.set_num_threads(1)
+    rows = build_rows()
+    rng = np.random.default_rng(SEED)
+    order = rng.permutation(len(rows))
+    train_end = int(0.8 * len(rows))
+    validation_end = int(0.9 * len(rows))
+    train_rows = [rows[index] for index in order[:train_end]]
+    validation_rows = [rows[index] for index in order[train_end:validation_end]]
+    test_rows = [rows[index] for index in order[validation_end:]]
+    state, capabilities, action, targets = tensors(train_rows)
+    model = NeuralModelMachine()
+    optimizer = torch.optim.AdamW(model.parameters(), lr=2e-3, weight_decay=1e-5)
+    best = -1.0
+    best_state = None
+    best_epoch = 0
+    trackio.init(
+        project="kernelmind-model-machine",
+        name="neural-os-transition-runtime-v1",
+        config={
+            "parameters": parameter_count(model),
+            "training_transitions": len(train_rows),
+            "state_bits": len(STATE_NAMES),
+            "capability_bits": len(CAPABILITY_NAMES),
+        },
+    )
+    for epoch in range(1, 81):
+        permutation = torch.randperm(len(state))
+        model.train()
+        for start in range(0, len(state), 512):
+            indexes = permutation[start : start + 512]
+            logits = model(state[indexes], capabilities[indexes], action[indexes])
+            loss = F.binary_cross_entropy_with_logits(logits, targets[indexes])
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+        validation = evaluate(model, validation_rows)
+        if validation["exact_transition_accuracy"] > best:
+            best = validation["exact_transition_accuracy"]
+            best_epoch = epoch
+            best_state = {
+                name: value.detach().cpu().clone()
+                for name, value in model.state_dict().items()
+            }
+        if epoch == 1 or epoch % 10 == 0:
+            trackio.log({"epoch": epoch, **validation})
+        if best == 1.0 and epoch >= 20:
+            break
+    assert best_state is not None
+    model.load_state_dict(best_state)
+    test = evaluate(model, test_rows)
+    rollouts = rollout_audit(model)
+    report = {
+        "model": "KernelMind Neural Model Machine",
+        "parameters": parameter_count(model),
+        "training_transitions": len(train_rows),
+        "heldout_transitions": len(test_rows),
+        "best_epoch": best_epoch,
+        "test": test,
+        "multi_step_audit": rollouts,
+        "boundary": "Models an eight-bit virtual state; it does not control the host OS",
+    }
+    ARTIFACT_DIR.mkdir(parents=True, exist_ok=True)
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    save_file(model.state_dict(), ARTIFACT_DIR / "model_machine.safetensors")
+    (ARTIFACT_DIR / "evaluation.json").write_text(
+        json.dumps(report, indent=2), encoding="utf-8"
+    )
+    pd.DataFrame(
+        {
+            "state": [row["state"] for row in rows],
+            "capabilities": [row["capabilities"] for row in rows],
+            "action": [row["action"] for row in rows],
+            "next_state": [row["next_state"] for row in rows],
+            "blocked": [row["blocked"] for row in rows],
+        }
+    ).to_parquet(DATA_DIR / "transitions.parquet", index=False)
+    trackio.log({**test, **rollouts})
+    trackio.finish()
+    print(json.dumps(report, indent=2))
+
+
+if __name__ == "__main__":
+    main()
+