Downloads · 30 days
8.6K
24% of all-time downloads
nvidia/magpie_tts_multilingual_357m
magpie_tts_multilingual_357m is a text-to-speech model from nvidia. Use it when you need text read aloud. It is set up for nemo. The card lists the license as other.
<style imgmodel-badge { display: inline; } </style
Downloads · 30 days
8.6K
24% of all-time downloads
All-time downloads
36.1K
Public
Repo size
6.1 GB
Likes
226
Trending 3
Click a slice to open those files.
.nemo1.5 GB · 72%
From the Hugging Face model README
🤗 Hugging Face MagpieTTS Multilingual demo: magpie_tts_multilingual_demo
💻 NeMo Speech Framework: github.com/NVIDIA-NeMo/Speech
[!Note] July 21, 2026: MagpieTTS v2607 was released with support for 3 new languages (Arabic, Korean, Portuguese).
For the older checkpoints, refer to below tags:
MagpieTTS is an end-to-end multilingual neural text-to-speech model that synthesizes speech using 5 English speaker voices — Aria, Jason, Leo, Sofia, and John Van Stan — across 12 languages: Arabic (ar), Chinese (zh), English (en), French (fr), German (de), Hindi (hi), Italian (it), Japanese (ja), Korean (ko), Portuguese (pt), Spanish (es), and Vietnamese (vi). The model adopts a transformer encoder–decoder architecture that autoregressively predicts discrete audio codec tokens, using multi-codebook prediction (typically 8 codebooks) with frame stacking (factor = 2) and a local transformer for fine-grained refinement of high-fidelity audio. To improve robustness and controllability, training incorporates attention priors for stable text-to-audio alignment, classifier-free guidance (CFG) for stronger conditioning, and Group Relative Policy Optimization (GRPO) for preference-aligned generation. At inference time, MagpieTTS supports batched synthesis of complete utterances as well as long-form generation of extended text via a sliding-window mechanism; the predicted codec tokens are then decoded into speech waveforms by a frozen pretrained audio codec model (NanoCodec). This release also removed zero-shot voice-cloning capability for security reasons, and added IPA grapheme-to-phoneme (G2P) support for custom dictionaries and code-switching, and updated G2P support for English-to-Katakana code-switching.
This model is ready for commercial use.
MagpieTTS is for developers, researchers, and product teams building multilingual speech applications that need consistent speaker voices across 12 languages. Typical applications include cascade voice agents, audiobook and content narration, accessibility tools, dubbing and localization pipelines, and interactive media. IPA grapheme-to-phoneme (G2P) support for custom dictionaries and code-switching (including English-to-Katakana) also enables mixed-language content and domain-specific pronunciation.
MagpieTTS acts as a dedicated speech-generation layer that plugs into existing AI pipelines without changing upstream language models or downstream audio handling. In cascade voice-agent setups, it converts Large Language Model (LLM) text into natural, real-time speech for user playback. It can also replace or extend existing NVIDIA TTS integrations when multilingual coverage from a single unified model is required.
Deployment Geography: Global
This model is not intended for zero-shot voice cloning, languages outside the 12 supported languages, or use cases that bypass the NVIDIA Open Model License terms. See Technical Limitations & Mitigations for additional constraints.
Architecture Type: Transformer Encoder, Transformer Decoder, Local Transformer, and Feedforward Layers
<img src="magpietts_architecture.png" alt="MagpieTTS Model Architecture" width="600">Figure 1: MagpieTTS Model Architecture
Network Architecture:
Number of model parameters: 3.64 x 10^8 (364M parameters)
Input Type(s): Text<br> Input Format: String<br> Input Parameters: One-Dimensional (1D)<br> Other Properties Related to Input: Text input is UTF-8 encoded; text normalization is required.
Output Type(s): Audio<br> Output Format: WAV<br> Output Parameters: One-Dimensional (1D)<br> Other Properties Related to Output: Mono, PCM-encoded 16 bit audio; sampling rate of 22.05 kHz; Audio output with dimensions (B x T), where B is batch size and T is time dimension.
[!TIP] Try the hosted API, run locally with NeMo-Speech.cpp, or use the NeMo Speech Framework for Python inference and training.
<a id="hosted-api-quickstart"></a>
Synthesize speech using the hosted NVIDIA NIM API on Magpie TTS Multilingual — no local GPU, Docker, or checkpoint download required.
1. Get a free API key: Open Magpie TTS Multilingual and choose Get API Key.
2. Install the Riva client:
pip install nvidia-riva-client
3. Synthesize speech to a WAV file:
import wave
import riva.client
from riva.client.proto.riva_audio_pb2 import AudioEncoding
auth = riva.client.Auth(
uri="grpc.nvcf.nvidia.com:443",
use_ssl=True,
metadata_args=[
["function-id", "877104f7-e885-42b9-8de8-f6e4c6303969"],
["authorization", "Bearer nvapi-YOUR_API_KEY"],
],
)
service = riva.client.SpeechSynthesisService(auth)
sample_rate_hz = 22050
resp = service.synthesize(
"Hello from the Magpie multilingual hosted API.",
"Magpie-Multilingual.EN-US.Sofia",
"en-US",
sample_rate_hz=sample_rate_hz,
encoding=AudioEncoding.LINEAR_PCM,
)
with wave.open("out.wav", "wb") as wf:
wf.setnchannels(1)
wf.setsampwidth(2)
wf.setframerate(sample_rate_hz)
wf.writeframesraw(resp.audio)
Or use the CLI (list voices, then synthesize):
git clone https://github.com/nvidia-riva/python-clients.git
export NVIDIA_API_KEY="nvapi-YOUR_API_KEY"
python python-clients/scripts/tts/talk.py \
--server grpc.nvcf.nvidia.com:443 --use-ssl \
--metadata function-id "877104f7-e885-42b9-8de8-f6e4c6303969" \
--metadata authorization "Bearer $NVIDIA_API_KEY" \
--list-voices
python python-clients/scripts/tts/talk.py \
--server grpc.nvcf.nvidia.com:443 --use-ssl \
--metadata function-id "877104f7-e885-42b9-8de8-f6e4c6303969" \
--metadata authorization "Bearer $NVIDIA_API_KEY" \
--text "Hello from Magpie." \
--voice "Magpie-Multilingual.EN-US.Sofia" \
--language-code en-US \
--sample-rate-hz 22050 \
-o out.wav
Note: Voice IDs and supported sample rates follow the deployed NIM. Use
--list-voicesagainst this endpoint, or see the API Reference on the Magpie TTS Multilingual page.
NeMo-Speech.cpp provides a lightweight native C++ runtime for running this model locally. It downloads the v2607 GGUF, tokenizer assets, and companion NanoCodec decoder automatically.
After installing NeMo-Speech.cpp:
nemo-speech synthesize "Hello from Magpie Multilingual." \
--output speech.wav
Use nemo-speech pull magpie to download the model stack without running
synthesis.
<a id="local-inference-with-nemo"></a>
To train, fine-tune or perform TTS with this model, you will need to install NVIDIA NeMo Speech. We recommend you install it after you've installed latest PyTorch version and Python version ≥ 3.10.12.
pip install nemo_toolkit[tts]@main
pip install kaldialign
The model is available for use in the NVIDIA NeMo Speech Framework, and can be used as a pre-trained checkpoint for inference or for fine-tuning on another dataset.
Two inference paths are available: Method 1 (single utterance) and Method 2 (batch inference and evaluation).
Synthesize one (text, language) pair at a time. Text normalization can be applied for all 12 languages.
Load the open-source MagpieTTS checkpoint from Hugging Face and call the model's do_tts(transcript: str, language: str, apply_TN: bool, use_cfg: bool, speaker_index: int) method. This returns the generated audio and the length of the audio.
from nemo.collections.tts.models import MagpieTTSModel
speaker_map = {
"Aria": 0,
"Jason": 1,
"John": 2,
"Leo": 3,
"Sofia": 4,
}
transcript = "Hello world from NeMo Text to Speech."
language = "en"
speaker = "Sofia"
speaker_idx = speaker_map[speaker]
# Load the latest checkpoint (from the `main` branch).
model = MagpieTTSModel.from_pretrained("nvidia/magpie_tts_multilingual_357m")
audio, audio_len = model.do_tts(transcript, language=language, apply_TN=False, speaker_index=speaker_idx)
# To apply custom phoneme customization in supported languages like English
# Surround the IPA string in a '|' character and add a space token between each IPA character.
ipa_transcript = "Hello world from | ˈ n ɛ m o ʊ | Text to Speech."
audio, audio_len = model.do_tts(ipa_transcript, language=language, apply_TN=False, speaker_index=speaker_idx)
<details open>
<summary><strong>Choosing a model version</strong></summary>
from_pretrained(...) always loads the latest checkpoint from the main branch. To load a specific release instead, download the .nemo file for that version tag and restore it with restore_from(...). Available tags: v2607 (latest, on main), v2602, and v2512.
from huggingface_hub import hf_hub_download
from nemo.collections.tts.models import MagpieTTSModel
# Pin a specific release by its tag (branch, tag, or commit hash).
model_path = hf_hub_download(
repo_id="nvidia/magpie_tts_multilingual_357m",
filename="magpie_tts_multilingual_357m.nemo",
revision="v2602",
)
model = MagpieTTSModel.restore_from(model_path)
</details>
Run batch inference and optional evaluation with examples/tts/magpietts_inference.py. The script supports:
.nemo files or .ckpt checkpointsThe script requires a JSON configuration file that defines the metadata for the datasets to process.
Format
{
"dataset_name_1": {
"manifest_path": "/absolute/path/to/manifest.json",
"audio_dir": "/",
},
"dataset_name_2": {
"manifest_path": "/path/to/another_manifest.json",
"audio_dir": "/base/audio/path",
}
}
Fields
| Field | Required | Description |
|---|---|---|
manifest_path | Yes | Absolute path to the NeMo manifest JSON file |
audio_dir | Yes | Base directory for audio files. Use "/" if manifest contains absolute paths |
whisper_language | No | Language code for ASR evaluation (default: "en") |
Example
{
"libritts_test_clean": {
"manifest_path": "/data/libritts/test_clean_manifest.json",
"audio_dir": "/",
"whisper_language": "en"
},
"vctk": {
"manifest_path": "/data/vctk/manifest.json",
"audio_dir": "/data/vctk/wav48",
}
}
</details>
<details open>
<summary><strong>Manifest format</strong></summary>
The manifest is a JSON-lines file where each line is a JSON object representing one utterance.
Minimum required fields
For models with fixed speaker context embeddings (no audio/text conditioning needed):
{
"audio_filepath": "/path/to/audio.wav",
"text": "The transcript text.",
"duration": 3.5
}
| Field | Type | Description |
|---|---|---|
audio_filepath | string | Path to the target audio file |
text | string | Text transcript to synthesize |
duration | float | Audio duration in seconds |
# Basic inference (no evaluation)
python examples/tts/magpietts_inference.py \
--nemo_files "nvidia/magpie_tts_multilingual_357m" \
--datasets_json_path /path/to/evalset_config.json \
--out_dir /path/to/output \
--codecmodel_path "nvidia/nemo-nano-codec-22khz-1.89kbps-21.5fps" \
--use_cfg \
--cfg_scale 2.5
# Inference with evaluation
python examples/tts/magpietts_inference.py \
--nemo_files "nvidia/magpie_tts_multilingual_357m" \
--datasets_json_path /path/to/evalset_config.json \
--out_dir /path/to/output \
--codecmodel_path "nvidia/nemo-nano-codec-22khz-1.89kbps-21.5fps" \
--run_evaluation \
--use_cfg \
--cfg_scale 2.5
</details>
<details open>
<summary><strong>Outputs and evaluation metrics</strong></summary>
After running, you'll find:
<out_dir>/<checkpoint_name>/metrics.jsonWhen --run_evaluation is enabled, the following metrics are computed:
| Metric | Description |
|---|---|
| CER | Character Error Rate (lower is better) |
| WER | Word Error Rate (lower is better) |
| SSIM (pred-gt) | Speaker similarity between predicted and ground truth |
| SSIM (pred-context) | Speaker similarity between predicted and context |
| UTMOSv2 | Audio quality score (higher is better, requires utmosv2 package) |
| RTF | Real-time factor (processing time / audio duration) |
Runtime Engine(s):
Acceleration Engine: Tensor(RT)-LLM, Triton
Supported Hardware Microarchitecture Compatibility:
Preferred/Supported Operating System(s):
Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.
The integration of foundation and fine-tuned models into AI systems requires additional testing using use-case-specific data to ensure safe and effective deployment. Following the V-model methodology, iterative testing and validation at both unit and system levels are essential to mitigate risks, meet technical and functional requirements, and ensure compliance with safety and ethical standards before deployment.
Audio Training Data Size
Properties:
~54.3k hoursEvaluation data spans all 12 supported languages with the same modalities, content types, and collection method as the training data.
We report two metrics on per-language held-out test sets:
There are two modes of inference, namely, standard and long-form. In standard mode, this model can generate up to 20 seconds of speech at a time in any of the 12 supported languages. In long-form mode, the model performs optimally when the input text contains punctuation and capitalization. The model was trained on a mix of publicly available speech datasets and internally recorded datasets in 12 languages. As a result, it is not suitable for speech generation in any language other than the 12 languages mentioned. We have removed zero-shot capabilities of this model for this release. Text normalization is required.
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.
Please report model quality, risk, security vulnerabilities or NVIDIA AI Concerns here.
GOVERNING TERMS: Use of this model is governed by the NVIDIA Open Model License Agreement.