Preserve current AVIF compression, local voice pipelines, practice workflows, UI API migration, locale updates, and packaging work. Native integration validation remains pending.
86 lines
4.4 KiB
Python
86 lines
4.4 KiB
Python
"""Offline Czech fine-tuned Chatterbox; explicit authorized weights only."""
|
|
import json
|
|
from pathlib import Path
|
|
from f5_russian_narration import (LocalEngine, validate_profile, provenance, text_hash, check_source_identity)
|
|
|
|
LANGUAGES = ('cs',)
|
|
MODEL = 'Thomcles/Chatterbox-TTS-Czech'
|
|
MODEL_REVISION = '1be084192841e27c8bdf7386326405dee08db803'
|
|
KEY = 'chatterbox_czech'
|
|
|
|
|
|
def validate(profile):
|
|
validate_profile(profile, MODEL, MODEL_REVISION, 'cs')
|
|
|
|
|
|
def descriptor(config):
|
|
value = config.get(KEY)
|
|
if isinstance(value, str):
|
|
value = json.loads((Path(__file__).resolve().parents[1] / value).read_text())
|
|
if value is not None:
|
|
validate(value)
|
|
check_source_identity(value)
|
|
return value
|
|
|
|
|
|
class Engine(LocalEngine):
|
|
def __init__(self, profile, local_path):
|
|
validate(profile)
|
|
super().__init__(profile, local_path, __file__)
|
|
|
|
def load(self):
|
|
if self.model is not None:
|
|
return
|
|
self.runtime()
|
|
from chatterbox.mtl_tts import ChatterboxMultilingualTTS
|
|
from safetensors.torch import load_file
|
|
from chatterbox.models.t3 import T3
|
|
from chatterbox.models.t3.modules.t3_config import T3Config
|
|
from chatterbox.models.s3gen import S3Gen
|
|
from chatterbox.models.voice_encoder import VoiceEncoder
|
|
from chatterbox.models.tokenizers import MTLTokenizer
|
|
root = Path(self.local['models'])
|
|
# Same official from_local component construction, loading the selected
|
|
# fine-tune directly so a second 2GB T3 checkpoint is unnecessary.
|
|
ve = VoiceEncoder()
|
|
ve.load_state_dict(self.torch.load(root / 'chatterbox-multilingual/ve.pt', map_location='cpu', weights_only=True))
|
|
t3 = T3(T3Config.multilingual())
|
|
t3.load_state_dict(load_file(root / 'chatterbox-czech/t3_cs.safetensors', device='cpu'))
|
|
s3gen = S3Gen()
|
|
s3gen.load_state_dict(self.torch.load(root / 'chatterbox-multilingual/s3gen.pt', map_location='cpu', weights_only=True))
|
|
from chatterbox.models.tokenizers.tokenizer import ChineseCangjieConverter
|
|
from unittest.mock import patch
|
|
def local_mapping(converter, model_dir=None):
|
|
data = json.loads((root / 'chatterbox-multilingual/Cangjie5_TC.json').read_text())
|
|
for entry in data:
|
|
word, code = entry.split('\t')[:2]
|
|
converter.word2cj[word] = code
|
|
converter.cj2word.setdefault(code, []).append(word)
|
|
# Czech never uses Chinese segmentation. Avoid upstream's unconditional
|
|
# HF mapping lookup and pkuseg network initialization during construction.
|
|
with patch.object(ChineseCangjieConverter, '_load_cangjie_mapping', local_mapping), \
|
|
patch.object(ChineseCangjieConverter, '_init_segmenter', lambda converter: None):
|
|
tokenizer = MTLTokenizer(str(root / 'chatterbox-multilingual/grapheme_mtl_merged_expanded_v1.json'))
|
|
self.model = ChatterboxMultilingualTTS(t3.eval(), s3gen.eval(), ve.eval(), tokenizer, 'cpu')
|
|
|
|
def synthesize(self, text):
|
|
from chatterbox import mtl_tts
|
|
from functools import partial
|
|
from unicodedata import normalize
|
|
from unittest.mock import patch
|
|
language = self.profile['language_id']
|
|
if language == 'cs':
|
|
token = self.model.tokenizer.tokenizer.token_to_id('[cs]')
|
|
if token != self.profile['language_token_id'] or token == self.model.tokenizer.tokenizer.token_to_id('[UNK]'):
|
|
raise RuntimeError('Pinned tokenizer has no Czech language token')
|
|
# The fine-tuned checkpoint's tokenizer includes [cs]; the upstream
|
|
# registry omits it. Scope the registry extension to this single call.
|
|
if self.profile['normalization'] not in ('NFC', 'NFKD'):
|
|
raise ValueError('Czech reference tokenizer requires a pinned normalization form')
|
|
tokens = partial(self.model.tokenizer.text_to_tokens, nfkd_normalize=self.profile['normalization'] == 'NFKD')
|
|
with patch.dict(mtl_tts.SUPPORTED_LANGUAGES, {'cs': 'Czech'}), \
|
|
patch.object(self.model.tokenizer, 'text_to_tokens', tokens):
|
|
audio = self.model.generate(normalize(self.profile['normalization'], text), language_id=language, audio_prompt_path=self.local['reference'],
|
|
**self.profile['parameters'])
|
|
return audio.detach().float().cpu().numpy(), self.model.sr
|