File size: 6,768 Bytes
93bfac1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 | """Contracts for causal self-decoding, zero intervention, and frozen evaluation."""
import json
import numpy as np
import pytest
import torch
from llm_memory_editability.bridge_reencoding import (
ReencodingGPT,
alternative_entity,
audit,
reencode_state,
run,
)
from llm_memory_editability.latent_scaling import build_world, model_digest
from llm_memory_editability.representation_alignment import new_model
from llm_memory_editability.storage_composition import generate_rows
torch.set_num_threads(1)
def small_spec():
return dict(
world=771001,
initialization=772001,
stream_seed=773001,
heads_n=32,
bridges_n=32,
tails_n=16,
familiar_n=8,
strict_n=4,
anchor_n=4,
holdout_fraction=0.25,
low_extra="anchors",
composition_count=32,
width=32,
heads=4,
layers=1,
repeats=2,
dropout=0.0,
)
def make_model(condition="self_decode", alpha=0.5):
model = new_model(small_spec(), "cpu")
model.__class__ = ReencodingGPT
model.bridge_start, model.bridge_count = 53, 32
model.configure(condition, alpha)
return model.eval()
def test_zero_is_exact_identity_and_formula_has_no_outer_normalization():
torch.manual_seed(11)
h, e = torch.randn(17, 32), torch.randn(17, 32)
assert reencode_state(h, e, 0) is h
for alpha in (0.1, 0.5, 1):
result = reencode_state(h, e, alpha)
expected = (1 - alpha) * h + alpha * h.norm(
dim=-1, keepdim=True
) * torch.nn.functional.normalize(e)
torch.testing.assert_close(result, expected)
torch.testing.assert_close(
reencode_state(h, e, 1), h.norm(dim=-1, keepdim=True) * torch.nn.functional.normalize(e)
)
assert reencode_state(h, -h, 0.5).abs().max() < 1e-6
torch.testing.assert_close(
reencode_state(h, e, 0.5, "paper_unit"),
0.5 * h + 0.5 * torch.nn.functional.normalize(e),
)
with pytest.raises(ValueError):
reencode_state(h, e, 1.1)
def test_alpha_zero_matches_original_logits_and_complete_generation():
spec = small_spec()
reference = new_model(spec, "cpu").eval()
model = make_model(alpha=0)
tokens = torch.tensor([[2, 21, 3, 13, 3, 17, 4], [2, 22, 3, 14, 3, 18, 4]])
torch.testing.assert_close(model(tokens), reference(tokens), atol=0, rtol=0)
rows = build_world(spec)["strict_test"][:8]
_, original = generate_rows(reference, rows, "cpu")
for condition in ("baseline", "self_decode", "wrong_entity"):
model.configure(condition, 0)
_, actual = generate_rows(model, rows, "cpu")
for key in original:
np.testing.assert_array_equal(original[key], actual[key])
def test_decoding_is_original_full_vocabulary_and_cannot_see_future():
model = make_model()
a = torch.tensor([[2, 21, 3, 13, 3, 17, 4, 85]])
b = torch.tensor([[2, 21, 3, 13, 4, 20, 5, 86]])
_, ia = model(a, return_bridge=True)
_, ib = model(b, return_bridge=True)
torch.testing.assert_close(ia["state"], ib["state"], atol=0, rtol=0)
assert torch.equal(ia["decoded"], ib["decoded"])
expected = torch.nn.functional.linear(model.ln_final(ia["state"]), model.token.weight).argmax(
-1
)
assert torch.equal(ia["decoded"], expected)
assert torch.equal(ia["selected"], expected)
assert model.oracle_table is None
def test_alternative_entity_never_uses_truth_and_is_nonself():
decoded = torch.arange(101)
selected = alternative_entity(decoded, 53, 32)
assert torch.all((selected >= 53) & (selected < 85))
assert torch.all(selected != decoded)
model = make_model("wrong_entity")
tokens = torch.tensor([[2, 21, 3, 13, 3, 17, 4]])
_, info = model(tokens, return_bridge=True)
assert torch.equal(info["selected"], alternative_entity(info["decoded"], 53, 32))
assert model.oracle_table is None
def test_single_execution_changes_only_sender_position_and_keeps_parameters():
model = make_model("self_decode", 1)
tokens = torch.tensor([[2, 21, 3, 13, 3, 17, 4], [2, 22, 3, 14, 3, 18, 4]])
digest = model_digest(model)
changed = model(tokens, repeats=1)
model.configure("baseline", 0)
original = model(tokens, repeats=1)
unchanged_positions = [0, 1, 2, 4, 5, 6]
torch.testing.assert_close(
changed[:, unchanged_positions], original[:, unchanged_positions], atol=0, rtol=0
)
assert not torch.equal(changed[:, 3], original[:, 3])
assert model_digest(model) == digest
def test_oracle_is_explicit_and_does_not_modify_model_parameters():
model = make_model()
before = model_digest(model)
with pytest.raises(ValueError, match="explicit"):
model.configure("oracle", 1)
truth = torch.full((101, 101), -1, dtype=torch.long)
truth[21, 13] = 53
model.configure("oracle", 1, truth)
_, info = model(torch.tensor([[2, 21, 3, 13, 3, 17, 4]]), return_bridge=True)
assert info["selected"].item() == 53
assert info["oracle_available"].item()
assert model_digest(model) == before
model.configure("self_decode", 1)
assert model.oracle_table is None
def test_full_run_and_reload_preserve_raw_predictions_and_reject_corruption(tmp_path):
parent = tmp_path / "parent"
parent.mkdir()
spec = small_spec()
model = new_model(spec, "cpu")
torch.save({"spec": spec, "model": model.state_dict()}, parent / "model.pt")
np.savez_compressed(parent / "world.npz", **build_world(spec))
out = tmp_path / "evaluation"
request = {
"parent_dir": str(parent),
"alphas": [0, 0.5],
"variants": ["norm_matched", "paper_unit"],
"conditions": ["baseline", "self_decode", "wrong_entity", "oracle"],
}
run(request, out, "cpu")
result = audit(out, "cpu")
assert result["passed"] and result["raw_predictions_recounted"]
assert json.loads((out / "complete.json").read_text())["independently_reloaded"]
with pytest.raises(FileExistsError):
run(request, out, "cpu")
predictions = dict(np.load(out / "predictions.npz"))
assert "norm_matched-a0-self_decode__strict_test_first_generated" in predictions
assert "norm_matched-a0-self_decode__strict_test_common_atoms_and_self_bridge" in predictions
fixed = predictions["baseline__strict_test_coverage"]
for name in json.loads((out / "run.json").read_text())["cases"]:
np.testing.assert_array_equal(
fixed, predictions[f"{name}__strict_test_baseline_common_atoms"]
)
predictions["norm_matched-a0-self_decode__strict_test_generated"][0, 0] += 1
np.savez_compressed(out / "predictions.npz", **predictions)
with pytest.raises(AssertionError):
audit(out, "cpu")
|