Mai Linh Vietnamese TTS: CoreML (.mlpackage) + ONNX + Swift + scripts

Mai Linh/mailinh250626.onnx

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

Mai Linh/mailinh250626.onnx.json

@@ -0,0 +1,492 @@
+{
+  "audio": {
+    "sample_rate": 22050,
+    "quality": "medium"
+  },
+  "espeak": {
+    "voice": "vi"
+  },
+  "inference": {
+    "noise_scale": 0.667,
+    "length_scale": 1,
+    "noise_w": 0.8
+  },
+  "phoneme_map": {},
+  "phoneme_id_map": {
+    "_": [
+      0
+    ],
+    "^": [
+      1
+    ],
+    "$": [
+      2
+    ],
+    " ": [
+      3
+    ],
+    "!": [
+      4
+    ],
+    "'": [
+      5
+    ],
+    "(": [
+      6
+    ],
+    ")": [
+      7
+    ],
+    ",": [
+      8
+    ],
+    "-": [
+      9
+    ],
+    ".": [
+      10
+    ],
+    ":": [
+      11
+    ],
+    ";": [
+      12
+    ],
+    "?": [
+      13
+    ],
+    "a": [
+      14
+    ],
+    "b": [
+      15
+    ],
+    "c": [
+      16
+    ],
+    "d": [
+      17
+    ],
+    "e": [
+      18
+    ],
+    "f": [
+      19
+    ],
+    "h": [
+      20
+    ],
+    "i": [
+      21
+    ],
+    "j": [
+      22
+    ],
+    "k": [
+      23
+    ],
+    "l": [
+      24
+    ],
+    "m": [
+      25
+    ],
+    "n": [
+      26
+    ],
+    "o": [
+      27
+    ],
+    "p": [
+      28
+    ],
+    "q": [
+      29
+    ],
+    "r": [
+      30
+    ],
+    "s": [
+      31
+    ],
+    "t": [
+      32
+    ],
+    "u": [
+      33
+    ],
+    "v": [
+      34
+    ],
+    "w": [
+      35
+    ],
+    "x": [
+      36
+    ],
+    "y": [
+      37
+    ],
+    "z": [
+      38
+    ],
+    "æ": [
+      39
+    ],
+    "ç": [
+      40
+    ],
+    "ð": [
+      41
+    ],
+    "ø": [
+      42
+    ],
+    "ħ": [
+      43
+    ],
+    "ŋ": [
+      44
+    ],
+    "œ": [
+      45
+    ],
+    "ǀ": [
+      46
+    ],
+    "ǁ": [
+      47
+    ],
+    "ǂ": [
+      48
+    ],
+    "ǃ": [
+      49
+    ],
+    "ɐ": [
+      50
+    ],
+    "ɑ": [
+      51
+    ],
+    "ɒ": [
+      52
+    ],
+    "ɓ": [
+      53
+    ],
+    "ɔ": [
+      54
+    ],
+    "ɕ": [
+      55
+    ],
+    "ɖ": [
+      56
+    ],
+    "ɗ": [
+      57
+    ],
+    "ɘ": [
+      58
+    ],
+    "ə": [
+      59
+    ],
+    "ɚ": [
+      60
+    ],
+    "ɛ": [
+      61
+    ],
+    "ɜ": [
+      62
+    ],
+    "ɞ": [
+      63
+    ],
+    "ɟ": [
+      64
+    ],
+    "ɠ": [
+      65
+    ],
+    "ɡ": [
+      66
+    ],
+    "ɢ": [
+      67
+    ],
+    "ɣ": [
+      68
+    ],
+    "ɤ": [
+      69
+    ],
+    "ɥ": [
+      70
+    ],
+    "ɦ": [
+      71
+    ],
+    "ɧ": [
+      72
+    ],
+    "ɨ": [
+      73
+    ],
+    "ɪ": [
+      74
+    ],
+    "ɫ": [
+      75
+    ],
+    "ɬ": [
+      76
+    ],
+    "ɭ": [
+      77
+    ],
+    "ɮ": [
+      78
+    ],
+    "ɯ": [
+      79
+    ],
+    "ɰ": [
+      80
+    ],
+    "ɱ": [
+      81
+    ],
+    "ɲ": [
+      82
+    ],
+    "ɳ": [
+      83
+    ],
+    "ɴ": [
+      84
+    ],
+    "ɵ": [
+      85
+    ],
+    "ɶ": [
+      86
+    ],
+    "ɸ": [
+      87
+    ],
+    "ɹ": [
+      88
+    ],
+    "ɺ": [
+      89
+    ],
+    "ɻ": [
+      90
+    ],
+    "ɽ": [
+      91
+    ],
+    "ɾ": [
+      92
+    ],
+    "ʀ": [
+      93
+    ],
+    "ʁ": [
+      94
+    ],
+    "ʂ": [
+      95
+    ],
+    "ʃ": [
+      96
+    ],
+    "ʄ": [
+      97
+    ],
+    "ʈ": [
+      98
+    ],
+    "ʉ": [
+      99
+    ],
+    "ʊ": [
+      100
+    ],
+    "ʋ": [
+      101
+    ],
+    "ʌ": [
+      102
+    ],
+    "ʍ": [
+      103
+    ],
+    "ʎ": [
+      104
+    ],
+    "ʏ": [
+      105
+    ],
+    "ʐ": [
+      106
+    ],
+    "ʑ": [
+      107
+    ],
+    "ʒ": [
+      108
+    ],
+    "ʔ": [
+      109
+    ],
+    "ʕ": [
+      110
+    ],
+    "ʘ": [
+      111
+    ],
+    "ʙ": [
+      112
+    ],
+    "ʛ": [
+      113
+    ],
+    "ʜ": [
+      114
+    ],
+    "ʝ": [
+      115
+    ],
+    "ʟ": [
+      116
+    ],
+    "ʡ": [
+      117
+    ],
+    "ʢ": [
+      118
+    ],
+    "ʲ": [
+      119
+    ],
+    "ˈ": [
+      120
+    ],
+    "ˌ": [
+      121
+    ],
+    "ː": [
+      122
+    ],
+    "ˑ": [
+      123
+    ],
+    "˞": [
+      124
+    ],
+    "β": [
+      125
+    ],
+    "θ": [
+      126
+    ],
+    "χ": [
+      127
+    ],
+    "ᵻ": [
+      128
+    ],
+    "ⱱ": [
+      129
+    ],
+    "0": [
+      130
+    ],
+    "1": [
+      131
+    ],
+    "2": [
+      132
+    ],
+    "3": [
+      133
+    ],
+    "4": [
+      134
+    ],
+    "5": [
+      135
+    ],
+    "6": [
+      136
+    ],
+    "7": [
+      137
+    ],
+    "8": [
+      138
+    ],
+    "9": [
+      139
+    ],
+    "̧": [
+      140
+    ],
+    "̃": [
+      141
+    ],
+    "̪": [
+      142
+    ],
+    "̯": [
+      143
+    ],
+    "̩": [
+      144
+    ],
+    "ʰ": [
+      145
+    ],
+    "ˤ": [
+      146
+    ],
+    "ε": [
+      147
+    ],
+    "↓": [
+      148
+    ],
+    "#": [
+      149
+    ],
+    "\"": [
+      150
+    ],
+    "↑": [
+      151
+    ],
+    "̺": [
+      152
+    ],
+    "̻": [
+      153
+    ]
+  },
+  "num_symbols": 256,
+  "num_speakers": 1,
+  "speaker_id_map": {},
+  "piper_version": "1.0.0",
+  "language": {
+    "code": "vi_VN",
+    "family": "vi",
+    "region": "VN",
+    "name_native": "Tiếng Việt",
+    "name_english": "Vietnamese",
+    "country_english": "Vietnam"
+  },
+  "dataset": "mailinh"
+}

MaiLinh.mlpackage/Data/com.apple.CoreML/model.mlmodel

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

MaiLinh.mlpackage/Data/com.apple.CoreML/weights/weight.bin

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

MaiLinh.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "212E4D8C-9780-421A-A76E-222EB6990D60": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "44CF003F-6AE9-4964-9EAF-FDE358FC4167": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "212E4D8C-9780-421A-A76E-222EB6990D60"
+}

MaiLinhTTS.swift

@@ -0,0 +1,87 @@
+import Foundation
+import CoreML
+import AVFoundation
+
+/// Mai Linh - Vietnamese TTS (Piper/VITS) chay tren CoreML.
+///
+/// Model I/O:
+///   input         : MLMultiArray [1, 256] Int32   - phoneme ids, pad 0 cho du 256
+///   input_lengths : MLMultiArray [1]      Int32   - so phoneme id thuc (<= 256)
+///   scales        : MLMultiArray [3]      Float32 - [noise, length, noise_w] = [0.667, 1.0, 0.8]
+/// Output:
+///   audio    : MLMultiArray Float32 - 22050Hz mono, do dai co dinh (max_frames*256)
+///   n_frames : MLMultiArray Int32   - so frame that; CAT audio tai n_frames*256
+///
+/// CON THIEU (phai tu lam): phonemize tieng Viet -> phoneme ids.
+/// Dung espeak-ng (voice "vi") de ra chuoi IPA, roi map qua `phoneme_id_map`
+/// trong mailinh250626.onnx.json, chen pad id 0 giua cac phoneme (logic phonemes_to_ids cua piper).
+final class MaiLinhTTS {
+    static let sampleRate = 22050
+    static let hop = 256
+    static let maxPhonemes = 256
+
+    private let model: MLModel
+
+    init() throws {
+        // Xcode tu bien dich MaiLinh.mlpackage -> MaiLinh.mlmodelc khi build.
+        let url = Bundle.main.url(forResource: "MaiLinh", withExtension: "mlmodelc")!
+        model = try MLModel(contentsOf: url)
+    }
+
+    /// Tra ve waveform mono Float (22050Hz), da cat dung do dai + fade-out.
+    func synthesize(phonemeIds: [Int32],
+                    noiseScale: Float = 0.667,
+                    lengthScale: Float = 1.0,
+                    noiseW: Float = 0.8) throws -> [Float] {
+        let L = Self.maxPhonemes
+        let n = min(phonemeIds.count, L)
+
+        let input = try MLMultiArray(shape: [1, NSNumber(value: L)], dataType: .int32)
+        for i in 0..<L { input[i] = 0 }
+        for i in 0..<n { input[i] = NSNumber(value: phonemeIds[i]) }
+
+        let lengths = try MLMultiArray(shape: [1], dataType: .int32)
+        lengths[0] = NSNumber(value: n)
+
+        let scales = try MLMultiArray(shape: [3], dataType: .float32)
+        scales[0] = NSNumber(value: noiseScale)
+        scales[1] = NSNumber(value: lengthScale)
+        scales[2] = NSNumber(value: noiseW)
+
+        let provider = try MLDictionaryFeatureProvider(dictionary: [
+            "input": input, "input_lengths": lengths, "scales": scales,
+        ])
+        let out = try model.prediction(from: provider)
+
+        let audio = out.featureValue(for: "audio")!.multiArrayValue!
+        let nFrames = out.featureValue(for: "n_frames")!.multiArrayValue![0].intValue
+        let cut = min(nFrames * Self.hop, audio.count)
+
+        var samples = [Float](repeating: 0, count: cut)
+        let p = audio.dataPointer.assumingMemoryBound(to: Float32.self)
+        for i in 0..<cut { samples[i] = p[i] }
+
+        // fade-out ~8ms de bo transient o ranh gioi mask (tieng "up")
+        let f = min(Int(0.008 * Double(Self.sampleRate)), cut)
+        for i in 0..<f {
+            let t = Double(i) / Double(max(f - 1, 1))
+            samples[cut - f + i] *= Float(0.5 * (1.0 + cos(.pi * t)))
+        }
+        return samples
+    }
+
+    /// Phat waveform Float qua AVAudioEngine.
+    func play(_ samples: [Float], engine: AVAudioEngine, player: AVAudioPlayerNode) throws {
+        let fmt = AVAudioFormat(standardFormatWithSampleRate: Double(Self.sampleRate), channels: 1)!
+        let buf = AVAudioPCMBuffer(pcmFormat: fmt, frameCapacity: AVAudioFrameCount(samples.count))!
+        buf.frameLength = AVAudioFrameCount(samples.count)
+        memcpy(buf.floatChannelData![0], samples, samples.count * MemoryLayout<Float>.size)
+        if !engine.isRunning {
+            engine.attach(player)
+            engine.connect(player, to: engine.mainMixerNode, format: fmt)
+            try engine.start()
+        }
+        player.scheduleBuffer(buf, completionHandler: nil)
+        player.play()
+    }
+}

README.md

@@ -0,0 +1,47 @@
+# Mai Linh - Vietnamese TTS (Piper/VITS) — CoreML + ONNX
+
+Giọng **Mai Linh** tiếng Việt, chạy on-device. Hai dạng:
+- `MaiLinh.mlpackage` — **CoreML** (cho app iOS/macOS native), fp32, 22050Hz.
+- `Mai Linh/mailinh250626.onnx` + `.onnx.json` — **ONNX** (chạy bằng onnxruntime trên PC/Mac).
+
+Credit: voice từ [`quangdung/Piper_checkpoint`](https://huggingface.co/quangdung/Piper_checkpoint) (fine-tune từ `vi_VN/vais1000/medium`), base [OHF-Voice/piper1-gpl](https://github.com/OHF-Voice/piper1-gpl). License MIT.
+
+## File
+
+| File | Mô tả |
+|---|---|
+| `MaiLinh.mlpackage` | Model CoreML (fp32, L=256 phoneme, M=500 ≈ 5.8s/câu) |
+| `MaiLinhTTS.swift` | Code Swift mẫu: load + chạy + cắt + fade + phát |
+| `Mai Linh/mailinh250626.onnx(.json)` | Model ONNX + config (chứa `phoneme_id_map`) |
+| `coreml_tts.py` / `tts.py` | Inference tham chiếu (Python) cho CoreML / ONNX |
+| `convert_coreml.py` | Script convert ckpt → CoreML (chỉnh L/M/precision rồi chạy lại) |
+
+## CoreML — I/O contract
+
+**Input**
+- `input` : MLMultiArray `[1, 256]` Int32 — phoneme ids, pad `0` cho đủ 256.
+- `input_lengths` : `[1]` Int32 — số phoneme id thật (≤256).
+- `scales` : `[3]` Float32 — `[noise=0.667, length=1.0, noise_w=0.8]`. `length>1` đọc chậm hơn.
+
+**Output**
+- `audio` : Float32 mono 22050Hz, độ dài cố định (M·256 mẫu).
+- `n_frames` : Int32 — số frame thật. **Phải cắt `audio` tại `n_frames*256`** rồi fade-out ngắn, nếu không sẽ có tiếng "ụp" ở cuối.
+
+## Tích hợp iOS
+
+1. Kéo `MaiLinh.mlpackage` vào Xcode (tự biên dịch ra `.mlmodelc` khi build).
+2. Dùng `MaiLinhTTS.swift` — đã làm sẵn phần load model, dựng input, chạy, cắt theo `n_frames`, fade-out, và phát qua `AVAudioEngine`.
+3. **Phần còn phải tự làm: phonemize tiếng Việt.** Model nhận *phoneme ids*, không nhận text. Cần:
+   - `espeak-ng` (voice `vi`) build cho iOS (arm64) để đổi text → chuỗi IPA.
+   - Map IPA → ids bằng `phoneme_id_map` trong `mailinh250626.onnx.json`, chèn pad id `0` giữa các phoneme (logic `phonemes_to_ids` của piper).
+4. Câu dài > 5.8s: tách câu rồi tổng hợp từng câu (đúng cách piper làm). Muốn câu dài hơn: tăng `M` trong `convert_coreml.py` rồi convert lại.
+
+> Lưu ý: ANE compile fail nên model chạy trên GPU/CPU (vẫn CoreML native). Đủ nhanh (~26ms/câu trên Mac).
+
+## Mac/PC (ONNX) — nhanh, linh hoạt
+
+```bash
+pip install piper-tts          # hoặc dùng .venv kèm theo
+python tts.py "Xin chào các bạn" out.wav     # hoặc ./say.sh "..."
+```
+ONNX dynamic, ~52x realtime với 4 thread; không giới hạn độ dài câu.

bench_coreml_vs_onnx.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""So sanh toc do model: CoreML (.mlpackage, shape tinh) vs onnx (dynamic)."""
+import time
+import numpy as np
+import onnxruntime as ort
+import coremltools as ct
+from piper import PiperVoice
+
+L = 256
+SR, HOP = 22050, 256
+ONNX = "Mai Linh/mailinh250626.onnx"
+CONF = "Mai Linh/mailinh250626.onnx.json"
+scales = np.array([0.667, 1.0, 0.8], dtype=np.float32)
+
+v = PiperVoice.load(ONNX, CONF)
+
+# onnx session, 4 threads (cau hinh nhanh nhat da do)
+so = ort.SessionOptions(); so.intra_op_num_threads = 4; so.log_severity_level = 3
+onnx_sess = ort.InferenceSession(ONNX, sess_options=so, providers=["CPUExecutionProvider"])
+
+ml = ct.models.MLModel("MaiLinh.mlpackage")
+
+
+def ids_for(text):
+    s = v.phonemize(text)
+    return np.asarray(v.phonemes_to_ids(s[0]), dtype=np.int64)
+
+
+def bench_onnx(ids, k=7):
+    inp = ids[None, :]
+    il = np.array([ids.shape[0]], dtype=np.int64)
+    feed = {"input": inp, "input_lengths": il, "scales": scales}
+    onnx_sess.run(None, feed)  # warmup
+    best, n = 1e9, 0
+    for _ in range(k):
+        t = time.perf_counter(); out = onnx_sess.run(None, feed); dt = time.perf_counter() - t
+        best = min(best, dt); n = np.asarray(out[0]).reshape(-1).shape[0]
+    return best, n / SR
+
+
+def bench_coreml(ids, k=7):
+    n = min(ids.shape[0], L)
+    arr = np.zeros((1, L), dtype=np.int32); arr[0, :n] = ids[:n]
+    feed = {"input": arr, "input_lengths": np.array([n], dtype=np.int32), "scales": scales}
+    out = ml.predict(feed)  # warmup (+ ANE compile attempt)
+    a = np.asarray(out["audio"]).reshape(-1)
+    thr = 0.02 * np.max(np.abs(a)); nz = np.where(np.abs(a) > thr)[0]
+    spoken = (nz[-1] + 1) / SR if len(nz) else len(a) / SR
+    best = 1e9
+    for _ in range(k):
+        t = time.perf_counter(); ml.predict(feed); dt = time.perf_counter() - t
+        best = min(best, dt)
+    return best, spoken, len(a) / SR
+
+
+for label, text in [("SHORT", "Xin chào các bạn."),
+                    ("LONG", "Xin chào, tôi là Mai Linh, rất vui được gặp tất cả các bạn ở đây ngày hôm nay nhé.")]:
+    ids = ids_for(text)
+    o_t, o_dur = bench_onnx(ids)
+    c_t, c_spoken, c_full = bench_coreml(ids)
+    print(f"\n[{label}] phonemes={ids.shape[0]}  (spoken ~{c_spoken:.2f}s)")
+    print(f"  onnx  (4-thread, dynamic): {o_t*1000:7.1f} ms  -> audio {o_dur:.2f}s  RTF={o_t/o_dur:.4f}  {o_dur/o_t:.0f}x")
+    print(f"  coreml(.mlpackage, fixed): {c_t*1000:7.1f} ms  (tinh du {c_full:.2f}s) RTF_spoken={c_t/c_spoken:.4f}  {c_spoken/c_t:.0f}x")

convert_coreml.py

@@ -0,0 +1,309 @@
+#!/usr/bin/env python3
+"""Convert Mai Linh Piper VITS checkpoint -> CoreML .mlpackage (static shapes).
+
+VITS co shape phu thuoc du lieu (do dai audio = tong duration). CoreML khong tao
+duoc tensor co shape phu thuoc gia tri -> ep ve shape TINH hoan toan:
+  - L: do dai chuoi phoneme co dinh (pad input toi L).
+  - M: so frame audio toi da (output luon M*hop mau, ngan hon -> zero qua y_mask).
+Patch them relative-position attention de pad thanh hang so.
+"""
+import sys
+import traceback
+
+SRC = "/private/tmp/claude-501/-Users-tmduc3-projects/2be6ca63-e3fb-464a-aa29-ca1f99db870f/scratchpad/piper1-gpl/src"
+sys.path.insert(0, SRC)
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+import coremltools as ct
+from piper.train.vits.lightning import VitsModel
+import piper.train.vits.attentions as A
+
+CKPT = "Mai Linh/mailinh-epoch=0019.ckpt"
+L = 256   # phoneme length co dinh (pad input toi L; ~1 cau dai)
+M = 500   # max audio frames (~ M*256/22050 = 5.8s)
+HOP = 256
+
+# --- patch 1: coremltools _cast (numpy 2.x int(np.array([v])) bug on size-1) ---
+import coremltools.converters.mil.frontend.torch.ops as _ctops
+
+
+def _cast_fixed(context, node, dtype, dtype_name):
+    inputs = _ctops._get_inputs(context, node, expected=1)
+    x = inputs[0]
+    if not (len(x.shape) == 0 or np.all([d == 1 for d in x.shape])):
+        raise ValueError("input to cast must be either a scalar or a length 1 tensor")
+    if x.can_be_folded_to_const():
+        val = x.val
+        if isinstance(val, np.ndarray):
+            val = val.reshape(()).item()
+        res = x if isinstance(val, dtype) else _ctops.mb.const(val=dtype(val), name=node.name)
+    elif len(x.shape) > 0:
+        xs = _ctops.mb.squeeze(x=x, name=node.name + "_item")
+        res = _ctops.mb.cast(x=xs, dtype=dtype_name, name=node.name)
+    else:
+        res = _ctops.mb.cast(x=x, dtype=dtype_name, name=node.name)
+    context.add(res, node.name)
+
+
+_ctops._cast = _cast_fixed
+
+
+# aten::IntImplicit (n_channels[0] tensor->int in WN fused op) not implemented
+@_ctops.register_torch_op
+def intimplicit(context, node):
+    _cast_fixed(context, node, int, "int32")
+
+
+# --- patch 2: relative-position attention pads -> constant length L ---
+MHA = A.MultiHeadAttention
+
+
+def _get_rel_emb(self, relative_embeddings, length):
+    length = L
+    pad_length = max(length - (self.window_size + 1), 0)
+    s = max((self.window_size + 1) - length, 0)
+    e = s + 2 * length - 1
+    if pad_length > 0:
+        relative_embeddings = F.pad(relative_embeddings, (0, 0, pad_length, pad_length, 0, 0))
+    return relative_embeddings[:, s:e]
+
+
+def _rel2abs(self, x):
+    b, h, length = 1, self.n_heads, L
+    x = F.pad(x, (0, 1, 0, 0, 0, 0, 0, 0))
+    x_flat = x.reshape(b, h, length * 2 * length)
+    x_flat = F.pad(x_flat, (0, length - 1, 0, 0, 0, 0))
+    return x_flat.reshape(b, h, length + 1, 2 * length - 1)[:, :, :length, length - 1:]
+
+
+def _abs2rel(self, x):
+    b, h, length = 1, self.n_heads, L
+    x = F.pad(x, (0, length - 1, 0, 0, 0, 0, 0, 0))
+    x_flat = x.reshape(b, h, length * length + length * (length - 1))
+    x_flat = F.pad(x_flat, (length, 0, 0, 0, 0, 0))
+    return x_flat.reshape(b, h, length, 2 * length)[:, :, :, 1:]
+
+
+MHA._get_relative_embeddings = _get_rel_emb
+MHA._relative_position_to_absolute_position = _rel2abs
+MHA._absolute_position_to_relative_position = _abs2rel
+
+# --- patch 3: rational-quadratic spline (sdp) -> CoreML-friendly form ---
+# Bo boolean-mask indexing (shape dong) bang torch.where; bo searchsorted/gather
+# bang arange-compare + one-hot-sum; bo moi in-place assignment.
+import piper.train.vits.modules as MOD
+import piper.train.vits.transforms as TR
+
+
+def _set_first_last(c, first, last):
+    fc = torch.full_like(c[..., :1], float(first))
+    lc = torch.full_like(c[..., :1], float(last))
+    return torch.cat([fc, c[..., 1:-1], lc], dim=-1)
+
+
+def _pwrqt_cf(inputs, uw, uh, ud, inverse=False, tails="linear", tail_bound=1.0,
+              min_bin_width=1e-3, min_bin_height=1e-3, min_derivative=1e-3):
+    assert tails == "linear"
+    num_bins = uw.shape[-1]
+    dt = inputs.dtype
+    tb = tail_bound
+    inside = (inputs >= -tb) & (inputs <= tb)
+
+    ud = F.pad(ud, (1, 1))
+    constant = float(np.log(np.exp(1 - min_derivative) - 1))
+    c0 = torch.full_like(ud[..., :1], constant)
+    ud = torch.cat([c0, ud[..., 1:-1], c0], dim=-1)
+
+    widths = F.softmax(uw, -1)
+    widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
+    cumwidths = F.pad(torch.cumsum(widths, -1), (1, 0), value=0.0)
+    cumwidths = 2 * tb * cumwidths - tb
+    cumwidths = _set_first_last(cumwidths, -tb, tb)
+    widths = cumwidths[..., 1:] - cumwidths[..., :-1]
+
+    derivatives = min_derivative + F.softplus(ud)
+
+    heights = F.softmax(uh, -1)
+    heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
+    cumheights = F.pad(torch.cumsum(heights, -1), (1, 0), value=0.0)
+    cumheights = 2 * tb * cumheights - tb
+    cumheights = _set_first_last(cumheights, -tb, tb)
+    heights = cumheights[..., 1:] - cumheights[..., :-1]
+
+    x = torch.clamp(inputs, -tb, tb)
+    locations = cumheights if inverse else cumwidths
+    loc = torch.cat([locations[..., :-1], locations[..., -1:] + 1e-6], dim=-1)
+    bin_idx = ((x.unsqueeze(-1) >= loc).to(dt).sum(-1) - 1).clamp(0, num_bins - 1)
+
+    ar = torch.arange(num_bins, device=inputs.device).to(dt)
+    ar1 = torch.arange(num_bins + 1, device=inputs.device).to(dt)
+    oh = (bin_idx.unsqueeze(-1) == ar).to(dt)
+    oh1 = (bin_idx.unsqueeze(-1) == ar1).to(dt)
+    gb = lambda v: (oh * v).sum(-1)
+    gc = lambda v: (oh1 * v).sum(-1)
+
+    in_cumw = gc(cumwidths)
+    in_binw = gb(widths)
+    in_cumh = gc(cumheights)
+    delta = heights / widths
+    in_delta = gb(delta)
+    in_der = gb(derivatives[..., :num_bins])
+    in_der1 = gb(derivatives[..., 1:])
+    in_h = gb(heights)
+
+    if inverse:
+        a = (x - in_cumh) * (in_der + in_der1 - 2 * in_delta) + in_h * (in_delta - in_der)
+        b = in_h * in_der - (x - in_cumh) * (in_der + in_der1 - 2 * in_delta)
+        c = -in_delta * (x - in_cumh)
+        disc = torch.clamp(b * b - 4 * a * c, min=0.0)
+        root = (2 * c) / (-b - torch.sqrt(disc))
+        out_inner = root * in_binw + in_cumw
+    else:
+        theta = (x - in_cumw) / in_binw
+        tomt = theta * (1 - theta)
+        num = in_h * (in_delta * theta.pow(2) + in_der * tomt)
+        den = in_delta + (in_der + in_der1 - 2 * in_delta) * tomt
+        out_inner = in_cumh + num / den
+
+    outputs = torch.where(inside, out_inner, inputs)
+    return outputs, torch.zeros_like(inputs)
+
+
+# unit-check: reimpl vs original (output fidelity)
+def _spline_unit_check():
+    torch.manual_seed(0)
+    nb = 10
+    N = 2000
+    xi = (torch.rand(N) * 12 - 6)  # span inside+outside tail_bound=5
+    uw = torch.randn(N, nb); uh = torch.randn(N, nb); udv = torch.randn(N, nb - 1)
+    for inv in (True, False):
+        o0, _ = TR.piecewise_rational_quadratic_transform(
+            xi.clone(), uw.clone(), uh.clone(), udv.clone(),
+            inverse=inv, tails="linear", tail_bound=5.0)
+        o1, _ = _pwrqt_cf(xi.clone(), uw.clone(), uh.clone(), udv.clone(),
+                          inverse=inv, tails="linear", tail_bound=5.0)
+        d = (o0 - o1).abs().max().item()
+        print(f"  spline unit-check inverse={inv}: max|diff|={d:.2e}", flush=True)
+        assert d < 1e-3, "spline reimpl mismatch"
+
+
+print("=== spline reimpl unit-check ===", flush=True)
+_spline_unit_check()
+MOD.piecewise_rational_quadratic_transform = _pwrqt_cf
+
+# --- load model ---
+torch.manual_seed(1234)
+g = VitsModel.load_from_checkpoint(CKPT, map_location="cpu").model_g
+g.eval()
+with torch.no_grad():
+    g.dec.remove_weight_norm()
+
+
+def seq_mask_fixed(length, maxlen):
+    rng = torch.arange(maxlen, dtype=length.dtype, device=length.device)
+    return rng.unsqueeze(0) < length.unsqueeze(1)
+
+
+def gen_path_fixed(duration, mask):
+    # duration [b,1,L], mask [b,1,M,L] -> path [b,1,M,L]
+    b = 1
+    cum = torch.cumsum(duration, -1).view(b * L)
+    path = seq_mask_fixed(cum, M).type_as(mask).view(b, L, M)
+    path = path - F.pad(path, (0, 0, 1, 0, 0, 0))[:, :-1]
+    return (path.unsqueeze(1).transpose(2, 3)) * mask
+
+
+class StaticInfer(torch.nn.Module):
+    def __init__(self, g):
+        super().__init__()
+        self.g = g
+
+    def forward(self, text, text_lengths, scales):
+        g = self.g
+        noise_scale, length_scale, noise_scale_w = scales[0], scales[1], scales[2]
+        x, m_p, logs_p, x_mask = g.enc_p(text, text_lengths)
+        logw = g.dp(x, x_mask, g=None, reverse=True, noise_scale=noise_scale_w)
+        w = torch.exp(logw) * x_mask * length_scale
+        w_ceil = torch.ceil(w)
+        y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1.0).long()
+        y_mask = seq_mask_fixed(y_lengths, M).unsqueeze(1).type_as(x_mask)  # [b,1,M]
+        attn_mask = x_mask.unsqueeze(2) * y_mask.unsqueeze(-1)              # [b,1,M,L]
+        attn = gen_path_fixed(w_ceil, attn_mask)                            # [b,1,M,L]
+        m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
+        logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
+        z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
+        z = g.flow(z_p, y_mask, g=None, reverse=True)
+        o = g.dec(z * y_mask, g=None)                                       # [b,1,M*HOP]
+        return o, y_lengths  # y_lengths = so frame audio that su -> cat dung cho het noise duoi
+
+
+net = StaticInfer(g).eval()
+
+seq = torch.randint(1, g.n_vocab, (1, L), dtype=torch.long)
+ln = torch.LongTensor([L])
+scales_det = torch.FloatTensor([0.0, 1.0, 0.0])  # deterministic for validation
+
+print(f"=== L={L} M={M} -> audio {M*HOP} samples ({M*HOP/22050:.2f}s) ===", flush=True)
+print("=== stage 1: trace ===", flush=True)
+with torch.no_grad():
+    ref, ref_nf = net(seq, ln, scales_det)
+    traced = torch.jit.trace(net, (seq, ln, scales_det), check_trace=False)
+print("trace OK, ref audio:", tuple(ref.shape), flush=True)
+
+print("=== stage 2: coremltools.convert (static) ===", flush=True)
+try:
+    mlmodel = ct.convert(
+        traced,
+        inputs=[
+            ct.TensorType(name="input", shape=(1, L), dtype=np.int32),
+            ct.TensorType(name="input_lengths", shape=(1,), dtype=np.int32),
+            ct.TensorType(name="scales", shape=(3,), dtype=np.float32),
+        ],
+        outputs=[ct.TensorType(name="audio"), ct.TensorType(name="n_frames")],
+        minimum_deployment_target=ct.target.iOS16,
+        convert_to="mlprogram",
+        compute_precision=ct.precision.FLOAT32,  # giu fp32 nhu ban goc, tranh nhieu fp16
+        compute_units=ct.ComputeUnit.ALL,
+    )
+    # metadata (set trong-bo-nho truoc khi save; KHONG load+save lai vi save ve
+    # cung path se xoa target roi copy that bai -> mat file)
+    mlmodel.short_description = "Mai Linh - Vietnamese TTS (Piper/VITS) CoreML. Input phoneme ids -> 22050Hz mono audio."
+    mlmodel.author = "Hert4 (beyoru). Voice: quangdung/Piper_checkpoint. Base: OHF-Voice/piper1-gpl."
+    mlmodel.license = "MIT"
+    mlmodel.version = "1.0"
+    mlmodel.input_description["input"] = "Phoneme ids (int32), pad 0 toi do dai 256."
+    mlmodel.input_description["input_lengths"] = "So phoneme id thuc (int32, <=256)."
+    mlmodel.input_description["scales"] = "[noise, length, noise_w], mac dinh [0.667,1.0,0.8]; length>1 doc cham."
+    mlmodel.output_description["audio"] = "Waveform fp32 mono 22050Hz, do dai co dinh; cat tai n_frames*256."
+    mlmodel.output_description["n_frames"] = "So frame that; cat audio tai n_frames*256 roi fade-out."
+    _u = mlmodel.user_defined_metadata
+    _u.update({"sample_rate": "22050", "hop_length": "256", "max_phonemes": str(L),
+               "max_frames": str(M), "default_scales": "0.667,1.0,0.8", "language": "vi",
+               "voice": "Mai Linh", "phonemizer": "espeak-ng vi + phoneme_id_map (mailinh250626.onnx.json)"})
+
+    _OUT = "/Users/tmduc3/projects/piper-mailinh/MaiLinh.mlpackage"
+    import os as _os, shutil as _sh
+    if _os.path.exists(_OUT):
+        _sh.rmtree(_OUT)
+    mlmodel.save(_OUT)
+    print(f"CONVERT OK -> {_OUT} exists={_os.path.exists(_OUT)}", flush=True)
+except Exception:
+    print("CONVERT FAILED:", flush=True)
+    traceback.print_exc()
+    sys.exit(2)
+
+print("=== stage 3: validate CoreML vs PyTorch (deterministic) ===", flush=True)
+out = mlmodel.predict({
+    "input": seq.numpy().astype(np.int32),
+    "input_lengths": ln.numpy().astype(np.int32),
+    "scales": scales_det.numpy().astype(np.float32),
+})
+ca = np.asarray(out["audio"]).reshape(-1)
+ra = ref.numpy().reshape(-1)
+n = min(len(ca), len(ra))
+diff = np.abs(ca[:n] - ra[:n])
+print(f"coreml audio shape {ca.shape}, pytorch {ra.shape}", flush=True)
+print(f"max|diff|={diff.max():.6f}  mean|diff|={diff.mean():.6e}", flush=True)
+print(f"n_frames coreml={int(np.asarray(out['n_frames']).reshape(-1)[0])} pytorch={int(ref_nf.reshape(-1)[0])}", flush=True)

coreml_tts.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""Inference giong Mai Linh bang CoreML MaiLinh.mlpackage (khong can onnxruntime
+cho phan model; chi dung piper de phonemize text -> ids)."""
+import sys
+import wave
+import numpy as np
+import coremltools as ct
+from piper import PiperVoice
+
+L = 256
+SR = 22050
+HOP = 256
+
+text = sys.argv[1] if len(sys.argv) > 1 else "Xin chào, tôi là Mai Linh."
+out = sys.argv[2] if len(sys.argv) > 2 else "coreml_demo.wav"
+
+# phonemize (dung config da sinh)
+v = PiperVoice.load("Mai Linh/mailinh250626.onnx", "Mai Linh/mailinh250626.onnx.json")
+sentences = v.phonemize(text)
+ids = v.phonemes_to_ids(sentences[0])
+n = min(len(ids), L)
+arr = np.zeros((1, L), dtype=np.int32)
+arr[0, :n] = np.asarray(ids[:n], dtype=np.int32)
+
+m = ct.models.MLModel("/Users/tmduc3/projects/piper-mailinh/MaiLinh.mlpackage")
+res = m.predict({
+    "input": arr,
+    "input_lengths": np.array([n], dtype=np.int32),
+    "scales": np.array([0.667, 1.0, 0.8], dtype=np.float32),
+})
+audio = np.asarray(res["audio"]).reshape(-1)
+
+# cat dung tai do dai that (n_frames*HOP) -> bo het vung mask=0 va transient "up"
+nf = int(np.asarray(res["n_frames"]).reshape(-1)[0])
+cut = min(nf * HOP, len(audio))
+audio = audio[:cut].copy()
+
+# fade-out ~8ms de xoa transient con sot o ranh gioi (do receptive field cua decoder)
+f = min(int(0.008 * SR), len(audio))
+if f > 1:
+    audio[-f:] *= 0.5 * (1 + np.cos(np.linspace(0.0, np.pi, f)))
+
+pcm = (np.clip(audio, -1, 1) * 32767).astype(np.int16)
+with wave.open(out, "wb") as w:
+    w.setnchannels(1)
+    w.setsampwidth(2)
+    w.setframerate(SR)
+    w.writeframes(pcm.tobytes())
+print(f"phonemes={n}  audio={len(audio)/SR:.2f}s  saved: {out}")

say.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# Mai Linh - Vietnamese TTS (Piper) - CLI đơn giản, tối ưu 4 thread.
+# Usage:
+#   ./say.sh "câu tiếng việt"               -> out.wav (tự phát)
+#   ./say.sh "câu tiếng việt" giong.wav     -> giong.wav
+#   ./say.sh "câu tiếng việt" giong.wav 1.2 -> đọc chậm hơn
+set -euo pipefail
+DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+TEXT="${1:?Usage: ./say.sh \"text\" [out.wav] [length_scale]}"
+OUT="${2:-out.wav}"
+LEN="${3:-1.0}"
+
+"$DIR/.venv/bin/python" "$DIR/tts.py" "$TEXT" "$OUT" "$LEN"
+command -v afplay >/dev/null 2>&1 && afplay "$OUT"

tts.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""Mai Linh - Vietnamese TTS (Piper) - CLI tối ưu 4 thread cho Apple Silicon.
+
+  python tts.py "câu tiếng việt"                -> out.wav
+  python tts.py "câu tiếng việt" giong.wav      -> giong.wav
+  python tts.py "câu tiếng việt" giong.wav 1.2  -> đọc chậm hơn (length_scale)
+  echo "câu" | python tts.py                    -> đọc từ stdin
+"""
+import sys
+import wave
+from pathlib import Path
+
+import onnxruntime as ort
+from piper import PiperVoice, SynthesisConfig
+
+DIR = Path(__file__).resolve().parent
+MODEL = DIR / "Mai Linh" / "mailinh250626.onnx"
+CONF = DIR / "Mai Linh" / "mailinh250626.onnx.json"
+THREADS = 4  # sweet spot benchmark trên chip M (52x realtime); >4 chậm lại
+
+
+def main() -> None:
+    text = sys.argv[1] if len(sys.argv) > 1 else sys.stdin.read()
+    out = sys.argv[2] if len(sys.argv) > 2 else "out.wav"
+    length = float(sys.argv[3]) if len(sys.argv) > 3 else 1.0
+
+    so = ort.SessionOptions()
+    so.intra_op_num_threads = THREADS
+    so.log_severity_level = 3
+
+    voice = PiperVoice.load(str(MODEL), str(CONF))
+    voice.session = ort.InferenceSession(
+        str(MODEL), sess_options=so, providers=["CPUExecutionProvider"]
+    )
+
+    syn = SynthesisConfig(length_scale=length)
+    sr = voice.config.sample_rate
+    with wave.open(out, "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(sr)
+        for chunk in voice.synthesize(text.strip(), syn_config=syn):
+            w.writeframes(chunk.audio_int16_bytes)
+
+    print(f"saved: {out}")
+
+
+if __name__ == "__main__":
+    main()