moss-tts-models

MOSS-TTS family — MAESTRO mirror

Redistribution of the OpenMOSS MOSS-TTS v1.5 checkpoints, MOSS-TTS-Nano and their codecs, packaged for the MAESTRO audio workstation's offline runtime. All credit to the OpenMOSS team (Fudan University) — code and weights are Apache-2.0 (MOSS-TTS, MOSS-TTS-Nano, MOSS-Audio-Tokenizer).

MOSS-TTS v1.5 is zero-shot voice-cloning text-to-speech in 31 languages: clone a speaker from a few seconds of reference audio (no transcript) or use the model's own voice, with explicit language tags, inline [pause X.Ys] marks and token-level duration control. MOSS-TTS-Nano is the 0.1B sibling: the same cloning workflow at 48 kHz stereo on a CPU, 20 languages detected from the text.

Layout

local_v15/model/   config.json, model.safetensors (bf16, 9.10 GB — VERBATIM upstream),
                   tokenizer + config files
local_v15/codec/   config.json (upstream + the shipped codec_weight_dtype)
                   encoder.safetensors   — encoder.* tensors
                   decoder.safetensors   — decoder.* tensors
                   quantizer.safetensors — quantizer.* tensors (always fp32)
                   model.safetensors.index.json — maps every tensor → the three files
                   sha256.json           — upstream shard hashes + per-tensor provenance
delay_v15/model/   config.json, model-0000N-of-00004.safetensors (bf16, 17.0 GB — VERBATIM),
                   model.safetensors.index.json, tokenizer + config files
delay_v15/codec/   config.json, decoder.safetensors (decoder.* + quantizer.*, fp32),
                   encoder.safetensors (encoder.*, fp32), model.safetensors.index.json,
                   sha256.json — byte-identical to upstream (per-tensor sha256 proof)
nano/model/        config.json, model.safetensors (bf16, 235 MB — the upstream
                   pytorch_model.bin CONVERTED: every tensor verbatim, the 17 tied
                   head tensors dropped — see below), tokenizer.model,
                   tokenizer_config.json, special_tokens_map.json,
                   sha256.json — upstream .bin hash + per-tensor sha256 + the dropped keys
nano/codec/        config.json, encoder.safetensors / decoder.safetensors /
                   quantizer.safetensors (all fp32, 88 MB), model.safetensors.index.json,
                   sha256.json — byte-identical to upstream (per-tensor sha256 proof)

Why the Nano checkpoint is converted

Upstream ships MOSS-TTS-Nano as a bf16 pytorch_model.bin in which the text head (text_lm_head.weight) and the 16 audio heads (audio_lm_heads.N.weight) share storage with their embeddings (transformer.wte.weight, audio_embeddings.N.weight). safetensors refuses aliased tensors, so the mirror drops the 17 head keys and keeps every other tensor verbatim (no cast). MossTTSNanoForCausalLM.tie_weights() — and MAESTRO's runner — re-alias the heads after loading; nano/model/sha256.json records the upstream .bin sha256, every shipped tensor's sha256 and the dropped key → embedding map.

Why the codecs are re-sharded

Voice cloning encodes the reference clip once and decodes the take once — never both at the same time. The codecs are re-partitioned by top-level module so MAESTRO can materialise one half at a time and move it on and off the GPU around its single call; on a 12 GB card that is the difference between the 4B language model fitting and not. Each lane's codec/sha256.json carries the upstream shard hashes and a per-tensor sha256 so the split is verifiable: the v1 codec and the v2 quantizer are byte-identical to upstream; if local_v15/codec/config.json says codec_weight_dtype: bf16, the v2 encoder/decoder halves were cast fp32 → bf16 (upstream's own default codec_weight_dtype for this model) and both the upstream and the shipped digest are recorded.

What was dropped

The upstream repos' remote-code .py files. MAESTRO vendors the GitHub moss_tts_local_v1.5/ and moss_tts_delay/ graphs, the Nano weights repo's model code, and all three codec implementations (patched for transformers 4.57.x) and never uses trust_remote_code. The upstream READMEs are replaced by this card.

Loading

With the upstream code (the model repos carry it):

from transformers import AutoModel, AutoProcessor
processor = AutoProcessor.from_pretrained("OpenMOSS-Team/MOSS-TTS-Local-Transformer-v1.5",
                                          trust_remote_code=True)
model = AutoModel.from_pretrained("AEmotionStudio/moss-tts-models", subfolder="local_v15/model",
                                  trust_remote_code=True, torch_dtype="bfloat16")

For the Nano lane, load the converted safetensors into MossTTSNanoForCausalLM from the upstream repo's code (load_state_dict(..., strict=False) then tie_weights()), and the codec through the re-sharded index (nano/codec/model.safetensors.index.json maps every tensor).

Inside MAESTRO: backend/ai/models/moss_tts.py (one runner, the two v1.5 lanes; codec halves via ai/moss_tts_vendor/audio_tokenizer_v2/loading.py and ai/moss_tts_vendor/audio_tokenizer/loading.py) and backend/ai/models/moss_tts_nano.py (the CPU lane; whole codec via ai/moss_tts_vendor/audio_tokenizer_nano/loading.py).

License

Apache License 2.0 — © OpenMOSS / Fudan University. This mirror adds no restrictions and claims no ownership. Please cite the upstream projects.