Upload folder using huggingface_hub

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

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

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

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

HTDemucs_6S_Split_F32.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "A5ED0403-384D-4AB3-B8E0-154E6EC780BB": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        },
+        "ADB7E7D2-7FF6-416F-B6F9-D25FFD816320": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        }
+    },
+    "rootModelIdentifier": "ADB7E7D2-7FF6-416F-B6F9-D25FFD816320"
+}

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

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

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

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

HTDemucs_SourceSeparation_F32.mlpackage/Manifest.json

@@ -0,0 +1,18 @@
+{
+    "fileFormatVersion": "1.0.0",
+    "itemInfoEntries": {
+        "2D126888-F20C-42D9-B54C-A25C7994664D": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Specification",
+            "name": "model.mlmodel",
+            "path": "com.apple.CoreML/model.mlmodel"
+        },
+        "D2E7EAD1-5A9F-4503-8620-2485EE5A5AB0": {
+            "author": "com.apple.CoreML",
+            "description": "CoreML Model Weights",
+            "name": "weights",
+            "path": "com.apple.CoreML/weights"
+        }
+    },
+    "rootModelIdentifier": "2D126888-F20C-42D9-B54C-A25C7994664D"
+}

convert_htdemucs_6s_split_coreml.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""
+Convert Meta's htdemucs_6s model to a CoreML package that matches the
+StemsPlayer iOS DSP pipeline.
+
+This export intentionally keeps STFT/iSTFT outside the CoreML graph. The iOS
+app computes the complex spectrogram with Accelerate, calls this model, then
+reconstructs audio with iSTFT. This avoids CoreMLTools' complex64 conversion
+failure when trying to convert the waveform-only HTDemucs graph.
+
+Inputs:
+  spectral_magnitude: [1, 4, 2048, 336]  # stereo complex spectrogram as
+                                         # L.real, L.imag, R.real, R.imag
+  audio_waveform:      [1, 2, 343980]
+
+Outputs:
+  freq_output: [1, 24, 2048, 336]        # 6 stems * 2 channels * real/imag
+  time_output: [1, 12, 343980]           # 6 stems * 2 channels
+
+Source order:
+  drums, bass, other, vocals, guitar, piano
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import coremltools as ct
+import torch
+from demucs.pretrained import get_model
+from einops import rearrange
+
+
+SEGMENT_SAMPLES = 343_980
+NUM_BINS = 2_048
+NUM_FRAMES = 336
+
+
+class HTDemucs6SSplitExport(torch.nn.Module):
+    def __init__(self, model: torch.nn.Module):
+        super().__init__()
+        self.model = model
+
+    def forward(
+        self,
+        spectral_magnitude: torch.Tensor,
+        audio_waveform: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        model = self.model
+        x = spectral_magnitude
+        xt = audio_waveform
+
+        batch = x.shape[0]
+        spec_channels = x.shape[1]
+        freq_bins = x.shape[2]
+        frames = x.shape[3]
+
+        mean = x.mean(dim=(1, 2, 3), keepdim=True)
+        std = x.std(dim=(1, 2, 3), keepdim=True)
+        x = (x - mean) / (1e-5 + std)
+
+        time_mean = xt.mean(dim=(1, 2), keepdim=True)
+        time_std = xt.std(dim=(1, 2), keepdim=True)
+        xt = (xt - time_mean) / (1e-5 + time_std)
+
+        saved = []
+        saved_t = []
+        lengths = []
+        lengths_t = []
+
+        for idx, encode in enumerate(model.encoder):
+            lengths.append(x.shape[-1])
+            inject = None
+
+            if idx < len(model.tencoder):
+                lengths_t.append(xt.shape[-1])
+                tenc = model.tencoder[idx]
+                xt = tenc(xt)
+
+                if not tenc.empty:
+                    saved_t.append(xt)
+                else:
+                    inject = xt
+
+            x = encode(x, inject)
+
+            if idx == 0 and model.freq_emb is not None:
+                freqs = torch.arange(x.shape[-2], device=x.device)
+                emb = model.freq_emb(freqs).t()[None, :, :, None].expand_as(x)
+                x = x + model.freq_emb_scale * emb
+
+            saved.append(x)
+
+        if model.crosstransformer:
+            if model.bottom_channels:
+                _, _, freq, _ = x.shape
+                x = rearrange(x, "b c f t -> b c (f t)")
+                x = model.channel_upsampler(x)
+                x = rearrange(x, "b c (f t) -> b c f t", f=freq)
+                xt = model.channel_upsampler_t(xt)
+
+            x, xt = model.crosstransformer(x, xt)
+
+            if model.bottom_channels:
+                _, _, freq, _ = x.shape
+                x = rearrange(x, "b c f t -> b c (f t)")
+                x = model.channel_downsampler(x)
+                x = rearrange(x, "b c (f t) -> b c f t", f=freq)
+                xt = model.channel_downsampler_t(xt)
+
+        for idx, decode in enumerate(model.decoder):
+            skip = saved.pop(-1)
+            x, pre = decode(x, skip, lengths.pop(-1))
+
+            offset = model.depth - len(model.tdecoder)
+            if idx >= offset:
+                tdec = model.tdecoder[idx - offset]
+                length_t = lengths_t.pop(-1)
+
+                if tdec.empty:
+                    pre = pre[:, :, 0]
+                    xt, _ = tdec(pre, None, length_t)
+                else:
+                    skip = saved_t.pop(-1)
+                    xt, _ = tdec(xt, skip, length_t)
+
+        stem_count = len(model.sources)
+
+        freq_out = x.view(batch, stem_count, -1, freq_bins, frames)
+        freq_out = freq_out * std[:, None] + mean[:, None]
+        freq_out = freq_out.reshape(batch, stem_count * spec_channels, freq_bins, frames)
+
+        time_out = xt.view(batch, stem_count, -1, audio_waveform.shape[-1])
+        time_out = time_out * time_std[:, None] + time_mean[:, None]
+        time_out = time_out.reshape(batch, stem_count * 2, audio_waveform.shape[-1])
+
+        return freq_out, time_out
+
+
+def convert(output: Path) -> None:
+    bag = get_model("htdemucs_6s")
+    model = bag.models[0] if hasattr(bag, "models") else bag
+    model.eval()
+
+    print(f"sources: {model.sources}")
+    print(f"samplerate: {model.samplerate}")
+    print(f"segment_samples: {int(model.segment * model.samplerate)}")
+
+    wrapper = HTDemucs6SSplitExport(model).eval()
+    spectral = torch.randn(1, 4, NUM_BINS, NUM_FRAMES)
+    waveform = torch.randn(1, 2, SEGMENT_SAMPLES)
+
+    with torch.no_grad():
+        freq_out, time_out = wrapper(spectral, waveform)
+    print(f"freq_output: {tuple(freq_out.shape)}")
+    print(f"time_output: {tuple(time_out.shape)}")
+
+    traced = torch.jit.trace(
+        wrapper,
+        (spectral, waveform),
+        strict=False,
+        check_trace=False,
+    )
+
+    mlmodel = ct.convert(
+        traced,
+        inputs=[
+            ct.TensorType(name="spectral_magnitude", shape=spectral.shape),
+            ct.TensorType(name="audio_waveform", shape=waveform.shape),
+        ],
+        outputs=[
+            ct.TensorType(name="freq_output"),
+            ct.TensorType(name="time_output"),
+        ],
+        minimum_deployment_target=ct.target.iOS16,
+        convert_to="mlprogram",
+        compute_precision=ct.precision.FLOAT32,
+    )
+
+    mlmodel.author = "Meta Research (Demucs)"
+    mlmodel.license = "MIT License"
+    mlmodel.short_description = (
+        "HTDemucs 6-stem split CoreML export. STFT/iSTFT are computed by the app; "
+        "the model runs the HTDemucs neural network body."
+    )
+    mlmodel.input_description["spectral_magnitude"] = (
+        "Stereo complex STFT [1,4,2048,336]: L.real, L.imag, R.real, R.imag."
+    )
+    mlmodel.input_description["audio_waveform"] = (
+        "Stereo waveform [1,2,343980] at 44100 Hz."
+    )
+    mlmodel.output_description["freq_output"] = (
+        "Frequency branch [1,24,2048,336]. Source order: drums, bass, other, vocals, guitar, piano."
+    )
+    mlmodel.output_description["time_output"] = (
+        "Time branch [1,12,343980]. Source order: drums, bass, other, vocals, guitar, piano."
+    )
+
+    mlmodel.save(str(output))
+    print(f"Saved {output}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--output",
+        type=Path,
+        default=Path("HTDemucs_6S_Split_F32.mlpackage"),
+        help="Output .mlpackage path.",
+    )
+    args = parser.parse_args()
+    convert(args.output)
+
+
+if __name__ == "__main__":
+    main()