"""Portable phoneme-only FastMicro 24K runtime. Requires PyTorch and packaged code.""" import hashlib import importlib import json import math from pathlib import Path import sys import threading SCHEMA = 'inflect-fastmicro24k-phonemes-v1' VOICES = ('hope', 'sophia', 'cassidy', 'james', 'jasper', 'mark') DONORS = ('af_heart', 'af_heart', 'af_sarah', 'am_michael', 'am_michael', 'am_michael') CODE_FILES = ('native_mini_inference.py', 'native26_text_model.py', 'native33_text_model.py', 'native33_text_fast.py', 'inflect_kokoro_student27.py', 'native27_nativegen_bridge.py', 'qualify_native27_native_generator_budget.py', 'student.py', 'student_decoder.py', 'kokoro/__init__.py', 'kokoro/model.py', 'kokoro/modules.py', 'kokoro/istftnet.py', 'kokoro/custom_stft.py', 'vhead.py', 'fastmicro_inference_20261029.py') PAYLOAD_KEYS = {'schema', 'text_config', 'text_state', 'joint_state', 'styles', 'vocab', 'max_frames', 'sample_rate', 'provenance'} _LOCK = threading.RLock() def sha(path): h = hashlib.sha256() with open(path, 'rb') as f: for chunk in iter(lambda: f.read(1024 * 1024), b''): h.update(chunk) return h.hexdigest() def verify_manifest(directory): root = Path(directory).resolve(strict=True) if (root / 'manifest.json').is_symlink(): raise ValueError('Symlink manifest is not allowed') manifest = json.loads((root / 'manifest.json').read_text(encoding='utf-8')) files = manifest.get('files') required = {'weights.pt'} | {'code/' + name for name in CODE_FILES} if manifest.get('schema') != SCHEMA or not isinstance(files, dict) or not required <= set(files): raise ValueError('Invalid export manifest or missing required files') for name, digest in files.items(): if not isinstance(name, str) or '\\' in name or not isinstance(digest, str): raise ValueError('Invalid manifest entry') parts = name.split('/') if any(p in ('', '.', '..') for p in parts) or name.startswith('/') or ':' in name: raise ValueError('Unsafe export path') path = root.joinpath(*parts) if any(root.joinpath(*parts[:i]).is_symlink() for i in range(1, len(parts) + 1)): raise ValueError('Symlink in export path') if not path.is_file() or not path.resolve().is_relative_to(root) or sha(path) != digest: raise ValueError('Export file hash mismatch: ' + name) return root, manifest def _code_path(root): code = root / 'code' # Avoid silently importing a different model's identically named modules. names = {Path(name).parts[0].removesuffix('.py') for name in CODE_FILES} for name, module in tuple(sys.modules.items()): if name.split('.')[0] not in names or name == __name__: continue origin = getattr(module, '__file__', None) if not origin or not Path(origin).resolve().is_relative_to(code): raise RuntimeError('Conflicting preloaded module: ' + name) if str(code) in sys.path: sys.path.remove(str(code)) sys.path.insert(0, str(code)) def _make_joint(torch, mini, vhead, max_frames): nn = torch.nn class ConditionedHead(nn.Module): def __init__(self): super().__init__() self.head = vhead.SourceFilterHead2(in_ch=128, dim=320, blocks=7) self.head.blocks[-1] = vhead.ConvNeXt(320, mult=2) self.style_affine = nn.Linear(128, 256) def forward(self, hidden, style, f0): scale, shift = self.style_affine(style).chunk(2, -1) conditioned = hidden * (1 + 0.1 * torch.tanh(scale[:, :, None])) + shift[:, :, None] return self.head(conditioned, f0, c0=None) class Joint(nn.Module): def __init__(self): super().__init__() self.bridge = mini.build_bridge(max_frames) del self.bridge.projection self.head = ConditionedHead() def forward(self, asr, f0, noise, style, sid): bridge, trunk = self.bridge, self.bridge.trunk speakers = torch.full((asr.shape[0],), sid, device=asr.device, dtype=torch.long) voice_style = bridge.speaker_embedding(speakers) f0_conv, n_conv = trunk.F0_conv(f0[:, None]), trunk.N_conv(noise[:, None]) x = trunk.encode(torch.cat((asr, f0_conv, n_conv), 1), voice_style) residual, use_residual = trunk.asr_res(asr), True for block in trunk.decode: if use_residual: x = torch.cat((x, residual, f0_conv, n_conv), 1) x = block(x, voice_style) if block.upsample_type != 'none': use_residual = False if x.shape != (asr.shape[0], 128, f0.shape[1]): raise ValueError('Unexpected trunk output shape') return self.head(x, style, f0) return Joint() class FastMicro: def __init__(self, payload, root, device='cpu', allow_cuda=False): import torch if set(payload) != PAYLOAD_KEYS or payload['schema'] != SCHEMA: raise ValueError('Invalid payload schema') dev = torch.device(device) if dev.type != 'cpu' and not (dev.type == 'cuda' and allow_cuda): raise ValueError('Only CPU or explicitly allowed CUDA is supported') if payload['sample_rate'] != 24000 or type(payload['max_frames']) is not int or not 2 <= payload['max_frames'] <= 1200: raise ValueError('Invalid sample rate or frame bound') _code_path(root) mini = importlib.import_module('native_mini_inference') factory = importlib.import_module('native26_text_model') vhead = importlib.import_module('vhead') if payload['text_config'] != factory.default_config(): raise ValueError('Text configuration differs') with torch.random.fork_rng(devices=[]): self.text = factory.build_model(payload['text_config']) self.joint = _make_joint(torch, mini, vhead, payload['max_frames']) for model, state in ((self.text, payload['text_state']), (self.joint, payload['joint_state'])): mini.tensor_state(state) mini.strict_load(model, state) styles, vocab = payload['styles'], payload['vocab'] if not isinstance(styles, dict) or set(styles) != {'banks', 'offsets', 'strengths'}: raise ValueError('Invalid style schema') if set(styles['banks']) != set(DONORS) or any(not torch.is_tensor(x) or x.shape != (510, 128) or x.dtype != torch.float32 or not bool(torch.isfinite(x).all()) for x in styles['banks'].values()): raise ValueError('Invalid style banks') offsets, strengths = styles['offsets'], styles['strengths'] if not torch.is_tensor(offsets) or offsets.shape != (6, 128) or offsets.dtype != torch.float32 or not bool(torch.isfinite(offsets).all()) or not isinstance(strengths, list) or len(strengths) != 6 or not all(type(x) in (int, float) and math.isfinite(x) and 0 <= x <= 1 for x in strengths): raise ValueError('Invalid voice offsets or strengths') if not isinstance(vocab, dict) or not vocab or not all(isinstance(k, str) and len(k) == 1 and type(v) is int and 0 < v < 178 for k, v in vocab.items()) or len(set(vocab.values())) != len(vocab): raise ValueError('Invalid vocabulary') self.text.to(dev).eval().requires_grad_(False) self.joint.to(dev).eval().requires_grad_(False) self.styles, self.vocab, self.max_frames, self.device = styles, vocab, payload['max_frames'], dev self.parameter_counts = {'text': sum(p.numel() for p in self.text.parameters()), 'joint': sum(p.numel() for p in self.joint.parameters())} def synthesize_phonemes(self, phones, voice, speed=1., seed=42): import torch if not isinstance(phones, str) or not 1 <= len(phones) <= 510 or any(c not in self.vocab for c in phones): raise ValueError('Expected 1..510 known phoneme characters') if voice not in VOICES or type(seed) is not int or not 0 <= seed < 2**32: raise ValueError('Invalid voice or seed') if type(speed) not in (int, float) or not math.isfinite(speed) or not 0.75 <= speed <= 1.25: raise ValueError('Speed must be finite and within 0.75..1.25') sid = VOICES.index(voice) ids = [0] + [self.vocab[c] for c in phones] + [0] tokens = torch.tensor([ids], device=self.device, dtype=torch.long) lengths = torch.tensor([len(ids)], device=self.device, dtype=torch.long) speakers = torch.tensor([sid], device=self.device, dtype=torch.long) devices = [self.device.index if self.device.index is not None else torch.cuda.current_device()] if self.device.type == 'cuda' else [] with _LOCK, torch.no_grad(): durations, _, _, _ = self.text(tokens, lengths, speaker_ids=speakers) if durations.shape != tokens.shape or not bool(torch.isfinite(durations).all()): raise ValueError('Invalid predicted duration') scaled = durations / speed if not bool(torch.isfinite(scaled).all()) or not bool((scaled.abs() < 1e7).all()): raise ValueError('Predicted duration overflow') counts = scaled.round().clamp(min=1) expected_frames = max(2, int(counts.sum())) if expected_frames > self.max_frames: raise ValueError('Predicted frame limit exceeded') result = self.text.infer(tokens, lengths, speakers, speed=speed) frames = result['asr'].shape[-1] if not torch.equal(result['dur'], durations) or frames != expected_frames or int(result['frame_lengths'][0]) != frames: raise ValueError('Unexpected predicted frames') if result['asr'].shape != (1, 512, frames) or result['F0'].shape != (1, 2 * frames) or result['N'].shape != (1, 2 * frames) or not all(bool(torch.isfinite(result[k]).all()) for k in ('asr', 'F0', 'N')): raise ValueError('Invalid predicted feature shapes or values') style = (self.styles['banks'][DONORS[sid]][len(ids) - 3].to(self.device) + self.styles['offsets'][sid].to(self.device) * self.styles['strengths'][sid])[None] with torch.random.fork_rng(devices=devices): torch.manual_seed(seed) audio = self.joint(result['asr'], result['F0'], result['N'], style, sid)[0] if audio.ndim != 1 or len(audio) != 600 * frames or not bool(torch.isfinite(audio).all()): raise ValueError('Invalid generated waveform') audio = audio.detach().to(device='cpu', dtype=torch.float32) return {'audio': audio, 'sample_rate': 24000, 'metadata': {'voice': voice, 'seed': seed, 'speed': speed, 'frames': frames, 'parameter_counts': dict(self.parameter_counts)}} def load_export(directory, device='cpu', allow_cuda=False): import torch root, _ = verify_manifest(directory) payload = torch.load(root / 'weights.pt', map_location='cpu', weights_only=True) return FastMicro(payload, root, device=device, allow_cuda=allow_cuda)