Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,13 @@
+Copyright 2025 (c) Meta Platforms, Inc. and affiliates.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

README.md

@@ -1,3 +1,136 @@
 ---
+language:
+- multilingual
+library_name: onnxruntime
+pipeline_tag: audio-classification
+tags:
+- audio
+- speech
+- tts
+- quality-classification
+- wav2vec2
+- onnx
 license: apache-2.0
 ---
+
+# TTS Suitability Classifier
+
+ONNX audio classifier that estimates whether a speech segment is suitable for
+TTS training.
+
+The model is a binary classifier based on the 300M wav2vec2 encoder from
+[facebook/omniASR](https://github.com/facebookresearch/omnilingual-asr).
+The ONNX file is self-contained and does not require `fairseq2`, PyTorch, or the
+original omnilingual-asr repository for inference.
+
+## Labels
+
+| Class | Label | Meaning |
+|---:|---|---|
+| 0 | `not_tts` | Audio is not suitable for TTS training |
+| 1 | `tts` | Audio is suitable for TTS training |
+
+`p_tts` is the softmax probability of class 1. The default decision threshold
+is `0.5`. For dataset filtering, choose the threshold on a manually labeled
+validation set.
+
+## Installation
+
+```bash
+pip install -r requirements.txt
+```
+
+For CUDA inference, replace `onnxruntime` with a compatible
+`onnxruntime-gpu` build.
+
+## Command-line inference
+
+```bash
+python inference.py sample.mp3
+python inference.py /path/to/audio-directory --provider cpu
+python inference.py sample.wav --provider cuda --cuda-device-id 0
+```
+
+Each result is printed as one JSON object:
+
+```json
+{
+  "label": "tts",
+  "predicted_class": 1,
+  "p_not_tts": 0.02,
+  "p_tts": 0.98,
+  "logits": [-2.2, 1.5]
+}
+```
+
+## Python API
+
+```python
+from inference import TTSSuitabilityClassifier
+
+classifier = TTSSuitabilityClassifier(provider="auto")
+result = classifier.predict("sample.mp3")
+
+print(result["label"])
+print(result["p_tts"])
+```
+
+## Input preprocessing
+
+The included inference code applies the same preprocessing as the training and
+export recipe:
+
+1. Decode WAV, FLAC, MP3, OGG, or M4A.
+2. Mix channels to mono.
+3. Resample to 16 kHz.
+4. Apply waveform layer normalization.
+5. Split long audio into 10-second chunks.
+6. Average chunk logits and apply softmax.
+
+The ONNX input is a float32 tensor named `waveforms` with shape
+`[batch_size, num_frames]`. The output is `logits` with shape
+`[batch_size, 2]`. Both input axes are dynamic; ONNX opset 17 is used.
+
+## Files
+
+- `model.onnx`: self-contained FP32 ONNX model.
+- `inference.py`: standalone ONNX Runtime inference.
+- `requirements.txt`: CPU inference dependencies.
+
+## Upload to Hugging Face
+
+Create an empty model repository, then run from this directory:
+
+```bash
+hf upload-large-folder <username>/<repo-name> . --repo-type model
+```
+
+`model.onnx` is configured for Git LFS in `.gitattributes`.
+
+## Training and export
+
+The released model corresponds to training checkpoint step 94,000. It was
+exported using the repository recipes:
+
+- `workflows/recipes/wav2vec2/binary_classification/export_onnx.py`
+- `workflows/recipes/wav2vec2/binary_classification/run_onnx.py`
+
+Architecture: `wav2vec2_asr 300m`  
+Sample rate: `16000 Hz`  
+Training maximum audio length: `160000` samples  
+Classes: `not_tts`, `tts`
+
+## Limitations
+
+- The score measures similarity to the training definition of TTS-suitable
+  audio; it is not a general-purpose MOS score.
+- Music, noise, clipping, overlapping speakers, and unusual recording
+  conditions may affect predictions.
+- Probabilities are not guaranteed to be calibrated.
+- Validate the threshold on data from the intended domain before filtering a
+  large dataset.
+
+## License
+
+Apache 2.0. The base architecture and code originate from the
+omnilingual-asr project.

inference.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import numpy as np
+import onnxruntime as ort
+import soundfile as sf
+from scipy.signal import resample_poly
+
+
+MODEL_PATH = Path(__file__).with_name("model.onnx")
+SAMPLE_RATE = 16_000
+CHUNK_FRAMES = 160_000
+SUPPORTED_EXTENSIONS = {".wav", ".flac", ".mp3", ".ogg", ".m4a"}
+
+
+def load_audio(path: Path) -> tuple[np.ndarray, int]:
+    audio, sample_rate = sf.read(path, dtype="float32", always_2d=True)
+    waveform = np.ascontiguousarray(audio.mean(axis=1), dtype=np.float32)
+    return waveform, int(sample_rate)
+
+
+def resample_audio(
+    waveform: np.ndarray, source_rate: int, target_rate: int
+) -> np.ndarray:
+    gcd = np.gcd(source_rate, target_rate)
+    waveform = resample_poly(
+        waveform, target_rate // gcd, source_rate // gcd
+    ).astype(np.float32)
+    return np.ascontiguousarray(waveform)
+
+
+def layer_norm(waveform: np.ndarray, eps: float = 1e-5) -> np.ndarray:
+    mean = waveform.mean(dtype=np.float64)
+    variance = waveform.var(dtype=np.float64)
+    return ((waveform - mean) / np.sqrt(variance + eps)).astype(np.float32)
+
+
+def chunk_waveform(waveform: np.ndarray, chunk_frames: int) -> np.ndarray:
+    if chunk_frames <= 0 or waveform.size <= chunk_frames:
+        return waveform[None, :]
+
+    chunks = [
+        waveform[start : start + chunk_frames]
+        for start in range(0, waveform.size, chunk_frames)
+    ]
+    max_length = max(chunk.size for chunk in chunks)
+    batch = np.zeros((len(chunks), max_length), dtype=np.float32)
+
+    for index, chunk in enumerate(chunks):
+        batch[index, : chunk.size] = chunk
+
+    return batch
+
+
+def softmax(logits: np.ndarray) -> np.ndarray:
+    logits = logits.astype(np.float64)
+    probabilities = np.exp(logits - logits.max())
+    return probabilities / probabilities.sum()
+
+
+class TTSSuitabilityClassifier:
+    def __init__(
+        self,
+        model_path: str | Path = MODEL_PATH,
+        provider: str = "auto",
+        cuda_device_id: int = 0,
+    ) -> None:
+        available = set(ort.get_available_providers())
+
+        if provider == "auto":
+            provider = "cuda" if "CUDAExecutionProvider" in available else "cpu"
+
+        if provider == "cuda":
+            if "CUDAExecutionProvider" not in available:
+                raise RuntimeError(
+                    "CUDAExecutionProvider is unavailable. Install onnxruntime-gpu "
+                    "or use provider='cpu'."
+                )
+            providers = [
+                ("CUDAExecutionProvider", {"device_id": cuda_device_id}),
+                "CPUExecutionProvider",
+            ]
+        elif provider == "cpu":
+            providers = ["CPUExecutionProvider"]
+        else:
+            raise ValueError("provider must be one of: auto, cpu, cuda")
+
+        self.session = ort.InferenceSession(str(model_path), providers=providers)
+        self.input_name = self.session.get_inputs()[0].name
+        self.output_names = [output.name for output in self.session.get_outputs()]
+
+    def predict(self, audio_path: str | Path) -> dict[str, object]:
+        path = Path(audio_path).expanduser().resolve()
+        waveform, sample_rate = load_audio(path)
+
+        if sample_rate != SAMPLE_RATE:
+            waveform = resample_audio(waveform, sample_rate, SAMPLE_RATE)
+
+        waveform = layer_norm(waveform)
+        batch = chunk_waveform(waveform, CHUNK_FRAMES)
+        logits = self.session.run(
+            self.output_names, {self.input_name: batch}
+        )[0].mean(axis=0)
+        probabilities = softmax(logits)
+        predicted_class = int(probabilities.argmax())
+
+        return {
+            "path": str(path),
+            "label": "tts" if predicted_class == 1 else "not_tts",
+            "predicted_class": predicted_class,
+            "p_not_tts": float(probabilities[0]),
+            "p_tts": float(probabilities[1]),
+            "logits": [float(value) for value in logits],
+        }
+
+
+def collect_audio_paths(path: Path) -> list[Path]:
+    path = path.expanduser().resolve()
+    if path.is_file():
+        return [path]
+
+    return sorted(
+        child
+        for child in path.rglob("*")
+        if child.is_file() and child.suffix.lower() in SUPPORTED_EXTENSIONS
+    )
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="ONNX inference for the TTS suitability classifier."
+    )
+    parser.add_argument("audio", type=Path, help="Audio file or directory.")
+    parser.add_argument(
+        "--model", type=Path, default=MODEL_PATH, help="Path to model.onnx."
+    )
+    parser.add_argument(
+        "--provider", choices=("auto", "cpu", "cuda"), default="auto"
+    )
+    parser.add_argument("--cuda-device-id", type=int, default=0)
+    args = parser.parse_args()
+
+    classifier = TTSSuitabilityClassifier(
+        args.model, args.provider, args.cuda_device_id
+    )
+    paths = collect_audio_paths(args.audio)
+
+    if not paths:
+        raise RuntimeError(f"No supported audio files found at '{args.audio}'.")
+
+    for path in paths:
+        print(json.dumps(classifier.predict(path), ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

model.onnx

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

requirements.txt

@@ -0,0 +1,4 @@
+numpy>=1.24
+onnxruntime>=1.17
+scipy>=1.10
+soundfile>=0.12