interp-engine 1.2.6__tar.gz → 1.2.7__tar.gz

{interp_engine-1.2.6 → interp_engine-1.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: interp-engine
-Version: 1.2.6
+Version: 1.2.7
 Summary: A fast, standardized interpretability engine that supports most modern models and architectures. Powers Neuronpedia.
 Project-URL: Homepage, https://github.com/decoderesearch/interp-engine
 Project-URL: Repository, https://github.com/decoderesearch/interp-engine

{interp_engine-1.2.6 → interp_engine-1.2.7}/interp_engine/vllm_capture/freeze.py

@@ -252,8 +252,24 @@ def resolve_freeze_points(
     ``graph_replay`` is False only when freeze is omitted and ``enforce_eager`` is not False
     (today's hooked vLLM). ``freeze_points="auto"`` or ``enforce_eager=False`` with no list
     freezes ``resid_post`` at every layer on a conventional trunk, and ``resid_streams`` at
-    every layer on a hyper-connection trunk.
+    every layer on a hyper-connection trunk -- to read AND to write.
+
+    Auto covers the write because the two are one decision for the caller who asks for it. ``auto``
+    says "serve the residual endpoints on this engine", and read taps alone serve half of them: a
+    lens read-out works, and every steer, ablation and swap derived from that read-out is refused
+    for want of a site at the very address already being tapped. Nothing in the caller's vocabulary
+    distinguished the two halves, either -- ``freeze_writes`` is a list of addresses, so asking for
+    the write meant restating every layer of a set ``auto`` had just built.
+
+    An explicit list is left alone, since a caller who named the points named what they wanted. So
+    is ``freeze_writes=[]``, which is how to ask for the reads WITHOUT the write buffers: those
+    buffers are per layer and per token, and they are what steps ``max_num_batched_tokens`` down
+    when the ladder in :func:`fit_max_num_batched_tokens` cannot fit them.
     """
+    # `None` and `[]` mean different things here and nowhere else in this signature: the first is
+    # "say nothing about writes", which auto fills in, and the second is "no writes", which it must
+    # not. Read before the comprehension below, which cannot tell them apart.
+    writes_declared = freeze_writes is not None
     writes = [to_address(a) for a in (freeze_writes or ())]
     graph = freeze_points is not None or bool(writes) or enforce_eager is False
     if not graph:
@@ -264,14 +280,21 @@ def resolve_freeze_points(
             "Do not pass enforce_eager=True with a freeze set; omit freeze_points for hooked vLLM."
         )
 
+    auto = False
     if freeze_points is None:
-        reads: list[Address] = [] if writes else _auto_reads(n_layers, n_streams)
+        # Writes without a read list stay writes-only: naming a write site is already explicit
+        # about what this engine is for, and auto-reading every layer beside it is not implied.
+        auto = not writes
+        reads: list[Address] = _auto_reads(n_layers, n_streams) if auto else []
     elif isinstance(freeze_points, str):
         if freeze_points != "auto":
             raise ValueError(f"freeze_points must be 'auto', a list of addresses, or []; got {freeze_points!r}")
         reads = _auto_reads(n_layers, n_streams)
+        auto = True
     else:
         reads = [to_address(a) for a in freeze_points]
+    if auto and not writes_declared:
+        writes = list(reads)
 
     for address in (*reads, *writes):
         reason = freeze_unsupported_reason(address.name) or multi_stream_refusal_reason(address.name, n_streams)
@@ -990,7 +1013,16 @@ def worker_install_freeze(worker: object) -> None:
 
 
 def _install_mhc_freeze(worker: object, mhc_sites: Sequence[_Site]) -> None:
-    from interp_engine.vllm_capture.mhc import mhc_taps, require_available
+    """Wrap the mHC kernels for every stacked freeze site, refusing one this model cannot serve.
+
+    A site that carries a ``delta`` is asked the STEER question rather than the capture one, because
+    they differ by exactly the thing a write depends on: ``resid_streams`` is written by running the
+    fused kernel's second half again on the edited stack, so that half has to be forwardable
+    (:func:`~interp_engine.vllm_capture.mhc.pre_rerun_gap`). Asked here because freeze installs in
+    ``Worker.load_model`` -- a gap found later surfaces mid-forward, on an engine that has already
+    started and reported itself healthy.
+    """
+    from interp_engine.vllm_capture.mhc import mhc_taps, require_available, require_steerable
 
     model = _worker_model(worker)
     taps = mhc_taps(worker)
@@ -999,7 +1031,10 @@ def _install_mhc_freeze(worker: object, mhc_sites: Sequence[_Site]) -> None:
         if id(site) in seen:
             continue
         seen.add(id(site))
-        require_available(model, site.address.name, site.address.layer)
+        if site.delta is not None:
+            require_steerable(model, site.address.name, site.address.layer)
+        else:
+            require_available(model, site.address.name, site.address.layer)
         taps.add(site.address, _freeze_mhc_recorder(worker, site))
 
 

{interp_engine-1.2.6 → interp_engine-1.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "interp-engine"
-version = "1.2.6"
+version = "1.2.7"
 description = "A fast, standardized interpretability engine that supports most modern models and architectures. Powers Neuronpedia."
 readme = "README.md"
 license = "Apache-2.0"

{interp_engine-1.2.6 → interp_engine-1.2.7}/tests/test_freeze_set.py

@@ -8,6 +8,7 @@ import pytest
 import torch
 
 from interp_engine.address import Address
+from interp_engine.points import steer_refusal_reason
 from interp_engine.vllm_capture.freeze import (
     BREAKABLE_ENV,
     FREEZE_SKIP_ABSENT_ENV,
@@ -59,21 +60,22 @@ def test_empty_list_is_graphs_with_no_taps():
 def test_auto_is_resid_post_at_every_layer():
     reads, writes, graph = resolve_freeze_points("auto", n_layers=3, n_streams=1)
     assert graph is True
-    assert writes == []
     assert reads == [Address("resid_post", 0), Address("resid_post", 1), Address("resid_post", 2)]
+    assert writes == reads
 
 
 def test_enforce_eager_false_with_no_list_is_auto():
-    reads, _, graph = resolve_freeze_points(None, n_layers=2, n_streams=1, enforce_eager=False)
+    reads, writes, graph = resolve_freeze_points(None, n_layers=2, n_streams=1, enforce_eager=False)
     assert graph is True
     assert reads == [Address("resid_post", 0), Address("resid_post", 1)]
+    assert writes == reads, "the same set either way in; auto is auto however it was reached"
 
 
 def test_auto_is_resid_streams_on_a_hyper_connection_trunk():
     reads, writes, graph = resolve_freeze_points("auto", n_layers=3, n_streams=4)
     assert graph is True
-    assert writes == []
     assert reads == [Address("resid_streams", 0), Address("resid_streams", 1), Address("resid_streams", 2)]
+    assert writes == reads
 
 
 def test_resid_streams_can_be_frozen():
@@ -105,11 +107,69 @@ def test_explicit_mlp_out_is_allowed_on_a_hyper_connection_trunk():
     assert reads == [Address("mlp_out", 21)]
 
 
-def test_writes_are_not_implied_by_auto():
-    _, writes, _ = resolve_freeze_points("auto", n_layers=2, n_streams=1)
+def test_auto_writes_where_it_reads_so_a_read_out_can_be_intervened_on():
+    """The point of the change: an auto engine can steer at the addresses it captures.
+
+    Reads alone made the two halves of the residual endpoints disagree -- a lens read at layer 7
+    came back, and the steer, ablation or swap that read implies was refused for want of a site at
+    ``resid_post.7``, which was already tapped a few bytes away.
+    """
+    reads, writes, _ = resolve_freeze_points("auto", n_layers=2, n_streams=1)
+    assert writes == reads
+    assert writes == [Address("resid_post", 0), Address("resid_post", 1)]
+
+
+def test_an_explicit_read_list_still_implies_no_writes():
+    """Auto is a default, not a rewrite rule. A caller who named the points named all of them."""
+    reads, writes, _ = resolve_freeze_points([Address("resid_post", 1)], n_layers=4, n_streams=1)
+    assert reads == [Address("resid_post", 1)]
     assert writes == []
 
 
+def test_an_empty_write_list_asks_auto_for_the_reads_without_the_write_buffers():
+    """``[]`` and None have to part company here, and nowhere else in this signature.
+
+    This is the opt-out for the memory: write buffers are per layer and per token, so on a pod
+    where they would step ``max_num_batched_tokens`` down, a caller who only ever reads can say so.
+    """
+    reads, writes, graph = resolve_freeze_points("auto", n_layers=2, n_streams=1, freeze_writes=[])
+    assert graph is True
+    assert reads == [Address("resid_post", 0), Address("resid_post", 1)]
+    assert writes == []
+
+
+def test_an_empty_write_list_alone_is_still_not_a_reason_to_capture_graphs():
+    """Distinguishing ``[]`` from None must not turn ``freeze_writes=[]`` into a freeze request."""
+    reads, writes, graph = resolve_freeze_points(None, n_layers=2, n_streams=1, freeze_writes=[])
+    assert (reads, writes, graph) == ([], [], False)
+
+
+def test_a_named_write_is_not_joined_by_reads_it_did_not_ask_for():
+    reads, writes, graph = resolve_freeze_points(
+        None, n_layers=4, n_streams=1, freeze_writes=[Address("resid_post", 1)], enforce_eager=False
+    )
+    assert graph is True
+    assert reads == []
+    assert writes == [Address("resid_post", 1)]
+
+
+def test_a_generation_only_engine_gains_neither_half():
+    """``[]`` is graphs with no taps at all, and the auto write must not creep into it."""
+    reads, writes, graph = resolve_freeze_points([], n_layers=12, n_streams=1)
+    assert (reads, writes, graph) == ([], [], True)
+
+
+def test_the_auto_writes_on_a_stacked_trunk_are_ones_the_engine_agrees_are_writable():
+    """Auto now hands ``resid_streams`` to the write validation below, which used to see only reads.
+
+    A write set built by default has to clear the same bar as one a caller typed, or DeepSeek-V4
+    would refuse to load with `cannot freeze-write` from a set nobody asked for.
+    """
+    _, writes, _ = resolve_freeze_points("auto", n_layers=3, n_streams=4)
+    assert {a.name for a in writes} == {"resid_streams"}
+    assert all(steer_refusal_reason(a.name) is None for a in writes)
+
+
 def test_freeze_writes_without_reads_is_still_graph_mode():
     reads, writes, graph = resolve_freeze_points(
         None, n_layers=4, n_streams=1, freeze_writes=[Address("resid_post", 1)]