File size: 6,998 Bytes
dc5b70c | 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 | """CPU helpers for the fixed Kokoro v1 / 24 kHz harmonic-source contract.
Phase and oscillator arithmetic remain FP32. The Gaussian transform preserves
the seeded reference samples while using FP64 arithmetic and parallel execution.
"""
from __future__ import annotations
import json
from collections import OrderedDict
from pathlib import Path
import numpy as np
import torch
from torch.nn import functional as F
class NativeNoise:
"""Optional C++ source; owns a separate generator with the same seed/draws."""
def __init__(self, library, threads=8):
import ctypes
self.ctypes = ctypes
self.library = ctypes.CDLL(str(library))
self.function = self.library.kokoro_normal
self.function.argtypes = [ctypes.c_uint64, ctypes.c_int64, ctypes.c_int,
ctypes.c_void_p, ctypes.c_int]
self.function.restype = ctypes.c_int
self.threads = threads
def __call__(self, samples, harmonics, seed):
result = torch.empty(1, harmonics, samples, dtype=torch.float32)
status = self.function(seed, samples, harmonics, result.data_ptr(), self.threads)
if status:
raise RuntimeError(f"Native Gaussian source failed: {status}")
return result.transpose(1, 2)
def kokoro_normal(samples, harmonics):
"""Vectorized FP64 Box-Muller for the reference's strided CPU normal fill.
This helper is used only after resetting the CPU generator for a Kokoro
source call. The sample count is even and there is no cached normal value.
Uniform draws, pair order and physical output order match PyTorch 2.8's
scalar normal_distribution<double> path; the arithmetic remains FP64 until
the original final FP32 rounding.
"""
count = samples * harmonics
if count % 2:
raise ValueError("The Kokoro source requires an even normal sample count")
uniform = torch.rand(count // 2, 2, dtype=torch.float64)
radius = torch.sqrt(-2.0 * torch.log1p(-uniform[:, 1]))
theta = (2.0 * torch.pi) * uniform[:, 0]
pairs = torch.empty(count // 2, 2, dtype=torch.float32)
pairs[:, 0] = radius * torch.cos(theta)
pairs[:, 1] = radius * torch.sin(theta)
return pairs.reshape(1, harmonics, samples).transpose(1, 2)
def low_rate_sine(f0, cfg, seed, *, fast_noise=False, native_noise=None):
"""Avoid audio-rate frequency/remainder tensors; preserve RNG and FP32 order.
The reference repeats each low-rate pitch value 300 times, then samples
frequency increments back down at positions 149.5, 449.5, ... . Both
neighbors at those positions are identical repeats of the same pitch.
The random initial phase placed at audio sample zero is never sampled,
but its random draw must still be consumed before generating noise.
"""
if cfg["upsample_scale"] != 300 or cfg["sampling_rate"] != 24000:
raise ValueError("This optimization requires Kokoro's 300x / 24 kHz source contract")
pitch = torch.from_numpy(f0)
if pitch.dtype != torch.float32 or pitch.ndim != 2 or pitch.shape[0] != 1 or pitch.shape[1] < 1:
raise ValueError("Expected nonempty batch-one FP32 pitch [1, frames]")
harmonics = cfg["harmonic_num"] + 1
with torch.inference_mode(), torch.random.fork_rng(devices=[]):
torch.manual_seed(seed)
frequencies = pitch[:, :, None] * torch.arange(1, harmonics + 1, dtype=torch.float32)[None, None]
increments = (frequencies / cfg["sampling_rate"]) % 1
# Retain the reference generator's consumption, including fundamental.
torch.rand(1, harmonics)
phase = torch.cumsum(increments, dim=1) * 2 * torch.pi
phase = F.interpolate(phase.transpose(1, 2) * cfg["upsample_scale"],
scale_factor=cfg["upsample_scale"], mode="linear").transpose(1, 2)
waves = torch.sin(phase) * cfg["sine_amp"]
uv = (pitch > cfg["voiced_threshold"]).to(torch.float32).repeat_interleave(
cfg["upsample_scale"], dim=1)[:, :, None]
noise_amp = uv * cfg["noise_std"] + (1 - uv) * cfg["sine_amp"] / 3
if native_noise is not None:
gaussian = native_noise(waves.shape[1], harmonics, seed)
else:
gaussian = kokoro_normal(waves.shape[1], harmonics) if fast_noise else torch.randn_like(waves)
noise = noise_amp * gaussian
return waves * uv + noise
def optimized_sine(f0, cfg, seed):
return low_rate_sine(f0, cfg, seed, fast_noise=True)
class CPUHelpers:
"""Reusable harmonic DSP and bounded cache for exact style-affine inputs.
The owning TTS worker serializes calls, as with the reference's fork_rng.
Each native noise call uses private buffers and a private seeded generator.
"""
def __init__(self, root, *, noise_library=None, noise_threads=16, cache_styles=16):
self.cfg = json.loads((Path(root) / "host_source.json").read_text())
self.native_noise = NativeNoise(noise_library, noise_threads) if noise_library else None
self.noise_implementation = "native-fp64" if self.native_noise else "torch-vector-fp64"
self.window = torch.hann_window(self.cfg["n_fft"], periodic=True, dtype=torch.float32)
self.affine_cache = OrderedDict()
self.cache_styles = cache_styles
self.affine_hits = 0
def sine(self, f0, seed):
return low_rate_sine(f0, self.cfg, seed, fast_noise=True, native_noise=self.native_noise)
def affine(self, backend, style):
exact = np.ascontiguousarray(style[:, :128], dtype=np.float32)
key = exact.tobytes()
if key in self.affine_cache:
self.affine_hits += 1
self.affine_cache.move_to_end(key)
return self.affine_cache[key]
value = backend.run("host_affine", {"style": exact})[0]
if self.cache_styles > 0:
value.setflags(write=False)
self.affine_cache[key] = value
while len(self.affine_cache) > self.cache_styles:
self.affine_cache.popitem(last=False)
return value
def stft(self, merged):
with torch.inference_mode():
data = torch.from_numpy(merged).transpose(1, 2).squeeze(1)
spectrum = torch.stft(data, self.cfg["n_fft"], self.cfg["hop_length"],
self.cfg["n_fft"], window=self.window, return_complex=True)
return torch.cat([torch.abs(spectrum), torch.angle(spectrum)], dim=1).numpy()
def harmonic_features(self, f0, backend, seed):
import time
record = getattr(backend, "add_timing", lambda name, seconds: None)
start = time.perf_counter()
waves = self.sine(f0, seed)
record("source_oscillator", time.perf_counter() - start)
merged = backend.run("harmonic_merge", {"harmonics": waves.numpy()})[0]
start = time.perf_counter()
result = self.stft(merged)
record("source_stft", time.perf_counter() - start)
return result
|