File size: 5,762 Bytes
a775b3f | 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 | """Six-voice Mini factory initialized identically from the compact1000 pilot.
Caller verifies the full source checkpoint file SHA before deserialization and
supplies the existing pinned upstream import paths. No training/jobs/downloads.
The new full-six training contract needs a NEW optimizer, not the two-voice
pilot update function that restores inactive embedding rows after every update.
"""
from copy import deepcopy
import hashlib
import json
import torch
from inflect_kokoro_student27 import TextStudent27
_CONFIG = dict(speaker_count=6, preset="s+mlp", n_token=178, teacher_dim=512,
max_dur=50, widths=[256, 6, 4, 192, 32, 3], variant="baseline")
EXPECTED_PARAMETERS = 4_231_988
ACOUSTIC_PARAMETERS = 22_396_242
SOURCE_SCHEMA = "compact-text-full-utterance-v1"
SOURCE_STEP = 1000
def _require(value, message):
if not value:
raise ValueError(message)
def default_config():
return deepcopy(_CONFIG)
class Native26TextModel(TextStudent27):
def __init__(self, speaker_count=6, preset="s+mlp", n_token=178, teacher_dim=512,
max_dur=50, widths=None, variant="baseline"):
config = dict(speaker_count=speaker_count, preset=preset, n_token=n_token,
teacher_dim=teacher_dim, max_dur=max_dur,
widths=list(_CONFIG["widths"] if widths is None else widths), variant=variant)
_require(config == _CONFIG, "Unqualified native26 architecture/config")
super().__init__(**config)
def build_model(config):
_require(isinstance(config, dict) and config == _CONFIG, "Exact native26 default_config() required")
model = Native26TextModel.from_config(deepcopy(config))
_require(sum(p.numel() for p in model.parameters()) == EXPECTED_PARAMETERS,
"Unexpected resident parameter count; inspect source pins")
return model
def _digest(state):
h = hashlib.sha256()
for name, tensor in sorted(state.items()):
tensor = tensor.detach().cpu().contiguous()
header = json.dumps([name, str(tensor.dtype), list(tensor.shape)], separators=(",", ":")).encode()
data = tensor.view(torch.uint8).numpy().tobytes()
h.update(len(header).to_bytes(8, "big")); h.update(header)
h.update(len(data).to_bytes(8, "big")); h.update(data)
return h.hexdigest()
def initialize_from_checkpoint(model, state):
"""Load every tensor identically, preserving all source states; no row reset.
state is the full trusted CPU checkpoint. File-SHA validation is the caller's
responsibility, since a loaded dict does not establish its container SHA.
No source optimizer/RNG is loaded or changed: full-six sampling is a NEW run.
"""
_require(isinstance(model, Native26TextModel) and model.get_config() == _CONFIG,
"Expected Native26TextModel with exact config")
_require(all(p.device.type == "cpu" and p.requires_grad for p in model.parameters()),
"Initialize a CPU model with all parameters trainable")
_require(isinstance(state, dict) and state.get("schema") == SOURCE_SCHEMA
and state.get("stage") == "text", "Wrong compact checkpoint schema/stage")
_require(type(state.get("step")) is int and state["step"] == SOURCE_STEP, "Expected compact1000 checkpoint")
_require(state.get("model_config") == _CONFIG, "Source compact model_config mismatch")
contract = state.get("contract")
_require(isinstance(contract, dict) and contract.get("active_speakers") == [0, 3]
and contract.get("model_config") == _CONFIG, "Expected original Hope0/James3 training contract")
_require(isinstance(contract.get("sources"), dict) and bool(contract["sources"]),
"Source provenance required")
source, expected = state.get("model"), model.state_dict()
_require(isinstance(source, dict) and set(source) == set(expected), "Strict source state keys mismatch")
for name, target in expected.items():
tensor = source[name]
_require(torch.is_tensor(tensor) and tensor.device.type == "cpu", "CPU source tensor required: " + name)
_require(tensor.shape == target.shape and tensor.dtype == target.dtype,
"Source tensor shape/dtype mismatch: " + name)
_require(bool(torch.isfinite(tensor).all()), "Nonfinite source tensor: " + name)
before = _digest(source)
model.load_state_dict(source, strict=True)
_require(all(torch.equal(tensor, model.state_dict()[name]) for name, tensor in source.items()),
"Strict identity readback failed")
_require(_digest(source) == before, "Source state mutated")
return dict(schema="native26-compact1000-fullsix-init-v1", source_step=SOURCE_STEP,
source_schema=SOURCE_SCHEMA, source_model_config=default_config(),
target_model_config=default_config(), source_contract=deepcopy(contract),
source_state_sha256=before, target_state_sha256=_digest(model.state_dict()),
exact_model_weight_identity=True, exact_training_resume=False,
fresh_optimizer_required=True, source_optimizer_rng_mutated=False,
source_trained_speaker_ids=[0, 3], previously_untrained_speaker_ids=[1, 2, 4, 5],
new_training_speaker_ids=list(range(6)), random_or_replicated_target_rows=0,
parameter_count=EXPECTED_PARAMETERS, core_total_parameters=EXPECTED_PARAMETERS+ACOUSTIC_PARAMETERS,
buffer_values=sum(t.numel() for t in model.buffers()),
source_file_sha256_verification="REQUIRED from caller; loaded dict does not prove file SHA",
caveat="Six rows exist, but only source speakers0/3 were trained. No six-voice quality claim; voice assets additional.")
|