update: use static320 FP32 decode path and add config.json

Promote the quality-equivalent static320 FP32 ONNX decode model to the default path. Update README/runtime scripts and remove legacy package layout files.

.gitattributes

@@ -40,3 +40,15 @@ models/axmodels/tts_decode_step_u16.axmodel filter=lfs diff=lfs merge=lfs -text
 models/axmodels/tts_local_decoder.axmodel filter=lfs diff=lfs merge=lfs -text
 models/axmodels/tts_local_fixed_sampled_frame.axmodel filter=lfs diff=lfs merge=lfs -text
 models/axmodels/tts_prefill.axmodel filter=lfs diff=lfs merge=lfs -text
+bin/moss_tts_ax650/libonnxruntime.so filter=lfs diff=lfs merge=lfs -text
+bin/moss_tts_ax650/libonnxruntime.so.1 filter=lfs diff=lfs merge=lfs -text
+bin/moss_tts_ax650/libonnxruntime.so.1.23.2 filter=lfs diff=lfs merge=lfs -text
+bin/moss_tts_ax650/moss_tts_ax650 filter=lfs diff=lfs merge=lfs -text
+models/axmodels_650/codec_decode.axmodel filter=lfs diff=lfs merge=lfs -text
+models/axmodels_650/tts_decode_step.axmodel filter=lfs diff=lfs merge=lfs -text
+models/axmodels_650/tts_local_fixed_sampled_frame.axmodel filter=lfs diff=lfs merge=lfs -text
+models/axmodels_650/tts_prefill.axmodel filter=lfs diff=lfs merge=lfs -text
+models/onnxmodels/candidates/default_512_fp32/moss_tts_decode_step.data filter=lfs diff=lfs merge=lfs -text
+models/onnxmodels/candidates/static320_fp32/moss_tts_decode_step.data filter=lfs diff=lfs merge=lfs -text
+models/onnxmodels/candidates/static320_int8_qdq/moss_tts_decode_step.onnx.data filter=lfs diff=lfs merge=lfs -text
+models/onnxmodels/moss_tts_decode_step.data filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,4 @@
+outputs/
+__pycache__/
+.cache/
+*.pyc

MODEL_SHA256SUMS

@@ -0,0 +1,15 @@
+27c474ec1cf819d72ebaa0ed33ae8d308eef508da74bb6860d99e916904fcc30  models/axmodels_650/codec_decode.axmodel
+f64eda392b2186b61830aece478dd6d415f7d584a71ab12f45f28127f5a43e35  models/axmodels_650/tts_decode_step.axmodel
+4d929e9c05a26ec0b638e84fc8b4fc3476a7f3a578a09b679067a4ffec8d82f7  models/axmodels_650/tts_local_fixed_sampled_frame.axmodel
+dfe5ae88a2549f708ab9134d1c6dbd8c53e49aff76fedff8a902459a7c4b6597  models/axmodels_650/tts_prefill.axmodel
+31294cf854687c937f5769baf44b796b055e559bc74bb0450af327c51c8f6969  models/onnxmodels/moss_tts_decode_step.onnx
+710ca7f6123372488a1641c579159908d8e6461569ae0b83fc071de8eb3de34f  models/onnxmodels/moss_tts_decode_step.data
+35f309211297e504ed42b57e3011234023b78a453b8c5ba1e1d690ccb3612136  models/onnxmodels/candidates/default_512_fp32/moss_tts_decode_step.onnx
+9269ab372a4f59d4db869c44da21b228abf2bf1db7059b1144d0a536c5cec985  models/onnxmodels/candidates/default_512_fp32/moss_tts_decode_step.data
+0a59338df1984be8bcd4b49020eae5572c3eff03c4fdda75ead8c03c02e6e8b8  models/onnxmodels/candidates/static320_int8_qdq/moss_tts_decode_step.onnx
+7232d99b91b6be4b0bc86486b7df1c17f05bf6fae93c8629552274ab1a61cd91  models/onnxmodels/candidates/static320_int8_qdq/moss_tts_decode_step.onnx.data
+31294cf854687c937f5769baf44b796b055e559bc74bb0450af327c51c8f6969  models/onnxmodels/candidates/static320_fp32/moss_tts_decode_step.onnx
+710ca7f6123372488a1641c579159908d8e6461569ae0b83fc071de8eb3de34f  models/onnxmodels/candidates/static320_fp32/moss_tts_decode_step.data
+eddd60c9cbe74805d94342c032143f1a7d7af91f02af21eb749b6f919804e9be  bin/moss_tts_ax650/moss_tts_ax650
+ab8c4363e06ac80b3d1279ea55ebea44e906c5b131ba783ff684a067540c0e94  bin/moss_tts_ax650/libonnxruntime.so.1.23.2
+e229c8e7b2abc2a50e550b3ed099178bdbe1948cf3a40447f753a01720aa9052  bin/moss_tts_ax650/libonnxruntime_providers_shared.so

README.md

@@ -1,131 +1,204 @@
-# Moss-TTS-Nano.AXERA
+---
+library_name: axengine
+pipeline_tag: text-to-speech
+tags:
+- axera
+- ax650
+- moss-tts
+license: apache-2.0
+---
 
-MOSS-TTS-Nano AX650 板端推理demo，包含板端 Python 推理脚本、配置文件、ONNX 对照模型和 AX650 可执行的 axmodel。
+# MOSS-TTS-Nano.AXERA_HUG
 
-[模型导出](https://github.com/AXERA-TECH/Moss-TTS-Nano.AXERA)
+AX650 量化模型和板端推理包。该仓库只发布量化 `.axmodel`、质量路径所需的 decode
+ONNX、最小 Python 推理代码、AX650 AArch64 可执行文件及 ONNX Runtime 运行库，不包含
+C++ 源码或浮点 checkpoint。
 
+源码、模型导出、校准和 Pulsar2 量化工程见：
 
-## 当前状态
+```text
+https://github.com/AXERA-TECH/Moss-TTS-Nano.AXERA
+```
+
+## 发布内容
 
-- 支持内置音色。
-- 当前推理未加入音色克隆。原因是量化后音色克隆链路损失较大。
-- 推理稳定性有待验证，当前板端推理 RTF 约为 3，实时率偏大，流式step输出效果无法对齐，RTF也在1.5-2左右，后续加入音色克隆模型推理耗时会更多。
-- 当前音频解码实际使用全量 codec decode， 一次性还原。
+```text
+models/axmodels_650/
+├── tts_prefill.axmodel
+├── tts_decode_step.axmodel              # 量化模型，诊断/低延迟实验用
+├── tts_local_fixed_sampled_frame.axmodel
+└── codec_decode.axmodel
+
+models/onnxmodels/
+├── moss_tts_decode_step.onnx             # 默认质量路径：static320 FP32
+├── moss_tts_decode_step.data
+└── candidates/
+    ├── default_512_fp32/                 # 原始 512-KV FP32 备份
+    ├── static320_fp32/                   # 默认模型的来源副本
+    └── static320_int8_qdq/               # 可选速度候选，静态 KV=320
+
+bin/moss_tts_ax650/
+├── moss_tts_ax650
+├── libonnxruntime.so.1.23.2
+└── libonnxruntime_providers_shared.so
+```
 
-## 目录结构
+## 推荐质量路径
 
 ```text
-Moss-TTS-Nano.AXERA/
-├── configs/
-├── models/
-│   ├── axmodels/
-│   └── onnxmodels/
-├── scripts/
-├── infer_board_axmodel_decode.py
-├── infer_board_onnx_decode.py
-├── requirements.txt
-└── README.md
+tts_prefill.axmodel
+→ tts_local_fixed_sampled_frame.axmodel
+→ moss_tts_decode_step.onnx（ONNX Runtime CPU）
+→ codec_decode.axmodel
 ```
 
-## 环境
+这是当前默认的质量和速度平衡路径。它使用 static320 FP32 decode ONNX，板端多句测试中
+与原始 512-KV FP32 路径生成的 Token 和 WAV 完全一致。稳态结果：
 
-### 安装 pyaxengine
-[pyaxengine Releases](https://github.com/AXERA-TECH/pyaxengine/releases/latest) 下载对应版本的 .whl 文件，然后安装：
+```text
+Total RTF:       1.10–1.13
+Generation RTF:  1.01–1.04
+Decode:          69–70 ms/frame
 ```
-pip install axengine-x.x.x-py3-none-any.whl
+
+以上数值来自板端空闲、关闭其他 NPU/CPU 服务后的多句稳态测试；单句冷启动或板端同时运行
+`axllm serve` 等任务时，ONNX CPU decode 会受到资源争用影响，RTF 可能显著升高。模型加载
+时间不计入 RTF，但首帧运行时初始化和系统负载仍会影响实测值。
+
+模型加载时间不计入 RTF。默认 static320 路径要求：
+
+```text
+实际 prefill 长度 + max_new_frames <= 320
 ```
 
-### Python 依赖：
+当前脚本默认 `max_new_frames=110`、decode warmup 为 32 帧；长文本请按标点分段。全 AXModel 路径速度约 `RTF 0.44–0.48`，但长句存在提前停止
+或尾部噪音风险，因此仅保留为诊断选项。
 
-```bash
-pip install -r requirements.txt
+## 可选速度候选：static320 INT8 QDQ
+
+`models/onnxmodels/candidates/static320_int8_qdq/` 是经过主机和板端测试的 ONNX Runtime
+INT8 候选，只量化常量权重 Linear，注意力、LayerNorm、Softmax 和 KV 保持 FP32。它的静态
+KV 容量为 320，必须满足：
+
+```text
+实际 prefill 长度 + max_new_frames <= 320
 ```
 
-## 推理  
+板端多句测试在一次模型已缓存、32 帧 decode warmup 的运行中得到：
+
+```text
+Total RTF：0.8462
+Generation RTF：0.7547
+```
 
-### 中文  
+这是最佳观测值，不是空闲/繁忙状态下都能保证的固定值；同一板端后台服务运行时曾测得
+`RTF 1.8502`，并出现过 AXEngine 句柄资源不足。因此候选只作为实验速度路径，默认发布
+路径仍保持 FP32 ONNX。它的 Token 流与默认 FP32 质量路径也不是逐 token 一致，使用前必须
+在目标板端试听确认。示例：
 
 ```bash
-python3 infer_board_axmodel_decode.py \
-  --text "你好，今天是美好的一天" \
-  --voice Junhao \
-  --seed 1234 \
+bash run_ax650.sh \
+  --text "你好，今天是美好的一天。" \
+  --decode-backend onnx \
+  --decode-onnx models/onnxmodels/candidates/static320_int8_qdq/moss_tts_decode_step.onnx \
+  --max-new-frames 110 \
+  --decode-warmup-frames 32 \
+  --output-wav outputs/static320_int8_qdq.wav
+```
+
+���始 512-KV FP32 模型保存在 `models/onnxmodels/candidates/default_512_fp32/`，仅用于
+回归对比。若需使用原始路径：
+
+```bash
+bash run_ax650.sh \
+  --text "你好，今天是美好的一天。" \
+  --decode-backend onnx \
+  --decode-onnx models/onnxmodels/candidates/default_512_fp32/moss_tts_decode_step.onnx \
   --max-new-frames 128 \
-  --output-audio-path outputs/zh.wav
+  --decode-warmup-frames 32 \
+  --output-wav outputs/default_512_fp32.wav
 ```
 
-结果：
+## Python 推理
 
+板端安装 Python 依赖和匹配的 `pyaxengine/axengine`：
+
+```bash
+python3 -m pip install -r requirements.txt
+python3 -c "import axengine, numpy, sentencepiece; print('Python runtime OK')"
 ```
-=======================================================
- 板端全 AXModel 推理结果
-=======================================================
-  输出:         /path/to/Moss-TTS-Nano.AXERA/outputs/zh.wav
-  音频时长:     3.20s
-  推理耗时:     9.34s
-  RTF:          2.9180
-=======================================================
+
+运行 Python 参考链路：
+
+```bash
+python3 python/infer_moss_tts.py \
+  --config-dir config \
+  --axmodel-dir models/axmodels_650 \
+  --onnx-dir models/onnxmodels \
+  --text "明天上午九点，我们一起去公园散步，然后喝一杯热咖啡。" \
+  --voice Junhao \
+  --sample-mode fixed \
+  --local-fixed-backend axmodel \
+  --prefill-backend axmodel \
+  --decode-backend onnx \
+  --output-audio-path outputs/python_decode_onnx.wav
 ```
 
-### 英文    
+若要在 Python 中测试全 AXModel 诊断路径：
 
 ```bash
-python3 infer_board_axmodel_decode.py \
-  --text "hello,today is a good day." \
-  --voice Ava \
-  --seed 1234 \
-  --max-new-frames 128 \
-  --output-audio-path outputs/en.wav
+python3 python/infer_moss_tts.py \
+  --config-dir config --axmodel-dir models/axmodels_650 \
+  --onnx-dir models/onnxmodels \
+  --text "你好，今天是美好的一天。" --voice Junhao \
+  --decode-backend axmodel \
+  --output-audio-path outputs/python_all_axmodel.wav
 ```
 
-结果：
+## C++ AX650 推理
+
+`bin/moss_tts_ax650/moss_tts_ax650` 已交叉编译，无需在板端编译。运行库位于同目录，
+脚本会自动设置 `LD_LIBRARY_PATH`：
 
+```bash
+bash run_ax650.sh \
+  --text "明天上午九点，我们一起去公园散步，然后喝一杯热咖啡。" \
+  --voice Junhao \
+  --decode-backend onnx \
+  --output-wav outputs/cpp_decode_onnx.wav \
+  --output-log outputs/cpp_decode_onnx.log
 ```
-=======================================================
- 板端全 AXModel 推理结果
-=======================================================
-  输出:         /path/to/Moss-TTS-Nano.AXERA/outputs/en.wav
-  音频时长:     3.04s
-  推理耗时:     8.77s
-  RTF:          2.8861
-=======================================================
+
+只用于诊断量化 AXModel：
+
+```bash
+bash run_ax650.sh \
+  --text "你好，今天是美好的一天。" \
+  --decode-backend axmodel \
+  --output-wav outputs/cpp_all_axmodel.wav
+```
+
+直接运行二进制时，必须从包根目录执行：
+
+```bash
+export LD_LIBRARY_PATH="$PWD/bin/moss_tts_ax650:${LD_LIBRARY_PATH:-}"
+./bin/moss_tts_ax650/moss_tts_ax650 --help
 ```
---voice 可选18种（Junhao、Zhiming、等）
 
-## 内置音色
+## 工具链说明
 
-| 名称 | 描述 | 类型 |
-|------|------|------|
-| Junhao | CN 欢迎关注模思智能 | Chinese Male |
-| Zhiming | CN 京味胡同闲聊 | Chinese Male |
-| Weiguo | CN 说书 | Chinese Male |
-| Xiaoyu | CN 明星 | Chinese Female |
-| Yuewen | CN 机车 | Chinese Female |
-| Lingyu | CN 深夜电台 | Chinese Female |
-| Trump | EN Trump | English Male |
-| Ava | EN The Bitter Lesson | English Female |
-| Bella | EN A Gentle Reminder | English Female |
-| Adam | EN English News | English Male |
-| Nathan | EN The Quiet Motion of the World | English Male |
-| Soyo | JP Soyo | Japanese Female |
-| Saki | JP Saki | Japanese Female |
-| Mortis | JP Mortis | Japanese Female |
-| Umiri | JP Umiri | Japanese Female |
-| Mei | JP Togawa | Japanese Female |
-| Anon | JP Anon | Japanese Female |
-| Arisa | JP Arisa | Japanese Female |
+源码仓库记录的本机工具链路径为：
 
-## ONNX decode_step 对比推理  
+```text
+GCC：/data/shared/huyuan/toolchains/gcc-arm-9.2-2019.12-x86_64-aarch64-none-linux-gnu
+AX650 BSP：/data/shared/huyuan/toolchains/ax650n_bsp_sdk/msp/out
+```
 
-注：`infer_board_onnx_decode.py` 和 `infer_board_axmodel_decode.py` 的差别是 `decode_step` 使用了 ONNX 模型（效果好一些），其余模型仍然使用 axmodel。
+这些工具链不上传到 Hugging Face。C++ 源码和交叉编译方法见配套 GitHub 仓库。
 
-执行命令：
+## 完整性检查
 
 ```bash
-python3 infer_board_onnx_decode.py \
-  --text "你好，今天是美好的一天" \
-  --voice Junhao \
-  --seed 1234 \
-  --max-new-frames 128 \
-  --output-audio-path outputs/onnx_decode_step.wav
+chmod +x run_ax650.sh verify_package.sh bin/moss_tts_ax650/moss_tts_ax650
+bash verify_package.sh
 ```

models/axmodels/tts_local_decoder.axmodel → bin/moss_tts_ax650/libonnxruntime.so

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:d189cb4cab14401e95b787cf829eaf205dff238c4ccd26fbf52681019600da4e
-size 84574470
+oid sha256:ab8c4363e06ac80b3d1279ea55ebea44e906c5b131ba783ff684a067540c0e94
+size 18693384

models/axmodels/tts_decode_step_u16.axmodel → bin/moss_tts_ax650/libonnxruntime.so.1

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:9cb39e7c48d398a57120dec59f29a7ba9bf09d9102c03fc1acb3baacbe2c5502
-size 144441291
+oid sha256:ab8c4363e06ac80b3d1279ea55ebea44e906c5b131ba783ff684a067540c0e94
+size 18693384

models/axmodels/codec_encode.axmodel → bin/moss_tts_ax650/libonnxruntime.so.1.23.2

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6ca92f2ca6f20147f87b8aa6af9ebb0c4b6eebe6c4e0d9192c50931989029798
-size 102540526
+oid sha256:ab8c4363e06ac80b3d1279ea55ebea44e906c5b131ba783ff684a067540c0e94
+size 18693384

bin/moss_tts_ax650/moss_tts_ax650

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eddd60c9cbe74805d94342c032143f1a7d7af91f02af21eb749b6f919804e9be
+size 124096

configuration.json

@@ -0,0 +1,15 @@
+{
+  "model_type": "moss-tts-nano",
+  "library_name": "axengine",
+  "pipeline_tag": "text-to-speech",
+  "target_hardware": ["AX650"],
+  "source_code": "https://github.com/AXERA-TECH/Moss-TTS-Nano.AXERA",
+  "source_code_standardized": "https://github.com/AXERA-TECH/Moss-TTS-Nano.AXERA",
+  "quality_path": "prefill.axmodel -> local_fixed_sampled_frame.axmodel -> static320 FP32 decode ONNX CPU -> codec_decode.axmodel",
+  "rtf_reference": 1.10,
+  "rtf_generation_reference": 1.01,
+  "decode_kv_capacity": 320,
+  "decode_warmup_frames": 32,
+  "onnxruntime_version": "1.23.2",
+  "compiler": "AX650 GCC ARM 9.2 / AX650 BSP"
+}

infer_board_axmodel_decode.py

@@ -1,112 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import logging
-import sys
-from pathlib import Path
-from typing import Optional, Sequence
-
-_HERE = Path(__file__).resolve().parent
-
-
-def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
-    p = argparse.ArgumentParser(
-        description=(
-            "MOSS-TTS-Nano："
-            "prefill(axmodel) -> decode_step(axmodel) -> local_decoder(axmodel) -> codec_decode(axmodel)。"
-        )
-    )
-    p.add_argument("--config-dir", default=str(_HERE / "configs"),
-                   help="config directory (default: ./configs)")
-    p.add_argument("--axmodel-dir", default=str(_HERE / "models" / "axmodels"),
-                   help="axmodel directory (default: ./models/axmodels)")
-    p.add_argument("--output-audio-path",
-                   default=str(_HERE / "outputs" / "board_axmodel_decode.wav"),
-                   help="output WAV path")
-
-    text_group = p.add_mutually_exclusive_group(required=True)
-    text_group.add_argument("--text", help="待合成文本")
-    text_group.add_argument("--text-file", help="UTF-8 文本文件路径")
-
-    p.add_argument("--voice", default="Junhao", help="内置音色名称")
-    p.add_argument("--prompt-audio-path", "--reference-audio-path",
-                   dest="prompt_audio_path", default=None,
-                   help="参考音频路径（语音克隆，覆盖 --voice）")
-    p.add_argument("--sample-mode", choices=("greedy", "fixed", "full"), default="full")
-    p.add_argument("--do-sample", type=int, default=0, choices=[0, 1],
-                   help="是否采样 (0=argmax, 1=sample)")
-    p.add_argument("--streaming", type=int, default=0, choices=[0, 1],
-                   help="按文本 chunk 增量写 WAV (1)；不改变 codec 全量解码方式")
-    p.add_argument("--max-new-frames", type=int, default=150,
-                   help="最大生成帧数")
-    p.add_argument("--voice-clone-max-text-tokens", type=int, default=75,
-                   help="语音克隆每段最大 token 数")
-    p.add_argument("--seed", type=int, default=None, help="随机种子")
-    p.add_argument("--debug", action="store_true", help="启用 debug 日志")
-    return p.parse_args(argv)
-
-
-def main(argv: Optional[Sequence[str]] = None) -> dict:
-    args = parse_args(argv)
-
-    logging.basicConfig(
-        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
-        level=logging.DEBUG if args.debug else logging.INFO,
-        stream=sys.stderr,
-    )
-
-    raw_text = (
-        str(args.text)
-        if args.text is not None
-        else Path(args.text_file).read_text(encoding="utf-8")
-    )
-
-    logging.info("config_dir:  %s", args.config_dir)
-    logging.info("axmodel_dir: %s", args.axmodel_dir)
-    logging.info("text: %r", raw_text[:60])
-
-    from scripts.tts_runtime import AxTtsRuntime
-
-    runtime = AxTtsRuntime(
-        config_dir=args.config_dir,
-        axmodel_dir=args.axmodel_dir,
-        use_onnx_decode=False,
-        max_new_frames=args.max_new_frames,
-        do_sample=bool(args.do_sample),
-        sample_mode=args.sample_mode,
-    )
-
-    logging.info("decode_step backend: AXModel (NPU)")
-    logging.info("chain: prefill(axmodel) -> decode_step(axmodel) -> local_decoder(axmodel) -> codec_decode(axmodel)")
-    if args.prompt_audio_path:
-        logging.info("参考音频: %s", args.prompt_audio_path)
-    else:
-        logging.info("内置音色: %s", args.voice)
-
-    result = runtime.synthesize(
-        text=raw_text,
-        voice=args.voice,
-        prompt_audio_path=args.prompt_audio_path,
-        output_audio_path=args.output_audio_path,
-        sample_mode=args.sample_mode,
-        do_sample=bool(args.do_sample),
-        streaming=bool(args.streaming),
-        max_new_frames=args.max_new_frames,
-        voice_clone_max_text_tokens=args.voice_clone_max_text_tokens,
-        seed=args.seed,
-    )
-    t = result["timing"]
-    print(f"\n{'='*55}")
-    print(f" 板端全 AXModel 推理结果")
-    print(f"{'='*55}")
-    print(f"  输出:         {result['audio_path']}")
-    print(f"  音频时长:     {t['audio_duration_sec']:.2f}s")
-    print(f"  推理耗时:     {t['total_infer_time_sec']:.2f}s")
-    print(f"  RTF:          {t['rtf']:.4f}")
-    print(f"{'='*55}\n")
-
-    return result
-
-
-if __name__ == "__main__":
-    main()

models/{axmodels → axmodels_650}/codec_decode.axmodel

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:edcadd065f5c2d114b955805a6045afaac347c33a83e5da13f104516383db0ce
-size 52534674
+oid sha256:27c474ec1cf819d72ebaa0ed33ae8d308eef508da74bb6860d99e916904fcc30
+size 52017863

models/{axmodels → axmodels_650}/tts_decode_step.axmodel

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:effb33389b8447097931036d8d289ce88dc95a1c9361ea3f51910f4f64a113de
-size 441548285
+oid sha256:f64eda392b2186b61830aece478dd6d415f7d584a71ab12f45f28127f5a43e35
+size 144663502

models/{axmodels → axmodels_650}/tts_local_fixed_sampled_frame.axmodel

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bb532a0e1367d1607288b36b3e5fc546942b51e7ea4870fee51272120a9010f4
-size 385673439
+oid sha256:4d929e9c05a26ec0b638e84fc8b4fc3476a7f3a578a09b679067a4ffec8d82f7
+size 215139340

models/{axmodels → axmodels_650}/tts_prefill.axmodel

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a27d6de7e122bf487d8a34ce5a1558267e6b7dc245908157b8e7909a3fb3c29b
-size 146156002
+oid sha256:dfe5ae88a2549f708ab9134d1c6dbd8c53e49aff76fedff8a902459a7c4b6597
+size 147742699

models/onnxmodels/candidates/default_512_fp32/moss_tts_decode_step.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9269ab372a4f59d4db869c44da21b228abf2bf1db7059b1144d0a536c5cec985
+size 881631240

models/onnxmodels/candidates/default_512_fp32/moss_tts_decode_step.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:35f309211297e504ed42b57e3011234023b78a453b8c5ba1e1d690ccb3612136
+size 178765

models/onnxmodels/candidates/static320_fp32/moss_tts_decode_step.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:710ca7f6123372488a1641c579159908d8e6461569ae0b83fc071de8eb3de34f
+size 440816136

models/onnxmodels/candidates/static320_fp32/moss_tts_decode_step.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31294cf854687c937f5769baf44b796b055e559bc74bb0450af327c51c8f6969
+size 151626

models/onnxmodels/candidates/static320_int8_qdq/moss_tts_decode_step.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a59338df1984be8bcd4b49020eae5572c3eff03c4fdda75ead8c03c02e6e8b8
+size 638590

models/onnxmodels/candidates/static320_int8_qdq/moss_tts_decode_step.onnx.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7232d99b91b6be4b0bc86486b7df1c17f05bf6fae93c8629552274ab1a61cd91
+size 186012168

models/onnxmodels/moss_tts_decode_step.data

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:710ca7f6123372488a1641c579159908d8e6461569ae0b83fc071de8eb3de34f
+size 440816136

models/onnxmodels/moss_tts_decode_step.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31294cf854687c937f5769baf44b796b055e559bc74bb0450af327c51c8f6969
+size 151626

models/onnxmodels/tts_decode_step.onnx

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7ea885af519913fb9a79b99523b9a9ed7bc4c1d9673077d6124e00edbad15a65
-size 440954551

infer_board_onnx_decode.py → python/infer_moss_tts.py

@@ -6,6 +6,10 @@ import sys
 from pathlib import Path
 from typing import Optional, Sequence
 
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import numpy as np
+
 _HERE = Path(__file__).resolve().parent
 
 
@@ -13,17 +17,37 @@ def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
     p = argparse.ArgumentParser(
         description=(
             "MOSS-TTS-Nano："
-            "prefill(axmodel) -> decode_step(ONNX CPU) -> local_decoder(axmodel) -> codec_decode(axmodel)。"
+            "默认走全 AXModel 快速路径；也可仅将 "
+            "local_fixed_sampled_frame 切换为 ONNX Runtime CPU，"
+            "用于验证量化后的离散 Token 分叉。"
         )
     )
-    p.add_argument("--config-dir", default=str(_HERE / "configs"),
+    p.add_argument("--config-dir", default=str(_HERE.parent / "config"),
                    help="config directory (default: ./configs)")
-    p.add_argument("--axmodel-dir", default=str(_HERE / "models" / "axmodels"),
+    p.add_argument("--axmodel-dir", default=str(_HERE.parent / "models" / "axmodels_650"),
                    help="axmodel directory (default: ./models/axmodels)")
-    p.add_argument("--onnx-dir", default=str(_HERE / "models" / "onnxmodels"),
-                   help="ONNX model directory (default: ./models/onnxmodels)")
+    p.add_argument("--onnx-dir", default=str(_HERE.parent / "models" / "onnxmodels"),
+                   help="ONNX directory (default: ./models/onnxmodels)")
+    p.add_argument(
+        "--prefill-backend",
+        choices=("axmodel", "onnx"),
+        default="axmodel",
+        help="prefill backend (default: axmodel)",
+    )
+    p.add_argument(
+        "--decode-backend",
+        choices=("axmodel", "onnx"),
+        default="axmodel",
+        help="decode_step backend (default: axmodel)",
+    )
+    p.add_argument(
+        "--local-fixed-backend",
+        choices=("axmodel", "onnx"),
+        default="axmodel",
+        help="local_fixed_sampled_frame backend (default: axmodel)",
+    )
     p.add_argument("--output-audio-path",
-                   default=str(_HERE / "outputs" / "board_onnx_decode.wav"),
+                   default=str(_HERE / "outputs" / "board_axmodel_decode.wav"),
                    help="output WAV path")
 
     text_group = p.add_mutually_exclusive_group(required=True)
@@ -34,9 +58,19 @@ def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
     p.add_argument("--prompt-audio-path", "--reference-audio-path",
                    dest="prompt_audio_path", default=None,
                    help="参考音频路径（语音克隆，覆盖 --voice）")
-    p.add_argument("--sample-mode", choices=("greedy", "fixed", "full"), default="full")
-    p.add_argument("--do-sample", type=int, default=0, choices=[0, 1],
-                   help="是否采样 (0=argmax, 1=sample)")
+    p.add_argument(
+        "--sample-mode",
+        choices=("greedy", "fixed", "full"),
+        default="fixed",
+        help="fixed=单次 local-fixed 快速路径；full/greedy=逐 codebook local-decoder 慢路径",
+    )
+    p.add_argument(
+        "--do-sample",
+        type=int,
+        default=1,
+        choices=[0, 1],
+        help="兼容参数；默认与 fixed 快速路径配置一致",
+    )
     p.add_argument("--streaming", type=int, default=0, choices=[0, 1],
                    help="按文本 chunk 增量写 WAV (1)；不改变 codec 全量解码方式")
     p.add_argument("--max-new-frames", type=int, default=150,
@@ -44,8 +78,23 @@ def parse_args(argv: Optional[Sequence[str]] = None) -> argparse.Namespace:
     p.add_argument("--voice-clone-max-text-tokens", type=int, default=75,
                    help="语音克隆每段最大 token 数")
     p.add_argument("--seed", type=int, default=None, help="随机种子")
+    p.add_argument(
+        "--greedy-prefix-frames",
+        type=int,
+        default=4,
+        help="前 N 帧使用 top-1 音频采样，之后恢复随机采样",
+    )
+    p.add_argument(
+        "--assistant-random-u",
+        type=float,
+        default=None,
+        help="可选：固定每帧继续/停止采样值，取值范围 [0, 1)",
+    )
     p.add_argument("--debug", action="store_true", help="启用 debug 日志")
-    return p.parse_args(argv)
+    args = p.parse_args(argv)
+    if args.assistant_random_u is not None and not 0.0 <= args.assistant_random_u < 1.0:
+        p.error("--assistant-random-u must be in [0, 1)")
+    return args
 
 
 def main(argv: Optional[Sequence[str]] = None) -> dict:
@@ -74,14 +123,27 @@ def main(argv: Optional[Sequence[str]] = None) -> dict:
         config_dir=args.config_dir,
         axmodel_dir=args.axmodel_dir,
         onnx_dir=args.onnx_dir,
-        use_onnx_decode=True,
+        use_onnx_prefill=args.prefill_backend == "onnx",
+        use_onnx_decode=args.decode_backend == "onnx",
+        use_onnx_local_fixed=args.local_fixed_backend == "onnx",
         max_new_frames=args.max_new_frames,
         do_sample=bool(args.do_sample),
         sample_mode=args.sample_mode,
     )
 
-    logging.info("decode_step backend: ONNX (CPU)")
-    logging.info("chain: prefill(axmodel) -> decode_step(ONNX) -> local_decoder(axmodel) -> codec_decode(axmodel)")
+    logging.info("decode_step backend: %s", args.decode_backend.upper())
+    logging.info("prefill backend: %s", args.prefill_backend.upper())
+    local_stage = (
+        f"local_fixed_sampled_frame({args.local_fixed_backend}, fast)"
+        if args.sample_mode == "fixed"
+        else "local_decoder(axmodel, slow x17/frame)"
+    )
+    logging.info(
+        "chain: prefill(%s) -> %s -> decode_step(%s) -> codec_decode(axmodel)",
+        args.prefill_backend,
+        local_stage,
+        args.decode_backend,
+    )
     if args.prompt_audio_path:
         logging.info("参考音频: %s", args.prompt_audio_path)
     else:
@@ -98,15 +160,37 @@ def main(argv: Optional[Sequence[str]] = None) -> dict:
         max_new_frames=args.max_new_frames,
         voice_clone_max_text_tokens=args.voice_clone_max_text_tokens,
         seed=args.seed,
+        greedy_prefix_frames=args.greedy_prefix_frames,
+        assistant_random_u=args.assistant_random_u,
     )
+    token_path = Path(args.output_audio_path).expanduser().resolve().with_suffix(".tokens.npy")
+    token_path.parent.mkdir(parents=True, exist_ok=True)
+    np.save(token_path, np.asarray(result["audio_token_ids"], dtype=np.int32))
+    result["audio_token_path"] = str(token_path)
     t = result["timing"]
     print(f"\n{'='*55}")
-    print(f" 板端 ONNX decode_step 推理结果")
+    result_kind = (
+        "板端混合 ONNX/AXModel 推理结果"
+        if (
+            args.local_fixed_backend == "onnx"
+            or args.prefill_backend == "onnx"
+            or args.decode_backend == "onnx"
+        )
+        else "板端全 AXModel 推理结果"
+    )
+    print(f" {result_kind}")
     print(f"{'='*55}")
     print(f"  输出:         {result['audio_path']}")
+    print(f"  Token:        {result['audio_token_path']}")
     print(f"  音频时长:     {t['audio_duration_sec']:.2f}s")
     print(f"  推理耗时:     {t['total_infer_time_sec']:.2f}s")
     print(f"  RTF:          {t['rtf']:.4f}")
+    print(f"  生成模型 RTF: {t['generation_model_rtf']:.4f}")
+    print(
+        "  local calls:  "
+        f"fixed={t['per_model_calls'].get('local_fixed_sampled_frame', 0)}  "
+        f"decoder={t['per_model_calls'].get('local_decoder', 0)}"
+    )
     print(f"{'='*55}\n")
 
     return result

python/prepare_request.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+import sentencepiece as spm
+
+
+def build_text_rows(token_ids: list[int], cfg: dict) -> list[list[int]]:
+    row_width = int(cfg["n_vq"]) + 1
+    rows = []
+    for tid in token_ids:
+        row = [int(cfg["audio_pad_token_id"])] * row_width
+        row[0] = int(tid)
+        rows.append(row)
+    return rows
+
+
+def build_audio_prefix_rows(prompt_audio_codes: list[list[int]], cfg: dict) -> list[list[int]]:
+    row_width = int(cfg["n_vq"]) + 1
+    rows = []
+    for code_row in prompt_audio_codes:
+        row = [int(cfg["audio_pad_token_id"])] * row_width
+        row[0] = int(cfg["audio_user_slot_token_id"])
+        for i in range(min(len(code_row), int(cfg["n_vq"]))):
+            row[i + 1] = int(code_row[i])
+        rows.append(row)
+    return rows
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="Prepare C++ MOSS-TTS request rows with Python tokenizer.")
+    ap.add_argument("--config-dir", default="configs")
+    group = ap.add_mutually_exclusive_group(required=True)
+    group.add_argument("--text")
+    group.add_argument("--token-ids", help="comma/space separated SentencePiece token ids")
+    ap.add_argument("--voice", default="Junhao")
+    ap.add_argument("--output", default="cpp/cpp_request.txt")
+    ap.add_argument("--seed", type=int, default=1234)
+    ap.add_argument("--max-new-frames", type=int, default=128)
+    ap.add_argument("--greedy-prefix-frames", type=int, default=4)
+    ap.add_argument(
+        "--assistant-random-u",
+        type=float,
+        default=None,
+        help="fix the continue/end sampling value; 0.5 selects the more probable decision",
+    )
+    args = ap.parse_args()
+    if args.max_new_frames <= 0:
+        raise SystemExit("--max-new-frames must be positive")
+    if args.greedy_prefix_frames < 0:
+        raise SystemExit("--greedy-prefix-frames must be non-negative")
+    if args.assistant_random_u is not None and not 0.0 <= args.assistant_random_u < 1.0:
+        raise SystemExit("--assistant-random-u must be in [0, 1)")
+
+    config_dir = Path(args.config_dir)
+    manifest = json.loads((config_dir / "browser_poc_manifest.json").read_text("utf-8"))
+    tts_meta = json.loads((config_dir / "tts_browser_onnx_meta.json").read_text("utf-8"))
+    cfg = manifest["tts_config"]
+    templates = manifest["prompt_templates"]
+
+    if args.token_ids:
+        token_ids = [int(x) for x in args.token_ids.replace(",", " ").split() if x.strip()]
+    else:
+        sp = spm.SentencePieceProcessor(model_file=str(config_dir / manifest["model_files"]["tokenizer_model"]))
+        token_ids = [int(x) for x in sp.encode(str(args.text), out_type=int)]
+
+    voice = None
+    for item in manifest["builtin_voices"]:
+        if item["voice"] == args.voice:
+            voice = item
+            break
+    if voice is None:
+        raise SystemExit(f"voice not found: {args.voice}")
+
+    prefix_ids = [
+        *templates["user_prompt_prefix_token_ids"],
+        int(cfg["audio_start_token_id"]),
+    ]
+    suffix_ids = [
+        int(cfg["audio_end_token_id"]),
+        *templates["user_prompt_after_reference_token_ids"],
+        *token_ids,
+        *templates["assistant_prompt_prefix_token_ids"],
+        int(cfg["audio_start_token_id"]),
+    ]
+    rows = [
+        *build_text_rows(prefix_ids, cfg),
+        *build_audio_prefix_rows(voice["prompt_audio_codes"], cfg),
+        *build_text_rows(suffix_ids, cfg),
+    ]
+    actual_len = len(rows)
+    static_len = int(tts_meta["static_shapes"]["prefill_seq"])
+    row_width = int(cfg["n_vq"]) + 1
+    if actual_len > static_len:
+        raise SystemExit(f"request too long: actual={actual_len}, static={static_len}")
+    pad_row = [int(cfg["audio_pad_token_id"])] * row_width
+    pad_row[0] = int(cfg["pad_token_id"])
+    rows = rows + [pad_row[:] for _ in range(static_len - actual_len)]
+    mask = [1] * actual_len + [0] * (static_len - actual_len)
+
+    # Serialize NumPy PCG64 draws so C++ and Python feed exactly the same
+    # four-input local-fixed sampler.  Prefix frames consume their draws first,
+    # then replace audio u with zero (top-1), matching the Python runtime.
+    sampler_steps = int(args.max_new_frames)
+    rng = np.random.default_rng(int(args.seed))
+    assistant_random_u: list[np.float32] = []
+    audio_random_u: list[list[np.float32]] = []
+    for step in range(sampler_steps):
+        sampled_assistant_u = np.float32(rng.random())
+        if args.assistant_random_u is not None:
+            sampled_assistant_u = np.float32(args.assistant_random_u)
+        assistant_random_u.append(sampled_assistant_u)
+        audio_row = np.asarray(rng.random(int(cfg["n_vq"])), dtype=np.float32)
+        if step < int(args.greedy_prefix_frames):
+            audio_row.fill(0.0)
+        audio_random_u.append([np.float32(value) for value in audio_row])
+
+    out = Path(args.output)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    with out.open("w", encoding="utf-8") as f:
+        f.write(f"actual_len {actual_len}\n")
+        f.write(f"prefill_seq {static_len}\n")
+        f.write(f"row_width {row_width}\n")
+        f.write("input_ids\n")
+        for row in rows:
+            f.write(" ".join(str(int(x)) for x in row) + "\n")
+        f.write("attention_mask\n")
+        f.write(" ".join(str(int(x)) for x in mask) + "\n")
+        f.write(f"sampler_steps {sampler_steps}\n")
+        f.write("assistant_random_u\n")
+        f.write(" ".join(format(float(value), ".9g") for value in assistant_random_u) + "\n")
+        f.write("audio_random_u\n")
+        for row in audio_random_u:
+            f.write(" ".join(format(float(value), ".9g") for value in row) + "\n")
+    print(
+        f"wrote {out} actual_len={actual_len} text_tokens={len(token_ids)} "
+        f"sampler_steps={sampler_steps} greedy_prefix_frames={args.greedy_prefix_frames}"
+    )
+
+
+if __name__ == "__main__":
+    main()

requirements-hybrid.txt

@@ -0,0 +1,2 @@
+-r requirements.txt
+onnxruntime

requirements.txt

@@ -1,5 +1,2 @@
 numpy
 sentencepiece
-onnxruntime>=1.16.0
-soundfile
-scipy

run_ax650.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PYTHON_BIN="${PYTHON_BIN:-python3}"
+TEXT="你好，今天是美好的一天。"
+VOICE="Junhao"
+SEED=1234
+MAX_NEW_FRAMES=110
+GREEDY_PREFIX_FRAMES=4
+DECODE_BACKEND="onnx"
+DECODE_ONNX_THREADS=0
+DECODE_WARMUP_FRAMES=32
+DECODE_ONNX="$ROOT_DIR/models/onnxmodels/moss_tts_decode_step.onnx"
+OUTPUT_WAV="$ROOT_DIR/outputs/moss_tts_ax650.wav"
+OUTPUT_LOG="$ROOT_DIR/outputs/moss_tts_ax650.log"
+
+usage() {
+  echo "usage: $0 --text TEXT [--voice NAME] [--decode-backend onnx|axmodel]"
+  echo "       [--decode-onnx FILE] [--decode-onnx-threads N] [--decode-warmup-frames N]"
+  echo "       [--seed N] [--max-new-frames N] [--output-wav FILE] [--output-log FILE]"
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --text) TEXT="$2"; shift 2 ;;
+    --voice) VOICE="$2"; shift 2 ;;
+    --seed) SEED="$2"; shift 2 ;;
+    --max-new-frames) MAX_NEW_FRAMES="$2"; shift 2 ;;
+    --greedy-prefix-frames) GREEDY_PREFIX_FRAMES="$2"; shift 2 ;;
+    --decode-backend) DECODE_BACKEND="$2"; shift 2 ;;
+    --decode-onnx) DECODE_ONNX="$2"; shift 2 ;;
+    --decode-onnx-threads) DECODE_ONNX_THREADS="$2"; shift 2 ;;
+    --decode-warmup-frames) DECODE_WARMUP_FRAMES="$2"; shift 2 ;;
+    --output-wav) OUTPUT_WAV="$2"; shift 2 ;;
+    --output-log) OUTPUT_LOG="$2"; shift 2 ;;
+    -h|--help) usage; exit 0 ;;
+    *) echo "unknown arg: $1" >&2; usage >&2; exit 2 ;;
+  esac
+done
+
+mkdir -p "$(dirname "$OUTPUT_WAV")" "$(dirname "$OUTPUT_LOG")"
+export LD_LIBRARY_PATH="$ROOT_DIR/bin/moss_tts_ax650:${LD_LIBRARY_PATH:-}"
+
+if [[ "$DECODE_BACKEND" == "onnx" ]]; then
+  [[ -f "$DECODE_ONNX" ]] || { echo "missing decode ONNX: $DECODE_ONNX" >&2; exit 1; }
+  EXTRA=(--decode-backend onnx --decode-onnx "$DECODE_ONNX"
+         --decode-onnx-threads "$DECODE_ONNX_THREADS"
+         --decode-warmup-frames "$DECODE_WARMUP_FRAMES")
+elif [[ "$DECODE_BACKEND" == "axmodel" ]]; then
+  EXTRA=(--decode-backend axmodel --decode-axmodel "$ROOT_DIR/models/axmodels_650/tts_decode_step.axmodel")
+else
+  echo "--decode-backend must be onnx or axmodel" >&2
+  exit 2
+fi
+
+REQUEST="$ROOT_DIR/outputs/request.txt"
+"$PYTHON_BIN" "$ROOT_DIR/python/prepare_request.py" \
+  --config-dir "$ROOT_DIR/config" --text "$TEXT" --voice "$VOICE" \
+  --seed "$SEED" --max-new-frames "$MAX_NEW_FRAMES" \
+  --greedy-prefix-frames "$GREEDY_PREFIX_FRAMES" --output "$REQUEST"
+
+"$ROOT_DIR/bin/moss_tts_ax650/moss_tts_ax650" \
+  --axmodel-dir "$ROOT_DIR/models/axmodels_650" \
+  --onnx-dir "$ROOT_DIR/models/onnxmodels" \
+  "${EXTRA[@]}" --request "$REQUEST" \
+  --output-wav "$OUTPUT_WAV" --max-new-frames "$MAX_NEW_FRAMES" \
+  --seed "$SEED" --greedy-prefix-frames "$GREEDY_PREFIX_FRAMES" \
+  2>&1 | tee "$OUTPUT_LOG"

scripts/tts_runtime.py

@@ -85,7 +85,9 @@ _AXMODEL_FILE_MAP: dict[str, str] = {
 }
 
 _ONNX_FILE_MAP: dict[str, str] = {
-    "decode": "tts_decode_step.onnx",
+    "prefill": "patched_moss_tts_prefill_finite_mask.onnx",
+    "decode": "moss_tts_decode_step.onnx",
+    "local_fixed_sampled_frame": "moss_tts_local_fixed_sampled_frame.onnx",
 }
 
 
@@ -463,14 +465,18 @@ class AxTtsRuntime:
         axmodel_dir: str | Path,
         *,
         onnx_dir: str | Path | None = None,
+        use_onnx_prefill: bool = False,
         use_onnx_decode: bool = False,
+        use_onnx_local_fixed: bool = False,
         max_new_frames: int | None = None,
         do_sample: bool = True,
         sample_mode: str | None = None,
     ) -> None:
         self.config_dir  = Path(config_dir).expanduser().resolve()
         self.axmodel_dir = Path(axmodel_dir).expanduser().resolve()
+        self.use_onnx_prefill = bool(use_onnx_prefill)
         self.use_onnx_decode = bool(use_onnx_decode)
+        self.use_onnx_local_fixed = bool(use_onnx_local_fixed)
         if onnx_dir is not None:
             self.onnx_dir = Path(onnx_dir).expanduser().resolve()
         else:
@@ -553,18 +559,34 @@ class AxTtsRuntime:
         sessions: dict[str, Any] = {}
         self._session_input_names: dict[str, list[str]] = {}
 
-        if self.use_onnx_decode:
-            onnx_name = _ONNX_FILE_MAP["decode"]
+        def load_onnx_cpu(key: str) -> Any:
+            onnx_name = _ONNX_FILE_MAP[key]
             onnx_path = self.onnx_dir / onnx_name
             if not onnx_path.exists():
                 raise FileNotFoundError(f"ONNX not found: {onnx_path}")
             if not _HAVE_ORT:
-                raise RuntimeError("onnxruntime not installed; cannot load ONNX decode_step.")
-            sess = ort.InferenceSession(str(onnx_path), providers=["CPUExecutionProvider"])
-            sessions["decode"] = sess
-            self._model_display_names["decode"] = f"{onnx_path.name} [onnxruntime CPU]"
-            self._session_input_names["decode"] = [inp.name for inp in sess.get_inputs()]
-            logging.info("loaded decode → %s (onnxruntime CPU)", onnx_path.name)
+                raise RuntimeError(
+                    f"onnxruntime not installed; cannot load ONNX session {key}."
+                )
+            available_providers = ort.get_available_providers()
+            if "CPUExecutionProvider" not in available_providers:
+                raise RuntimeError(
+                    "Hybrid inference requires ONNX Runtime CPUExecutionProvider; "
+                    f"available providers: {available_providers}"
+                )
+            sess = ort.InferenceSession(
+                str(onnx_path), providers=["CPUExecutionProvider"]
+            )
+            sessions[key] = sess
+            self._model_display_names[key] = (
+                f"{onnx_path.name} [onnxruntime CPU]"
+            )
+            self._session_input_names[key] = [inp.name for inp in sess.get_inputs()]
+            logging.info("loaded %s → %s (onnxruntime CPU)", key, onnx_path.name)
+            return sess
+
+        if self.use_onnx_decode:
+            load_onnx_cpu("decode")
         else:
             axmodel_name = _AXMODEL_FILE_MAP["decode"]
             axmodel_path = self.axmodel_dir / axmodel_name
@@ -577,7 +599,15 @@ class AxTtsRuntime:
             self._session_input_names["decode"] = [inp.name for inp in sess.get_inputs()]
             logging.info("loaded decode → %s (axmodel)", axmodel_path.name)
 
+        if self.use_onnx_local_fixed:
+            load_onnx_cpu("local_fixed_sampled_frame")
+
+        if self.use_onnx_prefill:
+            load_onnx_cpu("prefill")
+
         for key in ("prefill", "local_decoder", "local_fixed_sampled_frame", "codec_decode", "codec_encode"):
+            if key in sessions:
+                continue
             if key not in _AXMODEL_FILE_MAP:
                 continue
             axmodel_name = _AXMODEL_FILE_MAP[key]
@@ -934,6 +964,8 @@ class AxTtsRuntime:
         global_hidden: np.ndarray,
         *,
         previous_token_sets_by_channel: list[set[int]],
+        frame_index: int | None = None,
+        greedy_prefix_frames: int = 0,
     ) -> tuple[bool, list[int]]:
         n_vq = int(self.manifest["tts_config"]["n_vq"])
         codebook_size = int(self.tts_meta["model_config"]["audio_codebook_sizes"][0])
@@ -950,13 +982,17 @@ class AxTtsRuntime:
         }
         asst_u: float | None = None
         if "assistant_random_u" in session_input_names:
-            asst_u = float(self.rng.random())
+            # Always consume the seeded draw so fixing only the assistant
+            # continue/end decision does not shift subsequent audio draws.
+            sampled_asst_u = float(self.rng.random())
+            fixed_asst_u = getattr(self, "local_fixed_assistant_random_u", None)
+            asst_u = sampled_asst_u if fixed_asst_u is None else float(fixed_asst_u)
             input_feed["assistant_random_u"] = np.array([asst_u], dtype=np.float32)
         if "audio_random_u" in session_input_names:
-            input_feed["audio_random_u"] = np.asarray(
-                [[float(self.rng.random()) for _ in range(n_vq)]],
-                dtype=np.float32,
-            )
+            audio_random_u = [float(self.rng.random()) for _ in range(n_vq)]
+            if frame_index is not None and frame_index < int(greedy_prefix_frames):
+                audio_random_u = [0.0] * n_vq
+            input_feed["audio_random_u"] = np.asarray([audio_random_u], dtype=np.float32)
         outputs = self._run_session("local_fixed_sampled_frame", input_feed)
         out_names = [o.name for o in sess.get_outputs()]
         named = dict(zip(out_names, outputs, strict=True))
@@ -970,12 +1006,21 @@ class AxTtsRuntime:
         )
         return should_continue, [int(x) for x in frame_ids]
 
-    def _can_use_local_fixed_sampled_frame(self) -> bool:
+    def _local_fixed_sampled_frame_mode(self) -> str | None:
         sess = self.sessions.get("local_fixed_sampled_frame")
         if sess is None:
-            return False
+            return None
         session_input_names = {inp.name for inp in sess.get_inputs()}
-        return "audio_random_u" in session_input_names
+        required_inputs = {"global_hidden", "repetition_seen_mask"}
+        supported_inputs = required_inputs | {"assistant_random_u", "audio_random_u"}
+        if not required_inputs.issubset(session_input_names):
+            return None
+        if not session_input_names.issubset(supported_inputs):
+            return None
+        return "audio_sampling" if "audio_random_u" in session_input_names else "audio_argmax"
+
+    def _can_use_local_fixed_sampled_frame(self) -> bool:
+        return self._local_fixed_sampled_frame_mode() is not None
 
     def run_local_decoder(
         self,
@@ -1076,15 +1121,42 @@ class AxTtsRuntime:
         consecutive_pad_frames = 0
         _MAX_CONSECUTIVE_PAD_FRAMES = 10  # 0.8s silence → force stop (guard against quantized AXModel)
 
+        local_fixed_mode = self._local_fixed_sampled_frame_mode()
+        use_local_fixed = (
+            generation_defaults["sample_mode"] == SAMPLE_MODE_FIXED
+            and local_fixed_mode is not None
+        )
+        if use_local_fixed:
+            logging.info(
+                "[local-route] fast_path=local_fixed_sampled_frame mode=%s calls_per_frame=1",
+                local_fixed_mode,
+            )
+        else:
+            if "local_decoder" not in self.sessions:
+                raise RuntimeError(
+                    "local-fixed fast path is unavailable and local_decoder fallback was not loaded"
+                )
+            fallback_reason = (
+                f"sample_mode={generation_defaults['sample_mode']}"
+                if generation_defaults["sample_mode"] != SAMPLE_MODE_FIXED
+                else "local_fixed inputs are unsupported or model is missing"
+            )
+            logging.warning(
+                "[local-route] slow_path=local_decoder calls_per_frame=17 reason=%s",
+                fallback_reason,
+            )
+
         for step in range(int(generation_defaults["max_new_frames"])):
             frame: list[int] = []
 
-            if (
-                generation_defaults["sample_mode"] == SAMPLE_MODE_FIXED
-                and self._can_use_local_fixed_sampled_frame()
-            ):
+            if use_local_fixed:
                 should_continue, frame = self.run_local_fixed_sampled_frame(
-                    global_hidden, previous_token_sets_by_channel=prev_tok_sets
+                    global_hidden,
+                    previous_token_sets_by_channel=prev_tok_sets,
+                    frame_index=step,
+                    greedy_prefix_frames=int(
+                        generation_defaults.get("greedy_prefix_frames", 0)
+                    ),
                 )
                 if not should_continue:
                     logging.info("[gen] frame %d: should_continue=False → 停止生成", step)
@@ -1093,14 +1165,6 @@ class AxTtsRuntime:
                     prev_tokens[ci].append(tok)
                     prev_tok_sets[ci].add(tok)
             elif "local_decoder" in self.sessions:
-                if (
-                    generation_defaults["sample_mode"] == SAMPLE_MODE_FIXED
-                    and "local_fixed_sampled_frame" in self.sessions
-                    and step == 0
-                ):
-                    logging.warning(
-                        "local_fixed_sampled_frame 缺少 audio_random_u 输入，回退到 local_decoder 随机采样路径"
-                    )
                 local_text_logits, _ = self.run_local_decoder(global_hidden, 0, [])
                 next_text = _sample_assistant_text_token(
                     local_text_logits, self.manifest, generation_defaults, self.rng
@@ -1319,6 +1383,8 @@ class AxTtsRuntime:
         max_new_frames: int | None = None,
         voice_clone_max_text_tokens: int = 75,
         seed: int | None = None,
+        greedy_prefix_frames: int = 0,
+        assistant_random_u: float | None = None,
     ) -> dict[str, Any]:
         self._reset_timing_stats()
         gen = self.manifest["generation_defaults"]
@@ -1333,6 +1399,14 @@ class AxTtsRuntime:
         normalized_mode = self._normalize_sample_mode(sample_mode, do_sample)
         gen["sample_mode"] = normalized_mode
         gen["do_sample"] = normalized_mode != SAMPLE_MODE_GREEDY
+        if int(greedy_prefix_frames) < 0:
+            raise ValueError("greedy_prefix_frames must be non-negative")
+        gen["greedy_prefix_frames"] = int(greedy_prefix_frames)
+        if assistant_random_u is not None and not 0.0 <= float(assistant_random_u) < 1.0:
+            raise ValueError("assistant_random_u must be in [0, 1)")
+        self.local_fixed_assistant_random_u = (
+            None if assistant_random_u is None else float(assistant_random_u)
+        )
         if seed is not None:
             self.rng = np.random.default_rng(int(seed))
 
@@ -1415,6 +1489,29 @@ class AxTtsRuntime:
             )
             rtf = (total_infer_time / audio_duration_sec) if audio_duration_sec > 0 else float("inf")
             model_time_total = sum(self._model_time_stats.values())
+            frame_audio_duration_sec = (
+                float(self.codec_meta["codec_config"]["downsample_rate"]) / float(sample_rate)
+                if sample_rate > 0 else 0.0
+            )
+            generated_audio_duration_sec = len(all_generated_frames) * frame_audio_duration_sec
+            generation_model_keys = ("local_fixed_sampled_frame", "local_decoder", "decode")
+            generation_model_time_sec = sum(
+                self._model_time_stats.get(key, 0.0) for key in generation_model_keys
+            )
+            generation_model_rtf = (
+                generation_model_time_sec / generated_audio_duration_sec
+                if generated_audio_duration_sec > 0 else float("inf")
+            )
+            realtime_budget_ms_per_frame = frame_audio_duration_sec * 1000.0
+            per_model_mean_ms = {
+                key: (
+                    self._model_time_stats.get(key, 0.0)
+                    * 1000.0
+                    / self._model_call_stats.get(key, 1)
+                    if self._model_call_stats.get(key, 0) > 0 else 0.0
+                )
+                for key in self._model_display_names
+            }
             audio_path = out_path if streaming else _write_waveform_to_wav(out_path, final_waveform, sample_rate)
             logging.info("已保存 %s  sample_rate=%s  frames=%s", audio_path, sample_rate, len(all_generated_frames))
             logging.info(
@@ -1424,14 +1521,26 @@ class AxTtsRuntime:
                 rtf,
                 model_time_total,
             )
+            logging.info(
+                "[timing] generated_frames=%d  realtime_budget=%.3fms/frame  "
+                "generation_model_time=%.3fs  generation_model_rtf=%.4f",
+                len(all_generated_frames),
+                realtime_budget_ms_per_frame,
+                generation_model_time_sec,
+                generation_model_rtf,
+            )
             for key in sorted(self._model_display_names):
                 model_name = self._model_display_names[key]
+                calls = self._model_call_stats.get(key, 0)
+                total_sec = self._model_time_stats.get(key, 0.0)
                 logging.info(
-                    "[timing] session=%s  model=%s  calls=%d  total=%.3fs",
+                    "[timing] session=%s  model=%s  calls=%d  total=%.3fs  mean=%.3fms  share=%.1f%%",
                     key,
                     model_name,
-                    self._model_call_stats.get(key, 0),
-                    self._model_time_stats.get(key, 0.0),
+                    calls,
+                    total_sec,
+                    per_model_mean_ms[key],
+                    (100.0 * total_sec / total_infer_time) if total_infer_time > 0 else 0.0,
                 )
             return {
                 "audio_path": str(audio_path),
@@ -1447,8 +1556,14 @@ class AxTtsRuntime:
                     "audio_duration_sec": audio_duration_sec,
                     "rtf": rtf,
                     "model_time_total_sec": model_time_total,
+                    "frame_audio_duration_sec": frame_audio_duration_sec,
+                    "realtime_budget_ms_per_frame": realtime_budget_ms_per_frame,
+                    "generated_audio_duration_sec": generated_audio_duration_sec,
+                    "generation_model_time_sec": generation_model_time_sec,
+                    "generation_model_rtf": generation_model_rtf,
                     "per_model_time_sec": dict(self._model_time_stats),
                     "per_model_calls": dict(self._model_call_stats),
+                    "per_model_mean_ms": per_model_mean_ms,
                     "per_model_display_name": dict(self._model_display_names),
                     "used_model_keys": list(self._used_model_keys),
                 },

verify_package.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+set -euo pipefail
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$ROOT_DIR"
+required=(
+  README.md configuration.json config.json requirements.txt run_ax650.sh
+  python/infer_moss_tts.py python/prepare_request.py
+  scripts/axe_session.py scripts/tts_runtime.py scripts/__init__.py
+  config/browser_poc_manifest.json config/codec_browser_onnx_meta.json
+  config/tts_browser_onnx_meta.json config/tokenizer.model
+  models/axmodels_650/tts_prefill.axmodel models/axmodels_650/tts_decode_step.axmodel
+  models/axmodels_650/tts_local_fixed_sampled_frame.axmodel models/axmodels_650/codec_decode.axmodel
+  models/onnxmodels/moss_tts_decode_step.onnx models/onnxmodels/moss_tts_decode_step.data
+  models/onnxmodels/candidates/default_512_fp32/moss_tts_decode_step.onnx
+  models/onnxmodels/candidates/default_512_fp32/moss_tts_decode_step.data
+  models/onnxmodels/candidates/static320_int8_qdq/moss_tts_decode_step.onnx
+  models/onnxmodels/candidates/static320_int8_qdq/moss_tts_decode_step.onnx.data
+  models/onnxmodels/candidates/static320_fp32/moss_tts_decode_step.onnx
+  models/onnxmodels/candidates/static320_fp32/moss_tts_decode_step.data
+  bin/moss_tts_ax650/moss_tts_ax650 bin/moss_tts_ax650/libonnxruntime.so.1.23.2
+)
+for path in "${required[@]}"; do
+  [[ -f "$path" ]] || { echo "[FAIL] missing $path" >&2; exit 1; }
+done
+python3 -B - <<'PY'
+import ast
+from pathlib import Path
+
+for path in (
+    Path("python/infer_moss_tts.py"),
+    Path("python/prepare_request.py"),
+    Path("scripts/axe_session.py"),
+    Path("scripts/tts_runtime.py"),
+):
+    ast.parse(path.read_text(encoding="utf-8"), filename=str(path))
+PY
+bash -n run_ax650.sh
+readelf -d bin/moss_tts_ax650/moss_tts_ax650 | grep -q 'libonnxruntime.so.1'
+echo "[PASS] Hugging Face package structure and runtime dependencies are valid"