Upload folder using huggingface_hub

README.md

@@ -2,6 +2,7 @@
 language:
 - kab
 license: apache-2.0
+library_name: transformers
 base_model: hexgrad/Kokoro-82M
 tags:
 - kabyle
@@ -18,7 +19,7 @@ pipeline_tag: text-to-speech
 
 # Matoub-82M · Preview
 
-A text-to-speech model for **Kabyle** (Taqbaylit, `kab`), released as a **preview checkpoint**. An 82M-parameter StyleTTS2 fine-tune of [Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M) trained on 21,953 restored Common Voice Kabyle clips from a fifties male speaker. It synthesises 24 kHz speech that reproduces the gemination, spirantisation, emphatics, and pharyngeals of Kabyle phonology in a native speaker voice — twice the sample rate of `mms-tts-kab`, the incumbent Kabyle TTS model, and under a licence that permits commercial use where that one does not.
+A text-to-speech model for **Kabyle** (Taqbaylit, `kab`), released as a **preview**. An 82M-parameter StyleTTS2 fine-tune of [Kokoro-82M](https://huggingface.co/hexgrad/Kokoro-82M) trained on 21,953 restored Common Voice Kabyle clips from a fifties male speaker. It synthesises 24 kHz speech that reproduces the gemination, spirantisation, emphatics, and pharyngeals of Kabyle phonology in a native speaker voice — twice the sample rate of `mms-tts-kab`, the incumbent Kabyle TTS model, and under a licence that permits commercial use where that one does not.
 
 The work that makes it Kabyle is the front end. Kokoro's token table maps 114 symbols and carries none of `ˤ ʕ ħ` — pharyngealisation, and the letters `ɛ` and `ḥ` — while its G2P is built with `unk=''` and drops a phoneme it cannot represent rather than raising, which would have deleted three consonants from every training target behind a healthy loss curve. The 42-symbol Kabyle inventory was diffed against that table, the three missing symbols assigned to unused embedding rows and trained, the affricate tie bar folded onto `ʧ` and `ʤ`, and the front end made to validate against the vocabulary and raise. That is why the emphatics and pharyngeals survive to the decoder.
 
@@ -43,7 +44,9 @@ Three things worth reading carefully.
 
 **The training audio has a hard frequency ceiling.** The `kab_male` clips are band-limited at approximately 7.9 kHz -- not 11.5 kHz or 24 kHz -- because the recording conditions for Common Voice Kabyle combined with phone microphones, lossy encoding, and upload artefacts cut the spectral content. The model cannot synthesise what was not in its training data; any evaluation above 7.9 kHz measures silence. This is a property of the Kabyle speech record rather than of this checkpoint — the incumbent synthesises at 16 kHz, so both systems are band-limited, and closing it needs recordings that do not currently exist.
 
-**Diffusion was not trained in this checkpoint.** `lambda_diff: 0.0` in the training config. Passing `beta > 0.0` to the inference function injects Gaussian noise from an untrained sampler directly into the decoder. Use `alpha=0.0, beta=0.0` (pure reference style). This is the correct inference mode for this checkpoint and the one the sample audio was produced with.
+**Diffusion was never trained, so it is not in the release.** `lambda_diff: 0.0` for every epoch, which left the style sampler exactly as Kokoro initialised it — blending its output into the decoder injects noise from a module that learned nothing. The export drops it, along with the two style encoders, and carries the speaker style as a 256-dim vector instead. There is no `alpha` or `beta` to set and no way to set one wrong.
+
+**The vocoder is stochastic.** The harmonic-plus-noise source draws its noise floor and initial phase from the global RNG, so two calls on the same text return different samples. Seed `torch` if you need one waveform twice.
 
 ## Intended use
 
@@ -65,34 +68,45 @@ This preview stays permanently published. The production voices that follow it a
 
 ## Usage
 
-**Not a `from_pretrained` model.** StyleTTS2 is not a `transformers` architecture and this is
-a training checkpoint rather than an export, so the repository ships `inference.py` and that
-is the interface. Download the repository and run from inside it:
-
 ```bash
-pip install torch torchaudio librosa soundfile huggingface_hub
-hf download agbalu/Matoub-82M --local-dir Matoub-82M && cd Matoub-82M
+pip install "transformers>=5" torch soundfile
 ```
 
 ```python
-from inference import MatoubTTS
+import soundfile as sf
+from transformers import AutoModelForTextToWaveform, AutoTokenizer
 
-tts = MatoubTTS.load()
-tts.synthesise("Azul fell-awen, amek i telliḍ taṣebḥit-a?", "output.wav")
-```
+tokenizer = AutoTokenizer.from_pretrained("agbalu/Matoub-82M", trust_remote_code=True)
+model = AutoModelForTextToWaveform.from_pretrained("agbalu/Matoub-82M", trust_remote_code=True)
+model.eval()
 
-Or from the command line:
+inputs = tokenizer("Azul fell-awen, amek i telliḍ taṣebḥit-a?", return_tensors="pt")
+audio = model(**inputs).waveform[0]
 
-```bash
-python inference.py --text "Azul fell-awen, amek i telliḍ taṣebḥit-a?" --out output.wav
+sf.write("output.wav", audio.numpy(), model.config.sampling_rate)
 ```
 
+`trust_remote_code=True` is required: StyleTTS2 is not a `transformers` architecture, so the
+repository ships the modelling code beside the weights and nothing else is needed to run it —
+no StyleTTS2 checkout, no reference clip, no separate G2P package.
+
+`forward` takes `speed` (a duration multiplier, default `1.0`) and `voice` (a 256-dim style
+vector, defaulting to the one in the weights). It returns `waveform`, `waveform_lengths` and
+`durations` — frames per input phoneme, which is the alignment. A padded batch is synthesised
+item by item and right-padded; read `waveform_lengths` before trimming.
+
+**Text in, phonemes out.** The tokenizer is the front end: it runs the Kabyle G2P, folds the
+tie-bar affricates (`t͡ʃ` → `ʧ`, `d͡ʒ` → `ʤ`) onto the symbols in the token table, and raises
+on a character it has no rule for rather than dropping it. Inspect what it produced with
+`tokenizer.phonemize(text)`. Punctuation is discarded and the clitic hyphen is a word
+boundary, because that is what the training transcripts carried — the model has never been
+supervised on a comma. PL-BERT positions 510 tokens, so synthesise one sentence at a time.
+
 The synthesis pipeline:
 
-1. **G2P** -- converts Kabyle Latin text to IPA, folding affricate tie-bar sequences (`t͡ʃ` -> `ʧ`, `d͡ʒ` -> `ʤ`) to the symbols in Kokoro's token table.
-2. **Style extraction** -- a reference clip from the training voice is encoded by `style_encoder` and `predictor_encoder` to produce a 256-dim speaker style vector.
-3. **Duration and pitch prediction** -- `bert` (PL-BERT, 12 layers), `bert_encoder`, `predictor`, and `predictor_encoder` predict phoneme durations and F0 contours from the token sequence and style vector.
-4. **Waveform decoding** -- the HiFi-GAN `decoder` renders 24 kHz mono audio.
+1. **G2P** — Kabyle Latin orthography to IPA, with gemination, spirantisation, `a`-backing and nasal assimilation.
+2. **Duration and pitch prediction** — `bert` (PL-BERT, 12 layers), `bert_encoder` and `predictor` predict per-phoneme durations and the F0 and energy contours from the token sequence and the prosodic half of the style vector.
+3. **Waveform decoding** — `text_encoder`'s features are expanded to frames by the predicted durations, and the iSTFTNet `decoder` renders 24 kHz mono audio conditioned on the acoustic half.
 
 ## Architecture
 
@@ -100,18 +114,22 @@ Matoub-82M is a StyleTTS2 model initialised from Kokoro-82M weights and fine-tun
 
 | | |
 |---|---|
-| Parameters | **82M** (Kokoro base) |
+| Parameters | **81,731,256** across `bert`, `bert_encoder`, `predictor`, `text_encoder`, `decoder` |
 | Base model | hexgrad/Kokoro-82M |
-| Vocoder | HiFi-GAN decoder |
-| Style encoder | 128-dim acoustic style vector |
-| Predictor encoder | 128-dim prosodic style vector |
+| Vocoder | iSTFTNet — HiFi-GAN upsampling with an inverse-STFT head, 20-point FFT, hop 5 |
+| Speaker style | one 256-dim vector in the weights: 128 acoustic, 128 prosodic |
 | Language model | PL-BERT (12 layers) + BERT encoder projection |
-| Duration predictor | LSTM + linear projection |
-| F0 predictor | JDC pitch extractor |
-| Discriminators | MPD + MSD (Stage 1 only) |
+| Duration predictor | LSTM + linear projection, 50-frame maximum per phoneme |
 | Token table | 178 tokens (Kokoro base), 3 new rows trained for Kabyle phonemes |
 | Sample rate | 24 kHz |
-| Mel filterbank | 80 bins, f_min 0, f_max 8000, n_fft 2048, hop 300 |
+| Weights | `model.safetensors`, 327 MB, fp32, weight normalisation fused |
+
+The training checkpoint also held the two style encoders, the style diffusion sampler, the
+text aligner, the JDC pitch extractor, the MPD and MSD discriminators, the WavLM
+discriminator and the optimizer state — 1.93 GB of instruments that produce nothing at
+inference. None of them is in the release. The style encoders' one output, the 256-dim
+speaker vector, is; it was extracted from a restored `kab_male` corpus clip on the
+filterbank the recipe trains on, 80 mel bins over n_fft 2048 and hop 300 with f_max 8 kHz.
 
 **Stage 1 (multi-speaker)** trains `text_encoder`, `style_encoder`, `decoder`, `mpd`, `msd` on both voices merged under global speaker IDs. It builds the acoustic backbone from the Kokoro base.
 

__init__.py

@@ -0,0 +1 @@
+"""Standalone `agbalu/Matoub-82M`. Staged by `tools.stage_hub`."""

config.json

@@ -0,0 +1,61 @@
+{
+  "architectures": [
+    "MatoubForTextToWaveform"
+  ],
+  "auto_map": {
+    "AutoConfig": "configuration_matoub.MatoubConfig",
+    "AutoModel": "modeling_matoub.MatoubForTextToWaveform",
+    "AutoModelForTextToWaveform": "modeling_matoub.MatoubForTextToWaveform"
+  },
+  "dropout": 0.2,
+  "dtype": "float32",
+  "gen_istft_hop_size": 5,
+  "gen_istft_n_fft": 20,
+  "hidden_size": 512,
+  "max_duration": 50,
+  "model_type": "matoub",
+  "num_layers": 3,
+  "num_mels": 80,
+  "pad_token_id": 0,
+  "plbert_hidden_size": 768,
+  "plbert_intermediate_size": 2048,
+  "plbert_max_position_embeddings": 512,
+  "plbert_num_attention_heads": 12,
+  "plbert_num_hidden_layers": 12,
+  "resblock_dilation_sizes": [
+    [
+      1,
+      3,
+      5
+    ],
+    [
+      1,
+      3,
+      5
+    ],
+    [
+      1,
+      3,
+      5
+    ]
+  ],
+  "resblock_kernel_sizes": [
+    3,
+    7,
+    11
+  ],
+  "sampling_rate": 24000,
+  "style_dim": 128,
+  "text_encoder_kernel_size": 5,
+  "transformers_version": "5.12.1",
+  "upsample_initial_channel": 512,
+  "upsample_kernel_sizes": [
+    20,
+    12
+  ],
+  "upsample_rates": [
+    10,
+    6
+  ],
+  "vocab_size": 178
+}

configuration_matoub.py

@@ -0,0 +1,71 @@
+"""Configuration for the Matoub-82M Kabyle text-to-speech model."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from transformers import PreTrainedConfig
+
+
+class MatoubConfig(PreTrainedConfig):
+    """Field names are the published `config.json`'s, which is what a release must load."""
+
+    model_type = "matoub"
+
+    def __init__(
+        self,
+        vocab_size: int = 178,
+        hidden_size: int = 512,
+        style_dim: int = 128,
+        num_layers: int = 3,
+        max_duration: int = 50,
+        dropout: float = 0.2,
+        text_encoder_kernel_size: int = 5,
+        num_mels: int = 80,
+        sampling_rate: int = 24_000,
+        plbert_hidden_size: int = 768,
+        plbert_num_attention_heads: int = 12,
+        plbert_intermediate_size: int = 2048,
+        plbert_num_hidden_layers: int = 12,
+        plbert_max_position_embeddings: int = 512,
+        upsample_rates: tuple[int, ...] = (10, 6),
+        upsample_kernel_sizes: tuple[int, ...] = (20, 12),
+        upsample_initial_channel: int = 512,
+        resblock_kernel_sizes: tuple[int, ...] = (3, 7, 11),
+        resblock_dilation_sizes: tuple[tuple[int, ...], ...] = ((1, 3, 5), (1, 3, 5), (1, 3, 5)),
+        gen_istft_n_fft: int = 20,
+        gen_istft_hop_size: int = 5,
+        **kwargs: Any,
+    ) -> None:
+        self.vocab_size = vocab_size
+        self.hidden_size = hidden_size
+        self.style_dim = style_dim
+        self.num_layers = num_layers
+        self.max_duration = max_duration
+        self.dropout = dropout
+        self.text_encoder_kernel_size = text_encoder_kernel_size
+        self.num_mels = num_mels
+        self.sampling_rate = sampling_rate
+        self.plbert_hidden_size = plbert_hidden_size
+        self.plbert_num_attention_heads = plbert_num_attention_heads
+        self.plbert_intermediate_size = plbert_intermediate_size
+        self.plbert_num_hidden_layers = plbert_num_hidden_layers
+        self.plbert_max_position_embeddings = plbert_max_position_embeddings
+        self.upsample_rates = tuple(upsample_rates)
+        self.upsample_kernel_sizes = tuple(upsample_kernel_sizes)
+        self.upsample_initial_channel = upsample_initial_channel
+        self.resblock_kernel_sizes = tuple(resblock_kernel_sizes)
+        self.resblock_dilation_sizes = tuple(tuple(d) for d in resblock_dilation_sizes)
+        self.gen_istft_n_fft = gen_istft_n_fft
+        self.gen_istft_hop_size = gen_istft_hop_size
+
+        kwargs.setdefault("pad_token_id", 0)
+        super().__init__(**kwargs)
+
+    @property
+    def max_token_length(self) -> int:
+        """Longest token sequence PL-BERT can position, less the two special slots."""
+        return self.plbert_max_position_embeddings - 2
+
+
+__all__ = ["MatoubConfig"]

export.stats.json

@@ -0,0 +1,65 @@
+{
+  "checkpoint": "artifacts/matoub/epoch_2nd_00003.pth",
+  "epoch": 3,
+  "iterations": 13944,
+  "validation_loss": 0.34749212861061096,
+  "reference": "artifacts/matoub/reference_kab_male.wav",
+  "parameters": 81731256,
+  "voice_norm": 2.0576,
+  "voice_acoustic_norm": 1.348,
+  "voice_prosodic_norm": 1.5546,
+  "checkpoint_bytes": 1929793334,
+  "weights_bytes": 326977440,
+  "files": [
+    {
+      "name": "README.md",
+      "bytes": 16374,
+      "sha256": "0db249e029aa4373bd32fb1b2b70d54b4ea7892d316d1aa6d7c5ef857e189f39"
+    },
+    {
+      "name": "__init__.py",
+      "bytes": 67,
+      "sha256": "b49eb05048f3cc003e0739a2d280902279b5e03df3462e396cf39d2f6b625225"
+    },
+    {
+      "name": "config.json",
+      "bytes": 1135,
+      "sha256": "c7baff25c6c87cc7d3433934fd7517b171c576b6a16474a1a4ca4d876d73d48c"
+    },
+    {
+      "name": "configuration_matoub.py",
+      "bytes": 2738,
+      "sha256": "af0f83806014d439ec87b816bac77a14579179a7d53c1922fe830b94a5121b15"
+    },
+    {
+      "name": "istftnet.py",
+      "bytes": 15783,
+      "sha256": "fed3f4303626dd70842e2cae3da78b3862901d97ddf59057d93839739478d7b5"
+    },
+    {
+      "name": "model.safetensors",
+      "bytes": 326977440,
+      "sha256": "9c794adca72e8997d6213ddc15688c3a93c7eef76798ee49fee0c74028615c13"
+    },
+    {
+      "name": "modeling_matoub.py",
+      "bytes": 13735,
+      "sha256": "ffa1f1656f9b08bf0f4edf323c1797f0822ce3096c6a04d9b42a3ffa06a7c233"
+    },
+    {
+      "name": "tokenization_matoub.py",
+      "bytes": 8086,
+      "sha256": "c95fdf4bd23efa649287662a0059d9053d17c8cab4fade383784e084cc422416"
+    },
+    {
+      "name": "tokenizer_config.json",
+      "bytes": 482,
+      "sha256": "52cac28b6e8d7800f9389bec00bd3d4364673ed379f4923b17c59e7b2a4e01f9"
+    },
+    {
+      "name": "vocab.json",
+      "bytes": 1419,
+      "sha256": "27eb058bd6bd8ceb403c4a0c97c4ac2a59fea9913c9a338675d6298465db73a6"
+    }
+  ]
+}

inference.py

@@ -1,487 +0,0 @@
-"""Matoub-82M — standalone inference.
-
-No agbalu package required. Requires only:
-    pip install torch torchaudio librosa soundfile huggingface_hub
-
-Usage (command line):
-    python inference.py --text "Azul fell-awen, amek i telliḍ taṣebḥit-a?" --out out.wav
-
-Usage (Python):
-    from inference import MatoubTTS
-    tts = MatoubTTS.load()
-    tts.synthesise("Azul fell-awen.", "out.wav")
-"""
-
-from __future__ import annotations
-
-import argparse
-import sys
-from collections import OrderedDict
-from pathlib import Path
-from typing import Any
-
-try:
-    import librosa
-    import numpy as np
-    import soundfile as sf
-    import torch
-    import torchaudio
-    from huggingface_hub import hf_hub_download
-except ImportError as e:
-    sys.exit(
-        f"Missing dependency: {e}\n"
-        "Install with: pip install torch torchaudio librosa soundfile huggingface_hub"
-    )
-
-REPO_ID = "agbalu/Matoub-82M"
-CHECKPOINT_FILE = "epoch_2nd_00003.pth"
-SAMPLE_RATE = 24_000
-
-# Kabyle Latin to IPA table
-_KAB_G2P: dict[str, str] = {
-    "b": "b",
-    "d": "d",
-    "g": "ɡ",
-    "k": "k",
-    "p": "p",
-    "t": "t",
-    "q": "q",
-    "f": "f",
-    "v": "v",
-    "s": "s",
-    "z": "z",
-    "x": "x",
-    "ɣ": "ɣ",
-    "ğ": "ɣ",
-    "Ɣ": "ɣ",
-    "ɛ": "ɛ",
-    "h": "h",
-    "ḥ": "ħ",
-    "ṣ": "sˤ",
-    "ẓ": "zˤ",
-    "ḍ": "dˤ",
-    "ṭ": "tˤ",
-    "ṛ": "rˤ",
-    "č": "tʃ",
-    "ǧ": "dʒ",
-    "m": "m",
-    "n": "n",
-    "l": "l",
-    "r": "r",
-    "w": "w",
-    "y": "j",
-    "a": "a",
-    "e": "ə",
-    "i": "i",
-    "u": "u",
-    "A": "a",
-    "E": "ə",
-    "I": "i",
-    "U": "u",
-}
-
-_AFFRICATE_FOLD = {"tʃ": "ʧ", "dʒ": "ʤ"}
-
-
-def _phonemize(text: str) -> str:
-    text = text.strip()
-    ipa_chars: list[str] = []
-    for c in text:
-        if c in " .,!?:;-'\"()[]/_":
-            ipa_chars.append(c)
-            continue
-        ipa_chars.append(_KAB_G2P.get(c, c))
-    ipa = "".join(ipa_chars)
-    for src, tgt in _AFFRICATE_FOLD.items():
-        ipa = ipa.replace(src, tgt)
-    return ipa
-
-
-def _add_styletts2_to_path(styletts2_dir: str | Path) -> None:
-    root = str(Path(styletts2_dir).resolve())
-    if root not in sys.path:
-        sys.path.insert(0, root)
-
-
-_VOCAB = (
-    "$",
-    "ɑ",
-    "ɐ",
-    "ɒ",
-    "æ",
-    "ə",
-    "ɚ",
-    "ʌ",
-    "ɔ",
-    "ɛ",
-    "ɜ",
-    "ɝ",
-    "ɞ",
-    "ɟ",
-    "ɡ",
-    "ɣ",
-    "ʜ",
-    "ɦ",
-    "ħ",
-    "ɨ",
-    "ɪ",
-    "ɫ",
-    "ɬ",
-    "ɭ",
-    "ɮ",
-    "ʎ",
-    "ɱ",
-    "ɯ",
-    "ɰ",
-    "ŋ",
-    "ɳ",
-    "ɲ",
-    "ɴ",
-    "ø",
-    "ɵ",
-    "ɸ",
-    "θ",
-    "œ",
-    "ɶ",
-    "ʘ",
-    "ɹ",
-    "ɺ",
-    "ɾ",
-    "ɻ",
-    "ʀ",
-    "ʁ",
-    "ɽ",
-    "ʂ",
-    "ʃ",
-    "ʈ",
-    "ʧ",
-    "ʉ",
-    "ʊ",
-    "ʋ",
-    "ⱱ",
-    "ʌ",
-    "ɣ",
-    "ʍ",
-    "χ",
-    "ʎ",
-    "ʏ",
-    "ʑ",
-    "ʐ",
-    "ʒ",
-    "ʔ",
-    "ʡ",
-    "ʕ",
-    "ʢ",
-    "ǀ",
-    "ǁ",
-    "ǂ",
-    "ǃ",
-    "ˈ",
-    "ˌ",
-    "ː",
-    "ˑ",
-    "ʼ",
-    "ʴ",
-    "ʰ",
-    "ʱ",
-    "ʲ",
-    "ʷ",
-    "ʸ",
-    "˞",
-    "↓",
-    "↑",
-    "→",
-    "↗",
-    "↘",
-    "'",
-    '"',
-    "ˆ",
-    "ˋ",
-    " ",
-    "q",
-    "ʤ",
-    "ħ",
-    "a",
-    "b",
-    "d",
-    "e",
-    "f",
-    "h",
-    "i",
-    "j",
-    "k",
-    "l",
-    "m",
-    "n",
-    "p",
-    "r",
-    "s",
-    "t",
-    "u",
-    "v",
-    "w",
-    "x",
-    "y",
-    "z",
-    "ɛ",
-    "ɡ",
-    "dˤ",
-    "tˤ",
-    "sˤ",
-    "zˤ",
-    "rˤ",
-)
-
-_SYM_TO_IDX: dict[str, int] = {s: i for i, s in enumerate(_VOCAB)}
-
-
-def _ipa_to_tokens(ipa: str) -> list[int]:
-    ids = [0]
-    for ch in ipa:
-        idx = _SYM_TO_IDX.get(ch)
-        if idx is not None:
-            ids.append(idx)
-    return ids
-
-
-class MatoubTTS:
-    def __init__(
-        self,
-        model: dict[str, Any],
-        model_params: Any,
-        ref_style: torch.Tensor,
-        sampler: Any,
-        device: torch.device,
-        alpha: float = 0.0,
-        beta: float = 0.0,
-        diffusion_steps: int = 10,
-        embedding_scale: float = 1.0,
-    ) -> None:
-        self.model = model
-        self.model_params = model_params
-        self.ref_style = ref_style
-        self.sampler = sampler
-        self.device = device
-        self.alpha = alpha
-        self.beta = beta
-        self.diffusion_steps = diffusion_steps
-        self.embedding_scale = embedding_scale
-
-    @classmethod
-    def load(
-        cls,
-        checkpoint: str | Path | None = None,
-        reference_wav: str | Path | None = None,
-        styletts2_dir: str | Path = ".",
-        alpha: float = 0.0,
-        beta: float = 0.0,
-        diffusion_steps: int = 10,
-        embedding_scale: float = 1.0,
-        device: str | None = None,
-    ) -> MatoubTTS:
-        _add_styletts2_to_path(styletts2_dir)
-
-        torch_device = torch.device(
-            device if device else ("cuda" if torch.cuda.is_available() else "cpu")
-        )
-
-        if checkpoint is None:
-            checkpoint = hf_hub_download(repo_id=REPO_ID, filename=CHECKPOINT_FILE)
-        ckpt_path = Path(checkpoint)
-
-        import yaml
-
-        config_candidates = [
-            ckpt_path.parent / "config_stage2_kab_male.yml",
-            ckpt_path.parent / "config_stage2.yml",
-            ckpt_path.parent / "config.yml",
-            Path(styletts2_dir) / "Configs" / "config_ft.yml",
-            Path(styletts2_dir) / "Configs" / "config.yml",
-        ]
-        config_file = next((c for c in config_candidates if c.is_file()), None)
-        if config_file is None:
-            message = (
-                "No config YAML found. Pass the StyleTTS2 repository path as "
-                "`styletts2_dir`, or place a config.yml next to the checkpoint."
-            )
-            raise RuntimeError(message)
-        config = yaml.safe_load(config_file.read_text(encoding="utf-8"))
-
-        from models import build_model, load_ASR_models, load_F0_models
-        from utils import recursive_munch
-        from Utils.PLBERT.util import load_plbert
-
-        styletts2 = Path(styletts2_dir)
-        text_aligner = load_ASR_models(
-            str(styletts2 / "Utils" / "ASR" / "epoch_00080.pth"),
-            str(styletts2 / "Utils" / "ASR" / "config.yml"),
-        )
-        pitch_extractor = load_F0_models(str(styletts2 / "Utils" / "JDC" / "bst.t7"))
-        plbert = load_plbert(str(styletts2 / "Utils" / "PLBERT"))
-
-        model_params = recursive_munch(config.get("model_params", {}))
-        model = build_model(model_params, text_aligner, pitch_extractor, plbert)
-        for module in model.values():
-            if isinstance(module, torch.nn.Module):
-                module.to(torch_device).eval()
-
-        state = torch.load(ckpt_path, map_location=torch_device, weights_only=False)
-        net = state.get("net", state)
-        for key in model:
-            if key in net and hasattr(model[key], "load_state_dict"):
-                try:
-                    model[key].load_state_dict(net[key])
-                except Exception:
-                    sd = OrderedDict(
-                        (k[7:] if k.startswith("module.") else k, v) for k, v in net[key].items()
-                    )
-                    model[key].load_state_dict(sd, strict=False)
-
-        if reference_wav is None:
-            reference_wav = hf_hub_download(repo_id=REPO_ID, filename="reference_kab_male.wav")
-        ref_path = Path(reference_wav)
-
-        wave, sr = librosa.load(str(ref_path), sr=SAMPLE_RATE)
-        audio_trimmed, _ = librosa.effects.trim(wave, top_db=30)
-        if sr != SAMPLE_RATE:
-            audio_trimmed = librosa.resample(audio_trimmed, orig_sr=sr, target_sr=SAMPLE_RATE)
-
-        to_mel = torchaudio.transforms.MelSpectrogram(
-            n_fft=2048,
-            win_length=1200,
-            hop_length=300,
-            n_mels=80,
-            f_min=0,
-            f_max=8000,
-        )
-        mel = to_mel(torch.from_numpy(audio_trimmed).float().unsqueeze(0))
-        mel = (torch.log(1e-5 + mel) - (-4)) / 4
-        mel = mel.to(torch_device)
-
-        with torch.no_grad():
-            ref_s = model["style_encoder"](mel.unsqueeze(1))
-            ref_p = model["predictor_encoder"](mel.unsqueeze(1))
-            ref_style = torch.cat([ref_s, ref_p], dim=1)
-
-        from Modules.diffusion.sampler import ADPM2Sampler, DiffusionSampler, KarrasSchedule
-
-        sampler = DiffusionSampler(
-            model["diffusion"].diffusion,
-            sampler=ADPM2Sampler(),
-            sigma_schedule=KarrasSchedule(sigma_min=0.0001, sigma_max=3.0, rho=9.0),
-            clamp=False,
-        )
-
-        return cls(
-            model=model,
-            model_params=model_params,
-            ref_style=ref_style,
-            sampler=sampler,
-            device=torch_device,
-            alpha=alpha,
-            beta=beta,
-            diffusion_steps=diffusion_steps,
-            embedding_scale=embedding_scale,
-        )
-
-    def synthesise(self, text: str, output_path: str | Path = "output.wav") -> Path:
-        from utils import length_to_mask
-
-        ipa = _phonemize(text)
-        token_ids = _ipa_to_tokens(ipa)
-        tokens = torch.LongTensor([token_ids]).to(self.device)
-
-        with torch.no_grad():
-            input_lengths = torch.LongTensor([tokens.shape[-1]]).to(self.device)
-            text_mask = length_to_mask(input_lengths).to(self.device)
-
-            t_en = self.model["text_encoder"](tokens, input_lengths, text_mask)
-            bert_dur = self.model["bert"](tokens, attention_mask=(~text_mask).int())
-            d_en = self.model["bert_encoder"](bert_dur).transpose(-1, -2)
-
-            s_pred = self.sampler(
-                noise=torch.randn((1, 256)).unsqueeze(1).to(self.device),
-                embedding=bert_dur,
-                embedding_scale=self.embedding_scale,
-                features=self.ref_style,
-                num_steps=self.diffusion_steps,
-            ).squeeze(1)
-
-            ref = self.alpha * s_pred[:, :128] + (1 - self.alpha) * self.ref_style[:, :128]
-            s = self.beta * s_pred[:, 128:] + (1 - self.beta) * self.ref_style[:, 128:]
-
-            d = self.model["predictor"].text_encoder(d_en, s, input_lengths, text_mask)
-            x, _ = self.model["predictor"].lstm(d)
-            duration = torch.sigmoid(self.model["predictor"].duration_proj(x)).sum(axis=-1)
-            pred_dur = torch.round(duration.squeeze()).clamp(min=1)
-            if pred_dur.dim() == 0:
-                pred_dur = pred_dur.unsqueeze(0)
-            pred_dur[-1] += 5
-
-            n_tokens = int(input_lengths.item())
-            n_frames = int(pred_dur.sum().item())
-            pred_aln_trg = torch.zeros(n_tokens, n_frames)
-            c = 0
-            for i in range(n_tokens):
-                di = int(pred_dur[i].item())
-                pred_aln_trg[i, c : c + di] = 1
-                c += di
-            pred_aln_trg = pred_aln_trg.unsqueeze(0).to(self.device)
-
-            en = d.transpose(-1, -2) @ pred_aln_trg
-            if self.model_params.decoder.type == "hifigan":
-                asr_new = torch.zeros_like(en)
-                asr_new[:, :, 0] = en[:, :, 0]
-                asr_new[:, :, 1:] = en[:, :, 0:-1]
-                en = asr_new
-
-            F0_pred, N_pred = self.model["predictor"].F0Ntrain(en, s)
-
-            asr = t_en @ pred_aln_trg
-            if self.model_params.decoder.type == "hifigan":
-                asr_new = torch.zeros_like(asr)
-                asr_new[:, :, 0] = asr[:, :, 0]
-                asr_new[:, :, 1:] = asr[:, :, 0:-1]
-                asr = asr_new
-
-            out = self.model["decoder"](asr, F0_pred, N_pred, ref.squeeze().unsqueeze(0))
-            audio = out.squeeze().cpu().numpy()[..., :-50]
-
-        max_val = np.abs(audio).max()
-        if max_val > 0:
-            audio = (audio / max_val) * 0.95
-
-        out_path = Path(output_path)
-        out_path.parent.mkdir(parents=True, exist_ok=True)
-        sf.write(str(out_path), audio, SAMPLE_RATE)
-        return out_path
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Matoub-82M Kabyle TTS")
-    parser.add_argument("--text", required=True, help="Kabyle text to synthesise")
-    parser.add_argument("--out", default="output.wav", help="Output WAV path")
-    parser.add_argument("--checkpoint", default=None, help="Path to epoch_2nd_00003.pth")
-    parser.add_argument("--reference", default=None, help="Reference speaker WAV (24 kHz)")
-    parser.add_argument("--styletts2", default=".", help="StyleTTS2 repo root directory")
-    parser.add_argument("--alpha", type=float, default=0.0, help="Acoustic style blend")
-    parser.add_argument("--beta", type=float, default=0.0, help="Prosodic style blend")
-    parser.add_argument("--steps", type=int, default=10, help="Diffusion steps")
-    parser.add_argument("--device", default=None, help="cuda / cpu")
-    args = parser.parse_args()
-
-    tts = MatoubTTS.load(
-        checkpoint=args.checkpoint,
-        reference_wav=args.reference,
-        styletts2_dir=args.styletts2,
-        alpha=args.alpha,
-        beta=args.beta,
-        diffusion_steps=args.steps,
-        device=args.device,
-    )
-    out = tts.synthesise(args.text, args.out)
-    print(f"Written: {out}")
-
-
-if __name__ == "__main__":
-    main()

istftnet.py

@@ -0,0 +1,416 @@
+"""The iSTFTNet decoder Matoub-82M inherits from Kokoro-82M.
+
+Adapted from `hexgrad/Kokoro-82M`'s `istftnet.py` (Apache-2.0), itself adapted from
+StyleTTS2's `Modules/istftnet.py` (MIT). Module attribute names are the published
+checkpoint's `state_dict` keys; renaming one breaks `from_pretrained` for everybody who
+downloaded the release.
+
+Two deliberate departures from both upstreams. Weight normalisation is fused into the
+weight by the exporter, so the convolutions here are plain — a released model has no
+parametrisation to re-derive. And `InstanceNorm1d` is built without affine parameters, as
+the training code had it: Kokoro turns them on to work around an ONNX export bug, which
+adds tensors this checkpoint does not carry.
+
+The harmonic source draws noise and an initial phase from the global RNG, so two calls on
+the same text return different samples. That is inherited from HN-NSF, not a defect.
+"""
+
+from __future__ import annotations
+
+import math
+
+import torch
+from torch import Tensor, nn
+from torch.nn import functional as F  # noqa: N812
+
+
+def _padding(kernel_size: int, dilation: int = 1) -> int:
+    return (kernel_size * dilation - dilation) // 2
+
+
+class AdaIN1d(nn.Module):
+    """Instance norm whose scale and shift are read off the style vector."""
+
+    def __init__(self, style_dim: int, num_features: int) -> None:
+        super().__init__()
+        self.norm = nn.InstanceNorm1d(num_features, affine=False)
+        self.fc = nn.Linear(style_dim, num_features * 2)
+
+    def forward(self, x: Tensor, s: Tensor) -> Tensor:
+        h = self.fc(s).unsqueeze(-1)
+        gamma, beta = torch.chunk(h, chunks=2, dim=1)
+        normalised: Tensor = self.norm(x)
+        return (1 + gamma) * normalised + beta
+
+
+class AdaINResBlock1(nn.Module):
+    """HiFi-GAN's residual block with AdaIN conditioning and a Snake nonlinearity."""
+
+    def __init__(
+        self,
+        channels: int,
+        kernel_size: int = 3,
+        dilation: tuple[int, ...] = (1, 3, 5),
+        style_dim: int = 64,
+    ) -> None:
+        super().__init__()
+        self.convs1 = nn.ModuleList(
+            [
+                nn.Conv1d(
+                    channels,
+                    channels,
+                    kernel_size,
+                    1,
+                    dilation=d,
+                    padding=_padding(kernel_size, d),
+                )
+                for d in dilation
+            ]
+        )
+        self.convs2 = nn.ModuleList(
+            [
+                nn.Conv1d(
+                    channels, channels, kernel_size, 1, dilation=1, padding=_padding(kernel_size)
+                )
+                for _ in dilation
+            ]
+        )
+        self.adain1 = nn.ModuleList([AdaIN1d(style_dim, channels) for _ in dilation])
+        self.adain2 = nn.ModuleList([AdaIN1d(style_dim, channels) for _ in dilation])
+        self.alpha1 = nn.ParameterList([nn.Parameter(torch.ones(1, channels, 1)) for _ in dilation])
+        self.alpha2 = nn.ParameterList([nn.Parameter(torch.ones(1, channels, 1)) for _ in dilation])
+
+    def forward(self, x: Tensor, s: Tensor) -> Tensor:
+        blocks = zip(
+            self.convs1,
+            self.convs2,
+            self.adain1,
+            self.adain2,
+            self.alpha1,
+            self.alpha2,
+            strict=True,
+        )
+        for conv1, conv2, norm1, norm2, alpha1, alpha2 in blocks:
+            xt = norm1(x, s)
+            xt = xt + (1 / alpha1) * (torch.sin(alpha1 * xt) ** 2)
+            xt = conv1(xt)
+            xt = norm2(xt, s)
+            xt = xt + (1 / alpha2) * (torch.sin(alpha2 * xt) ** 2)
+            x = conv2(xt) + x
+        return x
+
+
+class TorchSTFT(nn.Module):
+    """The short-time transform the generator inverts to reach the waveform."""
+
+    def __init__(self, filter_length: int, hop_length: int, win_length: int) -> None:
+        super().__init__()
+        self.filter_length = filter_length
+        self.hop_length = hop_length
+        self.win_length = win_length
+
+    def _window(self, like: Tensor) -> Tensor:
+        # Built per call rather than held: it is twenty derived floats, it is deliberately
+        # absent from the checkpoint, and anything allocated in `__init__` is allocated on
+        # the meta device that `from_pretrained` constructs the model under.
+        return torch.hann_window(
+            self.win_length, periodic=True, dtype=torch.float32, device=like.device
+        )
+
+    def transform(self, waveform: Tensor) -> tuple[Tensor, Tensor]:
+        spectrum = torch.stft(
+            waveform,
+            self.filter_length,
+            self.hop_length,
+            self.win_length,
+            window=self._window(waveform),
+            return_complex=True,
+        )
+        return torch.abs(spectrum), torch.angle(spectrum)
+
+    def inverse(self, magnitude: Tensor, phase: Tensor) -> Tensor:
+        waveform = torch.istft(
+            magnitude * torch.exp(phase * 1j),
+            self.filter_length,
+            self.hop_length,
+            self.win_length,
+            window=self._window(magnitude),
+        )
+        return waveform.unsqueeze(-2)
+
+
+class SineGen(nn.Module):
+    """Harmonic excitation for the F0 contour, one sine per overtone."""
+
+    def __init__(
+        self,
+        sampling_rate: int,
+        upsample_scale: int,
+        harmonic_num: int = 0,
+        sine_amp: float = 0.1,
+        noise_std: float = 0.003,
+        voiced_threshold: float = 0.0,
+    ) -> None:
+        super().__init__()
+        self.sampling_rate = sampling_rate
+        self.upsample_scale = upsample_scale
+        self.harmonic_num = harmonic_num
+        self.dim = harmonic_num + 1
+        self.sine_amp = sine_amp
+        self.noise_std = noise_std
+        self.voiced_threshold = voiced_threshold
+
+    def _sine(self, f0_values: Tensor) -> Tensor:
+        radians = (f0_values / self.sampling_rate) % 1
+        initial_phase = torch.rand(f0_values.shape[0], f0_values.shape[2], device=f0_values.device)
+        initial_phase[:, 0] = 0
+        radians[:, 0, :] = radians[:, 0, :] + initial_phase
+        radians = F.interpolate(
+            radians.transpose(1, 2), scale_factor=1 / self.upsample_scale, mode="linear"
+        ).transpose(1, 2)
+        phase = torch.cumsum(radians, dim=1) * 2 * torch.pi
+        phase = F.interpolate(
+            phase.transpose(1, 2) * self.upsample_scale,
+            scale_factor=self.upsample_scale,
+            mode="linear",
+        ).transpose(1, 2)
+        return torch.sin(phase)
+
+    def forward(self, f0: Tensor) -> tuple[Tensor, Tensor]:
+        overtones = torch.arange(1, self.harmonic_num + 2, device=f0.device, dtype=f0.dtype)
+        sine_waves = self._sine(f0 * overtones) * self.sine_amp
+        voiced = (f0 > self.voiced_threshold).to(f0.dtype)
+        noise_amplitude = voiced * self.noise_std + (1 - voiced) * self.sine_amp / 3
+        noise = noise_amplitude * torch.randn_like(sine_waves)
+        return sine_waves * voiced + noise, voiced
+
+
+class SourceModuleHnNSF(nn.Module):
+    """Harmonic-plus-noise source, merged to one excitation channel."""
+
+    def __init__(
+        self,
+        sampling_rate: int,
+        upsample_scale: int,
+        harmonic_num: int = 0,
+        sine_amp: float = 0.1,
+        add_noise_std: float = 0.003,
+        voiced_threshold: float = 0.0,
+    ) -> None:
+        super().__init__()
+        self.sine_amp = sine_amp
+        self.noise_std = add_noise_std
+        self.l_sin_gen = SineGen(
+            sampling_rate, upsample_scale, harmonic_num, sine_amp, add_noise_std, voiced_threshold
+        )
+        self.l_linear = nn.Linear(harmonic_num + 1, 1)
+        self.l_tanh = nn.Tanh()
+
+    def forward(self, f0: Tensor) -> Tensor:
+        with torch.no_grad():
+            sine_waves, _ = self.l_sin_gen(f0)
+        merged: Tensor = self.l_tanh(self.l_linear(sine_waves))
+        return merged
+
+
+class Generator(nn.Module):
+    """Upsampling stack ending in an inverse short-time transform."""
+
+    def __init__(
+        self,
+        style_dim: int,
+        resblock_kernel_sizes: tuple[int, ...],
+        upsample_rates: tuple[int, ...],
+        upsample_initial_channel: int,
+        resblock_dilation_sizes: tuple[tuple[int, ...], ...],
+        upsample_kernel_sizes: tuple[int, ...],
+        gen_istft_n_fft: int,
+        gen_istft_hop_size: int,
+        sampling_rate: int,
+    ) -> None:
+        super().__init__()
+        self.num_kernels = len(resblock_kernel_sizes)
+        self.num_upsamples = len(upsample_rates)
+        scale = math.prod(upsample_rates) * gen_istft_hop_size
+        self.m_source = SourceModuleHnNSF(
+            sampling_rate=sampling_rate,
+            upsample_scale=scale,
+            harmonic_num=8,
+            voiced_threshold=10,
+        )
+        self.f0_upsamp = nn.Upsample(scale_factor=scale)
+        self.ups = nn.ModuleList(
+            [
+                nn.ConvTranspose1d(
+                    upsample_initial_channel // (2**i),
+                    upsample_initial_channel // (2 ** (i + 1)),
+                    k,
+                    u,
+                    padding=(k - u) // 2,
+                )
+                for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes, strict=True))
+            ]
+        )
+        self.resblocks = nn.ModuleList()
+        self.noise_convs = nn.ModuleList()
+        self.noise_res = nn.ModuleList()
+        channels = upsample_initial_channel
+        for i in range(len(self.ups)):
+            channels = upsample_initial_channel // (2 ** (i + 1))
+            shapes = zip(resblock_kernel_sizes, resblock_dilation_sizes, strict=True)
+            for kernel, dilation in shapes:
+                self.resblocks.append(AdaINResBlock1(channels, kernel, dilation, style_dim))
+            if i + 1 < len(upsample_rates):
+                stride = math.prod(upsample_rates[i + 1 :])
+                self.noise_convs.append(
+                    nn.Conv1d(
+                        gen_istft_n_fft + 2,
+                        channels,
+                        kernel_size=stride * 2,
+                        stride=stride,
+                        padding=(stride + 1) // 2,
+                    )
+                )
+                self.noise_res.append(AdaINResBlock1(channels, 7, (1, 3, 5), style_dim))
+            else:
+                self.noise_convs.append(nn.Conv1d(gen_istft_n_fft + 2, channels, kernel_size=1))
+                self.noise_res.append(AdaINResBlock1(channels, 11, (1, 3, 5), style_dim))
+        self.post_n_fft = gen_istft_n_fft
+        self.conv_post = nn.Conv1d(channels, self.post_n_fft + 2, 7, 1, padding=3)
+        self.reflection_pad = nn.ReflectionPad1d((1, 0))
+        self.stft = TorchSTFT(
+            filter_length=gen_istft_n_fft,
+            hop_length=gen_istft_hop_size,
+            win_length=gen_istft_n_fft,
+        )
+
+    def forward(self, x: Tensor, s: Tensor, f0_curve: Tensor) -> Tensor:
+        with torch.no_grad():
+            f0 = self.f0_upsamp(f0_curve[:, None]).transpose(1, 2)
+            harmonic = self.m_source(f0).transpose(1, 2).squeeze(1)
+            magnitude, phase = self.stft.transform(harmonic)
+            source = torch.cat([magnitude, phase], dim=1)
+
+        for i in range(self.num_upsamples):
+            x = F.leaky_relu(x, negative_slope=0.1)
+            excitation = self.noise_res[i](self.noise_convs[i](source), s)
+            x = self.ups[i](x)
+            if i == self.num_upsamples - 1:
+                x = self.reflection_pad(x)
+            x = x + excitation
+            stacked = self.resblocks[i * self.num_kernels](x, s)
+            for j in range(1, self.num_kernels):
+                stacked = stacked + self.resblocks[i * self.num_kernels + j](x, s)
+            x = stacked / self.num_kernels
+
+        x = self.conv_post(F.leaky_relu(x))
+        spectrum = torch.exp(x[:, : self.post_n_fft // 2 + 1, :])
+        phase = torch.sin(x[:, self.post_n_fft // 2 + 1 :, :])
+        return self.stft.inverse(spectrum, phase)
+
+
+class AdainResBlk1d(nn.Module):
+    """The decoder's conditioning block, optionally doubling the frame rate."""
+
+    def __init__(
+        self,
+        dim_in: int,
+        dim_out: int,
+        style_dim: int = 64,
+        *,
+        upsample: bool = False,
+    ) -> None:
+        super().__init__()
+        self.actv = nn.LeakyReLU(0.2)
+        self.upsample_type = "timepreserve" if upsample else "none"
+        self.learned_sc = dim_in != dim_out
+        self.conv1 = nn.Conv1d(dim_in, dim_out, 3, 1, 1)
+        self.conv2 = nn.Conv1d(dim_out, dim_out, 3, 1, 1)
+        self.norm1 = AdaIN1d(style_dim, dim_in)
+        self.norm2 = AdaIN1d(style_dim, dim_out)
+        if self.learned_sc:
+            self.conv1x1 = nn.Conv1d(dim_in, dim_out, 1, 1, 0, bias=False)
+        if upsample:
+            self.pool: nn.Module = nn.ConvTranspose1d(
+                dim_in, dim_in, kernel_size=3, stride=2, groups=dim_in, padding=1, output_padding=1
+            )
+        else:
+            self.pool = nn.Identity()
+
+    def _shortcut(self, x: Tensor) -> Tensor:
+        if self.upsample_type != "none":
+            x = F.interpolate(x, scale_factor=2, mode="nearest")
+        if not self.learned_sc:
+            return x
+        projected: Tensor = self.conv1x1(x)
+        return projected
+
+    def _residual(self, x: Tensor, s: Tensor) -> Tensor:
+        x = self.conv1(self.pool(self.actv(self.norm1(x, s))))
+        out: Tensor = self.conv2(self.actv(self.norm2(x, s)))
+        return out
+
+    def forward(self, x: Tensor, s: Tensor) -> Tensor:
+        combined: Tensor = self._residual(x, s) + self._shortcut(x)
+        scaled: Tensor = combined * (2.0**-0.5)
+        return scaled
+
+
+class Decoder(nn.Module):
+    """Aligned text features, pitch and energy to a 24 kHz waveform."""
+
+    def __init__(
+        self,
+        dim_in: int,
+        style_dim: int,
+        resblock_kernel_sizes: tuple[int, ...],
+        upsample_rates: tuple[int, ...],
+        upsample_initial_channel: int,
+        resblock_dilation_sizes: tuple[tuple[int, ...], ...],
+        upsample_kernel_sizes: tuple[int, ...],
+        gen_istft_n_fft: int,
+        gen_istft_hop_size: int,
+        sampling_rate: int,
+    ) -> None:
+        super().__init__()
+        self.encode = AdainResBlk1d(dim_in + 2, 1024, style_dim)
+        self.decode = nn.ModuleList(
+            [
+                AdainResBlk1d(1024 + 2 + 64, 1024, style_dim),
+                AdainResBlk1d(1024 + 2 + 64, 1024, style_dim),
+                AdainResBlk1d(1024 + 2 + 64, 1024, style_dim),
+                AdainResBlk1d(1024 + 2 + 64, 512, style_dim, upsample=True),
+            ]
+        )
+        self.F0_conv = nn.Conv1d(1, 1, kernel_size=3, stride=2, groups=1, padding=1)
+        self.N_conv = nn.Conv1d(1, 1, kernel_size=3, stride=2, groups=1, padding=1)
+        self.asr_res = nn.Sequential(nn.Conv1d(512, 64, kernel_size=1))
+        self.generator = Generator(
+            style_dim,
+            resblock_kernel_sizes,
+            upsample_rates,
+            upsample_initial_channel,
+            resblock_dilation_sizes,
+            upsample_kernel_sizes,
+            gen_istft_n_fft,
+            gen_istft_hop_size,
+            sampling_rate,
+        )
+
+    def forward(self, asr: Tensor, pitch: Tensor, energy: Tensor, s: Tensor) -> Tensor:
+        f0 = self.F0_conv(pitch.unsqueeze(1))
+        n = self.N_conv(energy.unsqueeze(1))
+        x = self.encode(torch.cat([asr, f0, n], dim=1), s)
+        residual = self.asr_res(asr)
+        carry = True
+        for block in self.decode:
+            if carry:
+                x = torch.cat([x, residual, f0, n], dim=1)
+            x = block(x, s)
+            if block.upsample_type != "none":
+                carry = False
+        waveform: Tensor = self.generator(x, s, pitch)
+        return waveform
+
+
+__all__ = ["AdaIN1d", "AdainResBlk1d", "Decoder"]

epoch_2nd_00003.pth → model.safetensors

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:4c7cda21df9b39b6ef5a5acf39be3568c5fe31231564ebbc99c837ac2909aeaa
-size 1929793334
+oid sha256:9c794adca72e8997d6213ddc15688c3a93c7eef76798ee49fee0c74028615c13
+size 326977440

modeling_matoub.py

@@ -0,0 +1,342 @@
+"""Matoub-82M: Kabyle text to a 24 kHz waveform.
+
+A StyleTTS2 model fine-tuned from Kokoro-82M. The text and prosody modules are adapted
+from `hexgrad/Kokoro-82M`'s `modules.py` (Apache-2.0), itself adapted from StyleTTS2's
+`models.py` (MIT). Module attribute names are the published checkpoint's `state_dict`
+keys; renaming one breaks `from_pretrained` for everybody who downloaded the release.
+
+The speaker style is a 256-dim vector carried in the weights, so synthesis needs no
+reference clip: the first 128 dimensions condition the waveform decoder and the second
+128 condition duration and pitch. Style diffusion is not part of this checkpoint —
+`lambda_diff` was 0.0 for every epoch — so there is no sampler to blend against and no
+`alpha`/`beta` to set.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final
+
+import torch
+from torch import Tensor, nn
+from transformers import AlbertConfig, AlbertModel, PreTrainedModel
+from transformers.utils.generic import ModelOutput
+
+from .configuration_matoub import MatoubConfig
+from .istftnet import AdainResBlk1d, Decoder
+
+BATCHED_SEQUENCE_RANK: Final = 2
+
+
+@dataclass
+class MatoubOutput(ModelOutput):
+    """Synthesised audio, and the frame count each input token was given.
+
+    `waveform` is right-padded to the longest item in the batch; `waveform_lengths` says
+    where each one ends.
+    """
+
+    waveform: Tensor | None = None
+    waveform_lengths: Tensor | None = None
+    durations: Tensor | None = None
+
+
+class LayerNorm(nn.Module):
+    """Channel-last layer norm over a (batch, channels, time) tensor."""
+
+    def __init__(self, channels: int, eps: float = 1e-5) -> None:
+        super().__init__()
+        self.channels = channels
+        self.eps = eps
+        self.gamma = nn.Parameter(torch.ones(channels))
+        self.beta = nn.Parameter(torch.zeros(channels))
+
+    def forward(self, x: Tensor) -> Tensor:
+        x = x.transpose(1, -1)
+        x = nn.functional.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
+        return x.transpose(1, -1)
+
+
+class LinearNorm(nn.Module):
+    """A linear layer under the attribute name the checkpoint stores it by."""
+
+    def __init__(self, in_dim: int, out_dim: int) -> None:
+        super().__init__()
+        self.linear_layer = nn.Linear(in_dim, out_dim)
+
+    def forward(self, x: Tensor) -> Tensor:
+        projected: Tensor = self.linear_layer(x)
+        return projected
+
+
+class TextEncoder(nn.Module):
+    """Phoneme ids to the acoustic features the decoder reads."""
+
+    def __init__(self, channels: int, kernel_size: int, depth: int, n_symbols: int) -> None:
+        super().__init__()
+        self.embedding = nn.Embedding(n_symbols, channels)
+        padding = (kernel_size - 1) // 2
+        self.cnn = nn.ModuleList(
+            [
+                nn.Sequential(
+                    nn.Conv1d(channels, channels, kernel_size=kernel_size, padding=padding),
+                    LayerNorm(channels),
+                    nn.LeakyReLU(0.2),
+                    nn.Dropout(0.2),
+                )
+                for _ in range(depth)
+            ]
+        )
+        self.lstm = nn.LSTM(channels, channels // 2, 1, batch_first=True, bidirectional=True)
+
+    def forward(self, input_ids: Tensor) -> Tensor:
+        x = self.embedding(input_ids).transpose(1, 2)
+        for block in self.cnn:
+            x = block(x)
+        encoded: Tensor
+        encoded, _ = self.lstm(x.transpose(1, 2))
+        return encoded.transpose(-1, -2)
+
+
+class AdaLayerNorm(nn.Module):
+    """Layer norm whose scale and shift are read off the style vector."""
+
+    def __init__(self, style_dim: int, channels: int, eps: float = 1e-5) -> None:
+        super().__init__()
+        self.channels = channels
+        self.eps = eps
+        self.fc = nn.Linear(style_dim, channels * 2)
+
+    def forward(self, x: Tensor, s: Tensor) -> Tensor:
+        x = x.transpose(-1, -2).transpose(1, -1)
+        h = self.fc(s).view(s.size(0), -1, 1)
+        gamma, beta = torch.chunk(h, chunks=2, dim=1)
+        gamma, beta = gamma.transpose(1, -1), beta.transpose(1, -1)
+        x = nn.functional.layer_norm(x, (self.channels,), eps=self.eps)
+        x = (1 + gamma) * x + beta
+        return x.transpose(1, -1).transpose(-1, -2)
+
+
+class DurationEncoder(nn.Module):
+    """Style-conditioned recurrent stack the duration head reads."""
+
+    def __init__(self, sty_dim: int, d_model: int, nlayers: int, dropout: float) -> None:
+        super().__init__()
+        self.lstms = nn.ModuleList()
+        for _ in range(nlayers):
+            self.lstms.append(
+                nn.LSTM(
+                    d_model + sty_dim,
+                    d_model // 2,
+                    num_layers=1,
+                    batch_first=True,
+                    bidirectional=True,
+                )
+            )
+            self.lstms.append(AdaLayerNorm(sty_dim, d_model))
+
+    def forward(self, x: Tensor, style: Tensor) -> Tensor:
+        x = x.permute(2, 0, 1)
+        s = style.expand(x.shape[0], x.shape[1], -1)
+        x = torch.cat([x, s], dim=-1).transpose(0, 1).transpose(-1, -2)
+        for block in self.lstms:
+            if isinstance(block, AdaLayerNorm):
+                x = block(x.transpose(-1, -2), style).transpose(-1, -2)
+                x = torch.cat([x, s.permute(1, 2, 0)], dim=1)
+            else:
+                x, _ = block(x.transpose(-1, -2))
+                x = x.transpose(-1, -2)
+        return x.transpose(-1, -2)
+
+
+class ProsodyPredictor(nn.Module):
+    """Per-token duration, and the pitch and energy contours over the expanded frames."""
+
+    def __init__(
+        self, style_dim: int, d_hid: int, nlayers: int, max_dur: int, dropout: float
+    ) -> None:
+        super().__init__()
+        self.text_encoder = DurationEncoder(
+            sty_dim=style_dim, d_model=d_hid, nlayers=nlayers, dropout=dropout
+        )
+        self.lstm = nn.LSTM(d_hid + style_dim, d_hid // 2, 1, batch_first=True, bidirectional=True)
+        self.duration_proj = LinearNorm(d_hid, max_dur)
+        self.shared = nn.LSTM(
+            d_hid + style_dim, d_hid // 2, 1, batch_first=True, bidirectional=True
+        )
+        self.F0 = nn.ModuleList(
+            [
+                AdainResBlk1d(d_hid, d_hid, style_dim),
+                AdainResBlk1d(d_hid, d_hid // 2, style_dim, upsample=True),
+                AdainResBlk1d(d_hid // 2, d_hid // 2, style_dim),
+            ]
+        )
+        self.N = nn.ModuleList(
+            [
+                AdainResBlk1d(d_hid, d_hid, style_dim),
+                AdainResBlk1d(d_hid, d_hid // 2, style_dim, upsample=True),
+                AdainResBlk1d(d_hid // 2, d_hid // 2, style_dim),
+            ]
+        )
+        self.F0_proj = nn.Conv1d(d_hid // 2, 1, 1, 1, 0)
+        self.N_proj = nn.Conv1d(d_hid // 2, 1, 1, 1, 0)
+
+    def contours(self, aligned: Tensor, s: Tensor) -> tuple[Tensor, Tensor]:
+        x, _ = self.shared(aligned.transpose(-1, -2))
+        pitch = x.transpose(-1, -2)
+        for block in self.F0:
+            pitch = block(pitch, s)
+        energy = x.transpose(-1, -2)
+        for block in self.N:
+            energy = block(energy, s)
+        return self.F0_proj(pitch).squeeze(1), self.N_proj(energy).squeeze(1)
+
+
+class MatoubPreTrainedModel(PreTrainedModel):
+    config_class = MatoubConfig
+    base_model_prefix = "matoub"
+    main_input_name = "input_ids"
+
+    def _init_weights(self, module: nn.Module) -> None:
+        if isinstance(module, nn.Linear | nn.Conv1d | nn.ConvTranspose1d):
+            module.weight.data.normal_(mean=0.0, std=0.01)
+            if module.bias is not None:
+                module.bias.data.zero_()
+        elif isinstance(module, nn.Embedding):
+            module.weight.data.normal_(mean=0.0, std=0.02)
+
+
+class MatoubForTextToWaveform(MatoubPreTrainedModel):
+    """`model(**tokenizer(text, return_tensors="pt")).waveform` — 24 kHz mono float32."""
+
+    voice: Tensor
+
+    def __init__(self, config: MatoubConfig) -> None:
+        super().__init__(config)
+        self.bert = AlbertModel(
+            AlbertConfig(
+                vocab_size=config.vocab_size,
+                hidden_size=config.plbert_hidden_size,
+                num_attention_heads=config.plbert_num_attention_heads,
+                intermediate_size=config.plbert_intermediate_size,
+                num_hidden_layers=config.plbert_num_hidden_layers,
+                max_position_embeddings=config.plbert_max_position_embeddings,
+            )
+        )
+        self.bert_encoder = nn.Linear(config.plbert_hidden_size, config.hidden_size)
+        self.predictor = ProsodyPredictor(
+            style_dim=config.style_dim,
+            d_hid=config.hidden_size,
+            nlayers=config.num_layers,
+            max_dur=config.max_duration,
+            dropout=config.dropout,
+        )
+        self.text_encoder = TextEncoder(
+            channels=config.hidden_size,
+            kernel_size=config.text_encoder_kernel_size,
+            depth=config.num_layers,
+            n_symbols=config.vocab_size,
+        )
+        self.decoder = Decoder(
+            dim_in=config.hidden_size,
+            style_dim=config.style_dim,
+            resblock_kernel_sizes=config.resblock_kernel_sizes,
+            upsample_rates=config.upsample_rates,
+            upsample_initial_channel=config.upsample_initial_channel,
+            resblock_dilation_sizes=config.resblock_dilation_sizes,
+            upsample_kernel_sizes=config.upsample_kernel_sizes,
+            gen_istft_n_fft=config.gen_istft_n_fft,
+            gen_istft_hop_size=config.gen_istft_hop_size,
+            sampling_rate=config.sampling_rate,
+        )
+        self.register_buffer("voice", torch.zeros(1, config.style_dim * 2))
+        self.post_init()
+
+    @property
+    def sampling_rate(self) -> int:
+        return int(self.config.sampling_rate)
+
+    def _synthesise(self, input_ids: Tensor, style: Tensor, speed: float) -> tuple[Tensor, Tensor]:
+        attention = torch.ones_like(input_ids)
+        bert_dur = self.bert(input_ids, attention_mask=attention).last_hidden_state
+        d_en = self.bert_encoder(bert_dur).transpose(-1, -2)
+
+        prosody_style = style[:, self.config.style_dim :]
+        acoustic_style = style[:, : self.config.style_dim]
+
+        d = self.predictor.text_encoder(d_en, prosody_style)
+        x, _ = self.predictor.lstm(d)
+        duration = torch.sigmoid(self.predictor.duration_proj(x)).sum(dim=-1) / speed
+        frames = torch.round(duration).clamp(min=1).long().squeeze(0)
+
+        indices = torch.repeat_interleave(
+            torch.arange(input_ids.shape[1], device=input_ids.device), frames
+        )
+        alignment = torch.zeros(
+            (input_ids.shape[1], indices.shape[0]), device=input_ids.device, dtype=d.dtype
+        )
+        alignment[indices, torch.arange(indices.shape[0], device=input_ids.device)] = 1
+        alignment = alignment.unsqueeze(0)
+
+        pitch, energy = self.predictor.contours(d.transpose(-1, -2) @ alignment, prosody_style)
+        asr = self.text_encoder(input_ids) @ alignment
+        waveform = self.decoder(asr, pitch, energy, acoustic_style).squeeze(1).squeeze(0)
+        return waveform, frames
+
+    @torch.no_grad()
+    def forward(
+        self,
+        input_ids: Tensor,
+        attention_mask: Tensor | None = None,
+        speed: float = 1.0,
+        voice: Tensor | None = None,
+        return_dict: bool | None = None,
+    ) -> MatoubOutput | tuple[Tensor, Tensor, Tensor]:
+        if speed <= 0:
+            message = f"speed must be positive, got {speed}"
+            raise ValueError(message)
+        if input_ids.dim() != BATCHED_SEQUENCE_RANK:
+            message = f"input_ids must be (batch, tokens), got shape {tuple(input_ids.shape)}"
+            raise ValueError(message)
+        limit = self.config.max_token_length
+        if input_ids.shape[1] > limit:
+            message = (
+                f"{input_ids.shape[1]} tokens exceeds the {limit} PL-BERT can position; "
+                f"synthesise one sentence at a time"
+            )
+            raise ValueError(message)
+
+        style = self.voice if voice is None else voice.to(self.voice.dtype)
+        if style.shape[-1] != self.config.style_dim * 2:
+            message = (
+                f"voice must be a {self.config.style_dim * 2}-dim style vector, "
+                f"got shape {tuple(style.shape)}"
+            )
+            raise ValueError(message)
+        style = style.reshape(1, -1).to(input_ids.device)
+
+        # Each item is synthesised on its own: the alignment matrix that expands tokens to
+        # frames is built from that item's own durations, so a padded row would be given
+        # frames of its own padding.
+        mask = torch.ones_like(input_ids) if attention_mask is None else attention_mask
+        waveforms: list[Tensor] = []
+        durations: list[Tensor] = []
+        for row, keep in zip(input_ids, mask, strict=True):
+            tokens = row[keep.bool()].unsqueeze(0)
+            waveform, frames = self._synthesise(tokens, style, speed)
+            waveforms.append(waveform)
+            durations.append(
+                nn.functional.pad(frames, (0, int(input_ids.shape[1] - frames.shape[0])))
+            )
+
+        lengths = torch.tensor([w.shape[0] for w in waveforms], device=input_ids.device)
+        longest = int(lengths.max())
+        audio = torch.stack([nn.functional.pad(w, (0, longest - w.shape[0])) for w in waveforms])
+        stacked_durations = torch.stack(durations)
+
+        if return_dict is False:
+            return audio, lengths, stacked_durations
+        return MatoubOutput(waveform=audio, waveform_lengths=lengths, durations=stacked_durations)
+
+
+__all__ = ["MatoubForTextToWaveform", "MatoubOutput", "MatoubPreTrainedModel"]

tokenization_matoub.py

@@ -0,0 +1,244 @@
+"""Kabyle text to the phoneme ids Matoub-82M was trained on.
+
+The rules are a copy of `agbalu.tts.g2p` and `agbalu.tts.kokoro`, not an import: nothing
+under `hub/` may import `agbalu`, because the published repository ships without it.
+`tests/unit/test_hub_matoub.py` asserts the two agree over the corpus, and it is the only
+thing keeping them from drifting.
+
+A symbol with no rule raises. It is never dropped: silent deletion is the defect this
+front end exists to remove, and it has already cost three Kabyle consonants once —
+Kokoro's own G2P is built with `unk=''` and StyleTTS2's cleaner skips what it cannot find.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import TYPE_CHECKING, Any, Final
+
+from transformers import PreTrainedTokenizer
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from pathlib import Path
+
+VOCAB_FILE: Final = "vocab.json"
+
+VOWELS: Final = frozenset("aeiou")
+
+BACKING_TRIGGERS: Final = frozenset("ḍṣṭẓṛqɣx")
+
+SPIRANTS: Final[dict[str, tuple[str, str]]] = {
+    "b": ("β", "b"),
+    "d": ("ð", "d"),
+    "g": ("ʝ", "ɡ"),
+    "k": ("ç", "k"),
+    "t": ("θ", "t"),
+    "ḍ": ("ðˤ", "dˤ"),
+}
+
+PLAIN: Final[dict[str, str]] = {
+    "a": "æ",
+    "c": "ʃ",
+    "e": "ə",
+    "f": "f",
+    "h": "h",
+    "i": "i",
+    "j": "ʒ",
+    "l": "l",
+    "m": "m",
+    "n": "n",
+    "o": "o",
+    "p": "p",
+    "q": "q",
+    "r": "r",
+    "s": "s",
+    "u": "u",
+    "v": "v",
+    "w": "w",
+    "x": "χ",
+    "y": "j",
+    "z": "z",
+    "č": "t͡ʃ",
+    "ǧ": "d͡ʒ",
+    "ɛ": "ʕ",
+    "ɣ": "ʁ",
+    "ḥ": "ħ",
+    "ṛ": "rˤ",
+    "ṣ": "sˤ",
+    "ṭ": "tˤ",
+    "ẓ": "zˤ",
+}
+
+NASAL_ASSIMILATION: Final[dict[str, str]] = {"f": "m", "m": "m", "y": "ɲ", "q": "ŋ", "x": "ŋ"}
+
+FOLD: Final[dict[str, str]] = {"t͡ʃ": "ʧ", "d͡ʒ": "ʤ"}
+"""Tie-bar sequences the base model already carries as single symbols."""
+
+LEGACY_TENSE_T: Final = "ţ"
+LENGTH: Final = "ː"
+BOUNDARY: Final = " "
+
+_SPLIT: Final = re.compile(r"[\s\-]+")
+_STRIP: Final = "«»\"'“”‘’.,;:!?()[]{}…"
+
+
+class PhonemeError(ValueError):
+    """A character with no rule."""
+
+
+def _segment(word: str) -> list[tuple[str, bool]]:
+    segments: list[tuple[str, bool]] = []
+    index = 0
+    while index < len(word):
+        char = word[index]
+        paired = index + 1 < len(word) and word[index + 1] == char and char not in VOWELS
+        segments.append((char, paired))
+        index += 2 if paired else 1
+    return segments
+
+
+def _backed(chars: list[str], position: int) -> bool:
+    before = chars[position - 1] if position > 0 else ""
+    after = chars[position + 1] if position + 1 < len(chars) else ""
+    return before in BACKING_TRIGGERS or after in BACKING_TRIGGERS
+
+
+def phonemize_word(word: str) -> str:
+    """One orthographic word to IPA. Raises on any character without a rule."""
+    segments = _segment(word.casefold())
+    chars = [char for char, _ in segments]
+    out: list[str] = []
+    for position, (char, geminate) in enumerate(segments):
+        if char == LEGACY_TENSE_T:
+            out.append(SPIRANTS["t"][1] + LENGTH)
+            continue
+        if char in SPIRANTS:
+            short, stop = SPIRANTS[char]
+            out.append(stop + LENGTH if geminate else short)
+            continue
+        if char not in PLAIN:
+            message = f"no rule for {char!r} (U+{ord(char):04X}) in {word!r}"
+            raise PhonemeError(message)
+        if char == "a" and _backed(chars, position):
+            symbol = "ɑ"
+        elif char == "n" and not geminate and position + 1 < len(chars):
+            symbol = NASAL_ASSIMILATION.get(chars[position + 1], PLAIN["n"])
+        else:
+            symbol = PLAIN[char]
+        out.append(symbol + LENGTH if geminate else symbol)
+    return "".join(out)
+
+
+def fold(ipa: str) -> str:
+    """Rewrite tie-bar affricates onto the base model's own single symbols."""
+    for sequence, symbol in FOLD.items():
+        ipa = ipa.replace(sequence, symbol)
+    return ipa
+
+
+def phonemize(text: str) -> str:
+    """A Kabyle sentence to the phoneme string the model was fitted on."""
+    words = [token.strip(_STRIP) for token in _SPLIT.split(text) if token.strip(_STRIP)]
+    return fold(BOUNDARY.join(phonemize_word(word) for word in words))
+
+
+class MatoubTokenizer(PreTrainedTokenizer):
+    """Kabyle Latin orthography in, phoneme ids out.
+
+    Punctuation is dropped and the clitic hyphen is a word boundary, because that is what
+    the training transcripts carried: the model has never been supervised on a comma.
+    """
+
+    vocab_files_names: dict[str, str] = {"vocab_file": VOCAB_FILE}
+    model_input_names: list[str] = ["input_ids", "attention_mask"]
+
+    def __init__(
+        self,
+        vocab_file: str,
+        pad_token: str = "$",
+        bos_token: str = "$",
+        eos_token: str = "$",
+        **kwargs: Any,
+    ) -> None:
+        with open(vocab_file, encoding="utf-8") as handle:  # noqa: PTH123
+            self._vocab: dict[str, int] = json.load(handle)
+        self._ids_to_symbols = {index: symbol for symbol, index in self._vocab.items()}
+        super().__init__(pad_token=pad_token, bos_token=bos_token, eos_token=eos_token, **kwargs)
+
+    @property
+    def vocab_size(self) -> int:
+        return len(self._vocab)
+
+    def get_vocab(self) -> dict[str, int]:
+        return dict(self._vocab)
+
+    def phonemize(self, text: str) -> str:
+        """The IPA string this tokenizer will encode, for inspection."""
+        return phonemize(text)
+
+    def _tokenize(self, text: str, **kwargs: Any) -> list[str]:
+        return list(phonemize(text))
+
+    def _convert_token_to_id(self, token: str) -> int:
+        index = self._vocab.get(token)
+        if index is None:
+            message = (
+                f"no embedding row for {token!r} (U+{ord(token):04X}); the model would be "
+                f"given a phoneme it was never trained on"
+            )
+            raise KeyError(message)
+        return index
+
+    def _convert_id_to_token(self, index: int) -> str:
+        symbol: str = self._ids_to_symbols.get(index, "")
+        return symbol
+
+    def convert_tokens_to_string(self, tokens: list[str]) -> str:
+        return "".join(tokens)
+
+    def build_inputs_with_special_tokens(
+        self, token_ids_0: list[int], token_ids_1: list[int] | None = None
+    ) -> list[int]:
+        # `meldataset` wraps every training target in the pad symbol on both sides, so a
+        # sequence without them is off the distribution the durations were fitted on.
+        boundary = [self._vocab["$"]]
+        merged = boundary + token_ids_0 + boundary
+        return merged if token_ids_1 is None else merged + token_ids_1 + boundary
+
+    def get_special_tokens_mask(
+        self,
+        token_ids_0: list[int],
+        token_ids_1: list[int] | None = None,
+        already_has_special_tokens: bool = False,
+    ) -> list[int]:
+        if already_has_special_tokens:
+            return super().get_special_tokens_mask(
+                token_ids_0, token_ids_1, already_has_special_tokens=True
+            )
+        mask = [1, *([0] * len(token_ids_0)), 1]
+        return mask if token_ids_1 is None else mask + [0] * len(token_ids_1) + [1]
+
+    def save_vocabulary(
+        self, save_directory: str, filename_prefix: str | None = None
+    ) -> tuple[str]:
+        from pathlib import Path
+
+        name = f"{filename_prefix}-{VOCAB_FILE}" if filename_prefix else VOCAB_FILE
+        path = Path(save_directory) / name
+        path.write_text(
+            json.dumps(self._vocab, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+        )
+        return (str(path),)
+
+    @staticmethod
+    def write_vocabulary(symbols: Mapping[str, int], directory: Path) -> Path:
+        """Write the `vocab.json` a staged release is constructed from."""
+        path = directory / VOCAB_FILE
+        path.write_text(
+            json.dumps(dict(symbols), ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+        )
+        return path
+
+
+__all__ = ["MatoubTokenizer", "PhonemeError", "fold", "phonemize", "phonemize_word"]

tokenizer_config.json

@@ -0,0 +1,24 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "$",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "backend": "custom",
+  "bos_token": "$",
+  "eos_token": "$",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "$",
+  "tokenizer_class": "MatoubTokenizer",
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenization_matoub.MatoubTokenizer",
+      null
+    ]
+  }
+}

vocab.json

@@ -0,0 +1,120 @@
+{
+  "$": 0,
+  ";": 1,
+  ":": 2,
+  ",": 3,
+  ".": 4,
+  "!": 5,
+  "?": 6,
+  "—": 9,
+  "…": 10,
+  "\"": 11,
+  "(": 12,
+  ")": 13,
+  "“": 14,
+  "”": 15,
+  " ": 16,
+  "̃": 17,
+  "ʣ": 18,
+  "ʥ": 19,
+  "ʦ": 20,
+  "ʨ": 21,
+  "ᵝ": 22,
+  "ꭧ": 23,
+  "A": 24,
+  "I": 25,
+  "O": 31,
+  "Q": 33,
+  "S": 35,
+  "T": 36,
+  "W": 39,
+  "Y": 41,
+  "ᵊ": 42,
+  "a": 43,
+  "b": 44,
+  "c": 45,
+  "d": 46,
+  "e": 47,
+  "f": 48,
+  "h": 50,
+  "i": 51,
+  "j": 52,
+  "k": 53,
+  "l": 54,
+  "m": 55,
+  "n": 56,
+  "o": 57,
+  "p": 58,
+  "q": 59,
+  "r": 60,
+  "s": 61,
+  "t": 62,
+  "u": 63,
+  "v": 64,
+  "w": 65,
+  "x": 66,
+  "y": 67,
+  "z": 68,
+  "ɑ": 69,
+  "ɐ": 70,
+  "ɒ": 71,
+  "æ": 72,
+  "β": 75,
+  "ɔ": 76,
+  "ɕ": 77,
+  "ç": 78,
+  "ɖ": 80,
+  "ð": 81,
+  "ʤ": 82,
+  "ə": 83,
+  "ɚ": 85,
+  "ɛ": 86,
+  "ɜ": 87,
+  "ɟ": 90,
+  "ɡ": 92,
+  "ɥ": 99,
+  "ɨ": 101,
+  "ɪ": 102,
+  "ʝ": 103,
+  "ɯ": 110,
+  "ɰ": 111,
+  "ŋ": 112,
+  "ɳ": 113,
+  "ɲ": 114,
+  "ɴ": 115,
+  "ø": 116,
+  "ɸ": 118,
+  "θ": 119,
+  "œ": 120,
+  "ɹ": 123,
+  "ɾ": 125,
+  "ɻ": 126,
+  "ʁ": 128,
+  "ɽ": 129,
+  "ʂ": 130,
+  "ʃ": 131,
+  "ʈ": 132,
+  "ʧ": 133,
+  "ʊ": 135,
+  "ʋ": 136,
+  "ʌ": 138,
+  "ɣ": 139,
+  "ɤ": 140,
+  "χ": 142,
+  "ʎ": 143,
+  "ʒ": 147,
+  "ʔ": 148,
+  "ˈ": 156,
+  "ˌ": 157,
+  "ː": 158,
+  "ʰ": 162,
+  "ʲ": 164,
+  "↓": 169,
+  "→": 171,
+  "↗": 172,
+  "↘": 173,
+  "ᵻ": 177,
+  "ħ": 7,
+  "ʕ": 8,
+  "ˤ": 26
+}