File size: 8,644 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 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 | """Full-width, depth-pruned text student; initialization is NOT an exact resume.
Caller pins source checkpoint/files and supplies upstream import paths. No model
downloads, teacher/decoder loading, device movement, or training are performed.
The standard TextStudent27 forward/infer and state-key conventions are retained.
"""
from collections import OrderedDict
from copy import deepcopy
import hashlib
import json
import torch
from inflect_kokoro_student27 import TextStudent27
_CONFIG = dict(speaker_count=6, preset="native33_fullwidth_depth1+mlp", n_token=178,
teacher_dim=512, max_dur=50, widths=[512, 8, 8, 384, 64, 1],
variant="baseline")
SOURCE_CONFIG = dict(speaker_count=6, preset="inflect27+mlp", n_token=178,
teacher_dim=512, max_dur=50, widths=[512, 8, 8, 384, 64, 3],
variant="baseline")
EXPECTED_PARAMETERS = 11_914_548
SOURCE_PARAMETERS = 15_464_244
ACOUSTIC_PARAMETERS = 22_396_242
SOURCE_CHECKPOINT_SHA256 = "e3d106ce49338985d1bd23f6ceaa9468b2f861f5d6427a4d9024a4ee4449ecfd"
_DROPPED_PREFIXES = tuple("text_encoder.cnn.%d." % i for i in (1, 2)) + tuple(
"predictor.text_encoder.lstms.%d." % i for i in (2, 3, 4, 5))
def _require(value, message):
if not value:
raise ValueError(message)
def default_config():
return deepcopy(_CONFIG)
class Native33TextModel(TextStudent27):
def __init__(self, speaker_count=6, preset="native33_fullwidth_depth1+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 native33 architecture/config")
super().__init__(**config)
def build_model(config):
_require(isinstance(config, dict) and config == _CONFIG,
"Expected exact default_config(); unknown keys/configs are rejected")
model = Native33TextModel.from_config(deepcopy(config))
_require(sum(p.numel() for p in model.parameters()) == EXPECTED_PARAMETERS,
"Unexpected resident parameter count; check pinned upstream source")
return model
def parameter_report(model):
count = sum(p.numel() for p in model.parameters())
return dict(text_parameters=count, acoustic_parameters=ACOUSTIC_PARAMETERS,
core_total_parameters=count+ACOUSTIC_PARAMETERS,
buffer_values=sum(b.numel() for b in model.buffers()),
submodules={k: sum(p.numel() for p in module.parameters())
for k, module in model.named_children()},
caveat="Native length-dependent style banks/affine tables are additional; no quality claim")
def _digest(state):
"""Canonical tensor-state hash, independent of torch.save container encoding."""
result = 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()
result.update(len(header).to_bytes(8, "big")); result.update(header)
result.update(len(data).to_bytes(8, "big")); result.update(data)
return result.hexdigest()
def _normalize_source(raw, expected):
_require(isinstance(raw, dict) and bool(raw), "Source model state required")
result, aliases = OrderedDict(), {}
for name, tensor in raw.items():
_require(isinstance(name, str) and torch.is_tensor(tensor), "Only tensor model state accepted")
_require(tensor.device.type == "cpu", "Supply CPU source checkpoint; no GPU allocation here")
_require(bool(torch.isfinite(tensor).all()), "Nonfinite source: " + name)
destination = name
if name.endswith((".weight_g", ".weight_v")):
prefix, suffix = name.rsplit(".", 1)
destination = prefix+".parametrizations.weight.original"+("0" if suffix == "weight_g" else "1")
_require(destination in expected and destination not in raw,
"Unknown/colliding legacy weight-norm alias: " + name)
_require(prefix+".weight_g" in raw and prefix+".weight_v" in raw,
"Incomplete legacy weight-norm pair: " + name)
aliases[name] = destination
_require(destination not in result, "Duplicate normalized state key")
result[destination] = tensor
_require(set(result) == set(expected), "Source keys differ from full original15M architecture")
for name, tensor in result.items():
_require(tensor.shape == expected[name].shape and tensor.dtype == expected[name].dtype,
"Source shape/dtype mismatch: " + name)
return result, aliases
def initialize_from_checkpoint(model, state):
"""Copy every retained tensor exactly; caller MUST pin trusted source file SHA.
state is the full loaded CPU checkpoint, not just its model mapping. Source
optimizer/RNG/provenance remain untouched; parent creates a NEW optimizer/RNG
contract for this deliberately changed architecture. No trained-weight reset
or low-rank/weight-normalization arithmetic is used.
"""
_require(isinstance(model, Native33TextModel) and model.get_config() == _CONFIG,
"Expected fresh Native33TextModel")
_require(all(p.device.type == "cpu" for p in model.parameters()), "Initialize on CPU before .to(device)")
_require(isinstance(state, dict) and state.get("model_config") == SOURCE_CONFIG,
"Exact source15M model_config required")
_require(isinstance(state.get("config"), dict) and state["config"].get("stage") == "text",
"Source must be a text checkpoint")
_require(type(state.get("step")) is int and state["step"] >= 0, "Explicit source step required")
# Construct only a CPU schema donor. Its random initialization is unused and
# caller RNG is restored; no teacher/decoder is constructed.
with torch.random.fork_rng(devices=[]):
donor = TextStudent27.from_config(deepcopy(SOURCE_CONFIG))
_require(sum(p.numel() for p in donor.parameters()) == SOURCE_PARAMETERS,
"Unexpected source architecture count")
source, aliases = _normalize_source(state.get("model"), donor.state_dict())
target = model.state_dict()
dropped = sorted(set(source)-set(target))
_require(bool(dropped) and all(k.startswith(_DROPPED_PREFIXES) for k in dropped),
"Only documented extra CNN/duration blocks may be removed")
_require(set(target) <= set(source), "Target requires unknown/uninitialized tensors")
transferred = OrderedDict()
for name, expected in target.items():
tensor = source[name]
_require(tensor.shape == expected.shape and tensor.dtype == expected.dtype,
"Retained tensor mismatch: " + name)
transferred[name] = tensor.detach().clone()
model.load_state_dict(transferred, strict=True)
_require(all(torch.equal(tensor, model.state_dict()[name]) for name, tensor in transferred.items()),
"Transfer readback differs")
receipt = dict(schema="native33-fullwidth-depth-prune-v1", exact_training_resume=False,
functional_equivalence_claimed=False, fresh_optimizer_required=True,
source_step=state["step"], source_model_config=deepcopy(SOURCE_CONFIG),
target_model_config=default_config(), source_state_sha256=_digest(source),
transferred_state_sha256=_digest(transferred), dropped_state_sha256=_digest(
{k: source[k] for k in dropped}),
retained_tensors=len(transferred), random_target_tensors=0,
retained_values=sum(t.numel() for t in transferred.values()),
dropped_values=sum(source[k].numel() for k in dropped),
dropped_keys=dropped, source_key_aliases=aliases,
retained_cnn_blocks=[0], retained_duration_blocks=[0],
source_file_sha256_verification="REQUIRED from caller; not inferable from loaded dict",
selected_source_file_sha256=SOURCE_CHECKPOINT_SHA256,
source_optimizer_rng_mutated=False, budget=parameter_report(model),
caveat="Depth changes hidden distributions; train/evaluate before promotion. ALBERT8 shared iterations unchanged.")
return receipt
|