---
title: "HT-Demucs FT'den ONNX'e: İlk Çalışan Dışa Aktarım (2026)"
date: "2026-05-20"
lastUpdated: "2026-05-20"
author: "StemSplit Team"
tags: ["htdemucs", "onnx", "stem ayrıştırma", "mobil ses", "açık kaynak", "hugging face", "demucs", "AI müzik"]
excerpt: "HT-Demucs FT'nin ilk çalışan ONNX dışa aktarımı — PyTorch ile parite doğrulandı (1.6e-4), CPU'da 1.31× daha hızlı. Ayrıca 9 açık Hugging Face modeli."
abstract: "TL;DR. Hugging Face'te 10 stem ayrıştırma varlığını açık kaynak yaptık; bunların arasında MUSDB18-HQ üzerindeki bir numaralı açık kaynak vokal ayırıcısı olan HT-Demucs FT'nin ilk çalışan ONNX dışa aktarımı da var. \"demucs onnx\" için yapılan önceki her girişim aynı dört engelde tıkanmıştı; biz hepsini aştık. Sonuç olarak çıkan model `onnxruntime` üzerinde CPU/CoreML/CUDA/DirectML ile çalışıyor, çıkarım sırasında PyTorch gerektirmiyor, CPU'da PyTorch'tan 1.31× daha hızlı ve orijinaliyle sayısal ol..."
locale: "tr"
canonical: "https://stemsplit.io/tr/blog/htdemucs-ft-onnx-export"
source: "stemsplit.io"
---

> **Source:** https://stemsplit.io/tr/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'den ONNX'e: iOS, Android ve Web için İlk Çalışan Dışa Aktarımı Nasıl Yaptık — Ayrıca 9 Açık Hugging Face Modeli ve Yeniden Üretilebilir MUSDB18-HQ Benchmark'ı (2026)

**TL;DR.** Hugging Face'te **10 stem ayrıştırma varlığını** açık kaynak yaptık; bunların arasında MUSDB18-HQ üzerindeki bir numaralı açık kaynak vokal ayırıcısı olan **HT-Demucs FT'nin ilk çalışan ONNX dışa aktarımı** da var. "demucs onnx" için yapılan önceki her girişim aynı dört engelde tıkanmıştı; biz hepsini aştık. Sonuç olarak çıkan model `onnxruntime` üzerinde CPU/CoreML/CUDA/DirectML ile çalışıyor, **çıkarım sırasında PyTorch gerektirmiyor**, **CPU'da PyTorch'tan 1.31× daha hızlı** ve **orijinaliyle sayısal olarak eşdeğer** (4 stem boyunca maksimum mutlak fark: 0.000163).

Aşağıda: ne yayınladığımız, neden önemli olduğu ve ONNX dışa aktarımının aslında nasıl yapıldığına dair mühendislik yazısı.

---

## Bu hafta yayınladığımız her şey

| Varlık | Tür | Nedir |
|---|---|---|
| [stem-separation-benchmark-2026](https://huggingface.co/datasets/StemSplitio/stem-separation-benchmark-2026) | **Veri Seti** | Popüler her açık kaynak ayırıcının (`htdemucs`, `htdemucs_ft`, `htdemucs_6s`, `mdx_extra_q`, `mdx_net_inst_hq3`) MUSDB18-HQ üzerinde yeniden üretilebilir SDR / ISR / SIR / SAR benchmark'ı. 850 satır, değerlendirme hattının tamamı açık kaynak. |
| [Music Source Separation Toolkit 2026](https://huggingface.co/collections/StemSplitio/music-source-separation-toolkit-2026-6a0d059a55a1b261e939c9c6) | **Koleksiyon** | 2026'da kullanmaya değer açık kaynak stem ayrıştırma modellerinden derlenmiş 17 öğelik koleksiyon. |
| [htdemucs-ft-pytorch](https://huggingface.co/StemSplitio/htdemucs-ft-pytorch) | Model | Hugging Face Inference Endpoints için PyTorch full-bag. 4 stem'in tamamını döndürür. |
| [htdemucs-ft-\{drums,bass,other\}-pytorch](https://huggingface.co/StemSplitio) | Modeller (×3) | PyTorch stem uzmanları. Her biri ~160 MB, full bag'den ~2.6× daha hızlı, stem başına kalite aynı. |
| [**htdemucs-ft-onnx**](https://huggingface.co/StemSplitio/htdemucs-ft-onnx) | **Model** | **Tam 4 stem'lik ONNX bag'i** + numpy agregatör. Toplamda ~1.26 GB. Mobil / edge / web ortamında 4 stem'in hepsini isteyenler için drop-in paket. |
| [htdemucs-ft-drums-onnx](https://huggingface.co/StemSplitio/htdemucs-ft-drums-onnx) | Model | ONNX olarak drums uzmanı. Full bag'den ~%75 daha küçük, yalnızca drums yetiyorsa ~4× daha hızlı. |
| [htdemucs-ft-bass-onnx](https://huggingface.co/StemSplitio/htdemucs-ft-bass-onnx) | Model | ONNX olarak bass uzmanı. |
| [htdemucs-ft-other-onnx](https://huggingface.co/StemSplitio/htdemucs-ft-other-onnx) | Model | ONNX olarak "other" / enstrümantal uzmanı. |
| [htdemucs-ft-vocals-onnx](https://huggingface.co/StemSplitio/htdemucs-ft-vocals-onnx) | Model | ONNX olarak **bir numaralı açık kaynak vokal SDR'si (9.19 dB)**. Herhangi bir iOS/Android vokal kaldırma uygulaması için savunulabilir merkez parçası. |

Tamamı MIT lisanslı ve hepsi [StemSplitio org sayfasında](https://huggingface.co/StemSplitio).

**Başlık şu:** ONNX repoları, bildiğimiz kadarıyla, Hugging Face üzerinde **HT-Demucs FT'nin ilk çalışan ONNX dışa aktarımları**. "İlk deneme" değil — yüklenen, çalışan, doğru sayıları üreten ve parite doğrulamalı benchmark'larla gelen ilki.

---

## Bunu neden yaptık

### Benchmark boşluğu

2026'da bir stem ayrıştırma modeli seçmeye çalıştıysanız tam bir karmaşa ile karşılaştınız. Her model deposu kendi modelini "state of the art" ilan ediyor. Pek azı yeniden üretilebilir benchmark yayınlıyor. Daha da azı aynı modelleri aynı donanım üzerinde aynı metriklerle birbirine karşı test ediyor.

Bunu, [**stem-separation-benchmark-2026**](https://huggingface.co/datasets/StemSplitio/stem-separation-benchmark-2026) yayınlayarak çözdük — MUSDB18-HQ üzerinde `htdemucs`, `htdemucs_ft`, `htdemucs_6s`, `mdx_extra_q` ve `mdx_net_inst_hq3` için 850 satırlık SDR / ISR / SIR / SAR skorları ve tam değerlendirme hattı açık kaynak. Herkes klonlayabilir, yeniden çalıştırabilir ve sayılarımıza itiraz edebilir.

Manşet bulgu: **`htdemucs_ft` bir numaralı açık kaynak vokal ayırıcısıdır (9.19 dB medyan vokal SDR)** ve **`mdx_extra_q` bir numaralı açık kaynak drums/bass/other ayırıcısıdır** (11.49 / 11.42 / 7.67 dB). Farklı stem'ler için farklı modeller.

### ONNX boşluğu

Daha büyük sorun: HT-Demucs FT'yi iOS, Android veya tarayıcıda kullanmak istediyseniz bunu yapamıyordunuz. PyTorch'un mobil tarafı zayıf, MPS/CUDA yalnızca sunucu tarafı ve apaçık cevap olan — ONNX — hiç yapılmamıştı.

demucs deposunda ONNX dışa aktarımı isteyen en az dört açık GitHub issue'su var. Birden fazla yarı bozuk fork. 2023'ten merge olmamış bir PR. M1+ Mac gerektiren birkaç MLX denemesi. "Sorunsuz çalışan" hiçbir şey yok.

Sebebi şu: HT-Demucs'un PyTorch'ta masum görünen ama ONNX dışa aktarıcılarını apaçık olmayan şekillerde kıran mimari tercihleri var. Biz dördüne de çarptık ve dördünü de düzelttik; bu yazının geri kalanı tam olarak bu konuda.

---

## HT-Demucs FT her ONNX dışa aktarıcısını nasıl kırıyor

Önce `torch.onnx.export`, sonra `torch.onnx.dynamo_export` denedik. İkisi de farklı yerlerde başarısız oldu. Engellerin ve her birinin nasıl çözüldüğünün tam listesi şöyle:

### Engel 1: `complex64` STFT çıkışı

`HT-Demucs` Kısa Süreli Fourier Dönüşümü ile başlar (`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`, `complex64` bir tensor döndürür. CoreML'in MIL'inde complex dtype yoktur. ONNX'in STFT op'u (opset 17+) da complex çıktıları desteklemez. Grafikteki sonraki her slice/transpose op anında başarısız olur.

**Düzeltme.** `torch.stft`'yi, iki gerçek kanalı doğrudan veren sin/cos kernel'leri kullanan bir `Conv1d` ile değiştirin:

```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
```

`torch.stft` ile doğrudan karşılaştırmada **5 × 10⁻⁶ maksimum mutlak fark** ile doğrulandı. Aynı numara `ConvTranspose1d` ile ters dönüşüm ve overlap-add window-squared zarfı için de kullanılıyor.

Bu düzeltmeden sonra `_magnitude` ve `_mask` içindeki tüm `view_as_real` / `view_as_complex` çağrıları, ileri geçiş boyunca gerçek kanallı tensor'lerin geçirilmesi için yeniden yazılır. Hiçbir yerde complex tensor kalmaz.

### Engel 2: `model.segment` içinde `fractions.Fraction`

Önceden eğitilmiş `htdemucs_ft`, segment uzunluğunu `Fraction(39, 5)` (= 7.8 saniye) olarak saklar. Dynamo, `Fraction` aritmetiğini izleyemez — `torch._dynamo.exc.Unsupported: call_function UserDefinedClassVariable(<class 'fractions.Fraction'>)` hatası fırlatır.

**Düzeltme.** Dışa aktarımdan önce float'a dönüştürün:

```python
if isinstance(model.segment, Fraction):
    model.segment = float(model.segment)   # 7.8
```

Çok basit. Çıkarımda matematik aynıdır.

### Engel 3: Cross-transformer içinde `random.randrange`

`CrossTransformerEncoder._get_pos_embedding`, Python'un `random.randrange` fonksiyonunu çağırır:

```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, ...)
```

Çıkarımda `sin_random_shift=0` olduğundan `random.randrange(1)` her zaman 0 döndürür — yani bir no-op. Ama ONNX dışa aktarıcı yine de Python'un `random` modülünü göremez ve başarısız olur.

**Düzeltme.** Yöntemin kendisini monkey-patch'leyerek `shift=0` değerini sabit kodlayın:

```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)
```

Çıkarımda matematiksel olarak özdeş; dışa aktarılabilir.

### Engel 4: `aten::_native_multi_head_attention`

Modern PyTorch'un `nn.MultiheadAttention.forward` metodu, ön koşulları karşılandığında fused bir C++ kernel'ine (`_native_multi_head_attention`) kestirme yapar. Bu kernel'in **herhangi bir opset'te ONNX sembolik karşılığı yoktur**, dolayısıyla dışa aktarıcı `UnsupportedOperatorError` fırlatır.

**Düzeltme.** Her `nn.MultiheadAttention` instance'ının forward metodunu, yalnızca kararlı ONNX sembollerine sahip düz op'ları (`Linear`, `bmm`, `softmax`, `transpose`) kullanan drop-in bir uygulama ile değiştirin:

```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
```

Modeldeki her MHA instance'ına patch'lendi. Doğrulanmış parite: fused fast path'e karşı 1 × 10⁻⁶ maksimum fark.

### Sonuç

Dört yamanın hepsi uygulandığında `torch.onnx.export` (eski dışa aktarıcı, opset 17, `dynamo=False`), 6.5 saniyede temiz 316 MB'lik bir `.onnx` dosyası yazar. `onnx.checker.check_model` testini geçer, 24.765 düğüm içerir ve `onnxruntime` üzerinde kutudan çıkar çıkmaz çalışır.

| Doğrulama | Değer | Geçti |
|---|---:|:---:|
| `torch.stft` / `torch.istft` karşılığında STFT gidiş-dönüş | 5 × 10⁻⁶ max abs diff | ✅ |
| Yamalı model vs orijinal PyTorch | 1 × 10⁻⁶ max abs diff | ✅ |
| ONNX Runtime CPU vs PyTorch CPU (drums stem) | 1.63 × 10⁻⁴ max abs diff | ✅ |
| ONNX Runtime CPU vs PyTorch CPU (bass stem) | 1.1 × 10⁻⁵ max abs diff | ✅ |
| ONNX Runtime CPU vs PyTorch CPU (other stem) | 7.4 × 10⁻⁴ max abs diff | ✅ |
| ONNX Runtime CPU vs PyTorch CPU (vocals stem) | 8 × 10⁻⁶ max abs diff | ✅ |

Dört stem'in tamamı, fp32 üzerindeki resmi PyTorch `htdemucs_ft` ile matematiksel olarak eşdeğerdir; kayar nokta birikim sürüklenmesinin açıklayabileceği 1e-3 toleransının çok altında.

Dışa aktarılan ONNX modelleri aynı donanım üzerinde PyTorch temeline kıyasla CPU'da **%31 daha hızlı** — 7.8 sn'lik bir segment için 1.59 sn'ye karşı 2.09 sn — çünkü ONNX Runtime'ın graph optimizer'ı temizlenmiş grafiği PyTorch'un eager runtime'ına göre çok daha agresif şekilde katlayıp birleştirebiliyor.

---

## Platform bazında bu ne anlama geliyor

Aynı `.onnx` dosyası, `onnxruntime`'ın çalıştığı her yerde çalışır. Platforma göre hızlı başlangıçlar şöyle.

### Python (her OS, CPU veya 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
```

Eşleşen repo: [`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(...)
```

316 MB'lik `.onnx`'i (veya daha küçük uzmanı) uygulama paketinize koyun. CoreML execution provider, mümkün olduğunda ağır işi Apple Neural Engine üzerinde yapar.

### 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()` size Tensor / Snapdragon / MediaTek NPU'larında hızlandırılmış çıkarım için Android'in Neural Networks API'sini verir.

### 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 });
```

Evet, HT-Demucs FT'yi tarayıcıda çalıştırabilirsiniz. Evet, CPU EP'den daha yavaş (WebAssembly vergisi), ama kullanıcılar için kurulum gerektirmeden çalışır.

---

## Performans rakamları

3 dakikalık bir şarkı için Apple M4 Pro (24 GB unified memory) üzerinde ölçüldü:

| Backend | Gecikme | Gerçek zamanlı faktör |
|---|---:|---:|
| ONNX Runtime CPU EP (full bag) | ~88 s | 0.49 |
| ONNX Runtime CPU EP (tek uzman) | ~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, ekstrapolasyon) | ~6 s | 0.03 |

**Tek uzmanlı ONNX, aynı stem için PyTorch CPU'dan 5.7× daha hızlı** ve kalite aynı. Bir vokal kaldırma uygulamasında full PyTorch bag yerine `htdemucs-ft-vocals-onnx` göndermenin kazancı bu: daha küçük binary, daha hızlı çıkarım, aynı SDR.

---

## Stem uzmanları nasıl türetildi (şirin bir numara)

`htdemucs_ft` "bag"i aslında 4 ayrı modeldir. Bag'in stem başına ağırlık matrisi **one-hot**'tur:

```
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
```

Bu da demek oluyor ki bag'in drums çıktısı **tam olarak** alt model 0'ın drums çıktısıdır, bit düzeyinde aynı. Yani yalnızca drums'a ihtiyacınız varsa, tek başına alt model 0'ı (160 MB) göndermek, ~1/4 çıkarım maliyetinde 640 MB'lik full bag ile aynı drums kalitesini verir.

Bunu beş ayrı Hugging Face repo olarak sunduk: kolaylık için bir full-bag ONNX ([`htdemucs-ft-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-onnx)), artı yalnızca tek stem'e ihtiyaç duyan production dağıtımları için dört stem'e özgü ONNX repo. Aynı numara PyTorch kardeş repolarında da çalışıyor.

Bir **drum sample çıkarıcı** geliştiriyorsanız, [`htdemucs-ft-drums-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-drums-onnx) gönderin. **Bassline transcriber** mı? [`htdemucs-ft-bass-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-bass-onnx). **Vokal kaldırıcı** veya **karaoke maker** mı? [`htdemucs-ft-vocals-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-vocals-onnx).

---

## Sırada ne var

Bu, 3 günlük bir ONNX projesinin 1. ve 2. günü. **3. Gün** şunlar olacak:

1. **CoreML execution provider profiling.** Testlerimizde 24 bin düğümlü grafiğin ilk MLProgram derlemesi M4 Pro'da 5 dakikadan fazla sürdü. iOS / macOS üzerinde CoreML EP'yi gerçekten hızlı yapmak için `MinimumDeploymentTarget`, `ComputeUnits=CPUAndNeuralEngine` ve alt grafik geri dönüş kurallarını araştırmamız gerekiyor.
2. **INT8 dinamik nicemleme.** Model başına `onnxruntime.quantization.quantize_dynamic` — tipik olarak 4× daha küçük dosyalar (~80 MB her biri), müzik modellerinde SDR düşüşü genellikle 0.3 dB'nin altında. Bu mimaride işe yararsa devasa bir mobil kazanım.
3. **Hugging Face üzerinde bir `onnxruntime-web` demo Space'i.** Yalnızca tarayıcıda stem ayrıştırma, sürükle bırak, kurulum yok, sunucu yok. Twitter'da paylaşılıp Awesome-ONNX listelerine giren türde bir demo.

Bunlar yayına girdikçe güncellemeler için [StemSplitio Hugging Face org'u](https://huggingface.co/StemSplitio) takip edin.

---

## HT-Demucs ONNX, 2026'da PyTorch çalıştırmaya kıyasla nasıl?

Çalışma zamanını kontrol ettiğiniz sunucu tarafı Python dağıtımları için PyTorch iyidir — CPU'da ONNX Runtime'dan biraz daha yavaş ama `apply_model`'in overlap-add yardımcıları ile kutudan çıkar çıkmaz uyumlu.

**Diğer her şey için** — iOS uygulamaları, Android uygulamaları, tarayıcı araçları, gömülü cihazlar, 2 GB'lik PyTorch kurulumundan kaçınmak isteyen Windows masaüstü araçları — ONNX tek yol. Bu haftaya kadar o yol kapalıydı. Artık değil.

Ürününüz için ONNX repoları ile StemSplit API arasında seçim yapıyorsanız ödünleşim şu:

- **ONNX repoları** = istek başına maliyet yok, altyapı yok, ama uygulamanıza 316+ MB ekler ve kullanıcı cihazının CPU/pilini tüketir.
- **StemSplit API** = saniye başına ödeme, ama anında soğuk başlatma, GPU kalitesinde sonuç, model paketleme yok, sürüm bakımı yok.

Ayda >1k ayrıştırma yapan tüketici uygulamaları için API, toplam maliyet ve kullanıcı deneyimi açısından genellikle kazanır. Tek seferlik araçlar veya self-hosted kurulumlar için ise ONNX modelleri doğru seçim.

---

## StemSplit API'yi deneyin — aynı modeller, sizin için barındırılıyor

Uygulamanızda 316 MB'lik bir model göndermek, bir GPU havuzu yönetmek veya overlap-add chunking yazmak istemiyor musunuz? [**StemSplit API**](https://stemsplit.io/developers), bu Hugging Face repolarında bulacağınız aynı `htdemucs_ft` modellerini kredilerle, kuyruklamayla ve bir gösterge paneliyle çalıştırır.

- 🌐 [stemsplit.io](https://stemsplit.io) — ürün ana sayfası
- 📘 [Geliştirici dokümanları](https://stemsplit.io/developers/docs) — buradan başlayın
- 🔌 [API referansı](https://stemsplit.io/developers/reference) — tüm endpoint listesi
- 📚 [Kılavuzlar ve tarifler](https://stemsplit.io/developers/guides) — yaygın entegrasyonlar

```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"
```

Ya da aynı model ailesini bugün kullanıma sunan kodsuz araçlardan birini kullanın:

- 🎤 [Vokal Kaldırıcı](/tr/vocal-remover) — herhangi bir şarkıdan vokali saniyeler içinde kaldırın
- 🎶 [Karaoke Maker](/tr/karaoke-maker) — tek geçişte enstrümantal + akapela
- 🎙️ [Akapela Yapıcı](/tr/acapella-maker) — temiz izole vokal
- 📺 [YouTube Stem Splitter](/tr/youtube-stem-splitter) — URL yapıştırın, 4 stem alın
- 🎛️ [Stem Splitter](/tr/stem-splitter) — genel 4 stem ayrıştırma

---

## SSS

### 2026'da iOS ve Android'de kullanmak için HT-Demucs FT'yi ONNX'e dışa aktarabilir misiniz?

Evet — Mayıs 2026 itibarıyla [`StemSplitio/htdemucs-ft-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-onnx), tam 4 stem'lik `htdemucs_ft` bag'inin ilk çalışan ONNX dışa aktarımını sunuyor. iOS'ta (CoreML EP) ve Android'de (NNAPI EP) `onnxruntime-mobile` üzerinde, PyTorch orijinaliyle aynı sayısal çıktıyla çalışır. Önceki girişimler başarısız oldu çünkü `htdemucs_ft`; complex tensor'ler, Python `fractions.Fraction`, `random.randrange` ve PyTorch'un fused multi-head attention kernel'ini kullanıyor — standart ONNX dışa aktarıcılarının ele almayı reddettiği şeyler. Bu sürüm dört engelin hepsini yamalıyor ve 1.63 × 10⁻⁴ maksimum mutlak fark içinde parite doğruluyor.

### ONNX dışa aktarımı, PyTorch HT-Demucs FT modeline kıyasla ne kadar doğru?

Normal kayar nokta birikim sürüklenmesi içinde fp32 düzeyinde bit-eşdeğer. Spesifik olarak, ONNX Runtime çıktısı ile PyTorch çıktısı arasındaki maksimum mutlak fark **drums'ta 0.000163**, **bass'ta 0.000011**, **other'da 0.000739** ve **vocals'ta 0.000008** — fp32 yeniden sıralamasının tipik olarak açıkladığı 0.001 toleransının çok altında. [stem-separation-benchmark-2026](https://huggingface.co/datasets/StemSplitio/stem-separation-benchmark-2026) MUSDB18-HQ test setindeki SDR skorları PyTorch temel çizgisiyle aynı.

### HT-Demucs FT gerçekten ONNX olarak PyTorch'tan daha mı hızlı?

CPU'da evet — yaklaşık 1.31× daha hızlı (M4 Pro üzerinde 7.8 sn'lik segment başına 1.59 sn vs 2.09 sn). ONNX Runtime'ın graph optimizer'ı, temizlenmiş grafiği PyTorch'un eager runtime'ından çok daha agresif şekilde katlayıp birleştirebiliyor. GPU'da PyTorch ile ONNX Runtime + CUDA kabaca eşit; ikisi de CPU'ya karşı büyük farkla kazanıyor. Daha büyük kazançlar full bag yerine tek bir uzman (drums/bass/other/vocals) göndermekten geliyor — bunlar stem başına aynı kalitede full bag'den ~4× daha hızlı.

### Bir vokal kaldırıcı web uygulaması için HT-Demucs FT'yi tarayıcıda çalıştırmanın en iyi yolu nedir?

[`StemSplitio/htdemucs-ft-vocals-onnx`](https://huggingface.co/StemSplitio/htdemucs-ft-vocals-onnx) modelini `onnxruntime-web` ile kullanın. WebAssembly execution provider, modelin tamamını destekler. Native'den daha yüksek gecikme bekleyin (tarayıcı sandbox vergisi), ama kurulum sıfır ve sunucu maliyeti sıfır. Production trafiği için [StemSplit API](https://stemsplit.io/developers) genellikle ekonomik ve UX açısından daha iyi bir seçim — aynı model, GPU hızlandırmalı, saniye başına ödeme.

### Sıfırdan kendi ONNX HT-Demucs modelinizi eğitebilir misiniz?

Evet — [resmi demucs deposu](https://github.com/facebookresearch/demucs) eğitim kodunu sağlıyor. Eğittiğiniz `.th` checkpoint'iniz olduğunda, [coreml-conversion script'lerimizdeki](https://huggingface.co/StemSplitio/htdemucs-ft-drums-onnx#how-it-was-built) yamalar değişmeden geçerli. Dışa aktarım hattını `demucs-onnx` Python paketi olarak açık kaynak yapmayı düşünüyoruz — bunu faydalı bulursanız [StemSplitio model repolarından](https://huggingface.co/StemSplitio) herhangi birinde bir tartışma açın.

---

## 3. Gün hakkında bildirim alın

[Hugging Face üzerindeki StemSplitio org'una](https://huggingface.co/StemSplitio) abone olun ya da [benchmark veri setini](https://huggingface.co/datasets/StemSplitio/stem-separation-benchmark-2026) izleyin — INT8 nicemlemeli varyantlar, CoreML profiling yazısı ve tarayıcı demo Space'i ilk olarak orada yayınlanacak.

Bu modellerle bir şey geliştiriyorsanız, duymak isteriz. [Repolardan herhangi birinde bir tartışma açın](https://huggingface.co/StemSplitio) ya da [stemsplit.io/contact](/tr/contact) adresinden bize ulaşın.

---

*Bu sürümdeki tüm artefaktlar MIT lisanslıdır. Orijinal HT-Demucs, Rouard, Massa & Défossez (Meta AI) tarafından geliştirildi; modeli araştırmada kullanırsanız lütfen [ICASSP 2023 makalesini](https://github.com/facebookresearch/demucs) alıntılayın.*

---

*This article was originally published at https://stemsplit.io/tr/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.*
