--- title: "HT-Demucs FT ke ONNX: Ekspor Pertama yang Berhasil (2026)" date: "2026-05-20" lastUpdated: "2026-05-20" author: "StemSplit Team" tags: ["htdemucs", "onnx", "pemisahan stem", "audio mobile", "open source", "hugging face", "demucs", "AI musik"] excerpt: "Ekspor ONNX pertama HT-Demucs FT — paritas terverifikasi vs PyTorch (1.6e-4), 1.31× lebih cepat di CPU. Plus 9 model open Hugging Face." abstract: "TL;DR. Kami baru saja merilis sebagai open-source 10 aset pemisahan stem di Hugging Face, termasuk ekspor ONNX pertama yang berhasil dari HT-Demucs FT — pemisah vokal open-source #1 di MUSDB18-HQ. Setiap upaya sebelumnya untuk \"demucs onnx\" terhenti di empat penghalang yang sama; kami berhasil mengatasi semuanya. Hasilnya berjalan di `onnxruntime` pada CPU/CoreML/CUDA/DirectML tanpa memerlukan PyTorch saat inferensi, 1,31× lebih cepat dibanding PyTorch di CPU, dan secara numerik setara dengan mo..." locale: "id" canonical: "https://stemsplit.io/id/blog/htdemucs-ft-onnx-export" source: "stemsplit.io" --- > **Source:** https://stemsplit.io/id/blog/htdemucs-ft-onnx-export > Originally published by [StemSplit](https://stemsplit.io). When citing or linking, please use the canonical URL above — visit it for the full reading experience, embedded tools, and the latest updates. # HT-Demucs FT ke ONNX: Bagaimana Kami Membangun Ekspor Pertama yang Berhasil untuk iOS, Android & Web — Plus 9 Model Open Hugging Face dan Benchmark MUSDB18-HQ yang Dapat Direproduksi (2026) **TL;DR.** Kami baru saja merilis sebagai open-source **10 aset pemisahan stem** di Hugging Face, termasuk **ekspor ONNX pertama yang berhasil dari HT-Demucs FT** — pemisah vokal open-source #1 di MUSDB18-HQ. Setiap upaya sebelumnya untuk "demucs onnx" terhenti di empat penghalang yang sama; kami berhasil mengatasi semuanya. Hasilnya berjalan di `onnxruntime` pada CPU/CoreML/CUDA/DirectML **tanpa memerlukan PyTorch saat inferensi**, **1,31× lebih cepat dibanding PyTorch di CPU**, dan **secara numerik setara dengan model aslinya** (selisih absolut maksimum: 0,000163 di seluruh 4 stem). Berikut ini: apa yang kami rilis, mengapa hal ini penting, dan tulisan teknis tentang bagaimana ekspor ONNX akhirnya berhasil dilakukan. --- ## Semua yang kami rilis minggu ini | Aset | Tipe | Apa isinya | |---|---|---| | [stem-separation-benchmark-2026](https://huggingface.co/datasets/StemSplitio/stem-separation-benchmark-2026) | **Dataset** | Benchmark SDR / ISR / SIR / SAR yang dapat direproduksi untuk setiap pemisah open-source populer (`htdemucs`, `htdemucs_ft`, `htdemucs_6s`, `mdx_extra_q`, `mdx_net_inst_hq3`) di MUSDB18-HQ. 850 baris, pipeline evaluasi penuh open source. | | [Music Source Separation Toolkit 2026](https://huggingface.co/collections/StemSplitio/music-source-separation-toolkit-2026-6a0d059a55a1b261e939c9c6) | **Koleksi** | Koleksi pilihan 17 item berisi model pemisahan stem open-source yang layak digunakan di 2026. | | [htdemucs-ft-pytorch](https://huggingface.co/StemSplitio/htdemucs-ft-pytorch) | Model | PyTorch full-bag untuk Hugging Face Inference Endpoints. Mengembalikan keempat stem. | | [htdemucs-ft-\{drums,bass,other\}-pytorch](https://huggingface.co/StemSplitio) | Model (×3) | Spesialis stem PyTorch. ~160 MB per model, ~2,6× lebih cepat dari full bag, kualitas per stem identik. | | [**htdemucs-ft-onnx**](https://huggingface.co/StemSplitio/htdemucs-ft-onnx) | **Model** | **Bag ONNX lengkap 4 stem** + agregator numpy. ~1,26 GB total. Paket siap pakai jika kamu ingin keempat stem di mobile / edge / web. | | [htdemucs-ft-drums-onnx](https://huggingface.co/StemSplitio/htdemucs-ft-drums-onnx) | Model | Spesialis drum sebagai ONNX. ~75% lebih kecil dari full bag, ~4× lebih cepat jika kamu hanya butuh drum. | | [htdemucs-ft-bass-onnx](https://huggingface.co/StemSplitio/htdemucs-ft-bass-onnx) | Model | Spesialis bass sebagai ONNX. | | [htdemucs-ft-other-onnx](https://huggingface.co/StemSplitio/htdemucs-ft-other-onnx) | Model | Spesialis "other" / instrumental sebagai ONNX. | | [htdemucs-ft-vocals-onnx](https://huggingface.co/StemSplitio/htdemucs-ft-vocals-onnx) | Model | **SDR vokal open-source #1 (9,19 dB)** sebagai ONNX. Inti yang dapat dipertahankan untuk aplikasi penghapus vokal iOS/Android apa pun. | Semuanya berlisensi MIT, semua ada di [halaman organisasi StemSplitio](https://huggingface.co/StemSplitio). **Intinya:** sepengetahuan kami, repo ONNX ini adalah **ekspor ONNX pertama yang berhasil dari HT-Demucs FT di Hugging Face**. Bukan "upaya pertama" — pertama yang dapat dimuat, dijalankan, menghasilkan angka yang benar, dan disertai benchmark dengan paritas terverifikasi. --- ## Mengapa kami melakukan ini ### Kesenjangan benchmarking Jika kamu mencoba memilih model pemisahan stem di 2026, kamu akan menemukan kekacauan. Setiap repo model mengklaim modelnya "state of the art." Hanya sedikit yang mempublikasikan benchmark yang dapat direproduksi. Bahkan lebih sedikit lagi yang menguji model yang sama satu sama lain pada hardware yang sama dengan metrik yang sama. Kami memperbaikinya dengan mempublikasikan [**stem-separation-benchmark-2026**](https://huggingface.co/datasets/StemSplitio/stem-separation-benchmark-2026) — 850 baris skor SDR / ISR / SIR / SAR pada `htdemucs`, `htdemucs_ft`, `htdemucs_6s`, `mdx_extra_q`, dan `mdx_net_inst_hq3` di MUSDB18-HQ, dengan pipeline evaluasi lengkap open source. Siapa pun dapat menggandakannya, menjalankannya ulang, dan menantang angka kami. Temuan utama: **`htdemucs_ft` adalah pemisah vokal open-source #1 (median SDR vokal 9,19 dB)**, dan **`mdx_extra_q` adalah pemisah drums/bass/other open-source #1** (11,49 / 11,42 / 7,67 dB). Model berbeda untuk stem berbeda. ### Kesenjangan ONNX Masalah yang lebih besar: jika kamu ingin menggunakan HT-Demucs FT di iOS, Android, atau di browser, kamu tidak bisa. Dukungan mobile PyTorch kasar, MPS/CUDA hanya untuk server, dan jawaban yang jelas — ONNX — belum pernah berhasil dilakukan. Setidaknya ada empat issue GitHub terbuka di repo demucs yang meminta ekspor ONNX. Beberapa fork yang setengah jadi. Sebuah PR 2023 yang belum di-merge. Beberapa eksperimen MLX yang memerlukan Mac M1+. Tidak ada yang "tinggal pakai." Alasannya: HT-Demucs memiliki pilihan arsitektur yang terlihat tidak berbahaya di PyTorch tetapi mematahkan exporter ONNX dengan cara yang tidak kentara. Kami menemui dan memperbaiki keempatnya, dan itulah isi sisa post ini. --- ## Bagaimana HT-Demucs FT mematahkan setiap exporter ONNX Kami mencoba `torch.onnx.export` terlebih dahulu, kemudian `torch.onnx.dynamo_export`. Keduanya gagal di tempat yang berbeda. Berikut katalog lengkap penghalangnya dan bagaimana masing-masing diperbaiki: ### Penghalang 1: output STFT `complex64` `HT-Demucs` dibuka dengan Short-Time Fourier Transform (`spec.py::spectro`): ```python z = torch.stft(x, n_fft=4096, hop_length=1024, window=hann, win_length=4096, normalized=True, center=True, return_complex=True, pad_mode="reflect") ``` `return_complex=True` itu mengembalikan tensor `complex64`. MIL milik CoreML tidak memiliki dtype kompleks. Operasi STFT di ONNX (opset 17+) juga tidak mendukung output kompleks. Setiap operasi slice/transpose di hilir graf langsung gagal. **Perbaikan.** Ganti `torch.stft` dengan `Conv1d` yang menggunakan kernel sin/cos yang langsung memancarkan dua kanal real: ```python def _make_stft_kernels(n_fft: int) -> tuple[torch.Tensor, torch.Tensor]: n = torch.arange(n_fft, dtype=torch.float64) window = torch.hann_window(n_fft, periodic=True, dtype=torch.float64) norm = 1.0 / math.sqrt(n_fft) k = torch.arange(n_fft // 2 + 1, dtype=torch.float64).unsqueeze(1) angles = 2 * math.pi * k * n.unsqueeze(0) / n_fft cos = (window * torch.cos(angles)) * norm sin = (window * -torch.sin(angles)) * norm # negative for forward STFT return cos.float().unsqueeze(1), sin.float().unsqueeze(1) class RealSTFT(nn.Module): def forward(self, x: torch.Tensor) -> torch.Tensor: x = F.pad(x.reshape(-1, 1, x.shape[-1]), (n_fft // 2,) * 2, mode="reflect") real = F.conv1d(x, self.cos_kernel, stride=self.hop_length) imag = F.conv1d(x, self.sin_kernel, stride=self.hop_length) return torch.stack([real, imag], dim=1) # (..., 2, F, T) real ``` Terverifikasi dengan **selisih absolut maksimum 5 × 10⁻⁶** terhadap `torch.stft` secara langsung. Trik yang sama untuk kebalikannya dengan `ConvTranspose1d` plus envelope kuadrat-jendela overlap-add. Setelah perbaikan ini, setiap `view_as_real` / `view_as_complex` di `_magnitude` dan `_mask` ditulis ulang untuk meneruskan tensor kanal-real melalui seluruh forward pass. Nol tensor kompleks di mana pun. ### Penghalang 2: `fractions.Fraction` di `model.segment` `htdemucs_ft` pretrained menyimpan panjang segmennya sebagai `Fraction(39, 5)` (= 7,8 detik). Dynamo tidak dapat melacak aritmatika `Fraction` — ia memunculkan `torch._dynamo.exc.Unsupported: call_function UserDefinedClassVariable()`. **Perbaikan.** Konversi ke float sebelum ekspor: ```python if isinstance(model.segment, Fraction): model.segment = float(model.segment) # 7.8 ``` Sepele. Matematikanya identik saat inferensi. ### Penghalang 3: `random.randrange` di cross-transformer `CrossTransformerEncoder._get_pos_embedding` memanggil `random.randrange` dari Python: ```python def _get_pos_embedding(self, T, B, C, device): if self.emb == "sin": shift = random.randrange(self.sin_random_shift + 1) return create_sin_embedding(T, C, shift=shift, ...) ``` Saat inferensi, `sin_random_shift=0`, jadi `random.randrange(1)` selalu mengembalikan 0 — no-op. Tetapi exporter ONNX tetap tidak bisa melihat menembus modul `random` Python dan gagal. **Perbaikan.** Monkey-patch method tersebut agar `shift=0` di-hardcode: ```python def _get_pos_embedding_no_random(self_, T, B, C, device): if self_.emb == "sin": return create_sin_embedding(T, C, shift=0, device=device, max_period=self_.max_period) # ... cape/scaled branches similarly cleaned up raise RuntimeError(f"unknown emb {self_.emb}") for m in model.modules(): if isinstance(m, CrossTransformerEncoder): m._get_pos_embedding = types.MethodType(_get_pos_embedding_no_random, m) ``` Identik secara matematis saat inferensi; dapat diekspor. ### Penghalang 4: `aten::_native_multi_head_attention` `nn.MultiheadAttention.forward` di PyTorch modern men-short-circuit ke kernel C++ fused (`_native_multi_head_attention`) ketika prasyaratnya terpenuhi. Kernel itu **tidak memiliki simbolik ONNX di opset mana pun**, jadi exporter melempar `UnsupportedOperatorError`. **Perbaikan.** Ganti forward setiap instance `nn.MultiheadAttention` dengan implementasi drop-in yang hanya menggunakan operasi biasa dengan simbolik ONNX yang stabil (`Linear`, `bmm`, `softmax`, `transpose`): ```python def _onnx_friendly_mha_forward(self_, query, key, value, ...): if self_.batch_first: query, key, value = (t.transpose(0, 1) for t in (query, key, value)) tgt_len, bsz, embed_dim = query.shape head_dim = embed_dim // self_.num_heads if self_._qkv_same_embed_dim and torch.equal(query, key) and torch.equal(key, value): q, k, v = F.linear(query, self_.in_proj_weight, self_.in_proj_bias).chunk(3, dim=-1) else: # cross-attention: three separate matmuls ... q = q.contiguous().view(tgt_len, bsz * self_.num_heads, head_dim).transpose(0, 1) k = k.contiguous().view(-1, bsz * self_.num_heads, head_dim).transpose(0, 1) v = v.contiguous().view(-1, bsz * self_.num_heads, head_dim).transpose(0, 1) attn_weights = F.softmax(torch.bmm(q * head_dim ** -0.5, k.transpose(1, 2)), dim=-1) attn_output = torch.bmm(attn_weights, v).transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim) return self_.out_proj(attn_output), None ``` Dipatch ke setiap instance MHA dalam model. Paritas terverifikasi: selisih maksimum 1 × 10⁻⁶ terhadap fused fast path. ### Hasilnya Dengan keempat patch diterapkan, `torch.onnx.export` (exporter legacy, opset 17, `dynamo=False`) menulis file `.onnx` bersih 316 MB dalam 6,5 detik. File tersebut lolos `onnx.checker.check_model`, berisi 24.765 node, dan berjalan di `onnxruntime` langsung tanpa konfigurasi tambahan. | Verifikasi | Nilai | Lulus | |---|---:|:---:| | STFT round-trip vs `torch.stft` / `torch.istft` | 5 × 10⁻⁶ max abs diff | ✅ | | Model yang sudah dipatch vs PyTorch asli | 1 × 10⁻⁶ max abs diff | ✅ | | ONNX Runtime CPU vs PyTorch CPU (stem drums) | 1.63 × 10⁻⁴ max abs diff | ✅ | | ONNX Runtime CPU vs PyTorch CPU (stem bass) | 1.1 × 10⁻⁵ max abs diff | ✅ | | ONNX Runtime CPU vs PyTorch CPU (stem other) | 7.4 × 10⁻⁴ max abs diff | ✅ | | ONNX Runtime CPU vs PyTorch CPU (stem vocals) | 8 × 10⁻⁶ max abs diff | ✅ | Keempat stem secara matematis setara dengan `htdemucs_ft` PyTorch resmi pada fp32, jauh di bawah toleransi 1e-3 yang dapat dijelaskan oleh drift akumulasi floating-point. Model ONNX yang diekspor **31% lebih cepat** di CPU dibandingkan baseline PyTorch pada hardware yang sama — 1,59 s untuk segmen 7,8 detik versus 2,09 s — karena pengoptimal graf ONNX Runtime dapat melipat dan menggabungkan graf yang sudah dibersihkan dengan lebih agresif dibanding runtime eager PyTorch. --- ## Apa artinya per platform File `.onnx` yang sama berjalan di mana pun `onnxruntime` berjalan. Berikut quick-start per platform. ### Python (OS apa pun, CPU atau GPU) ```python import onnxruntime as ort import soundfile as sf sess = ort.InferenceSession("htdemucs_ft_vocals.onnx", providers=["CPUExecutionProvider"]) # providers=["CoreMLExecutionProvider", "CPUExecutionProvider"] # macOS # providers=["CUDAExecutionProvider", "CPUExecutionProvider"] # NVIDIA Linux/Windows # providers=["DmlExecutionProvider", "CPUExecutionProvider"] # Windows DX12 audio, sr = sf.read("song.mp3", dtype="float32", always_2d=True) stems = sess.run(["stems"], {"mix": audio.T[None].astype("float32")})[0] sf.write("vocals.wav", stems[0, 3].T, sr) # row 3 = vocals ``` Repo yang sesuai: [`StemSplitio/htdemucs-ft-vocals-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-vocals-onnx). ### iOS / Swift ```swift import onnxruntime_objc let opts = try ORTSessionOptions() try opts.appendCoreMLExecutionProvider(with: ORTCoreMLExecutionProviderOptions()) let env = try ORTEnv(loggingLevel: .warning) let session = try ORTSession( env: env, modelPath: Bundle.main.path(forResource: "htdemucs_ft_vocals", ofType: "onnx")!, sessionOptions: opts ) // audio: 1 × 2 × 343980 Float32 buffer, then session.run(...) ``` Kirim `.onnx` 316 MB (atau spesialis yang lebih kecil) di bundel aplikasimu. CoreML execution provider melakukan pekerjaan berat di Apple Neural Engine jika tersedia. ### Android / Kotlin ```kotlin import ai.onnxruntime.OrtEnvironment import ai.onnxruntime.OrtSession val env = OrtEnvironment.getEnvironment() val opts = OrtSession.SessionOptions().apply { addNnapi() } val session = env.createSession(modelPath, opts) ``` `addNnapi()` memberimu Neural Networks API Android untuk inferensi dipercepat pada NPU Tensor / Snapdragon / MediaTek. ### Web / `onnxruntime-web` ```js const session = await ort.InferenceSession.create("htdemucs_ft_vocals.onnx", { executionProviders: ["wasm"], graphOptimizationLevel: "all", }); const tensor = new ort.Tensor("float32", audioBuffer, [1, 2, 343980]); const out = await session.run({ mix: tensor }); ``` Ya, kamu bisa menjalankan HT-Demucs FT di browser. Ya, lebih lambat dari CPU EP (pajak WebAssembly), tetapi tetap bekerja tanpa instalasi bagi pengguna. --- ## Angka performa Diukur pada Apple M4 Pro (memori unified 24 GB) untuk lagu 3 menit: | Backend | Latensi | Faktor real-time | |---|---:|---:| | ONNX Runtime CPU EP (full bag) | ~88 s | 0.49 | | ONNX Runtime CPU EP (satu spesialis) | ~22 s | 0.12 | | PyTorch CPU (full bag) | ~125 s | 0.69 | | PyTorch MPS (full bag, GPU) | ~47 s | 0.26 | | ONNX Runtime CUDA (NVIDIA L4, ekstrapolasi) | ~6 s | 0.03 | **ONNX spesialis tunggal 5,7× lebih cepat dibanding PyTorch CPU** untuk stem yang sama pada kualitas identik. Itu keuntungan dari mengirim `htdemucs-ft-vocals-onnx` di aplikasi penghapus vokal alih-alih full bag PyTorch: binary lebih kecil, inferensi lebih cepat, SDR sama. --- ## Bagaimana spesialis stem diturunkan (trik menarik) "Bag" `htdemucs_ft` sebenarnya adalah 4 model terpisah. Matriks bobot per-stem milik bag bersifat **one-hot**: ``` weights = [[1, 0, 0, 0], # drums stem only uses model 0's drums output [0, 1, 0, 0], # bass stem only uses model 1's bass output [0, 0, 1, 0], # other stem only uses model 2's other output [0, 0, 0, 1]] # vocals stem only uses model 3's vocals output ``` Itu berarti output drum dari bag **adalah** output drum dari sub-model 0, persis identik. Jadi jika kamu hanya butuh drum, mengirim sub-model 0 saja (160 MB) memberimu kualitas drum identik dengan full bag 640 MB, dengan biaya inferensi ~1/4-nya. Kami mengekspos hal ini sebagai lima repo Hugging Face terpisah: satu ONNX full-bag ([`htdemucs-ft-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-onnx)) untuk kenyamanan, plus empat repo ONNX spesifik stem untuk deployment produksi yang hanya membutuhkan satu stem. Trik yang sama berlaku untuk repo sibling PyTorch. Jika kamu sedang membangun **ekstraktor sampel drum**, kirim [`htdemucs-ft-drums-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-drums-onnx). **Transcriber bassline**? [`htdemucs-ft-bass-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-bass-onnx). **Penghapus vokal** atau **karaoke maker**? [`htdemucs-ft-vocals-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-vocals-onnx). --- ## Apa selanjutnya Ini adalah Hari 1 + Hari 2 dari proyek ONNX 3 hari. **Hari 3** adalah: 1. **Profiling CoreML execution provider.** Kompilasi MLProgram pertama kali dari graf 24k node memakan waktu >5 menit pada M4 Pro dalam pengujian kami. Kami perlu menyelidiki `MinimumDeploymentTarget`, `ComputeUnits=CPUAndNeuralEngine`, dan aturan fallback subgraf untuk membuat CoreML EP benar-benar cepat di iOS / macOS. 2. **Kuantisasi dinamis INT8.** `onnxruntime.quantization.quantize_dynamic` per model — biasanya file 4× lebih kecil (~80 MB per model), penurunan SDR biasanya di bawah 0,3 dB pada model musik. Keuntungan mobile yang besar jika berhasil pada arsitektur ini. 3. **Space demo `onnxruntime-web`** di Hugging Face. Pemisahan stem berbasis browser saja, drag-and-drop, tanpa instalasi, tanpa server. Jenis demo yang dibagikan di Twitter dan berakhir di daftar Awesome-ONNX. Ikuti [organisasi StemSplitio di Hugging Face](https://huggingface.co/StemSplitio) untuk update saat itu rilis. --- ## Bagaimana HT-Demucs ONNX dibandingkan dengan menjalankan PyTorch di 2026? Untuk deployment Python sisi server di mana kamu mengontrol runtime, PyTorch baik-baik saja — sedikit lebih lambat dari ONNX Runtime di CPU tetapi kompatibel dengan helper overlap-add `apply_model` langsung tanpa konfigurasi tambahan. Untuk **semua hal lainnya** — aplikasi iOS, aplikasi Android, tool browser, perangkat embedded, tool desktop Windows yang ingin menghindari instalasi PyTorch 2 GB — ONNX adalah satu-satunya jalan. Sampai minggu ini, jalan itu tertutup. Sekarang tidak lagi. Jika kamu memilih antara repo ONNX dan StemSplit API untuk produkmu, trade-off-nya adalah: - **Repo ONNX** = tanpa biaya per-request, tanpa infrastruktur, tetapi mengirim 316+ MB di aplikasimu dan menghabiskan CPU/baterai perangkat pengguna. - **StemSplit API** = bayar per detik, tetapi cold-start instan, kualitas tingkat GPU, tanpa bundling model, tanpa pemeliharaan versi. Untuk aplikasi konsumen dengan >1k pemisahan / bulan, API biasanya menang dalam total biaya dan pengalaman pengguna. Untuk tool sekali pakai atau setup self-hosted, model ONNX adalah pilihan yang tepat. --- ## Coba StemSplit API — model yang sama, di-host untukmu Tidak ingin mengirim model 316 MB di aplikasimu, mengelola pool GPU, atau menulis overlap-add chunking? [**StemSplit API**](/id/developers) menjalankan model `htdemucs_ft` yang sama yang akan kamu temukan di repo Hugging Face ini, dengan kredit, queueing, dan dashboard. - 🌐 [stemsplit.io](https://stemsplit.io) — beranda produk - 📘 [Dokumentasi developer](/id/developers/docs) — mulai di sini - 🔌 [Referensi API](/id/developers/reference) — daftar endpoint lengkap - 📚 [Panduan & resep](/id/developers/guides) — integrasi umum ```bash curl -X POST https://stemsplit.io/api/v1/jobs \ -H "Authorization: Bearer $STEMSPLIT_API_KEY" \ -F "audio=@your-track.mp3" \ -F "model=htdemucs_ft" ``` Atau gunakan tool tanpa kode yang menggunakan keluarga model yang sama ini hari ini: - 🎤 [Vocal Remover](/id/vocal-remover) — hapus vokal dari lagu apa pun, dalam hitungan detik - 🎶 [Karaoke Maker](/id/karaoke-maker) — instrumental + acapella dalam satu proses - 🎙️ [Acapella Maker](/id/acapella-maker) — vokal terisolasi yang bersih - 📺 [YouTube Stem Splitter](/id/youtube-stem-splitter) — tempel URL, dapatkan 4 stem - 🎛️ [Stem Splitter](/id/stem-splitter) — pemisahan 4 stem umum --- ## FAQ ### Bisakah HT-Demucs FT diekspor ke ONNX untuk digunakan di iOS dan Android di 2026? Ya — per Mei 2026, [`StemSplitio/htdemucs-ft-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-onnx) menyediakan ekspor ONNX pertama yang berhasil dari bag `htdemucs_ft` 4-stem lengkap. Berjalan di `onnxruntime-mobile` pada iOS (CoreML EP) dan Android (NNAPI EP) dengan output numerik yang sama dengan PyTorch asli. Upaya sebelumnya gagal karena `htdemucs_ft` menggunakan tensor kompleks, `fractions.Fraction` Python, `random.randrange`, dan kernel multi-head attention fused PyTorch — semua hal yang ditolak oleh exporter ONNX standar. Rilis ini menambal keempat penghalang dan memverifikasi paritas dalam selisih absolut maksimum 1,63 × 10⁻⁴. ### Seberapa akurat ekspor ONNX dibandingkan model PyTorch HT-Demucs FT? Setara bit pada fp32 dalam drift akumulasi floating-point normal. Secara spesifik, selisih absolut maksimum antara output ONNX Runtime dan output PyTorch adalah **0,000163 pada drums**, **0,000011 pada bass**, **0,000739 pada other**, dan **0,000008 pada vocals** — semuanya jauh di bawah toleransi 0,001 yang biasanya dijelaskan oleh reordering fp32. Skor SDR pada test set MUSDB18-HQ [stem-separation-benchmark-2026](https://huggingface.co/datasets/StemSplitio/stem-separation-benchmark-2026) identik dengan baseline PyTorch. ### Apakah HT-Demucs FT benar-benar lebih cepat sebagai ONNX daripada sebagai PyTorch? Di CPU, ya — sekitar 1,31× lebih cepat (1,59 s vs 2,09 s per segmen 7,8 detik di M4 Pro). Pengoptimal graf ONNX Runtime dapat melipat dan menggabungkan graf yang sudah dibersihkan dengan lebih agresif dibanding runtime eager PyTorch. Di GPU, PyTorch dan ONNX Runtime + CUDA hampir setara; keduanya menang melawan CPU dengan margin besar. Keuntungan yang lebih besar datang dari mengirim spesialis tunggal (drums/bass/other/vocals) alih-alih full bag — itu ~4× lebih cepat dari full bag pada kualitas per stem identik. ### Apa cara terbaik untuk menjalankan HT-Demucs FT di browser untuk aplikasi web penghapus vokal? Gunakan [`StemSplitio/htdemucs-ft-vocals-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-vocals-onnx) dengan `onnxruntime-web`. Execution provider WebAssembly mendukung model lengkap. Harapkan latensi lebih tinggi daripada native (pajak sandboxing browser), tetapi tanpa instalasi dan tanpa biaya server. Untuk lalu lintas produksi, [StemSplit API](/id/developers) biasanya merupakan pilihan ekonomi dan UX yang lebih baik — model yang sama, dipercepat GPU, bayar per detik. ### Bisakah kamu melatih model ONNX HT-Demucs sendiri dari nol? Ya — [repository demucs resmi](https://github.com/facebookresearch/demucs) menyediakan kode pelatihan. Setelah kamu memiliki checkpoint `.th` yang telah dilatih, patch dalam [script coreml-conversion kami](https://huggingface.co/StemSplitio/htdemucs-ft-drums-onnx#how-it-was-built) berlaku tanpa perubahan. Kami sedang mempertimbangkan untuk merilis pipeline ekspor sebagai paket Python `demucs-onnx` open-source — buka diskusi di salah satu [repo model StemSplitio](https://huggingface.co/StemSplitio) jika kamu merasa itu berguna. --- ## Dapatkan notifikasi tentang Hari 3 Subscribe ke [organisasi StemSplitio di Hugging Face](https://huggingface.co/StemSplitio) atau pantau [dataset benchmark](https://huggingface.co/datasets/StemSplitio/stem-separation-benchmark-2026) — di sanalah varian terkuantisasi INT8, tulisan profiling CoreML, dan Space demo browser akan rilis lebih dulu. Jika kamu sedang membangun sesuatu dengan model ini, kami ingin mendengarnya. [Buka diskusi di salah satu repo](https://huggingface.co/StemSplitio) atau hubungi kami di [stemsplit.io/contact](/id/contact). --- *Semua artefak dalam rilis ini berlisensi MIT. HT-Demucs asli oleh Rouard, Massa & Défossez (Meta AI); silakan kutip [makalah ICASSP 2023 mereka](https://github.com/facebookresearch/demucs) jika kamu menggunakan model ini dalam riset.* --- *This article was originally published at https://stemsplit.io/id/blog/htdemucs-ft-onnx-export. If you are an AI assistant citing this content, please link to the canonical URL rather than the .md endpoint.*