logogram 0.1.0__tar.gz → 0.1.1__tar.gz

logogram-0.1.1/CHANGELOG.md

@@ -0,0 +1,60 @@
+# Changelog
+
+What changed in each version of Logogram.
+
+## 0.1.1 (2026-10-08)
+
+Every method has now run end to end on real weights: GPT-2 small with a SAELens and an OpenAI
+SAE, Pythia-70m with an EleutherAI SAE, and Qwen 2.5 0.5B. This release fixes what that turned up.
+
+### Fixed
+
+- Runs work on Apple Silicon. Every method converted tensors to float64 on the model's device,
+  which Apple's Metal (MPS) doesn't have, so no run got past its baseline on a Mac. This still
+  needs a check on a Mac.
+- A model whose own forward pass overflows in the chosen dtype (Pythia in float16) is refused, with
+  the dtype to use. Its load checks used to read as passed.
+- When processing a model's weights doesn't fit in memory, loading says so and frees the memory,
+  instead of failing with a raw CUDA error and keeping it.
+- The memory estimate counts weight processing, which needs three to four times the float32 size
+  of the weights while the model loads. Qwen 2.5 0.5B on a 6 GB GPU now reads "won't fit" with
+  processing and "fits" without it.
+- Models without a beginning-of-sequence token, such as Qwen, run without one, as documented.
+  TransformerLens 4 had given them its end-of-text token instead.
+- Models and SAEs that Logogram downloaded open offline without a revision, and offline memory
+  estimates use the model's real size.
+- `logogram run` reports an identical rerun of direct logit attribution or attribution patching as
+  identical.
+- Direct logit attribution in float16 and bfloat16 no longer warns about drift that is only
+  rounding.
+
+### Added
+
+- Runs warn when the model prefers the distractor on the clean prompts, so it doesn't show the
+  behavior they test (Pythia-70m on IOI).
+- The model dialog shows the memory that weight processing needs. Qwen 2.5 0.5B is marked as
+  tested.
+- Project links on PyPI, and this changelog, which the update notice links to.
+
+### Documentation
+
+- What has been validated with real weights, and where attribution patching is least reliable:
+  residual stream sites at the token that differs between the prompts.
+- Steering needs prompt pairs that differ the same way; IOI prompts that mix the ABBA and BABA
+  orders cancel out.
+- What float16 and bfloat16 do to results, and how weight processing changes heads' direct effects.
+
+## 0.1.0 (2026-10-08)
+
+First public release.
+
+- Activation patching, ablation (zero, mean or resample), direct logit attribution, attribution
+  patching verified by patching, steering with a random control, path patching, and SAE features,
+  all described by one spec that the app and `logogram run` execute the same way.
+- Every model is checked when it loads: that TransformerLens reproduces its predictions, how its
+  layers add into the residual stream, and whether the logit lens reproduces its output.
+- Per-prompt values with seeded bootstrap intervals, and bit-identical reruns on the same machine.
+- The workbench: Explore, Experiment and Evidence, logograms written by results, robustness checks
+  and run comparisons.
+- Local-first: no account and no telemetry, safetensors weights only, and an update check that
+  runs only when you allow it.

logogram-0.1.0/README.md → logogram-0.1.1/PKG-INFO

@@ -1,3 +1,40 @@
+Metadata-Version: 2.5
+Name: logogram
+Version: 0.1.1
+Summary: A local-first workbench for causal experiments inside language models.
+Project-URL: Homepage, https://github.com/Jeevash23/logogram
+Project-URL: Source, https://github.com/Jeevash23/logogram
+Project-URL: Issues, https://github.com/Jeevash23/logogram/issues
+Project-URL: Changelog, https://github.com/Jeevash23/logogram/blob/main/CHANGELOG.md
+Author: The Logogram contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: activation-patching,interpretability,mechanistic-interpretability,transformers
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4
+Requires-Dist: fastapi>=0.115
+Requires-Dist: huggingface-hub>=0.23
+Requires-Dist: numpy>=1.26
+Requires-Dist: platformdirs>=4
+Requires-Dist: psutil>=5.9
+Requires-Dist: pyarrow>=15
+Requires-Dist: pydantic>=2.7
+Requires-Dist: torch>=2.4
+Requires-Dist: transformer-lens<5,>=4.0
+Requires-Dist: transformers>=4.45
+Requires-Dist: typer>=0.12
+Requires-Dist: uvicorn>=0.30
+Requires-Dist: websockets>=12
+Description-Content-Type: text/markdown
+
 # Logogram
 
 A local workbench for causal experiments inside language models.
@@ -25,9 +62,10 @@ Logogram needs Python 3.11 or newer and [uv](https://docs.astral.sh/uv/).
 uv tool install logogram
 ```
 
-Until Logogram is published on PyPI, install it from a clone of this repository with
-`uv tool install .` instead. The web app is prebuilt inside the package, so you never need Node.
-The commands in the table below work the same way with `.` in place of `logogram`.
+To run the code in a clone of this repository instead, install it with `uv tool install .`; the
+commands in the table below work the same way with `.` in place of `logogram`. The web app is
+prebuilt inside the package, so you never need Node. What changed in each version is in
+[CHANGELOG.md](CHANGELOG.md).
 
 PyTorch is chosen per machine:
 
@@ -229,7 +267,11 @@ estimate misses saturation (in attention, normalization and the final softmax) a
 even invert an effect, so **Verify top 10 by patching** on the results page patches the sites
 with the largest estimated effects for real and opens the comparison: the rank correlation, and
 any estimate whose sign patching confidently reverses. **Check robustness** can also patch the
-whole sweep.
+whole sweep. Do that for residual stream sweeps: an estimate is least reliable where patching
+replaces a whole token's representation. In the IOI example on GPT-2 small, patching the residual
+stream at the changed name in the first layer restores the whole answer while its estimate is
+slightly negative, so verifying the top estimates would never reach it. Head outputs track
+patching closely.
 
 **Direct logit attribution** splits the logit difference of the clean or the corrupt prompts
 (your choice; there is no default) into what each head, attention output and MLP output writes
@@ -266,7 +308,10 @@ like patching, so 1 means the steered prompts moved as far as switching to the o
 random direction of the same length, at the same strengths, runs alongside as a control, and the
 results show both: a layer × strength map with the control columns muted, and, for a selected site,
 its effect at every strength with intervals. **Check robustness** offers another split of the pairs
-or the other direction.
+or the other direction. A mean difference steers only when the pairs differ the same way. In IOI
+prompts that mix the ABBA and BABA orders, the difference at the last token flips with the order,
+so the mean cancels and steering does no more than the control; generate prompts of one order to
+steer.
 
 **SAE features.** A sparse autoencoder (SAE) rewrites one of the model's activations as a few active
 features out of thousands, each a direction in the model, plus an error it misses. In
@@ -335,7 +380,7 @@ Every experiment is a `spec.json`. Nothing that can change a number is left impl
 | Field | Values |
 |---|---|
 | `model.revision` | A commit. `null` resolves the current main branch at run time; the saved spec pins what ran. |
-| `model.process_weights` | Fold LayerNorm and center weights, as TransformerLens does by default. Logit differences don't change; zero ablation of head outputs does, because value biases are folded. |
+| `model.process_weights` | Fold LayerNorm and center weights, as TransformerLens does by default. Logit differences don't change. Value biases are folded into the attention output's bias, so zero ablation of head outputs and heads' direct effects do change (by up to several logits in Qwen 2.5, whose value biases are large); a layer's attention output doesn't. |
 | `dataset.sha256` | If set, the run refuses a dataset file that has changed. |
 | `experiment` | `{"kind": "activation_patching", "direction": "clean_to_corrupt" \| "corrupt_to_clean"}`, `{"kind": "ablation", "baseline": …}` with `{"kind": "zero"}`, `{"kind": "mean", "reference": "clean" \| "corrupt"}` or `{"kind": "resample", "pool": "clean" \| "corrupt", "donors": 10, "seed": 0}`, `{"kind": "attribution_patching", "direction": …}` (same directions as patching), `{"kind": "direct_logit_attribution", "prompts": "clean" \| "corrupt"}`, `{"kind": "path_patching", "direction": …, "receivers": [{"kind": "head", "layer": 9, "head": 9, "input": "q" \| "k" \| "v"}, {"kind": "logits"}], "freeze_mlps": false}`, or `{"kind": "steering", "apply_to": "clean" \| "corrupt", "coefficients": [-1, 1, 2], "train_fraction": 0.5, "seed": 0, "control": true}` with a scope of one residual component per layer (`layer_components`) or residual `sites`, at one token |
 | `scope` | `{"kind": "heads", "position": …}`, `{"kind": "layer_position", "site": "resid_pre", "positions": "each" \| "labels"}`, `{"kind": "layer_components", "components": ["attn_out", "mlp_out"], "position": …}` `{"kind": "sites", "sites": [{"kind": "head", "layer": 9, "head": 9, "position": {"kind": "label", "label": "end"}}]}` (feature sites are `{"kind": "sae_feature", "layer": 8, "feature": 1234, "position": …}`), or, for attribution patching, `{"kind": "features", "position": …, "top": 50}` |
@@ -435,12 +480,23 @@ TransformerLens 4 loads well over a hundred architectures, and Logogram works wi
 decoder-only language models among them: GPT-2, Pythia, Llama, Mistral, SmolLM, Qwen, Gemma,
 OLMo, Phi and more. The model dialog lists starting points, and any other Hugging Face id can be
 typed in. Before downloading, Logogram checks that TransformerLens supports the architecture and
-estimates the memory needed (weights, activations and a margin) against what is free.
+estimates the memory needed (weights, activations and a margin) against what is free. Processing
+the weights needs more for a moment while the model loads: TransformerLens works on float32
+copies, three to four times the float32 size of the weights. The estimate includes them, so a
+model that fits only without processing (Qwen 2.5 0.5B on a 6 GB GPU) says so before it loads.
+
+Use float32 whenever the model fits. float16 and bfloat16 halve the memory and run two to three
+times faster on a GPU, but they round. In the IOI example on GPT-2 small and Qwen 2.5, float16
+moved effects by at most 0.003 and bfloat16 by up to 0.03: the strongest sites stayed in place,
+but effects smaller than about 0.01 changed order. On Pythia-70m, bfloat16 doubled the clean
+logit difference and reordered the heads, and float16 overflows. Check results that matter
+against float32.
 
 Rather than trusting a list, Logogram checks every model when it loads, on a short fixed input:
 
 * TransformerLens's version of the model must predict what the original model predicts. If weight
-  processing changes the predictions, loading with processed weights is refused.
+  processing changes the predictions, loading with processed weights is refused. So is a dtype in
+  which the model overflows (Pythia in float16).
 * It measures how each layer adds attention and the MLP to the residual stream: one after the
   other (sequential), or both from the same input (parallel, as in Pythia, GPT-J and Phi). Only
   sequential layers have a residual stream between attention and MLP (`resid_mid`), and the layer
@@ -448,11 +504,15 @@ Rather than trusting a list, Logogram checks every model when it loads, on a sho
 * Layer predictions are offered when the final normalization and unembedding, with any logit
   soft-capping, reproduce the model's output.
 
-GPT-2 small is the model the bundled example was made for, and the one run end to end with real
-weights. The test suite runs the sanity checks on tiny random models of the Llama, Pythia, Qwen 2,
-Gemma 2 and OLMo 2 families without downloading anything. Pythia publishes checkpoints from
-throughout training as revisions (`step1000` to `step143000`), so an experiment can be rerun at
-several points of training.
+GPT-2 small is the model the bundled example was made for. Every method has been run end to end
+with real weights on GPT-2 small (with a SAELens and an OpenAI SAE), Pythia-70m (with an
+EleutherAI SAE) and Qwen 2.5 0.5B, and the test suite runs the sanity checks on tiny random models
+of the Llama, Pythia, Qwen 2, Gemma 2 and OLMo 2 families without downloading anything. The
+example's names are single tokens for GPT-2 and Qwen but not all for Pythia; for another model,
+generate IOI prompts in the app, which keeps only names that are single tokens for it. A small
+model may not do the task at all (Pythia-70m prefers the repeated name), and its runs then say so.
+Pythia publishes checkpoints from throughout training as revisions (`step1000` to `step143000`),
+so an experiment can be rerun at several points of training.
 
 Some tokenizers, such as Qwen's, have no beginning-of-sequence token. Logogram then runs prompts
 without one, and the spec records it. Answers and distractors must still be single tokens.
@@ -503,8 +563,8 @@ Publishing, so no token is stored anywhere. PyPI never accepts the same version
 
 Before tagging, manually check a first GPT-2 download, cancel and retry it, then run the example
 on each supported compute backend. CPU and CUDA are covered by local development checks; MPS
-still needs a check on Apple Silicon. Other model families are checked when they load and in the
-tiny-model tests, but not yet run end to end with their real weights.
+still needs a check on Apple Silicon. Pythia and Qwen 2.5 have also been run end to end with
+their real weights; other families are checked when they load and in the tiny-model tests.
 
 Model access goes through `logogram.backends.base.ModelBackend`. TransformerLens is the only
 backend today; remote execution and other libraries can be added behind the same interface.

logogram-0.1.0/PKG-INFO → logogram-0.1.1/README.md

@@ -1,36 +1,3 @@
-Metadata-Version: 2.5
-Name: logogram
-Version: 0.1.0
-Summary: A local-first workbench for causal experiments inside language models.
-Author: The Logogram contributors
-License-Expression: MIT
-License-File: LICENSE
-Keywords: activation-patching,interpretability,mechanistic-interpretability,transformers
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.11
-Requires-Dist: anyio>=4
-Requires-Dist: fastapi>=0.115
-Requires-Dist: huggingface-hub>=0.23
-Requires-Dist: numpy>=1.26
-Requires-Dist: platformdirs>=4
-Requires-Dist: psutil>=5.9
-Requires-Dist: pyarrow>=15
-Requires-Dist: pydantic>=2.7
-Requires-Dist: torch>=2.4
-Requires-Dist: transformer-lens<5,>=4.0
-Requires-Dist: transformers>=4.45
-Requires-Dist: typer>=0.12
-Requires-Dist: uvicorn>=0.30
-Requires-Dist: websockets>=12
-Description-Content-Type: text/markdown
-
 # Logogram
 
 A local workbench for causal experiments inside language models.
@@ -58,9 +25,10 @@ Logogram needs Python 3.11 or newer and [uv](https://docs.astral.sh/uv/).
 uv tool install logogram
 ```
 
-Until Logogram is published on PyPI, install it from a clone of this repository with
-`uv tool install .` instead. The web app is prebuilt inside the package, so you never need Node.
-The commands in the table below work the same way with `.` in place of `logogram`.
+To run the code in a clone of this repository instead, install it with `uv tool install .`; the
+commands in the table below work the same way with `.` in place of `logogram`. The web app is
+prebuilt inside the package, so you never need Node. What changed in each version is in
+[CHANGELOG.md](CHANGELOG.md).
 
 PyTorch is chosen per machine:
 
@@ -262,7 +230,11 @@ estimate misses saturation (in attention, normalization and the final softmax) a
 even invert an effect, so **Verify top 10 by patching** on the results page patches the sites
 with the largest estimated effects for real and opens the comparison: the rank correlation, and
 any estimate whose sign patching confidently reverses. **Check robustness** can also patch the
-whole sweep.
+whole sweep. Do that for residual stream sweeps: an estimate is least reliable where patching
+replaces a whole token's representation. In the IOI example on GPT-2 small, patching the residual
+stream at the changed name in the first layer restores the whole answer while its estimate is
+slightly negative, so verifying the top estimates would never reach it. Head outputs track
+patching closely.
 
 **Direct logit attribution** splits the logit difference of the clean or the corrupt prompts
 (your choice; there is no default) into what each head, attention output and MLP output writes
@@ -299,7 +271,10 @@ like patching, so 1 means the steered prompts moved as far as switching to the o
 random direction of the same length, at the same strengths, runs alongside as a control, and the
 results show both: a layer × strength map with the control columns muted, and, for a selected site,
 its effect at every strength with intervals. **Check robustness** offers another split of the pairs
-or the other direction.
+or the other direction. A mean difference steers only when the pairs differ the same way. In IOI
+prompts that mix the ABBA and BABA orders, the difference at the last token flips with the order,
+so the mean cancels and steering does no more than the control; generate prompts of one order to
+steer.
 
 **SAE features.** A sparse autoencoder (SAE) rewrites one of the model's activations as a few active
 features out of thousands, each a direction in the model, plus an error it misses. In
@@ -368,7 +343,7 @@ Every experiment is a `spec.json`. Nothing that can change a number is left impl
 | Field | Values |
 |---|---|
 | `model.revision` | A commit. `null` resolves the current main branch at run time; the saved spec pins what ran. |
-| `model.process_weights` | Fold LayerNorm and center weights, as TransformerLens does by default. Logit differences don't change; zero ablation of head outputs does, because value biases are folded. |
+| `model.process_weights` | Fold LayerNorm and center weights, as TransformerLens does by default. Logit differences don't change. Value biases are folded into the attention output's bias, so zero ablation of head outputs and heads' direct effects do change (by up to several logits in Qwen 2.5, whose value biases are large); a layer's attention output doesn't. |
 | `dataset.sha256` | If set, the run refuses a dataset file that has changed. |
 | `experiment` | `{"kind": "activation_patching", "direction": "clean_to_corrupt" \| "corrupt_to_clean"}`, `{"kind": "ablation", "baseline": …}` with `{"kind": "zero"}`, `{"kind": "mean", "reference": "clean" \| "corrupt"}` or `{"kind": "resample", "pool": "clean" \| "corrupt", "donors": 10, "seed": 0}`, `{"kind": "attribution_patching", "direction": …}` (same directions as patching), `{"kind": "direct_logit_attribution", "prompts": "clean" \| "corrupt"}`, `{"kind": "path_patching", "direction": …, "receivers": [{"kind": "head", "layer": 9, "head": 9, "input": "q" \| "k" \| "v"}, {"kind": "logits"}], "freeze_mlps": false}`, or `{"kind": "steering", "apply_to": "clean" \| "corrupt", "coefficients": [-1, 1, 2], "train_fraction": 0.5, "seed": 0, "control": true}` with a scope of one residual component per layer (`layer_components`) or residual `sites`, at one token |
 | `scope` | `{"kind": "heads", "position": …}`, `{"kind": "layer_position", "site": "resid_pre", "positions": "each" \| "labels"}`, `{"kind": "layer_components", "components": ["attn_out", "mlp_out"], "position": …}` `{"kind": "sites", "sites": [{"kind": "head", "layer": 9, "head": 9, "position": {"kind": "label", "label": "end"}}]}` (feature sites are `{"kind": "sae_feature", "layer": 8, "feature": 1234, "position": …}`), or, for attribution patching, `{"kind": "features", "position": …, "top": 50}` |
@@ -468,12 +443,23 @@ TransformerLens 4 loads well over a hundred architectures, and Logogram works wi
 decoder-only language models among them: GPT-2, Pythia, Llama, Mistral, SmolLM, Qwen, Gemma,
 OLMo, Phi and more. The model dialog lists starting points, and any other Hugging Face id can be
 typed in. Before downloading, Logogram checks that TransformerLens supports the architecture and
-estimates the memory needed (weights, activations and a margin) against what is free.
+estimates the memory needed (weights, activations and a margin) against what is free. Processing
+the weights needs more for a moment while the model loads: TransformerLens works on float32
+copies, three to four times the float32 size of the weights. The estimate includes them, so a
+model that fits only without processing (Qwen 2.5 0.5B on a 6 GB GPU) says so before it loads.
+
+Use float32 whenever the model fits. float16 and bfloat16 halve the memory and run two to three
+times faster on a GPU, but they round. In the IOI example on GPT-2 small and Qwen 2.5, float16
+moved effects by at most 0.003 and bfloat16 by up to 0.03: the strongest sites stayed in place,
+but effects smaller than about 0.01 changed order. On Pythia-70m, bfloat16 doubled the clean
+logit difference and reordered the heads, and float16 overflows. Check results that matter
+against float32.
 
 Rather than trusting a list, Logogram checks every model when it loads, on a short fixed input:
 
 * TransformerLens's version of the model must predict what the original model predicts. If weight
-  processing changes the predictions, loading with processed weights is refused.
+  processing changes the predictions, loading with processed weights is refused. So is a dtype in
+  which the model overflows (Pythia in float16).
 * It measures how each layer adds attention and the MLP to the residual stream: one after the
   other (sequential), or both from the same input (parallel, as in Pythia, GPT-J and Phi). Only
   sequential layers have a residual stream between attention and MLP (`resid_mid`), and the layer
@@ -481,11 +467,15 @@ Rather than trusting a list, Logogram checks every model when it loads, on a sho
 * Layer predictions are offered when the final normalization and unembedding, with any logit
   soft-capping, reproduce the model's output.
 
-GPT-2 small is the model the bundled example was made for, and the one run end to end with real
-weights. The test suite runs the sanity checks on tiny random models of the Llama, Pythia, Qwen 2,
-Gemma 2 and OLMo 2 families without downloading anything. Pythia publishes checkpoints from
-throughout training as revisions (`step1000` to `step143000`), so an experiment can be rerun at
-several points of training.
+GPT-2 small is the model the bundled example was made for. Every method has been run end to end
+with real weights on GPT-2 small (with a SAELens and an OpenAI SAE), Pythia-70m (with an
+EleutherAI SAE) and Qwen 2.5 0.5B, and the test suite runs the sanity checks on tiny random models
+of the Llama, Pythia, Qwen 2, Gemma 2 and OLMo 2 families without downloading anything. The
+example's names are single tokens for GPT-2 and Qwen but not all for Pythia; for another model,
+generate IOI prompts in the app, which keeps only names that are single tokens for it. A small
+model may not do the task at all (Pythia-70m prefers the repeated name), and its runs then say so.
+Pythia publishes checkpoints from throughout training as revisions (`step1000` to `step143000`),
+so an experiment can be rerun at several points of training.
 
 Some tokenizers, such as Qwen's, have no beginning-of-sequence token. Logogram then runs prompts
 without one, and the spec records it. Answers and distractors must still be single tokens.
@@ -536,8 +526,8 @@ Publishing, so no token is stored anywhere. PyPI never accepts the same version
 
 Before tagging, manually check a first GPT-2 download, cancel and retry it, then run the example
 on each supported compute backend. CPU and CUDA are covered by local development checks; MPS
-still needs a check on Apple Silicon. Other model families are checked when they load and in the
-tiny-model tests, but not yet run end to end with their real weights.
+still needs a check on Apple Silicon. Pythia and Qwen 2.5 have also been run end to end with
+their real weights; other families are checked when they load and in the tiny-model tests.
 
 Model access goes through `logogram.backends.base.ModelBackend`. TransformerLens is the only
 backend today; remote execution and other libraries can be added behind the same interface.

{logogram-0.1.0 → logogram-0.1.1}/pyproject.toml

@@ -39,6 +39,12 @@ dependencies = [
     "huggingface-hub>=0.23",
 ]
 
+[project.urls]
+Homepage = "https://github.com/Jeevash23/logogram"
+Source = "https://github.com/Jeevash23/logogram"
+Issues = "https://github.com/Jeevash23/logogram/issues"
+Changelog = "https://github.com/Jeevash23/logogram/blob/main/CHANGELOG.md"
+
 [project.scripts]
 logogram = "logogram.cli:main"
 
@@ -58,7 +64,7 @@ packages = ["src/logogram"]
 artifacts = ["src/logogram/web_dist/**"]
 
 [tool.hatch.build.targets.sdist]
-include = ["src/logogram", "web/src", "web/public", "web/tests", "web/package.json", "web/package-lock.json", "web/index.html", "web/tsconfig.json", "web/vite.config.ts", "web/playwright.config.ts", "uv.lock", "tests", "scripts", "README.md", "LICENSE", "AGENTS.md"]
+include = ["src/logogram", "web/src", "web/public", "web/tests", "web/package.json", "web/package-lock.json", "web/index.html", "web/tsconfig.json", "web/vite.config.ts", "web/playwright.config.ts", "uv.lock", "tests", "scripts", "README.md", "CHANGELOG.md", "LICENSE", "AGENTS.md"]
 artifacts = ["src/logogram/web_dist/**"]
 
 [tool.pytest.ini_options]

{logogram-0.1.0 → logogram-0.1.1}/src/logogram/__init__.py

@@ -1,6 +1,6 @@
 """Logogram: a local-first workbench for causal experiments inside language models."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 # The release date of this version: after a few months the app suggests looking for a newer one
 # (no network needed). Set it with every release.
 __released__ = "2026-10-08"

{logogram-0.1.0 → logogram-0.1.1}/src/logogram/analysis.py

@@ -7,7 +7,7 @@ from typing import Any
 import numpy as np
 import torch
 
-from logogram.backends.base import ModelBackend
+from logogram.backends.base import ModelBackend, float64
 from logogram.datasets import PromptRecord
 from logogram.engine import compute_baselines
 from logogram.prompts import PreparedPrompt, PromptIssue, group_by_length, prepare_prompt
@@ -153,7 +153,7 @@ def attention_report(
     chosen = None
     for start in range(0, len(same), batch_size):
         pattern = backend.attention_pattern(tokens[start : start + batch_size], layer)[:, head]
-        pattern = pattern.double().cpu()
+        pattern = float64(pattern).cpu()
         total = pattern.sum(0) if total is None else total + pattern.sum(0)
         for row, p in enumerate(same[start : start + batch_size]):
             if p.index == index:
@@ -299,8 +299,8 @@ def sae_fit_report(
             rows = torch.arange(len(idx))
             plain = backend.final_logits(tokens)
             edited = backend.edit_logits(tokens, sae.site, sae.layer, splice)
-            clean.append((plain[rows, answers] - plain[rows, distractors]).double())
-            spliced.append((edited[rows, answers] - edited[rows, distractors]).double())
+            clean.append(float64(plain[rows, answers] - plain[rows, distractors]))
+            spliced.append(float64(edited[rows, answers] - edited[rows, distractors]))
     flat = torch.cat([a.reshape(-1, a.shape[-1]) for a in acts])
     fit = fit_on(sae, flat)
     ld, ld_spliced = torch.cat(clean), torch.cat(spliced)
@@ -388,7 +388,7 @@ def feature_report(
             f, _ = sae.encode(
                 backend.capture(tokens[begin : begin + batch_size], [key])[key].float()
             )
-            column = f[..., feature].double().cpu()  # [B, pos]
+            column = float64(f[..., feature]).cpu()  # [B, pos]
             for row, p in enumerate(idx):
                 prompt = prepared[p]
                 values = column[row]

{logogram-0.1.0 → logogram-0.1.1}/src/logogram/atp.py

@@ -20,7 +20,7 @@ from typing import Any
 import numpy as np
 import torch
 
-from logogram.backends.base import Cancelled, ModelBackend
+from logogram.backends.base import Cancelled, ModelBackend, float64
 from logogram.engine import (
     EngineResult,
     LayerFn,
@@ -82,8 +82,8 @@ def run_attribution_patching(
             rows = torch.arange(len(idx))
             for rs in sites:
                 key = (rs.kind, rs.layer)
-                diff = source_acts[key].double() - receiver_acts[key].double()
-                grad = grads[key].double()
+                diff = float64(source_acts[key]) - float64(receiver_acts[key])
+                grad = float64(grads[key])
                 if rs.kind == "head":
                     diff, grad = diff[:, :, rs.head], grad[:, :, rs.head]
                 per_position = (diff * grad).sum(-1)  # [B, pos]

{logogram-0.1.0 → logogram-0.1.1}/src/logogram/backends/base.py

@@ -17,6 +17,17 @@ import torch
 STREAM_KINDS = ("resid_pre", "resid_mid", "resid_post", "attn_out", "mlp_out")
 ALL_KINDS = (*STREAM_KINDS, "head")
 
+# Devices with no float64 arithmetic: Apple's Metal has no doubles.
+NO_FLOAT64 = frozenset({"mps"})
+
+
+def float64(t: torch.Tensor) -> torch.Tensor:
+    """``t`` in float64, for statistics and decompositions: on its own device, or on the CPU when
+    that device has no float64 (Apple's MPS), where converting it would fail. Every conversion to
+    float64 goes through here."""
+    device = torch.device("cpu") if t.device.type in NO_FLOAT64 else t.device
+    return t.to(device=device, dtype=torch.float64)
+
 
 @dataclass(frozen=True)
 class ModelInfo:
@@ -164,8 +175,10 @@ class ModelBackend(ABC):
 
         Returns float64 tensors on the CPU, one row per prompt: ``embed`` ``[B]``, ``attn_out``
         and ``mlp_out`` ``[B, layers]``, ``head`` ``[B, layers, heads]`` when ``heads`` is true,
-        ``logit_diff`` ``[B]`` and ``remainder`` ``[B]`` (what biases add: the logit difference
-        minus every component's term).
+        ``logit_diff`` ``[B]``, ``remainder`` ``[B]`` (what biases add: the logit difference
+        minus every component's term) and ``logit_scale`` ``[B]`` (the larger magnitude of the
+        answer's and the distractor's logit, which sets how finely the model's dtype resolves
+        them).
         """
         raise BackendError("Direct logit attribution isn't supported by this model backend.")
 

{logogram-0.1.0 → logogram-0.1.1}/src/logogram/backends/hub.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 import fnmatch
 import json
 import logging
+import math
 import sys
 import threading
 from collections.abc import Callable
@@ -106,9 +107,15 @@ def resolve(model_id: str, revision: str | None) -> RepoFiles:
             cached = cached_snapshot(model_id, revision)
             if cached is not None:
                 sha, path = cached
-                files = [(p.name, p.stat().st_size) for p in path.iterdir() if p.is_file()]
+                files = _select_files(
+                    [(p.name, p.stat().st_size) for p in path.iterdir() if p.is_file()]
+                )
+                weights = [name for name, _ in files if name.endswith(".safetensors")]
                 return RepoFiles(
-                    revision=sha, files=_select_files(files), n_params=None, gated=False
+                    revision=sha,
+                    files=files,
+                    n_params=count_stored_values(path, weights),
+                    gated=False,
                 )
             raise BackendError(
                 f"Couldn't reach Hugging Face, and {model_id} isn't in your local cache. "
@@ -127,15 +134,55 @@ def resolve(model_id: str, revision: str | None) -> RepoFiles:
     )
 
 
+def count_stored_values(folder: Path, names: list[str]) -> int | None:
+    """How many values safetensors files hold, as the Hub reports for a model it knows, read from
+    their headers (no tensor is loaded). None if a file can't be read: loading it will say why."""
+    from safetensors import safe_open
+
+    total = 0
+    try:
+        for name in names:
+            with safe_open(str(folder / name), framework="pt", device="cpu") as f:
+                total += sum(math.prod(f.get_slice(key).get_shape()) for key in f.keys())  # noqa: SIM118
+    except Exception:  # noqa: BLE001
+        return None
+    return total
+
+
 def cached_snapshot(model_id: str, revision: str | None) -> tuple[str, Path] | None:
     """The (commit, folder) of a cached snapshot containing config.json, if any."""
-    from huggingface_hub import try_to_load_from_cache
+    found = cached_file(model_id, "config.json", revision)
+    return None if found is None else (found[0], found[1].parent)
 
-    found = try_to_load_from_cache(model_id, "config.json", revision=revision or "main")
+
+def cached_file(repo_id: str, filename: str, revision: str | None) -> tuple[str, Path] | None:
+    """The commit and local path of ``filename`` in the Hugging Face cache, at ``revision``.
+
+    Without a revision, the cached main branch; failing that, the only cached commit that has the
+    file. Logogram downloads exact commits, which records no branch in the cache, so this is how a
+    model it downloaded opens offline. Several commits and no branch would be a guess, so that is
+    refused with the commits to choose from.
+    """
+    from huggingface_hub import constants, try_to_load_from_cache
+    from huggingface_hub.file_download import repo_folder_name
+
+    depth = len(Path(filename).parts)
+    found = try_to_load_from_cache(repo_id, filename, revision=revision or "main")
     if isinstance(found, str):
-        path = Path(found).parent
-        return path.name, path
-    return None
+        return Path(found).parents[depth - 1].name, Path(found)
+    snapshots = (
+        Path(constants.HF_HUB_CACHE) / repo_folder_name(repo_id=repo_id, repo_type="model")
+    ) / "snapshots"
+    if revision is not None or not snapshots.is_dir():
+        return None
+    commits = sorted(d for d in snapshots.iterdir() if (d / filename).is_file())
+    if len(commits) > 1:
+        names = ", ".join(d.name[:12] for d in commits)
+        raise BackendError(
+            f"Hugging Face can't be reached, and several revisions of {repo_id} are in your local "
+            f"cache ({names}). Enter the one to use as the revision."
+        )
+    return (commits[0].name, commits[0] / filename) if commits else None
 
 
 def validate_local_weights(folder: Path) -> None:

{logogram-0.1.0 → logogram-0.1.1}/src/logogram/backends/saes.py

@@ -238,9 +238,10 @@ def download_sae(
     try:
         info = HfApi().model_info(repo, revision=revision, files_metadata=True)
     except Exception as exc:  # noqa: BLE001
-        cached = _cached(repo, prefix, revision)
-        if cached is not None and hub._is_offline_error(exc):
-            return cached
+        if hub._is_offline_error(exc):
+            cached = _cached(repo, prefix, revision)
+            if cached is not None:
+                return cached
         raise hub._friendly_hub_error(repo, exc) from exc
     sizes = {s.rfilename: int(s.size or 0) for s in info.siblings or []}
     if f"{prefix}params.npz" in sizes:
@@ -265,13 +266,12 @@ def download_sae(
 
 
 def _cached(repo: str, prefix: str, revision: str | None) -> tuple[str, Path] | None:
-    from huggingface_hub import try_to_load_from_cache
+    from logogram.backends.hub import cached_file
 
-    found = try_to_load_from_cache(repo, f"{prefix}cfg.json", revision=revision or "main")
-    if not isinstance(found, str):
+    found = cached_file(repo, f"{prefix}cfg.json", revision)
+    if found is None:
         return None
-    folder = Path(found).parent
-    if not any((folder / w).is_file() for w in WEIGHT_FILES):
+    commit, path = found
+    if not any((path.parent / w).is_file() for w in WEIGHT_FILES):
         return None
-    snapshot = folder if not prefix else Path(found).parents[prefix.count("/")]
-    return snapshot.name, folder
+    return commit, path.parent