weightspace 0.1.0__tar.gz

weightspace-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,14 @@
+name: ci
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: pip install torch --index-url https://download.pytorch.org/whl/cpu
+      - run: pip install -e ".[all,dev]"
+      - run: ruff check . && ruff format --check .
+      - run: pytest -q

weightspace-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,30 @@
+name: publish
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - run: pip install build && python -m build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+  pypi:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

weightspace-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.egg-info/
+.venv/
+.pytest_cache/
+.ruff_cache/
+dist/
+runs/
+*.npz
+*.safetensors

weightspace-0.1.0/PKG-INFO

@@ -0,0 +1,181 @@
+Metadata-Version: 2.5
+Name: weightspace
+Version: 0.1.0
+Summary: Weight-space programming: let an LLM read and write neural network weights directly.
+Project-URL: Homepage, https://github.com/leofmarciano/weightspace
+Project-URL: Source, https://github.com/leofmarciano/weightspace
+Keywords: interpretability,llm,model-editing,pytorch,weights
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: all
+Requires-Dist: anthropic>=0.40; extra == 'all'
+Requires-Dist: openai>=1.40; extra == 'all'
+Requires-Dist: safetensors>=0.4; extra == 'all'
+Requires-Dist: torch>=2.1; extra == 'all'
+Requires-Dist: transformers>=4.40; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: hf
+Requires-Dist: safetensors>=0.4; extra == 'hf'
+Requires-Dist: torch>=2.1; extra == 'hf'
+Requires-Dist: transformers>=4.40; extra == 'hf'
+Provides-Extra: openai
+Requires-Dist: openai>=1.40; extra == 'openai'
+Provides-Extra: torch
+Requires-Dist: torch>=2.1; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# weightspace
+
+A small Python framework for **weight-space programming**: an LLM reads and edits a neural network's weights directly, by reasoning about what each part computes, instead of training it.
+
+Based on [Sparks of Weight-Space Programming](https://rikiyat.github.io/blog/weight-space-programming/) (Takehi, Teoh, Zhang, Khattab, 2026). This repo is the harness, not the paper's results: how well it works depends on the LLM you plug in.
+
+## What you get
+
+- **Any model.** PyTorch modules, Hugging Face models, or `.safetensors` / `.npz` / `.pt` files. The LLM only ever sees tensors, never the model object.
+- **Four tasks.** `read` (what does this network do?), `fix` (find and fix the cause of a failure), `write` (program a network from zero), `improve` (make it better at a goal).
+- **Tools for the LLM.** List, describe (norms, SVD) and read tensor slices; a persistent Python sandbox over the weights; edits, checkpoints and rollbacks.
+- **Budgeted forward passes.** You decide how the network may be run (scores, rollouts, generations, attention maps only...) by writing a `probe`, and how many times.
+- **Edit tracking.** Every run reports exactly how many weights changed, and exports a sparse patch.
+- **Text mode.** For small networks: dump every weight into the prompt and get one reply back, no tools (like the paper's first experiments).
+- **Providers.** OpenAI-compatible APIs (OpenAI, OpenRouter, vLLM, Ollama) and Anthropic, or your own `LLM` class.
+
+## Install
+
+```bash
+pip install -e ".[all]"        # or pick: .[torch] .[hf] .[openai] .[anthropic]
+export OPENAI_API_KEY=...      # or ANTHROPIC_API_KEY / OPENROUTER_API_KEY
+```
+
+## Quick start
+
+```python
+import torch
+import weightspace as wsp
+
+model = ...  # any torch.nn.Module
+
+
+@wsp.probe
+def accuracy():
+    """Per-class accuracy on a held-out batch."""
+    with torch.no_grad():
+        pred = model(x_val).argmax(-1)
+    return {c: float((pred[y_val == c] == c).float().mean()) for c in range(4)}
+
+
+res = wsp.fix(
+    model,
+    "The classifier never predicts class 3. Find out why and fix it.",
+    llm="openai:gpt-5",  # or "anthropic:claude-sonnet-4-5", "openrouter:..."
+    context="Linear(2->16) -> ReLU -> Linear(16->4); input is a 2D point, output is its quadrant.",
+    probes=[accuracy],
+    forward_budget=3,
+)
+
+print(res)  # answer, confidence, forward passes used, which weights changed
+res.save("runs/fix")  # transcript.jsonl, result.json, patch.npz
+```
+
+The model is edited in place. The other tasks look the same:
+
+```python
+wsp.read(model, "Which game was this policy trained on?", llm=..., context=GRID_AND_ACTIONS)
+wsp.read(model, "What does this network compute?", llm=..., text_mode=True)  # weights in the prompt
+wsp.write(model, "Play Breakout: move the paddle under the ball.", llm=..., context=GAME_RULES)  # zeroes first
+wsp.improve(hf_model, "Stop the reasoning loops.", llm=..., probes=[generate], forward_budget=25)
+```
+
+## Thinking on or off
+
+`thinking` sets how much the editing LLM reasons before it acts. Use `thinking=False` to have it edit the weights with no thinking at all:
+
+```python
+wsp.fix(model, "...", llm="openai:gpt-5.1", thinking=False)  # or "low" / "medium" / "high"; None = provider default
+```
+
+With thinking off, the provider's reasoning is disabled and the LLM is told to go straight to tool calls and edits. How that reaches each provider:
+
+| Backend | off | on |
+|---|---|---|
+| OpenAI | `reasoning_effort="none"` (`OpenAIChat(..., off_effort="minimal")` for gpt-5) | `reasoning_effort=<level>` |
+| OpenRouter | `reasoning.enabled=false` | `reasoning.effort=<level>` |
+| vLLM / SGLang (Qwen3 etc.) | `OpenAIChat(..., thinking_style="chat_template")` → `enable_thinking=false` | `enable_thinking=true` |
+| Anthropic | `thinking.type="disabled"` | extended thinking with a 2k / 8k / 16k token budget |
+
+CLI: `--no-thinking` or `--thinking low|medium|high`. The setting is saved in `result.json`, so you can compare runs with and without thinking.
+
+## Probes
+
+A probe is any function. It runs after the current weights are synced into the model, and whatever it returns is what the LLM sees. Its arguments become the tool's schema.
+
+```python
+@wsp.probe(cost=1)
+def generate(prompts: list, max_new_tokens: int = 256):
+    """Generate answers for up to 8 prompts and report repetition."""
+    ...
+```
+
+Want the LLM to see only attention patterns, not outputs? Write a probe that returns only attention patterns. That's how you set what the LLM can observe.
+
+## Lower level
+
+```python
+ws = wsp.WeightSpace.from_hf("Qwen/Qwen2.5-0.5B-Instruct")  # or from_torch / from_file / from_numpy
+ws.W["model.layers.15.mlp.down_proj.weight"][:, :64] -= ...  # tracked in-place edit
+print(ws.diff())  # what changed vs. the original
+ws.checkpoint("a")
+ws.restore("a")
+ws.revert()
+ws.save_patch("fix.npz")
+other.apply_patch("fix.npz")
+
+s = wsp.Session(
+    ws,
+    llm,
+    mode="improve",
+    probes=[...],
+    forward_budget=50,
+    tools=[my_tool],
+    namespace={"tok": tokenizer},
+    max_steps=80,
+    verbose=True,
+)
+res = s.run("...")
+```
+
+Custom tools: `wsp.tool("name", "description", x={"type": "number"})(fn)`.
+Offline runs and tests: `wsp.ScriptedLLM([...])` replays a fixed script.
+
+## CLI
+
+```bash
+weightspace inspect model.safetensors --describe
+weightspace read model.safetensors "What was this trained to do?" --llm openai:gpt-5 --context @notes.md
+weightspace fix model.safetensors "..." --llm anthropic:claude-sonnet-4-5 --save-weights fixed.safetensors --out runs/1
+```
+
+## Examples
+
+- `examples/fix_quadrants.py`: fix a sabotaged classifier (runs offline with a scripted LLM if you omit `--llm`)
+- `examples/read_which_task.py`: name the boolean function an MLP learned, from its weights in the prompt
+- `examples/hf_reduce_loops.py`: edit a Hugging Face LM to stop repetition loops, with generation and attention probes
+
+## Rules and caveats
+
+The system prompt tells the LLM not to train, fit weights to data, or run the network inside the sandbox; the only way to run it is the budgeted probes. The sandbox never holds the model object, but it is not a security boundary: code runs in your process, and an LLM could still multiply matrices by hand. Check transcripts if the rules matter for your experiment, as the paper's authors did.
+
+## Development
+
+```bash
+pip install -e ".[all,dev]"
+pytest
+ruff check . && ruff format --check .
+```

weightspace-0.1.0/README.md

@@ -0,0 +1,148 @@
+# weightspace
+
+A small Python framework for **weight-space programming**: an LLM reads and edits a neural network's weights directly, by reasoning about what each part computes, instead of training it.
+
+Based on [Sparks of Weight-Space Programming](https://rikiyat.github.io/blog/weight-space-programming/) (Takehi, Teoh, Zhang, Khattab, 2026). This repo is the harness, not the paper's results: how well it works depends on the LLM you plug in.
+
+## What you get
+
+- **Any model.** PyTorch modules, Hugging Face models, or `.safetensors` / `.npz` / `.pt` files. The LLM only ever sees tensors, never the model object.
+- **Four tasks.** `read` (what does this network do?), `fix` (find and fix the cause of a failure), `write` (program a network from zero), `improve` (make it better at a goal).
+- **Tools for the LLM.** List, describe (norms, SVD) and read tensor slices; a persistent Python sandbox over the weights; edits, checkpoints and rollbacks.
+- **Budgeted forward passes.** You decide how the network may be run (scores, rollouts, generations, attention maps only...) by writing a `probe`, and how many times.
+- **Edit tracking.** Every run reports exactly how many weights changed, and exports a sparse patch.
+- **Text mode.** For small networks: dump every weight into the prompt and get one reply back, no tools (like the paper's first experiments).
+- **Providers.** OpenAI-compatible APIs (OpenAI, OpenRouter, vLLM, Ollama) and Anthropic, or your own `LLM` class.
+
+## Install
+
+```bash
+pip install -e ".[all]"        # or pick: .[torch] .[hf] .[openai] .[anthropic]
+export OPENAI_API_KEY=...      # or ANTHROPIC_API_KEY / OPENROUTER_API_KEY
+```
+
+## Quick start
+
+```python
+import torch
+import weightspace as wsp
+
+model = ...  # any torch.nn.Module
+
+
+@wsp.probe
+def accuracy():
+    """Per-class accuracy on a held-out batch."""
+    with torch.no_grad():
+        pred = model(x_val).argmax(-1)
+    return {c: float((pred[y_val == c] == c).float().mean()) for c in range(4)}
+
+
+res = wsp.fix(
+    model,
+    "The classifier never predicts class 3. Find out why and fix it.",
+    llm="openai:gpt-5",  # or "anthropic:claude-sonnet-4-5", "openrouter:..."
+    context="Linear(2->16) -> ReLU -> Linear(16->4); input is a 2D point, output is its quadrant.",
+    probes=[accuracy],
+    forward_budget=3,
+)
+
+print(res)  # answer, confidence, forward passes used, which weights changed
+res.save("runs/fix")  # transcript.jsonl, result.json, patch.npz
+```
+
+The model is edited in place. The other tasks look the same:
+
+```python
+wsp.read(model, "Which game was this policy trained on?", llm=..., context=GRID_AND_ACTIONS)
+wsp.read(model, "What does this network compute?", llm=..., text_mode=True)  # weights in the prompt
+wsp.write(model, "Play Breakout: move the paddle under the ball.", llm=..., context=GAME_RULES)  # zeroes first
+wsp.improve(hf_model, "Stop the reasoning loops.", llm=..., probes=[generate], forward_budget=25)
+```
+
+## Thinking on or off
+
+`thinking` sets how much the editing LLM reasons before it acts. Use `thinking=False` to have it edit the weights with no thinking at all:
+
+```python
+wsp.fix(model, "...", llm="openai:gpt-5.1", thinking=False)  # or "low" / "medium" / "high"; None = provider default
+```
+
+With thinking off, the provider's reasoning is disabled and the LLM is told to go straight to tool calls and edits. How that reaches each provider:
+
+| Backend | off | on |
+|---|---|---|
+| OpenAI | `reasoning_effort="none"` (`OpenAIChat(..., off_effort="minimal")` for gpt-5) | `reasoning_effort=<level>` |
+| OpenRouter | `reasoning.enabled=false` | `reasoning.effort=<level>` |
+| vLLM / SGLang (Qwen3 etc.) | `OpenAIChat(..., thinking_style="chat_template")` → `enable_thinking=false` | `enable_thinking=true` |
+| Anthropic | `thinking.type="disabled"` | extended thinking with a 2k / 8k / 16k token budget |
+
+CLI: `--no-thinking` or `--thinking low|medium|high`. The setting is saved in `result.json`, so you can compare runs with and without thinking.
+
+## Probes
+
+A probe is any function. It runs after the current weights are synced into the model, and whatever it returns is what the LLM sees. Its arguments become the tool's schema.
+
+```python
+@wsp.probe(cost=1)
+def generate(prompts: list, max_new_tokens: int = 256):
+    """Generate answers for up to 8 prompts and report repetition."""
+    ...
+```
+
+Want the LLM to see only attention patterns, not outputs? Write a probe that returns only attention patterns. That's how you set what the LLM can observe.
+
+## Lower level
+
+```python
+ws = wsp.WeightSpace.from_hf("Qwen/Qwen2.5-0.5B-Instruct")  # or from_torch / from_file / from_numpy
+ws.W["model.layers.15.mlp.down_proj.weight"][:, :64] -= ...  # tracked in-place edit
+print(ws.diff())  # what changed vs. the original
+ws.checkpoint("a")
+ws.restore("a")
+ws.revert()
+ws.save_patch("fix.npz")
+other.apply_patch("fix.npz")
+
+s = wsp.Session(
+    ws,
+    llm,
+    mode="improve",
+    probes=[...],
+    forward_budget=50,
+    tools=[my_tool],
+    namespace={"tok": tokenizer},
+    max_steps=80,
+    verbose=True,
+)
+res = s.run("...")
+```
+
+Custom tools: `wsp.tool("name", "description", x={"type": "number"})(fn)`.
+Offline runs and tests: `wsp.ScriptedLLM([...])` replays a fixed script.
+
+## CLI
+
+```bash
+weightspace inspect model.safetensors --describe
+weightspace read model.safetensors "What was this trained to do?" --llm openai:gpt-5 --context @notes.md
+weightspace fix model.safetensors "..." --llm anthropic:claude-sonnet-4-5 --save-weights fixed.safetensors --out runs/1
+```
+
+## Examples
+
+- `examples/fix_quadrants.py`: fix a sabotaged classifier (runs offline with a scripted LLM if you omit `--llm`)
+- `examples/read_which_task.py`: name the boolean function an MLP learned, from its weights in the prompt
+- `examples/hf_reduce_loops.py`: edit a Hugging Face LM to stop repetition loops, with generation and attention probes
+
+## Rules and caveats
+
+The system prompt tells the LLM not to train, fit weights to data, or run the network inside the sandbox; the only way to run it is the budgeted probes. The sandbox never holds the model object, but it is not a security boundary: code runs in your process, and an LLM could still multiply matrices by hand. Check transcripts if the rules matter for your experiment, as the paper's authors did.
+
+## Development
+
+```bash
+pip install -e ".[all,dev]"
+pytest
+ruff check . && ruff format --check .
+```

weightspace-0.1.0/examples/fix_quadrants.py

@@ -0,0 +1,86 @@
+"""Fix a sabotaged classifier by editing its weights.
+
+A small MLP learns which quadrant a 2D point is in. We then break it so it
+never predicts class 3, and ask an LLM to find and fix the cause, with a
+budget of 3 forward passes.
+
+    python examples/fix_quadrants.py --llm openai:gpt-5
+    python examples/fix_quadrants.py --llm anthropic:claude-sonnet-4-5
+    python examples/fix_quadrants.py            # scripted LLM, no API key needed
+"""
+
+import argparse
+
+import torch
+
+import weightspace as wsp
+from weightspace.llm import ScriptedLLM, call, reply
+
+
+def train():
+    torch.manual_seed(0)
+    x = torch.randn(4096, 2)
+    y = (x[:, 0] > 0).long() * 2 + (x[:, 1] > 0).long()
+    model = torch.nn.Sequential(torch.nn.Linear(2, 16), torch.nn.ReLU(), torch.nn.Linear(16, 4))
+    opt = torch.optim.Adam(model.parameters(), lr=0.05)
+    for _ in range(300):
+        opt.zero_grad()
+        torch.nn.functional.cross_entropy(model(x), y).backward()
+        opt.step()
+    return model, x, y
+
+
+def scripted():
+    """What a good run could look like, so the example works offline."""
+    return ScriptedLLM(
+        [
+            reply("Check behaviour first.", call("forward_accuracy")),
+            reply(None, call("describe_tensor", name="2.bias"), call("read_tensor", name="2.bias")),
+            reply(
+                "Output bias for class 3 is far below the others; set it to their mean.",
+                call("checkpoint", label="start"),
+                call("python", code="b = W['2.bias']; b[3] = np.delete(b, 3).mean(); b"),
+            ),
+            reply(None, call("forward_accuracy")),
+            reply(None, call("submit", answer="Class 3's output bias was -8; reset it to the others' mean.", confidence=0.9)),
+        ]
+    )
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--llm", help='e.g. "openai:gpt-5"; omit to use a scripted LLM')
+    ap.add_argument("--out", default="runs/fix_quadrants")
+    args = ap.parse_args()
+
+    model, x, y = train()
+    with torch.no_grad():
+        model[2].bias[3] -= 8.0  # the bug
+
+    @wsp.probe
+    def accuracy():
+        """Per-class accuracy of the network on 4,096 held-out points."""
+        with torch.no_grad():
+            pred = model(x).argmax(-1)
+        return {f"class {c}": round(float((pred[y == c] == c).float().mean()), 3) for c in range(4)}
+
+    print("before:", accuracy())
+    res = wsp.fix(
+        model,
+        "The classifier never predicts class 3. Find out why and fix it.",
+        llm=args.llm or scripted(),
+        context=(
+            "Network: Linear(2->16) -> ReLU -> Linear(16->4). Input: a point (x0, x1) ~ N(0, I). "
+            "Output: logits for the quadrant: class = 2*(x0>0) + (x1>0)."
+        ),
+        probes=[accuracy],
+        forward_budget=3,
+        verbose=True,
+    )
+    print("\n" + str(res))
+    print("after:", accuracy())
+    res.save(args.out)
+
+
+if __name__ == "__main__":
+    main()

weightspace-0.1.0/examples/hf_reduce_loops.py

@@ -0,0 +1,106 @@
+"""Improve a Hugging Face causal LM by editing weights (Experiment 8 style).
+
+The LLM gets a Python kernel over the weights and a budget of forward passes:
+one probe generates answers and reports how often they loop, another returns
+only attention patterns (Experiment 7 style).
+
+    python examples/hf_reduce_loops.py --model Qwen/Qwen2.5-0.5B-Instruct --llm openai:gpt-5 --budget 25
+"""
+
+import argparse
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+import weightspace as wsp
+
+PROMPTS = [
+    "What is 17 * 23? Think step by step.",
+    "A train travels 60 km in 45 minutes. What is its speed in km/h?",
+    "Solve for x: 3x + 7 = 22.",
+    "How many prime numbers are there below 30?",
+]
+
+
+def repetition(ids: list[int], n: int = 8) -> float:
+    grams = [tuple(ids[i : i + n]) for i in range(len(ids) - n)]
+    return 1 - len(set(grams)) / len(grams) if grams else 0.0
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--model", default="Qwen/Qwen2.5-0.5B-Instruct")
+    ap.add_argument("--llm", required=True, help='e.g. "openai:gpt-5", or "dry-run" for a scripted smoke test')
+    ap.add_argument("--budget", type=int, default=25)
+    ap.add_argument("--max-new-tokens", type=int, default=256)
+    ap.add_argument("--out", default="runs/hf_reduce_loops")
+    args = ap.parse_args()
+
+    tok = AutoTokenizer.from_pretrained(args.model)
+    model = AutoModelForCausalLM.from_pretrained(args.model, torch_dtype=torch.float32, attn_implementation="eager").eval()
+
+    def chat(p):
+        if tok.chat_template:
+            return tok.apply_chat_template([{"role": "user", "content": p}], tokenize=False, add_generation_prompt=True)
+        return p
+
+    @wsp.probe
+    def generate(prompts: list = None, max_new_tokens: int = args.max_new_tokens):
+        """Generate greedy answers for up to 8 prompts (default: a fixed practice set). Returns each answer,
+        its 8-gram repetition rate, and whether it hit the token limit."""
+        prompts = (prompts or PROMPTS)[:8]
+        out = []
+        for p in prompts:
+            enc = tok(chat(p), return_tensors="pt")
+            with torch.no_grad():
+                gen = model.generate(**enc, max_new_tokens=max_new_tokens, do_sample=False)
+            ids = gen[0, enc.input_ids.shape[1] :].tolist()
+            out.append(
+                {
+                    "prompt": p,
+                    "answer": tok.decode(ids, skip_special_tokens=True)[-1500:],
+                    "repetition": round(repetition(ids), 3),
+                    "hit_limit": len(ids) >= max_new_tokens,
+                }
+            )
+        return out
+
+    @wsp.probe
+    def attention(text: str, layer: int):
+        """Attention weights of every head in one layer for a text you write (no outputs are shown)."""
+        enc = tok(text, return_tensors="pt")
+        with torch.no_grad():
+            att = model(**enc, output_attentions=True).attentions[layer][0]
+        toks = tok.convert_ids_to_tokens(enc.input_ids[0])
+        return {"tokens": toks, "attention[head][query][key]": att.round(decimals=3).tolist()}
+
+    llm = args.llm
+    if llm == "dry-run":
+        from weightspace.llm import ScriptedLLM, call, reply
+
+        llm = ScriptedLLM(
+            [
+                reply(None, call("list_tensors", pattern="mlp")),
+                reply(None, call("forward_generate", prompts=PROMPTS[:1], max_new_tokens=32)),
+                reply(None, call("forward_attention", text="2 + 2 = 4", layer=0)),
+                reply(None, call("submit", answer="dry run", confidence=0)),
+            ]
+        )
+
+    res = wsp.improve(
+        model,
+        "Make the model stop getting stuck in repetition loops on math questions, without hurting its answers.",
+        llm=llm,
+        context=f"{args.model}: {model.config.num_hidden_layers} layers, hidden size {model.config.hidden_size}. "
+        f"Tokenizer vocab {len(tok)}. You may use `tok` (the tokenizer) in Python.",
+        probes=[generate, attention],
+        forward_budget=args.budget,
+        namespace={"tok": tok},
+        verbose=True,
+    )
+    print(res)
+    res.save(args.out)
+
+
+if __name__ == "__main__":
+    main()

weightspace-0.1.0/examples/read_which_task.py

@@ -0,0 +1,56 @@
+"""Ask an LLM which task a network was trained on, from its weights alone (no tools).
+
+Two identical MLPs learn different rules over 8 inputs; the LLM gets one
+network's weights as text and must say which rule it computes.
+
+    python examples/read_which_task.py --llm openai:gpt-5 --task parity
+"""
+
+import argparse
+
+import torch
+
+import weightspace as wsp
+
+TASKS = {
+    "majority": lambda x: (x.sum(1) > 4).long(),
+    "first_bit": lambda x: x[:, 0].long(),
+    "parity_of_first_two": lambda x: (x[:, 0] != x[:, 1]).long(),
+    "last_bit_and_not_third": lambda x: ((x[:, 7] == 1) & (x[:, 2] == 0)).long(),
+}
+
+
+def train(rule, seed=0):
+    torch.manual_seed(seed)
+    x = torch.randint(0, 2, (4096, 8)).float()
+    y = rule(x)
+    model = torch.nn.Sequential(torch.nn.Linear(8, 8), torch.nn.Tanh(), torch.nn.Linear(8, 2))
+    opt = torch.optim.Adam(model.parameters(), lr=0.03)
+    for _ in range(600):
+        opt.zero_grad()
+        torch.nn.functional.cross_entropy(model(x), y).backward()
+        opt.step()
+    return model
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--llm", required=True)
+    ap.add_argument("--task", choices=list(TASKS), default="parity_of_first_two")
+    args = ap.parse_args()
+
+    model = train(TASKS[args.task])
+    res = wsp.read(
+        model,
+        "What boolean function of the 8 input bits does this network compute? Answer as a short formula.",
+        llm=args.llm,
+        context="MLP 8 -> 8 (tanh) -> 2 logits. Inputs are bits in {0,1}. Output 1 means the function is true.",
+        text_mode=True,
+        precision=3,
+    )
+    print(res)
+    print("truth:", args.task)
+
+
+if __name__ == "__main__":
+    main()

weightspace-0.1.0/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "weightspace"
+version = "0.1.0"
+description = "Weight-space programming: let an LLM read and write neural network weights directly."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["numpy>=1.24"]
+keywords = ["llm", "interpretability", "model-editing", "weights", "pytorch"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://github.com/leofmarciano/weightspace"
+Source = "https://github.com/leofmarciano/weightspace"
+
+[project.optional-dependencies]
+torch = ["torch>=2.1"]
+hf = ["torch>=2.1", "transformers>=4.40", "safetensors>=0.4"]
+openai = ["openai>=1.40"]
+anthropic = ["anthropic>=0.40"]
+all = ["torch>=2.1", "transformers>=4.40", "safetensors>=0.4", "openai>=1.40", "anthropic>=0.40"]
+dev = ["pytest>=8", "ruff>=0.5"]
+
+[project.scripts]
+weightspace = "weightspace.cli:main"
+
+[tool.hatch.build.targets.sdist]
+exclude = ["runs", "experiments"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/weightspace"]
+
+[tool.ruff]
+line-length = 130
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+ignore = ["E741", "B023"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]