melotts-mblt 0.0.0__tar.gz

melotts_mblt-0.0.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Mobilint, Inc.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

melotts_mblt-0.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+# Tests are development-only. setuptools already builds only the `melotts_mblt*` packages; prune them from the sdist
+# to pin that intent.
+prune tests

melotts_mblt-0.0.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: melotts-mblt
+Version: 0.0.0
+Summary: MeloTTS text-to-speech on Mobilint NPUs: English and Korean speech synthesis with a CLI and Gradio WebUI
+Author-email: "Mobilint Inc." <tech-support@mobilint.com>
+License: BSD-3-Clause AND MIT
+Project-URL: Home, https://www.mobilint.com/
+Project-URL: Repository, https://github.com/mobilint/MeloTTS-mblt
+Keywords: tts,text-to-speech,melotts,NPU,inference,mobilint,mblt,aries,regulus
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: <3.13,>=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mblt-npu-python>=0.1.0
+Requires-Dist: mobilint-qb-runtime>=1.4.0
+Requires-Dist: transformers-mblt>=0.0.0
+Requires-Dist: torch>=2.4.1
+Requires-Dist: numpy>=1.26.0
+Requires-Dist: huggingface-hub
+Requires-Dist: tqdm
+Requires-Dist: g2p_en>=2.1.0
+Requires-Dist: anyascii>=0.3.2
+Requires-Dist: jamo>=0.4.1
+Requires-Dist: g2pkk>=0.1.1
+Requires-Dist: unidic>=1.1.0
+Requires-Dist: python-mecab-ko>=1.3.7
+Requires-Dist: soundfile
+Requires-Dist: gradio
+Requires-Dist: click
+Dynamic: license-file
+
+# melotts-mblt
+
+<!-- markdownlint-disable MD033 -->
+<div align="center">
+<p>
+<a href="https://www.mobilint.com/" target="_blank">
+<img src="https://raw.githubusercontent.com/mobilint/.github/main/assets/Mobilint_Logo_Primary.png" alt="Mobilint Logo" width="60%">
+</a>
+</p>
+</div>
+<!-- markdownlint-enable MD033 -->
+
+Run [MeloTTS](https://github.com/myshell-ai/MeloTTS) text-to-speech on Mobilint NPUs. `melotts-mblt` ships
+pre-quantized MeloTTS synthesizers for English and Korean. It provides a Python API, a command line, and a Gradio
+WebUI. The acoustic model runs on the NPU, and its Mobilint BERT prosody encoder loads through
+[transformers-mblt](https://github.com/mobilint/transformers-mblt).
+
+Models run on Mobilint [ARIES](https://www.mobilint.com/aries) and [REGULUS](https://www.mobilint.com/regulus)
+boards. Supported target-device identifiers are `aries-rb`, `regulus-ra`, `regulus-rb`, `regulus-ra-usb`, and
+`regulus-rb-usb`.
+
+Version `0.0.0` is the first standalone release. It was extracted from `mblt-model-zoo` 2.11.0.
+
+## Installation
+
+[![PyPI - Version](https://img.shields.io/pypi/v/melotts-mblt?logo=pypi&logoColor=white)](https://pypi.org/project/melotts-mblt/)
+[![PyPI Downloads](https://static.pepy.tech/badge/melotts-mblt?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://clickpy.clickhouse.com/dashboard/melotts-mblt)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/melotts-mblt?logo=python&logoColor=gold)](https://pypi.org/project/melotts-mblt/)
+
+```bash
+pip install melotts-mblt
+# One-time download of the NLTK tagger (English G2P) and the UniDic dictionary
+melotts-mblt download
+```
+
+NPU execution requires a supported Mobilint NPU driver and device. Python packaging cannot run post-install steps, so
+run `melotts-mblt download` once after installing.
+
+## Quick start
+
+```python
+from melotts_mblt import TTS
+
+model = TTS(language="EN_NEWEST", device="cpu", trust_remote_code=True)
+try:
+    speaker_ids = model.hps.data.spk2id
+    model.tts_to_file("Did you ever hear a folk tale about a giant turtle?", speaker_ids["EN-Newest"], "en.wav", speed=1.0)
+finally:
+    model.dispose()  # release the NPU backends
+```
+
+`trust_remote_code=True` lets the Mobilint BERT prosody encoder load its Hub remote code; the `melotts-mblt` CLI and
+WebUI pass it for you. Use `language="KR"` with speaker `"KR"` for Korean. Each language downloads its model from the Mobilint Hugging Face
+organization: [`mobilint/MeloTTS-English-v3`](https://huggingface.co/mobilint/MeloTTS-English-v3) and
+[`mobilint/MeloTTS-Korean`](https://huggingface.co/mobilint/MeloTTS-Korean).
+
+These `TTS(...)` arguments select the NPU: `dev_no`, `target_core`, `target_device`, `encoder_mxq_path`, and
+`decoder_mxq_path`. The [API reference](melotts_mblt/README.md) has more examples.
+
+## Command line
+
+The `melotts-mblt` command provides three subcommands:
+
+- `tts` synthesizes speech with the MeloTTS CLI.
+- `ui` launches the Gradio WebUI.
+- `download` fetches the NLTK and UniDic resources.
+
+```bash
+melotts-mblt tts "Text to read" output.wav --language EN_NEWEST --speed 1.2
+melotts-mblt tts "text-to-speech 안녕하세요" kr.wav --language KR
+melotts-mblt tts file.txt out.wav --file
+melotts-mblt ui --host 0.0.0.0 --port 7860
+melotts-mblt download
+```
+
+`python -m melotts_mblt.cli` is equivalent to `melotts-mblt`. Run `melotts-mblt tts --help` for every TTS option.
+
+## Using with mblt-model-zoo
+
+This package replaces `mblt_model_zoo.MeloTTS`. The modules have the same contents, and only the import prefix and the
+command names differ:
+
+| mblt-model-zoo | melotts-mblt |
+| --- | --- |
+| `from mblt_model_zoo.MeloTTS.api import TTS` | `from melotts_mblt import TTS` |
+| `mblt_model_zoo.MeloTTS.<module>` | `melotts_mblt.<module>` |
+| `mblt-model-zoo melo ...` / `mblt-model-zoo melotts ...` | `melotts-mblt tts ...` |
+| `mblt-model-zoo melo-ui` | `melotts-mblt ui` |
+| `mblt-melotts-download` | `melotts-mblt download` |
+
+## Development
+
+Use [uv](https://docs.astral.sh/uv/) to manage the development environment:
+
+```bash
+git clone https://github.com/mobilint/MeloTTS-mblt.git
+cd MeloTTS-mblt
+uv venv --python 3.12
+source .venv/bin/activate
+uv pip install -e . --group dev
+pre-commit install
+```
+
+The [test guide](tests/TEST.md) explains the hardware-free and NPU test runs.
+
+## Support and issues
+
+For installation, model, or runtime support, visit the [Mobilint forum](https://discuss.mobilint.com/)
+or contact [tech-support@mobilint.com](mailto:tech-support@mobilint.com). Report reproducible
+package issues in the [MeloTTS-mblt issue tracker](https://github.com/mobilint/MeloTTS-mblt/issues).
+
+## License
+
+Mobilint's code is distributed under the [BSD 3-Clause License](LICENSE). The MeloTTS-derived code in `melotts_mblt`
+remains under [MyShell.ai's MIT License](melotts_mblt/LICENSE), and that license ships in the wheel. MeloTTS was
+created by Wenliang Zhao, Xumin Yu, and Zengyi Qin; see the [API reference](melotts_mblt/README.md#original-authors)
+for the original authors and the citation.

melotts_mblt-0.0.0/README.md

@@ -0,0 +1,117 @@
+# melotts-mblt
+
+<!-- markdownlint-disable MD033 -->
+<div align="center">
+<p>
+<a href="https://www.mobilint.com/" target="_blank">
+<img src="https://raw.githubusercontent.com/mobilint/.github/main/assets/Mobilint_Logo_Primary.png" alt="Mobilint Logo" width="60%">
+</a>
+</p>
+</div>
+<!-- markdownlint-enable MD033 -->
+
+Run [MeloTTS](https://github.com/myshell-ai/MeloTTS) text-to-speech on Mobilint NPUs. `melotts-mblt` ships
+pre-quantized MeloTTS synthesizers for English and Korean. It provides a Python API, a command line, and a Gradio
+WebUI. The acoustic model runs on the NPU, and its Mobilint BERT prosody encoder loads through
+[transformers-mblt](https://github.com/mobilint/transformers-mblt).
+
+Models run on Mobilint [ARIES](https://www.mobilint.com/aries) and [REGULUS](https://www.mobilint.com/regulus)
+boards. Supported target-device identifiers are `aries-rb`, `regulus-ra`, `regulus-rb`, `regulus-ra-usb`, and
+`regulus-rb-usb`.
+
+Version `0.0.0` is the first standalone release. It was extracted from `mblt-model-zoo` 2.11.0.
+
+## Installation
+
+[![PyPI - Version](https://img.shields.io/pypi/v/melotts-mblt?logo=pypi&logoColor=white)](https://pypi.org/project/melotts-mblt/)
+[![PyPI Downloads](https://static.pepy.tech/badge/melotts-mblt?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://clickpy.clickhouse.com/dashboard/melotts-mblt)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/melotts-mblt?logo=python&logoColor=gold)](https://pypi.org/project/melotts-mblt/)
+
+```bash
+pip install melotts-mblt
+# One-time download of the NLTK tagger (English G2P) and the UniDic dictionary
+melotts-mblt download
+```
+
+NPU execution requires a supported Mobilint NPU driver and device. Python packaging cannot run post-install steps, so
+run `melotts-mblt download` once after installing.
+
+## Quick start
+
+```python
+from melotts_mblt import TTS
+
+model = TTS(language="EN_NEWEST", device="cpu", trust_remote_code=True)
+try:
+    speaker_ids = model.hps.data.spk2id
+    model.tts_to_file("Did you ever hear a folk tale about a giant turtle?", speaker_ids["EN-Newest"], "en.wav", speed=1.0)
+finally:
+    model.dispose()  # release the NPU backends
+```
+
+`trust_remote_code=True` lets the Mobilint BERT prosody encoder load its Hub remote code; the `melotts-mblt` CLI and
+WebUI pass it for you. Use `language="KR"` with speaker `"KR"` for Korean. Each language downloads its model from the Mobilint Hugging Face
+organization: [`mobilint/MeloTTS-English-v3`](https://huggingface.co/mobilint/MeloTTS-English-v3) and
+[`mobilint/MeloTTS-Korean`](https://huggingface.co/mobilint/MeloTTS-Korean).
+
+These `TTS(...)` arguments select the NPU: `dev_no`, `target_core`, `target_device`, `encoder_mxq_path`, and
+`decoder_mxq_path`. The [API reference](melotts_mblt/README.md) has more examples.
+
+## Command line
+
+The `melotts-mblt` command provides three subcommands:
+
+- `tts` synthesizes speech with the MeloTTS CLI.
+- `ui` launches the Gradio WebUI.
+- `download` fetches the NLTK and UniDic resources.
+
+```bash
+melotts-mblt tts "Text to read" output.wav --language EN_NEWEST --speed 1.2
+melotts-mblt tts "text-to-speech 안녕하세요" kr.wav --language KR
+melotts-mblt tts file.txt out.wav --file
+melotts-mblt ui --host 0.0.0.0 --port 7860
+melotts-mblt download
+```
+
+`python -m melotts_mblt.cli` is equivalent to `melotts-mblt`. Run `melotts-mblt tts --help` for every TTS option.
+
+## Using with mblt-model-zoo
+
+This package replaces `mblt_model_zoo.MeloTTS`. The modules have the same contents, and only the import prefix and the
+command names differ:
+
+| mblt-model-zoo | melotts-mblt |
+| --- | --- |
+| `from mblt_model_zoo.MeloTTS.api import TTS` | `from melotts_mblt import TTS` |
+| `mblt_model_zoo.MeloTTS.<module>` | `melotts_mblt.<module>` |
+| `mblt-model-zoo melo ...` / `mblt-model-zoo melotts ...` | `melotts-mblt tts ...` |
+| `mblt-model-zoo melo-ui` | `melotts-mblt ui` |
+| `mblt-melotts-download` | `melotts-mblt download` |
+
+## Development
+
+Use [uv](https://docs.astral.sh/uv/) to manage the development environment:
+
+```bash
+git clone https://github.com/mobilint/MeloTTS-mblt.git
+cd MeloTTS-mblt
+uv venv --python 3.12
+source .venv/bin/activate
+uv pip install -e . --group dev
+pre-commit install
+```
+
+The [test guide](tests/TEST.md) explains the hardware-free and NPU test runs.
+
+## Support and issues
+
+For installation, model, or runtime support, visit the [Mobilint forum](https://discuss.mobilint.com/)
+or contact [tech-support@mobilint.com](mailto:tech-support@mobilint.com). Report reproducible
+package issues in the [MeloTTS-mblt issue tracker](https://github.com/mobilint/MeloTTS-mblt/issues).
+
+## License
+
+Mobilint's code is distributed under the [BSD 3-Clause License](LICENSE). The MeloTTS-derived code in `melotts_mblt`
+remains under [MyShell.ai's MIT License](melotts_mblt/LICENSE), and that license ships in the wheel. MeloTTS was
+created by Wenliang Zhao, Xumin Yu, and Zengyi Qin; see the [API reference](melotts_mblt/README.md#original-authors)
+for the original authors and the citation.

melotts_mblt-0.0.0/melotts_mblt/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 MyShell.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

melotts_mblt-0.0.0/melotts_mblt/__init__.py

@@ -0,0 +1,26 @@
+"""MeloTTS text-to-speech for Mobilint NPUs.
+
+``from melotts_mblt import TTS`` loads the speech synthesizer. The import is lazy, so ``import melotts_mblt`` does not
+import ``torch`` or ``transformers``.
+"""
+
+from typing import TYPE_CHECKING
+
+__version__ = "0.0.0"
+
+if TYPE_CHECKING:
+    from .api import TTS
+
+__all__ = ["TTS", "__version__"]
+
+
+def __getattr__(name: str):
+    if name == "TTS":
+        from .api import TTS
+
+        return TTS
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | set(__all__))

melotts_mblt-0.0.0/melotts_mblt/api.py

@@ -0,0 +1,310 @@
+import math
+import re
+from typing import Optional
+
+import numpy as np
+import soundfile
+import torch
+from torch import nn
+from tqdm import tqdm
+from transformers.models.auto.modeling_auto import AutoModelForMaskedLM
+from transformers.models.auto.tokenization_auto import AutoTokenizer
+
+from . import utils
+from .download_utils import (
+    LANG_TO_HF_REPO_ID,
+    load_or_download_config,
+    load_or_download_model,
+    resolve_local_bert_mxq,
+    resolve_local_mxq,
+)
+from .models import MobilintSynthesizerTrn
+from .split_utils import split_sentence
+from .text.cleaner import clean_text
+
+
+def _describe_value(value):
+    """``repr(value)`` for error messages, falling back to the type when ``repr`` itself fails (e.g. huge ints)."""
+    try:
+        return repr(value)
+    except Exception:
+        return f"<{type(value).__name__}>"
+
+
+def _validate_speed(speed):
+    """Return ``speed`` as a ``float`` if it is a finite real number greater than 0, else raise ``ValueError``.
+
+    Any real scalar ``float()`` accepts is allowed (``int``, ``float``, NumPy scalars, 0-d tensors, ``Fraction``,
+    ``Decimal``). Booleans and strings are rejected even though ``float()`` would convert them.
+    """
+    message = "speed must be a finite number greater than 0, got {}"
+    if isinstance(speed, (bool, np.bool_, str, bytes)):
+        raise ValueError(message.format(_describe_value(speed)))
+    try:
+        value = float(speed)
+    except (TypeError, ValueError, OverflowError):
+        # OverflowError: a finite real too large for a float, e.g. 10**10000.
+        raise ValueError(message.format(_describe_value(speed))) from None
+    if not math.isfinite(value) or value <= 0:
+        raise ValueError(message.format(_describe_value(speed)))
+    return value
+
+
+class TTS(nn.Module):
+    def __init__(self, 
+                language,
+                device='auto',
+                config_path=None,
+                ckpt_path=None,
+
+                trust_remote_code: Optional[bool]=None,
+                local_files_only: Optional[bool]=None,
+                
+                dev_no: Optional[int] = None,
+                target_core: Optional[str] = None,
+                encoder_mxq_path: Optional[str] = None,
+                decoder_mxq_path: Optional[str] = None,
+                target_device: Optional[str] = None,
+        ):
+        nn.Module.__init__(self)
+        if device == "auto":
+            device = "cpu"
+            if torch.cuda.is_available():
+                device = "cuda"
+            if torch.backends.mps.is_available():
+                device = "mps"
+        if "cuda" in device:
+            assert torch.cuda.is_available()
+
+        # config_path = 
+        hps = load_or_download_config(language, config_path=config_path, local_files_only=local_files_only)
+        
+        if dev_no is not None:
+            hps.model.dev_no = dev_no
+        
+        if target_core is not None:
+            hps.model.target_core = target_core
+        
+        if encoder_mxq_path is not None:
+            hps.model.encoder_mxq_path = encoder_mxq_path
+        
+        if decoder_mxq_path is not None:
+            hps.model.decoder_mxq_path = decoder_mxq_path
+
+        resolved_target_device = (
+            target_device
+            if target_device is not None
+            else getattr(hps.model, "target_device", "aries-rb")
+        )
+        hps.model.target_device = resolved_target_device
+
+        if local_files_only:
+            # mblt_npu downloads a missing MXQ from the Hub; resolve both synthesizer MXQs from the cache first so
+            # local_files_only never reaches the network (LocalEntryNotFoundError when they are not cached).
+            repo_id = LANG_TO_HF_REPO_ID[language]
+            hps.model.encoder_mxq_path = resolve_local_mxq(repo_id, hps.model.encoder_mxq_path)
+            hps.model.decoder_mxq_path = resolve_local_mxq(repo_id, hps.model.decoder_mxq_path)
+
+        num_languages = hps.num_languages
+        num_tones = hps.num_tones
+        symbols = hps.symbols
+
+        # A failure while building the synthesizer is cleaned up by MobilintSynthesizerTrn itself; from here on the
+        # NPU backends exist, so assign self.model before anything else can fail (including the device transfer).
+        self.model = MobilintSynthesizerTrn(
+            len(symbols),
+            hps.data.filter_length // 2 + 1,
+            hps.train.segment_size // hps.data.hop_length,
+            n_speakers=hps.data.n_speakers,
+            num_tones=num_tones,
+            num_languages=num_languages,
+            name_or_path=LANG_TO_HF_REPO_ID[language],
+            **hps.model,
+        )
+
+        try:
+            model = self.model.to(device)
+            model.eval()
+            self.model = model
+            self.symbol_to_id = {s: i for i, s in enumerate(symbols)}
+            self.hps = hps
+            self.device = device
+
+            # load state_dict
+            checkpoint_dict = load_or_download_model(language, device, ckpt_path=ckpt_path, local_files_only=local_files_only)
+            self.model.load_state_dict(checkpoint_dict['model'], strict=True)
+        
+            language = language.split('_')[0]
+            self.language = 'ZH_MIX_EN' if language == 'ZH' else language # we support a ZH_MIX_EN model
+
+            self.tokenizer = AutoTokenizer.from_pretrained(
+                hps.model.bert_model_id,
+                trust_remote_code=trust_remote_code,
+                local_files_only=local_files_only,
+            )
+
+            bert_kwargs = {}
+            if local_files_only:
+                # Same reason as the synthesizer MXQs: resolve the BERT MXQ from the cache before mblt_npu sees it.
+                bert_mxq_path = resolve_local_bert_mxq(hps.model.bert_model_id)
+                if bert_mxq_path is not None:
+                    bert_kwargs["mxq_path"] = bert_mxq_path
+
+            # Keep a reference to the loaded BERT (it owns an NPU backend) before the transfer, so dispose() can
+            # still release it if .to(device) fails.
+            self.bert = AutoModelForMaskedLM.from_pretrained(
+                hps.model.bert_model_id,
+                trust_remote_code=trust_remote_code,
+                local_files_only=local_files_only,
+
+                dev_no=hps.model.dev_no,
+                target_cores=[hps.model.target_core],
+                target_device=hps.model.target_device,
+                **bert_kwargs,
+            )
+            self.bert = self.bert.to(device)
+    
+        except BaseException:
+            # Checkpoint, tokenizer, or BERT loading failed after the synthesizer's NPU backends were created.
+            self.dispose()
+            raise
+
+    @staticmethod
+    def audio_numpy_concat(segment_data_list, sr, speed=1.0):
+        audio_segments = []
+        for segment_data in segment_data_list:
+            audio_segments += segment_data.reshape(-1).tolist()
+            audio_segments += [0] * int((sr * 0.05) / speed)
+        audio_segments = np.array(audio_segments).astype(np.float32)
+        return audio_segments
+
+    @staticmethod
+    def split_sentences_into_pieces(text, language, quiet=False):
+        texts = split_sentence(text, language_str=language)
+        if not quiet:
+            print(" > Text split to sentences.")
+            print("\n".join(texts))
+            print(" > ===========================")
+        return texts
+    
+    def _bert_token_count(self, text, language):
+        """Number of BERT tokens (special tokens included) the text produces after normalization."""
+        if language in ["EN", "ZH_MIX_EN"]:
+            text = re.sub(r"([a-z])([A-Z])", r"\1 \2", text)
+        _, _, _, word2ph = clean_text(text, language, tokenizer=self.tokenizer)
+        return len(word2ph)
+
+    def _bert_max_tokens(self):
+        config = getattr(getattr(self, "bert", None), "config", None)
+        limit = getattr(config, "max_position_embeddings", None) or getattr(self.tokenizer, "model_max_length", None)
+        # Tokenizers without a configured maximum report a huge sentinel value; fall back to BERT's usual 512.
+        return int(limit) if limit and limit < 100_000 else 512
+
+    def _fit_piece_to_bert(self, text, language, limit):
+        """Split ``text`` until every piece fits BERT's position limit.
+
+        Sentence splitting only breaks at punctuation, so unpunctuated input can exceed BERT's position embeddings,
+        which are computed for the whole input before the MXQ runs (synthesizer chunking cannot help). Bisect at
+        whitespace, or at the middle character for an unbroken run; each piece then goes through normalization,
+        G2P, and BERT on its own, so ``word2ph`` / phoneme alignment is recomputed per piece instead of truncated.
+        """
+        if self._bert_token_count(text, language) <= limit:
+            return [text]
+        words = text.split()
+        if len(words) > 1:
+            middle = len(words) // 2
+            left, right = " ".join(words[:middle]), " ".join(words[middle:])
+        else:
+            middle = len(text) // 2
+            left, right = text[:middle], text[middle:]
+        if not left.strip() or not right.strip():
+            return [text]
+        return self._fit_piece_to_bert(left, language, limit) + self._fit_piece_to_bert(right, language, limit)
+
+    def fit_pieces_to_bert(self, texts, language):
+        """Return ``texts`` with every piece split as needed to fit BERT's maximum input length."""
+        if getattr(self.hps.data, "disable_bert", False):
+            return list(texts)
+        limit = self._bert_max_tokens()
+        pieces = []
+        for text in texts:
+            pieces.extend(self._fit_piece_to_bert(text, language, limit))
+        return pieces
+
+    def tts_to_file(self, text, speaker_id, output_path=None, sdp_ratio=0.2, noise_scale=0.6, noise_scale_w=0.8, speed=1.0, pbar=None, format=None, position=None, quiet=False):
+        speed = _validate_speed(speed)
+        language = self.language
+        texts = self.fit_pieces_to_bert(self.split_sentences_into_pieces(text, language, quiet), language)
+        audio_list = []
+        if pbar:
+            tx = pbar(texts)
+        else:
+            if position:
+                tx = tqdm(texts, position=position)
+            elif quiet:
+                tx = texts
+            else:
+                tx = tqdm(texts)
+        for t in tx:
+            if language in ["EN", "ZH_MIX_EN"]:
+                t = re.sub(r"([a-z])([A-Z])", r"\1 \2", t)
+            device = self.device
+            bert, ja_bert, phones, tones, lang_ids = utils.get_text_for_tts_infer(t, language, self.hps, device, self.symbol_to_id, tokenizer=self.tokenizer, bert=self.bert)
+            with torch.no_grad():
+                x_tst = phones.to(device).unsqueeze(0)
+                tones = tones.to(device).unsqueeze(0)
+                lang_ids = lang_ids.to(device).unsqueeze(0)
+                bert = bert.to(device).unsqueeze(0)
+                ja_bert = ja_bert.to(device).unsqueeze(0)
+                x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
+                del phones
+                speakers = torch.LongTensor([speaker_id]).to(device)
+                audio = (
+                    self.model.infer(
+                        x_tst,
+                        x_tst_lengths,
+                        speakers,
+                        tones,
+                        lang_ids,
+                        bert,
+                        ja_bert,
+                        sdp_ratio=sdp_ratio,
+                        noise_scale=noise_scale,
+                        noise_scale_w=noise_scale_w,
+                        length_scale=1.0 / speed,
+                    )[0][0, 0]
+                    .data.cpu()
+                    .float()
+                    .numpy()
+                )
+                del x_tst, tones, lang_ids, bert, ja_bert, x_tst_lengths, speakers
+                #
+            audio_list.append(audio)
+        torch.cuda.empty_cache()
+        audio = self.audio_numpy_concat(audio_list, sr=self.hps.data.sampling_rate, speed=speed)
+        
+        if output_path is None:
+            return audio
+        else:
+            if format:
+                soundfile.write(
+                    output_path, audio, self.hps.data.sampling_rate, format=format
+                )
+            else:
+                soundfile.write(output_path, audio, self.hps.data.sampling_rate)
+
+    def launch(self):
+        self.model.launch()
+
+    def dispose(self):
+        model = getattr(self, "model", None)
+        if model is not None:
+            model.dispose()
+        # ``self.bert`` is a sibling NPU-backed module built via
+        # ``AutoModelForMaskedLM.from_pretrained``; if the loaded class is a
+        # Mobilint Bert (``MobilintBertForMaskedLM``) it owns its own NPU
+        # backend and must be released alongside the synthesizer, otherwise
+        # LPDDR stays pinned between TTS instances.
+        bert_dispose = getattr(getattr(self, "bert", None), "dispose", None)
+        if callable(bert_dispose):
+            bert_dispose()