Move verified ONNX export to its dedicated repository

README.md

@@ -262,11 +262,14 @@ The result is a 24 kHz mono `float32` waveform. Long input is split at punctuati
 
 ### ONNX Runtime
 
-A verified FP32 ONNX export is included under [`onnx/`](https://huggingface.co/owensong/Inflect-Micro-v2/tree/main/onnx).
-It supports dynamic lengths, CPU/CUDA/DirectML provider selection, deterministic
-seeds, and the same long-text wrapper without importing PyTorch:
+The official verified FP32 export is published separately as
+[`Inflect-Micro-v2-ONNX`](https://huggingface.co/owensong/Inflect-Micro-v2-ONNX).
+It supports dynamic lengths, CPU/CUDA/DirectML provider selection,
+deterministic seeds, and the same long-text wrapper without importing PyTorch:
 
 ```bash
+git clone https://huggingface.co/owensong/Inflect-Micro-v2-ONNX
+cd Inflect-Micro-v2-ONNX
 python -m pip install -r onnx/requirements.txt
 python onnx/inference_onnx.py \
   --text "The complete model now runs through ONNX Runtime." \
@@ -278,7 +281,7 @@ python onnx/inference_onnx.py \
 The neural model is split into `duration.onnx` and `decode.onnx`; together they
 contain the complete learned text-to-waveform path. The English eSpeak-ng
 frontend remains CPU-side code. See the
-[`ONNX guide`](https://huggingface.co/owensong/Inflect-Micro-v2/blob/main/onnx/README.md)
+[`ONNX repository`](https://huggingface.co/owensong/Inflect-Micro-v2-ONNX)
 for graph contracts, provenance, parity measurements, browser deployment, and
 re-export instructions.
 
@@ -342,7 +345,7 @@ This release is inference-first. New-voice and new-language adaptation are **not
 | `inference.py` | Public Python API and CLI |
 | `inflect_vits_frontend.py` | English normalization, phonemization, and punctuation frontend |
 | `runtime/` | Self-contained model implementation |
-| `onnx/` | Verified FP32 ONNX graphs, torch-free runner, parity report, checksums, and exporter |
+| [`Inflect-Micro-v2-ONNX`](https://huggingface.co/owensong/Inflect-Micro-v2-ONNX) | Separate official FP32 ONNX graphs, torch-free runner, parity report, checksums, and exporter |
 | `samples/` | Held-out example generations |
 | `evaluation/final/` | Frozen benchmark prompts, reports, and protocol artifacts |
 | `docs/` | API, deployment, evaluation, adaptation, and export documentation |

docs/EXPORTS.md

@@ -6,14 +6,16 @@
 | --- | --- | --- |
 | PyTorch FP32 | Supported | Canonical weights and the fully tested runtime. |
 | PyTorch FP16/BF16 | Not released | Smaller in memory, but not validated for waveform quality or CPU compatibility. |
-| ONNX FP32 | Supported | Verified dynamic-length graphs, torch-free Python runner, and reproducible exporter under `onnx/`. |
+| ONNX FP32 | Supported | Separate official [`Inflect-Micro-v2-ONNX`](https://huggingface.co/owensong/Inflect-Micro-v2-ONNX) repository with verified dynamic-length graphs, a torch-free Python runner, and a reproducible exporter. |
 | INT8 / INT4 | Not released | Naive weight quantization can audibly damage the integrated waveform decoder. |
 | GGUF | Not applicable today | GGUF targets transformer/LLM runtimes and is not a drop-in container for this VITS-family convolutional waveform model. |
 | Core ML / TFLite | Not released | Requires separate conversion and target-device validation. |
 
 ## Supported ONNX package
 
-The official ONNX package contains:
+The official
+[`Inflect-Micro-v2-ONNX`](https://huggingface.co/owensong/Inflect-Micro-v2-ONNX)
+package contains:
 
 - `onnx/duration.onnx`: token sequence to aligned acoustic distribution;
 - `onnx/decode.onnx`: aligned distribution and seeded noise to waveform;
@@ -26,7 +28,7 @@ seeded latent sampling, speed and variation controls, punctuation-aware
 long-text chunking, and CPU/CUDA/DirectML provider selection. eSpeak-ng remains
 the non-neural English frontend and is not embedded in the ONNX graphs.
 
-See [`onnx/README.md`](https://huggingface.co/owensong/Inflect-Micro-v2/blob/main/onnx/README.md)
+See the [`Inflect-Micro-v2-ONNX` model card](https://huggingface.co/owensong/Inflect-Micro-v2-ONNX)
 for installation and verified parity measurements.
 
 ## Why only verified FP32 ships

onnx/README.md

@@ -1,120 +1,10 @@
-# Inflect-Micro-v2 ONNX
+# ONNX export moved
 
-Official, verified FP32 ONNX Runtime export of
-[Inflect-Micro-v2](https://huggingface.co/owensong/Inflect-Micro-v2).
-The neural model is split into two graphs:
+The official verified FP32 ONNX Runtime package now lives in its own model
+repository:
 
-| File | Purpose | Size |
-| --- | --- | ---: |
-| `duration.onnx` | Text tokens to aligned acoustic distribution | 7.32 MB |
-| `decode.onnx` | Acoustic distribution and seeded noise to 24 kHz waveform | 30.43 MB |
+## [owensong/Inflect-Micro-v2-ONNX](https://huggingface.co/owensong/Inflect-Micro-v2-ONNX)
 
-The complete ONNX neural weights are about **37.75 MB**. The original FP32
-PyTorch checkpoint remains the canonical source of truth.
-
-## Install
-
-```bash
-python -m pip install -r onnx/requirements.txt
-```
-
-ONNX Runtime CPU is installed by default. For another execution provider, use
-the appropriate ONNX Runtime package for the target platform.
-
-## Generate speech
-
-From the repository root:
-
-```bash
-python onnx/inference_onnx.py \
-  --text "A compact voice can still sound clear and expressive." \
-  --output sample.wav \
-  --provider cpu \
-  --speed 1.0 \
-  --variation 0.667 \
-  --seed 7
-```
-
-Python:
-
-```python
-import sys
-
-sys.path.insert(0, "onnx")
-from inference_onnx import InflectONNX
-
-tts = InflectONNX(".", provider="cpu")
-sample_rate, waveform = tts.synthesize(
-    "Inflect runs through ONNX Runtime.",
-    speed=1.0,
-    variation=0.667,
-    seed=7,
-)
-```
-
-Accepted provider aliases are `cpu`, `cuda`, and `directml`. The corresponding
-provider must exist in the installed ONNX Runtime build.
-
-## What the export includes
-
-- Dynamic text and waveform lengths
-- The duration predictor, acoustic generator, flow, and waveform decoder
-- Seeded stochastic latent sampling in the Python wrapper
-- The same punctuation-aware long-text chunking used by the PyTorch package
-- 24 kHz mono `float32` waveform output
-
-The English normalization and phonemization frontend remains Python code and
-uses eSpeak-ng on the CPU. The ONNX files contain the learned neural graphs,
-not eSpeak-ng itself.
-
-## Verification
-
-The packaged graphs pass:
-
-- ONNX checker validation at opset 17
-- Dynamic-length inference tests
-- Short- and long-form end-to-end synthesis
-- Same-seed determinism and different-seed variation checks
-- Direct numerical comparison with the canonical PyTorch checkpoint
-- Independent re-export comparison from the published `model.pth`
-
-The direct PyTorch comparison measured a maximum absolute waveform error of
-`1.7583e-05`, mean absolute error of `2.2595e-07`, and correlation above
-`0.9999999999`. An independent re-export matched this package within
-`1.0617e-07` maximum waveform error.
-
-See [`parity_report.json`](parity_report.json), [`SOURCE.json`](SOURCE.json),
-and [`checksums.sha256`](checksums.sha256) for machine-readable details.
-
-## Re-export
-
-The export script is included for reproducibility:
-
-```bash
-python -m pip install torch==2.4.1 onnx==1.19.1
-python onnx/export_onnx.py \
-  --model-dir . \
-  --output-dir onnx-reexport \
-  --model-name Inflect-Micro-v2 \
-  --source-repository owensong/Inflect-Micro-v2 \
-  --source-revision 3e8c567f9bce1a309eea12d38ca9fbf7050df72e
-```
-
-Serialization hashes can differ across exporter versions even when numerical
-outputs match. Validate outputs rather than expecting byte-identical files.
-
-## Browser implementation and credit
-
-Robert Bak produced the original ONNX conversion and a complete browser runner:
-[robertbak/webtts-inflect](https://github.com/robertbak/webtts-inflect).
-The official package preserves that conversion credit and adds checkpoint
-provenance, metadata, reproducible export tooling, and Python ONNX Runtime
-validation. The browser project is Apache-2.0 and runs synthesis locally with
-ONNX Runtime Web and an eSpeak-ng WASM frontend.
-
-## Quantization status
-
-Only verified FP32 ONNX graphs are released. INT8 and INT4 are not included:
-naive quantization of the flow and waveform decoder can produce audible
-degradation, and no quantized build has passed matched listening and
-intelligibility validation yet.
+This canonical repository remains the PyTorch base model. The separate ONNX
+repository includes both graphs, the torch-free runner, export script, parity
+report, checksums, runtime files, and license notices.

onnx/SOURCE.json

@@ -1,16 +0,0 @@
-{
-  "format": "inflect_v2_onnx_source_v1",
-  "model": "Inflect-Micro-v2",
-  "source_repository": "owensong/Inflect-Micro-v2",
-  "source_revision": "3e8c567f9bce1a309eea12d38ca9fbf7050df72e",
-  "source_model_file": "model.pth",
-  "source_model_sha256": "3eede065c9ccfa88ade0a5a9a5c23de34afcbbb32213e59aad44d5cf100fdee8",
-  "conversion_repository": "https://github.com/robertbak/webtts-inflect",
-  "conversion_commit": "60832b1978115e4ed7fdddce4d9b9fd9161f9fe7",
-  "conversion_author": "Robert Bak",
-  "official_packaging": "Owen Song",
-  "precision": "FP32",
-  "onnx_opset": 17,
-  "sample_rate_hz": 24000,
-  "license": "Apache-2.0"
-}

onnx/checksums.sha256

@@ -1,8 +0,0 @@
-7940923add86f76e7fa78d910b0632ca1779f8cc9a2ca2b49236381a9ca77183  decode.onnx
-b728ca2564b9e5b7d6cf5e446f65e02a6fe2f1880ba281466fec93a667dd2388  duration.onnx
-77bd27277861c8cae670247e3c9e3b976134a4886506fb069331aa6828752be6  export_onnx.py
-cf48c4812f68e8315d80568e93650c64a7ad3fdfb9a0051c61a0d1d0746df274  inference_onnx.py
-10c88564d24fe65ea730dc6ec98aa19ec74d3590efa427595a3c122c4c0f7039  parity_report.json
-ecfaf6a3edca6ffc3152a61ccc6c27240f42daaa0ddf6efc08e1f9b277295734  README.md
-43abd2c128e4296f1f0171f12946f3fc7dee3f8c8e2bb1858bcae6b43b62b3c9  requirements.txt
-e950bf44034b011a64bba3773b388e386418ef952c3cd17ceefda5bfa94a3aaa  SOURCE.json

onnx/decode.onnx

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

onnx/duration.onnx

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

onnx/export_onnx.py

@@ -1,261 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-import logging
-import sys
-from pathlib import Path
-
-import onnx
-import torch
-from torch import nn
-
-
-PACKAGE_ROOT = Path(__file__).resolve().parents[1]
-commons = None
-
-
-class DurationGraph(nn.Module):
-    def __init__(self, model: nn.Module) -> None:
-        super().__init__()
-        self.enc_p = model.enc_p
-        self.dp = model.dp
-
-    def forward(
-        self,
-        tokens: torch.Tensor,
-        lengths: torch.Tensor,
-        length_scale: torch.Tensor,
-    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
-        hidden, m_p, logs_p, x_mask = self.enc_p(tokens, lengths)
-        logw = self.dp(hidden, x_mask, g=None)
-        durations = torch.ceil(torch.exp(logw) * x_mask * length_scale)
-        y_lengths = torch.clamp_min(torch.sum(durations, [1, 2]), 1).long()
-        if commons is None:
-            raise RuntimeError("Runtime helpers were not initialized.")
-        y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(
-            x_mask.dtype
-        )
-        attention_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
-        attention = commons.generate_path(durations, attention_mask)
-        m_p_exp = torch.matmul(
-            attention.squeeze(1),
-            m_p.transpose(1, 2),
-        ).transpose(1, 2)
-        logs_p_exp = torch.matmul(
-            attention.squeeze(1),
-            logs_p.transpose(1, 2),
-        ).transpose(1, 2)
-        return m_p_exp, logs_p_exp, y_mask
-
-
-class DecodeGraph(nn.Module):
-    def __init__(self, model: nn.Module) -> None:
-        super().__init__()
-        self.flow = model.flow
-        self.decoder = model.dec
-
-    def forward(
-        self,
-        m_p_exp: torch.Tensor,
-        logs_p_exp: torch.Tensor,
-        y_mask: torch.Tensor,
-        zp_noise: torch.Tensor,
-        noise_scale: torch.Tensor,
-    ) -> torch.Tensor:
-        z_p = m_p_exp + zp_noise * torch.exp(logs_p_exp) * noise_scale
-        z = self.flow(z_p, y_mask, g=None, reverse=True)
-        return self.decoder(z * y_mask, g=None)
-
-
-def sha256(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as handle:
-        for block in iter(lambda: handle.read(1024 * 1024), b""):
-            digest.update(block)
-    return digest.hexdigest()
-
-
-def load_model(root: Path) -> nn.Module:
-    global commons
-    runtime_root = root / "runtime"
-    sys.path.insert(0, str(runtime_root))
-    sys.path.insert(0, str(root))
-    import commons as runtime_commons
-    import utils
-    from models import SynthesizerTrn
-    from text.symbols import symbols
-
-    commons = runtime_commons
-    hps = utils.get_hparams_from_file(str(root / "config.json"))
-    model = SynthesizerTrn(
-        len(symbols),
-        hps.data.filter_length // 2 + 1,
-        hps.train.segment_size // hps.data.hop_length,
-        **hps.model,
-    ).cpu().eval()
-    logger = logging.getLogger()
-    previous_level = logger.level
-    try:
-        logger.setLevel(logging.WARNING)
-        utils.load_checkpoint(str(root / "model.pth"), model, None)
-    finally:
-        logger.setLevel(previous_level)
-    return model
-
-
-def attach_metadata(
-    path: Path,
-    *,
-    model_name: str,
-    source_repository: str,
-    source_revision: str,
-    source_model_sha256: str,
-) -> None:
-    graph = onnx.load(path)
-    metadata = {
-        "model_name": model_name,
-        "source_repository": source_repository,
-        "source_revision": source_revision,
-        "source_model_sha256": source_model_sha256,
-        "license": "Apache-2.0",
-        "sample_rate_hz": "24000",
-        "precision": "FP32",
-        "onnx_opset": "17",
-        "conversion_author": "Robert Bak (github.com/robertbak)",
-        "official_packaging": "Owen Song (huggingface.co/owensong)",
-    }
-    del graph.metadata_props[:]
-    for key, value in metadata.items():
-        item = graph.metadata_props.add()
-        item.key = key
-        item.value = value
-    onnx.checker.check_model(graph)
-    onnx.save(graph, path)
-
-
-def export(
-    root: Path,
-    output_dir: Path,
-    *,
-    model_name: str,
-    source_repository: str,
-    source_revision: str,
-) -> None:
-    torch.manual_seed(7)
-    model = load_model(root)
-    duration = DurationGraph(model).eval()
-    decode = DecodeGraph(model).eval()
-
-    output_dir.mkdir(parents=True, exist_ok=True)
-    duration_path = output_dir / "duration.onnx"
-    decode_path = output_dir / "decode.onnx"
-
-    tokens = torch.tensor(
-        [[0, 18, 0, 61, 0, 55, 0, 48, 0, 44, 0, 46, 0]],
-        dtype=torch.long,
-    )
-    lengths = torch.tensor([tokens.shape[1]], dtype=torch.long)
-    length_scale = torch.tensor(1.0, dtype=torch.float32)
-
-    torch.onnx.export(
-        duration,
-        (tokens, lengths, length_scale),
-        duration_path,
-        input_names=["tokens", "lengths", "length_scale"],
-        output_names=["m_p_exp", "logs_p_exp", "y_mask"],
-        dynamic_axes={
-            "tokens": {1: "text_len"},
-            "m_p_exp": {2: "mel_len"},
-            "logs_p_exp": {2: "mel_len"},
-            "y_mask": {2: "mel_len"},
-        },
-        opset_version=17,
-        do_constant_folding=True,
-        dynamo=False,
-    )
-
-    with torch.no_grad():
-        m_p_exp, logs_p_exp, y_mask = duration(tokens, lengths, length_scale)
-    zp_noise = torch.randn_like(m_p_exp)
-    noise_scale = torch.tensor(0.667, dtype=torch.float32)
-    torch.onnx.export(
-        decode,
-        (m_p_exp, logs_p_exp, y_mask, zp_noise, noise_scale),
-        decode_path,
-        input_names=[
-            "m_p_exp",
-            "logs_p_exp",
-            "y_mask",
-            "zp_noise",
-            "noise_scale",
-        ],
-        output_names=["waveform"],
-        dynamic_axes={
-            "m_p_exp": {2: "mel_len"},
-            "logs_p_exp": {2: "mel_len"},
-            "y_mask": {2: "mel_len"},
-            "zp_noise": {2: "mel_len"},
-            "waveform": {2: "wav_len"},
-        },
-        opset_version=17,
-        do_constant_folding=True,
-        dynamo=False,
-    )
-
-    source_hash = sha256(root / "model.pth")
-    for path in (duration_path, decode_path):
-        attach_metadata(
-            path,
-            model_name=model_name,
-            source_repository=source_repository,
-            source_revision=source_revision,
-            source_model_sha256=source_hash,
-        )
-
-    manifest = {
-        "format": "inflect_v2_onnx_export_v1",
-        "model_name": model_name,
-        "source_repository": source_repository,
-        "source_revision": source_revision,
-        "source_model_sha256": source_hash,
-        "torch_version": torch.__version__,
-        "onnx_version": onnx.__version__,
-        "opset": 17,
-        "files": {
-            duration_path.name: {
-                "bytes": duration_path.stat().st_size,
-                "sha256": sha256(duration_path),
-            },
-            decode_path.name: {
-                "bytes": decode_path.stat().st_size,
-                "sha256": sha256(decode_path),
-            },
-        },
-    }
-    (output_dir / "export_manifest.json").write_text(
-        json.dumps(manifest, indent=2) + "\n",
-        encoding="utf-8",
-    )
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Export Inflect v2 to ONNX.")
-    parser.add_argument("--model-dir", type=Path, default=PACKAGE_ROOT)
-    parser.add_argument("--output-dir", type=Path, required=True)
-    parser.add_argument("--model-name", required=True)
-    parser.add_argument("--source-repository", required=True)
-    parser.add_argument("--source-revision", required=True)
-    args = parser.parse_args()
-    export(
-        args.model_dir.resolve(),
-        args.output_dir.resolve(),
-        model_name=args.model_name,
-        source_repository=args.source_repository,
-        source_revision=args.source_revision,
-    )
-
-
-if __name__ == "__main__":
-    main()

onnx/inference_onnx.py

@@ -1,229 +0,0 @@
-from __future__ import annotations
-
-import argparse
-import re
-import sys
-from pathlib import Path
-
-import numpy as np
-import onnxruntime as ort
-import soundfile as sf
-
-
-PACKAGE_ROOT = Path(__file__).resolve().parents[1]
-RUNTIME_ROOT = PACKAGE_ROOT / "runtime"
-sys.path.insert(0, str(RUNTIME_ROOT))
-sys.path.insert(0, str(PACKAGE_ROOT))
-
-from inflect_vits_frontend import run_vits_frontend  # noqa: E402
-from text.symbols import symbols  # noqa: E402
-
-
-SAMPLE_RATE = 24_000
-SYMBOL_TO_ID = {symbol: index for index, symbol in enumerate(symbols)}
-
-
-def split_text(text: str, limit: int = 280) -> list[str]:
-    normalized = " ".join(text.split())
-    sentences = [
-        part.strip()
-        for part in re.split(r"(?<=[.!?;:])\s+", normalized)
-        if part.strip()
-    ]
-    chunks: list[str] = []
-    for sentence in sentences or [normalized]:
-        while len(sentence) > limit:
-            search = sentence[: limit + 1]
-            punctuation = max(search.rfind(mark) for mark in (",", ";", ":"))
-            split_at = (
-                punctuation + 1
-                if punctuation >= limit // 2
-                else sentence.rfind(" ", 0, limit + 1)
-            )
-            if split_at < limit // 2:
-                split_at = limit
-            chunks.append(sentence[:split_at].strip())
-            sentence = sentence[split_at:].strip()
-        if sentence:
-            chunks.append(sentence)
-    return chunks
-
-
-def boundary_pause_seconds(chunk: str) -> float:
-    ending = chunk.rstrip()[-1:] if chunk.strip() else ""
-    return {
-        "?": 0.28,
-        "!": 0.24,
-        ".": 0.22,
-        ";": 0.16,
-        ":": 0.13,
-        ",": 0.09,
-    }.get(ending, 0.08)
-
-
-def edge_fade(
-    waveform: np.ndarray,
-    sample_rate: int = SAMPLE_RATE,
-    milliseconds: float = 5.0,
-) -> np.ndarray:
-    frames = min(round(sample_rate * milliseconds / 1000.0), waveform.size // 2)
-    if frames <= 0:
-        return waveform
-    output = waveform.copy()
-    ramp = np.linspace(0.0, 1.0, frames, endpoint=True, dtype=np.float32)
-    output[:frames] *= ramp
-    output[-frames:] *= ramp[::-1]
-    return output
-
-
-def phonemes_to_tokens(phoneme_text: str) -> np.ndarray:
-    sequence = [SYMBOL_TO_ID[symbol] for symbol in phoneme_text]
-    if not sequence:
-        raise ValueError("The text frontend produced no speakable tokens.")
-    with_blanks = np.zeros(len(sequence) * 2 + 1, dtype=np.int64)
-    with_blanks[1::2] = sequence
-    return with_blanks[None, :]
-
-
-def available_provider(name: str) -> str:
-    aliases = {
-        "cpu": "CPUExecutionProvider",
-        "cuda": "CUDAExecutionProvider",
-        "directml": "DmlExecutionProvider",
-    }
-    provider = aliases.get(name.lower(), name)
-    available = ort.get_available_providers()
-    if provider not in available:
-        raise ValueError(
-            f"Provider {provider!r} is unavailable. Installed providers: {available}"
-        )
-    return provider
-
-
-class InflectONNX:
-    """Torch-free Inflect v2 inference through ONNX Runtime."""
-
-    def __init__(
-        self,
-        model_dir: str | Path = PACKAGE_ROOT,
-        provider: str = "cpu",
-    ) -> None:
-        root = Path(model_dir).resolve()
-        onnx_dir = root / "onnx"
-        selected_provider = available_provider(provider)
-        providers = [selected_provider]
-        if selected_provider != "CPUExecutionProvider":
-            providers.append("CPUExecutionProvider")
-        self.duration = ort.InferenceSession(
-            str(onnx_dir / "duration.onnx"),
-            providers=providers,
-        )
-        self.decode = ort.InferenceSession(
-            str(onnx_dir / "decode.onnx"),
-            providers=providers,
-        )
-
-    def _synthesize_chunk(
-        self,
-        text: str,
-        *,
-        speed: float,
-        variation: float,
-        seed: int,
-    ) -> np.ndarray:
-        phoneme_text = run_vits_frontend(text).phoneme_text
-        tokens = phonemes_to_tokens(phoneme_text)
-        duration_outputs = self.duration.run(
-            ["m_p_exp", "logs_p_exp", "y_mask"],
-            {
-                "tokens": tokens,
-                "lengths": np.asarray([tokens.shape[1]], dtype=np.int64),
-                "length_scale": np.asarray(1.0 / speed, dtype=np.float32),
-            },
-        )
-        m_p_exp, logs_p_exp, y_mask = duration_outputs
-        rng = np.random.default_rng(seed)
-        latent_noise = rng.standard_normal(m_p_exp.shape, dtype=np.float32)
-        waveform = self.decode.run(
-            ["waveform"],
-            {
-                "m_p_exp": m_p_exp,
-                "logs_p_exp": logs_p_exp,
-                "y_mask": y_mask,
-                "zp_noise": latent_noise,
-                "noise_scale": np.asarray(variation, dtype=np.float32),
-            },
-        )[0]
-        return edge_fade(np.asarray(waveform, dtype=np.float32).reshape(-1))
-
-    def synthesize(
-        self,
-        text: str,
-        *,
-        speed: float = 1.0,
-        variation: float = 0.667,
-        seed: int = 0,
-    ) -> tuple[int, np.ndarray]:
-        normalized = " ".join(text.split())
-        if not normalized:
-            raise ValueError("Text must not be empty.")
-        if not 0.5 <= speed <= 2.0:
-            raise ValueError("speed must be between 0.5 and 2.0")
-        if not 0.0 <= variation <= 1.0:
-            raise ValueError("variation must be between 0.0 and 1.0")
-
-        chunks = split_text(normalized)
-        pieces: list[np.ndarray] = []
-        for index, chunk in enumerate(chunks):
-            if index:
-                pause = boundary_pause_seconds(chunks[index - 1])
-                pieces.append(
-                    np.zeros(round(SAMPLE_RATE * pause), dtype=np.float32)
-                )
-            pieces.append(
-                self._synthesize_chunk(
-                    chunk,
-                    speed=speed,
-                    variation=variation,
-                    seed=seed + index,
-                )
-            )
-        waveform = np.clip(np.concatenate(pieces), -1.0, 1.0)
-        return SAMPLE_RATE, waveform
-
-    def save(self, text: str, output: str | Path, **kwargs: object) -> Path:
-        destination = Path(output)
-        destination.parent.mkdir(parents=True, exist_ok=True)
-        sample_rate, waveform = self.synthesize(text, **kwargs)
-        sf.write(destination, waveform, sample_rate)
-        return destination
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Run Inflect v2 through ONNX Runtime.")
-    parser.add_argument("--model-dir", type=Path, default=PACKAGE_ROOT)
-    parser.add_argument("--text", required=True)
-    parser.add_argument("--output", type=Path, required=True)
-    parser.add_argument(
-        "--provider",
-        default="cpu",
-        help="cpu, cuda, directml, or an ONNX Runtime provider name",
-    )
-    parser.add_argument("--speed", type=float, default=1.0)
-    parser.add_argument("--variation", type=float, default=0.667)
-    parser.add_argument("--seed", type=int, default=0)
-    args = parser.parse_args()
-
-    engine = InflectONNX(args.model_dir, provider=args.provider)
-    engine.save(
-        args.text,
-        args.output,
-        speed=args.speed,
-        variation=args.variation,
-        seed=args.seed,
-    )
-    print(f"wrote {args.output} at {SAMPLE_RATE} Hz")
-
-
-if __name__ == "__main__":
-    main()

onnx/parity_report.json

@@ -1,31 +0,0 @@
-{
-  "format": "inflect_v2_onnx_parity_v1",
-  "model": "Inflect-Micro-v2",
-  "onnx_checker": "pass",
-  "dynamic_lengths": "pass",
-  "end_to_end_short_text": "pass",
-  "end_to_end_long_text": "pass",
-  "same_seed_determinism": "pass",
-  "different_seed_variation": "pass",
-  "pytorch_parity": {
-    "duration_m_p_exp_max_abs_error": 9.5367431640625e-07,
-    "duration_logs_p_exp_max_abs_error": 3.5762786865234375e-07,
-    "duration_mask_exact": true,
-    "waveform_max_abs_error": 1.75834e-05,
-    "waveform_mean_abs_error": 2.2595e-07,
-    "waveform_correlation": 0.9999999999394602
-  },
-  "independent_reexport_parity": {
-    "duration_outputs_max_abs_error": [0.0, 0.0, 0.0],
-    "waveform_max_abs_error": 1.0617077350616455e-07,
-    "waveform_mean_abs_error": 4.823611288173879e-09,
-    "waveform_correlation": 0.9999999999995599
-  },
-  "validation_environment": {
-    "python": "3.12",
-    "onnx": "1.19.1",
-    "onnxruntime": "1.22.1",
-    "torch_for_reference": "2.4.1+cpu",
-    "provider": "CPUExecutionProvider"
-  }
-}

onnx/requirements.txt

@@ -1,7 +0,0 @@
-numpy>=1.26,<3
-onnxruntime>=1.18,<2
-soundfile>=0.13
-phonemizer>=3.3
-espeakng-loader>=0.2.4
-num2words>=0.5.14
-Unidecode>=1.3.8

release_manifest.json

@@ -29,8 +29,8 @@
     },
     {
       "path": "README.md",
-      "bytes": 20101,
-      "sha256": "3250258e2ec7b8e7e312da1579dda93ff68334ed803561f4ac3dcc26a5f2d644"
+      "bytes": 20268,
+      "sha256": "d0ba29dd9605ff524fdda51ab38167c1f80cd47404a7b1ada4f9c3c2d49ad1a2"
     },
     {
       "path": "THIRD_PARTY_NOTICES.md",
@@ -144,8 +144,8 @@
     },
     {
       "path": "docs/EXPORTS.md",
-      "bytes": 2808,
-      "sha256": "bcb70436c88e92d2926941e76f141498d63e2432e3584e921a9682785c474392"
+      "bytes": 2991,
+      "sha256": "b32a8ca478e72ee4e35a0415ef6214e18843d3253ded8cb773f7cb6e134320ae"
     },
     {
       "path": "docs/FINETUNING.md",
@@ -339,48 +339,8 @@
     },
     {
       "path": "onnx/README.md",
-      "bytes": 3907,
-      "sha256": "ecfaf6a3edca6ffc3152a61ccc6c27240f42daaa0ddf6efc08e1f9b277295734"
-    },
-    {
-      "path": "onnx/SOURCE.json",
-      "bytes": 633,
-      "sha256": "e950bf44034b011a64bba3773b388e386418ef952c3cd17ceefda5bfa94a3aaa"
-    },
-    {
-      "path": "onnx/checksums.sha256",
-      "bytes": 653,
-      "sha256": "d74c3c8d3a148f240d795dc603e18ac2c152a3f7ad3e45dcd66d3e14ee335b6b"
-    },
-    {
-      "path": "onnx/decode.onnx",
-      "bytes": 30427790,
-      "sha256": "7940923add86f76e7fa78d910b0632ca1779f8cc9a2ca2b49236381a9ca77183"
-    },
-    {
-      "path": "onnx/duration.onnx",
-      "bytes": 7322687,
-      "sha256": "b728ca2564b9e5b7d6cf5e446f65e02a6fe2f1880ba281466fec93a667dd2388"
-    },
-    {
-      "path": "onnx/export_onnx.py",
-      "bytes": 7884,
-      "sha256": "77bd27277861c8cae670247e3c9e3b976134a4886506fb069331aa6828752be6"
-    },
-    {
-      "path": "onnx/inference_onnx.py",
-      "bytes": 7333,
-      "sha256": "cf48c4812f68e8315d80568e93650c64a7ad3fdfb9a0051c61a0d1d0746df274"
-    },
-    {
-      "path": "onnx/parity_report.json",
-      "bytes": 1026,
-      "sha256": "10c88564d24fe65ea730dc6ec98aa19ec74d3590efa427595a3c122c4c0f7039"
-    },
-    {
-      "path": "onnx/requirements.txt",
-      "bytes": 126,
-      "sha256": "43abd2c128e4296f1f0171f12946f3fc7dee3f8c8e2bb1858bcae6b43b62b3c9"
+      "bytes": 410,
+      "sha256": "933af35f9c1ce5fda876e40e183a7cd3a6dc55cc9b0684062cbf40dfdd3e5008"
     },
     {
       "path": "requirements-tested.txt",
@@ -496,7 +456,7 @@
   "format": "inflect_v2_release_manifest_v1",
   "onnx_release": {
     "format": "FP32 ONNX opset 17",
-    "path": "onnx/",
+    "repository": "owensong/Inflect-Micro-v2-ONNX",
     "verified": true,
     "released": "2026-07-25"
   }