File size: 5,256 Bytes
2360e00 | 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 | """Sequential sparse-access comparison and reuse contracts."""
import copy
import numpy as np
import pytest
import torch
from test_sequential_transfer import fixture_data
from test_sequential_transfer import spec as data_spec
from llm_memory_editability import moe_sequential as ms
from llm_memory_editability import sequential_transfer as st
from llm_memory_editability.grokking_reproduction import model_digest
from llm_memory_editability.loop_kv_learning import construct as old_construct
from llm_memory_editability.realworld_composition import optimizer_for, update
@pytest.fixture(autouse=True)
def one_thread():
previous = torch.get_num_threads()
torch.set_num_threads(1)
yield
torch.set_num_threads(previous)
def options(arm="M4"):
return {
**data_spec(),
"architecture": arm,
"stage_b_steps": 4,
"replay_source": "full_stage_a",
"unique_layers": 4,
"repeats": 1,
"initialization_reference_layers": 8,
"microbatch_size": 2,
"balance_coefficient": 0.01,
"model": {
"vocab_size": 43,
"positions": 32,
"hidden_size": 16,
"attention_heads": 4,
"dropout": 0.0,
},
}
def records():
return [
{"encoded": {"input": [2, 5, 8, 1, 0], "prefix": [2, 5], "target": [8, 1]}},
{"encoded": {"input": [3, 9, 1], "prefix": [3], "target": [9, 1]}},
] * 2
def test_ordinary_weights_forward_and_actual_update_match_reusable_baseline(tmp_path):
spec = options("D4")
old_spec = {**spec, "arm": "standard", "base_unique_blocks": 4}
old, model = old_construct(old_spec, "cpu"), ms.construct(spec["model"], spec, "cpu")
assert model_digest(old) == model_digest(model)
x = torch.tensor([[1, 2, 3, 4]])
assert torch.equal(old(x), model(x))
old_optimizer, optimizer = [optimizer_for(m, 0.003, 0.1) for m in (old, model)]
expected = update(old, old_optimizer, records(), spec, "cpu", 0)
with ms.adapter(spec, tmp_path):
actual = st.update(model, optimizer, records(), spec, "cpu", 0)
assert expected == actual
assert model_digest(old) == model_digest(model)
def test_sparse_total_and_active_parameters_have_separate_dense_controls():
ledgers = {
arm: ms.manifest(ms.construct(options(arm)["model"], options(arm), "cpu"))
for arm in ms.ARMS
}
assert ledgers["M4"]["unique_parameters"] > ledgers["D4"]["unique_parameters"]
assert (
abs(ledgers["M4"]["unique_parameters"] - ledgers["W4"]["unique_parameters"])
< 0.03 * ledgers["M4"]["unique_parameters"]
)
assert ledgers["M4"]["active_unique_parameters"] < ledgers["W4"]["active_unique_parameters"]
common = [row["initialization"]["shared_tensor_sha256"] for row in ledgers.values()]
base = {k: v for k, v in common[0].items() if ".mlp." not in k}
assert base == common[1] == common[2]
def test_new_fact_exposure_is_identical_and_adapter_restores_after_exception(tmp_path):
data = fixture_data()
plans = [ms.training_plan(data, options(arm))[1] for arm in ms.ARMS]
assert all(np.array_equal(plans[0], plan) for plan in plans[1:])
originals = {
key: getattr(st, key) for key in ("construct", "training_plan", "update", "save_checkpoint")
}
with pytest.raises(RuntimeError), ms.adapter(options(), tmp_path):
raise RuntimeError("injected failure")
assert all(getattr(st, key) is value for key, value in originals.items())
@pytest.mark.parametrize("arm", ["M4", "W4"])
def test_cost_and_optimizer_restore_use_actual_sparse_or_wide_path(tmp_path, arm):
spec = options(arm)
model = ms.construct(spec["model"], spec, "cpu")
optimizer = optimizer_for(model, 0.003, 0.1)
with ms.adapter(spec, tmp_path):
result = st.update(model, optimizer, records(), spec, "cpu", 0)
saved_model, saved_optimizer = (
copy.deepcopy(model.state_dict()),
copy.deepcopy(optimizer.state_dict()),
)
st.update(model, optimizer, records(), spec, "cpu", 0)
restored = ms.construct(spec["model"], spec, "cpu")
restored.load_state_dict(saved_model)
restored_optimizer = optimizer_for(restored, 0.003, 0.1)
restored_optimizer.load_state_dict(saved_optimizer)
st.update(restored, restored_optimizer, records(), spec, "cpu", 0)
assert model_digest(restored) == model_digest(model)
assert (
result["estimated_matmul_training_flops"]
== result["compute"]["estimated_total_training_matmul_flops"]
)
if arm == "M4":
assert result["router"]["dropped_assignments"] == 0
assert result["router"]["replay_assignment_count_error"] == 0
assert result["routing_prepass_executed_input_tokens"] > 0
assert (
result["compute"]["selected_expert_assignments"]
== 4 * sum(len(r["encoded"]["input"]) for r in records()) * 2
)
else:
dense = ms.construct(options("D4")["model"], options("D4"), "cpu")
normal = update(dense, optimizer_for(dense, 0.003, 0.1), records(), spec, "cpu", 0)
assert result["estimated_matmul_training_flops"] > normal["estimated_matmul_training_flops"]
|