File size: 9,268 Bytes
6e802a4 | 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 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 | # test_p2cot_seams.py: The plan tier's cross-file contracts.
import json
import os
import subprocess
import sys
from pathlib import Path
import pytest
REPO_ROOT = Path(__file__).resolve().parents[1]
if str(REPO_ROOT) not in sys.path:
sys.path.insert(0, str(REPO_ROOT))
PROBE = r'''
import json, sys, tempfile
from pathlib import Path
REPO = Path(sys.argv[1])
sys.path.insert(0, str(REPO)); sys.path.insert(0, str(REPO / "scripts"))
out = {}
try:
import torch
from tokenizer import load_base_tokenizer, expand_tokenizer, TokenRegistry
import plan_extract as PX
import plan_adherence as PA
import delay_dataset as DD
import model as M
import train as TR
tok = load_base_tokenizer()
expand_tokenizer(tok)
reg = TokenRegistry(tok)
except Exception as e: # offline / missing cache
print(json.dumps({"unavailable": f"{type(e).__name__}: {e}"}))
raise SystemExit(0)
# A plan with a deliberately UNVOICED middle word and both extreme bins.
WORDS = [
{"word": "alpha", "pitch_bin": 3, "dur_bin": 4, "energy_bin": 2, "dur_frames": 7},
{"word": "sss", "pitch_bin": PX.PITCH_UNVOICED_BIN,
"dur_bin": 1, "energy_bin": 0, "dur_frames": 3},
{"word": "omega", "pitch_bin": 15, "dur_bin": 9, "energy_bin": 7, "dur_frames": 11},
]
T = sum(w["dur_frames"] for w in WORDS)
# ---- S1: extractor string -> tokenizer ids, one id per symbol --------------
plan_str = PX.plan_to_tokens(WORDS, wrap=True)
ids = tok.encode(plan_str, add_special_tokens=False)
n_symbols = 2 + sum(1 + (0 if w["pitch_bin"] == PX.PITCH_UNVOICED_BIN else 1) + 2
for w in WORDS)
out["extractor_string"] = plan_str
out["n_ids"] = len(ids)
out["n_symbols"] = n_symbols
out["ids_are_plan_block"] = all(reg.is_plan_token(int(i)) for i in ids)
# ---- S1/S2: dataset-emitted ids -> extractor parser ------------------------
row = {"prompt": "alpha sss omega",
"speech_tokens": [5] * T,
"residual_codes": [[7] * T for _ in range(DD.NUM_LEVELS - 1)],
"speaker_id": 1,
"plan": {"words": WORDS, "ok": True, "coverage": 1.0}}
p = Path(tempfile.mkdtemp()) / "rows.jsonl"
p.write_text(json.dumps(row) + "\n" + json.dumps(row) + "\n", encoding="utf-8")
ds = DD.DelayMimiDataset(str(p), tok, reg, max_seq_len=512, stage=2,
aligned=True, cot_mode="plan", audio_continue_weight=1.0)
item = ds[0]
seq = item["input_ids"].tolist()
plan_pos = [i for i, t in enumerate(seq) if reg.is_plan_token(t)]
dataset_str = "".join(tok.convert_ids_to_tokens([seq[i] for i in plan_pos]))
out["dataset_string"] = dataset_str
out["dataset_string_matches_extractor"] = (dataset_str == plan_str)
out["parsed_back"] = PX.tokens_to_plan(dataset_str)
# ---- S3: collator slots -> train adapter -> injector bins ------------------
batch = DD.DelayCollator(pad_token_id=0)([ds[0], ds[1]])
out["collator_plan_keys"] = sorted(k for k in batch if k.startswith("plan_"))
bins = TR.plan_bins_from_slots(batch["input_ids"], batch["plan_slots"], reg)
out["bins"] = bins.tolist()
inj = M.PlanInjector(d_model=16, n_pitch_bins=len(reg.pitch_ids),
n_duration_bins=len(reg.duration_ids),
n_energy_bins=len(reg.energy_ids), d_plan=8,
scaffold_dropout=0.0)
out["injector_accepts_batch"] = tuple(
inj(bins, batch["plan_schedule"]).shape) == (2, len(seq), 16)
# ---- S4: the two schedule builders ----------------------------------------
durs = [w["dur_frames"] for w in WORDS]
a0 = int(item["audio_start"])
ds_sched = item["plan_schedule"].tolist()
m_sched = M.build_plan_schedule([durs], a0, T, seq_len=len(seq))[0].tolist()
# plan_lookahead=1: the dataset places frame t one position EARLIER than
# model.build_plan_schedule does, because the input at p predicts the code at
# p+1. Shift by exactly that one position and the two must be identical.
shifted = [-1] * len(seq)
for t in range(T):
shifted[a0 + t - 1] = m_sched[a0 + t]
out["schedules_agree_modulo_lookahead"] = (shifted == ds_sched)
out["dataset_schedule_head"] = ds_sched[a0 - 2:a0 + 4]
out["model_schedule_head"] = m_sched[a0 - 2:a0 + 4]
# ---- S2/S5: PAS against the extractor's own output -------------------------
try:
out["pas_on_quantised_output"] = PA.pas(WORDS, WORDS)["pas"]
except Exception as e:
out["pas_on_quantised_output"] = f"RAISED {type(e).__name__}: {e}"
out["plan_extract_has_contract"] = {
n: hasattr(PX, n) for n in ("parse_plan_string", "extract_plan_words")}
try:
sg = PA.score_generation("g.wav", plan_str, "alpha sss omega",
extract_fn=lambda w, t, **k: PX.parse_plan_string(plan_str))
out["score_generation_self_pas"] = sg["pas"]["pas"]
except Exception as e:
out["score_generation_self_pas"] = f"RAISED {type(e).__name__}: {e}"
print(json.dumps(out))
'''
@pytest.fixture(scope="module")
def seams():
env = dict(os.environ)
env["MVC_ENABLE_PLAN_TOKENS"] = "1"
env["MVC_NUM_SPEECH_TOKENS"] = "1024"
env["MVC_NUM_CODEC_LEVELS"] = "10"
env["HF_HUB_OFFLINE"] = env.get("HF_HUB_OFFLINE", "1")
proc = subprocess.run([sys.executable, "-c", PROBE, str(REPO_ROOT)],
capture_output=True, text=True, env=env, timeout=900)
if proc.returncode != 0:
pytest.fail(f"seam probe crashed:\n{proc.stdout}\n{proc.stderr}")
line = proc.stdout.strip().splitlines()[-1]
data = json.loads(line)
if "unavailable" in data:
pytest.skip(f"real tokenizer unavailable: {data['unavailable']}")
return data
def test_plan_symbols_cost_exactly_one_token_id_each(seams):
assert seams["n_ids"] == seams["n_symbols"], seams["extractor_string"]
assert seams["ids_are_plan_block"], "a plan symbol tokenized outside the plan block"
def test_dataset_emits_exactly_the_string_the_extractor_writes(seams):
assert seams["dataset_string_matches_extractor"], (
f"dataset: {seams['dataset_string']!r}\n"
f"extractor: {seams['extractor_string']!r}")
def test_extractor_parser_recovers_the_dataset_program(seams):
expect = [{"pitch_bin": 3, "dur_bin": 4, "energy_bin": 2},
{"pitch_bin": 16, "dur_bin": 1, "energy_bin": 0},
{"pitch_bin": 15, "dur_bin": 9, "energy_bin": 7}]
assert seams["parsed_back"] == expect
def test_collator_emits_the_channels_the_train_loop_reads(seams):
assert seams["collator_plan_keys"] == [
"plan_durations", "plan_lengths", "plan_schedule", "plan_slots"]
def test_slots_decode_back_to_the_sidecar_bins(seams):
expect_row = [[3, 4, 2], [-1, 1, 0], [15, 9, 7]]
assert seams["bins"] == [expect_row, expect_row]
def test_injector_consumes_the_collated_batch_unchanged(seams):
assert seams["injector_accepts_batch"]
def test_pas_accepts_the_extractors_unvoiced_sentinel(seams):
assert seams["pas_on_quantised_output"] == 1.0, seams["pas_on_quantised_output"]
def test_training_and_decode_schedules_agree_modulo_the_lookahead(seams):
assert seams["schedules_agree_modulo_lookahead"], (
f"dataset {seams['dataset_schedule_head']} vs "
f"model {seams['model_schedule_head']}")
def test_plan_extract_exposes_the_entry_points_pas_resolves(seams):
assert seams["plan_extract_has_contract"] == {
"parse_plan_string": True, "extract_plan_words": True}
def test_score_generation_runs_through_the_real_parser(seams):
assert seams["score_generation_self_pas"] == 1.0, seams["score_generation_self_pas"]
def test_trailing_zero_duration_word_is_never_scheduled():
torch = pytest.importorskip("torch")
from model import build_plan_schedule
got = build_plan_schedule([[4, 0]], 0, 6)[0].tolist()
assert got == [0, 0, 0, 0, 0, 0], got
got = build_plan_schedule([[3, 2, 0, 0]], 0, 8)[0].tolist()
assert got == [0, 0, 0, 1, 1, 1, 1, 1], got
got = build_plan_schedule([[0, 0]], 0, 3)[0].tolist()
assert got == [-1, -1, -1], got
def test_documented_known_answers_still_hold():
pytest.importorskip("torch")
from model import build_plan_schedule
assert build_plan_schedule([[2, 3]], 0, 5)[0].tolist() == [0, 0, 1, 1, 1]
assert build_plan_schedule([[2, 2]], 0, 6)[0].tolist() == [0, 0, 1, 1, 1, 1]
assert build_plan_schedule([[3, 0, 2]], 0, 7)[0].tolist() == [0, 0, 0, 2, 2, 2, 2]
assert build_plan_schedule([[4]], 2, 3, 7)[0].tolist() == [-1, -1, 0, 0, 0, -1, -1]
@pytest.mark.skipif(
os.environ.get("MVC_ENABLE_PLAN_TOKENS") is not None,
reason="reads the AMBIENT gate; a process that exported it (a plan arm's "
"own CI) is not the default environment this asserts about")
def test_gate_off_leaves_no_plan_vocabulary():
import config
import importlib
importlib.reload(config)
assert config.ENABLE_PLAN_TOKENS is False
assert config.get_control_tokens() == [
config.USER_PROMPT_TOKEN, config.THINK_START_TOKEN, config.THINK_END_TOKEN,
config.AUDIO_START_TOKEN, config.AUDIO_END_TOKEN, config.SPEAKER_TOKEN,
] + config.EMOTION_TAGS + config.PROSODY_TAGS
def test_plan_extract_token_surface_matches_config_vocabulary():
sys.path.insert(0, str(REPO_ROOT / "scripts"))
import plan_extract as PX
assert PX.verify_config_vocab() == "ok"
|