Mel-Band RoFormer Duality (Aname) — ONNX / fp16 / WebGPU
Musetric no longer runs this core: since
musetric/musetric#1141 its
separation model is distilled from it, today
musetric/mel-band-roformer-duality-kara2-student-onnx.
This repository stays for the builds that pin it.
ONNX export of Aname-Tommy/Mel-Band-Roformer_Duality,
a Mel-Band RoFormer vocals / instrumental separation model, packaged for the
musetric packages/ai runtime
(onnxruntime-web on WebGPU). Apache-2.0, as the upstream weights.
The graph is the neural network core: it takes a precomputed STFT
representation and returns per-bin complex masks. The mel-band gather/average
tables are baked into the ONNX graph, so the host does not need sidecar
/tables/* assets. STFT, iSTFT, chunking and complex packing run host-side
(browser WGSL + FFT). This is not a drop-in PyTorch checkpoint.
Intended uses & limitations
Intended:
- Vocals / instrumental separation as the first stage of an audio pipeline.
- Client/edge inference via WebGPU through
onnxruntime-web, on desktop and on mobile GPUs alike.
Out of scope:
- Standalone use without a host that computes the STFT input, applies the
per-bin
masks, and runs iSTFT (seemusetricpackages/ai). - Use in other training frameworks — this is an inference-only export.
Limitations:
- One static time window, T = 1100 (~11 s), rounded down to a multiple of four. The upstream model was fine-tuned on 15 s chunks; see the window note below.
- Training-data provenance of the upstream weights is undocumented.
How to use
The session runs the core; the host supplies stft_repr and consumes masks.
import * as ort from 'onnxruntime-web/webgpu';
// .onnx and .onnx.data must sit in the same directory; .data loads automatically.
const session = await ort.InferenceSession.create('duality_core_t1100.onnx', {
executionProviders: [{ name: 'webgpu', storageBufferCacheMode: 'simple' }],
});
// stftRepr: Float32Array of shape [1, 2050, 1100, 2], produced host-side from one
// ~11 s audio chunk (n_fft=2048, hop=441, 44.1 kHz, stereo).
const input = new ort.Tensor('float32', stftRepr, [1, 2050, 1100, 2]);
const { masks } = await session.run({ stft_repr: input });
// masks: float32 [1, 2050, 1100, 2] -> apply to STFT, then iSTFT host-side.
See the musetric packages/ai host code for the full STFT/iSTFT and
chunk-recombination pipeline.
Files
One graph. Keep the .onnx next to its .onnx.data.
| File | Size | SHA256 |
|---|---|---|
duality_core_t1100.onnx |
7,306,315 B | 1ae7a97c87d854cc27259a5be5115adfe8e44d046390819a6b2fe259465f5a77 |
duality_core_t1100.onnx.data |
456,274,828 B | ba2a1daacde1608a57564c7bb24a3efe2f50388b2168143044019a6cbe3f21c6 |
Signature — opset ai.onnx 23, IR 10, no com.microsoft import. fp16
weights, fp32 graph I/O, T = 1100:
| Tensor | Type | Shape | Meaning |
|---|---|---|---|
stft_repr (in) |
float32 | [1, 2050, T, 2] |
batch, freq*2, time, complex |
masks (out) |
float32 | [1, 2050, T, 2] |
per-bin complex masks, already gathered/averaged from mel bands |
How these graphs are written
The timings in this section and the next were measured on the vocals core that
musetric used before this one (musetric/vocal-separation-roformer-onnx),
a model with the same transformer and a larger mask head; the shapes are the
same.
Attention is split along the query axis into 128-row blocks. Written in one
shot, each layer's score tensor is [60, 8, T, T] fp16 — 1110 MiB at this
window — and a mobile storage-buffer binding stops working past 256 MiB whatever
limit the adapter declares, silently returning zeros. Softmax normalizes each
query row over the full key axis on its own, so splitting the queries is
exact: same values, same work, no context given up. Inside a stream slab (below)
the peak score tensor becomes [15, 8, 128, T], which the time attentions hold
in fp32 (below): 64.5 MiB, the size of the fp16 [15, 8, 256, T] of bcb0c0b4
and of the whole [60, 8, 64, T] of b7565386.
The transformer's RMSNorms are the fused ai.onnx::RMSNormalization, in
fp16, with epsilon = 1e-9. Its WebGPU kernel accumulates the sum of squares
in f32 inside the shader, which is what makes fp16 safe here; an fp32 island
instead costs 387 MiB of activations at this window. The epsilon is not the
1e-12 an fp32 RMSNorm would carry: the kernel normalizes by the reciprocal
1/sqrt(mean(x^2) + epsilon) and casts it to the tensor dtype, so on an fp16
node any row whose mean(x^2) + epsilon falls below 1/65504^2 = 2.33e-10 gets
+inf, then 0 * inf = NaN, and one NaN row takes the whole output out through
the next attention softmax. Rows that small are ordinary — padded STFT edges,
silent frames, dead band-split features.
The band split runs in fp32. The fp16 conversion used to cast stft_repr
to fp16 before the band gather. Adreno GPUs read every fp16 subnormal, below
6.1e-5, as zero, and round that cast toward zero, while 12-18 % of the values of
a music STFT lie in that range. Each band-split RMSNormalization then scales
its band row to unit rms, so the zeroed bins of a quiet band became errors as
large as its features: the masks of the Adreno 660 and 750 stayed 20-25 dB from
onnxruntime's CPU provider against 38-42 dB on the desktop, and further the
quieter the input (musetric#971).
Since b7565386 the graph keeps the band gather, its reshapes and the 60 band
norms in fp32 and casts each norm's unit-scale output to fp16 for the band
Linear. Those norms carry epsilon = 1e-12, as an fp32 RMSNorm does; the fp16
epsilon damped every band row whose rms is below sqrt(1e-9) = 3.2e-5 against the
model's F.normalize, which alone kept the masks of the CPU provider 26-36 dB
from torch, against 55-62 dB since. The weights file did not change.
Masks of four 1100-frame units of Rxbyn, "Bad Side" (https://www.jamendo.com/track/1556580/bad-side, CC BY 3.0, from JamendoLyrics): 60-80 s, the same at half level, 20-26 s, and the first unit of the whole track. WebGPU with the musetric provider and session options, against the CPU provider of the same graph / against torch:
| Core | Desktop NVIDIA | Adreno 750 and 660 |
|---|---|---|
6e8039b7, band split in fp16 |
37.6-41.6 dB / 25.7-33.5 dB | 20.0-25.5 dB / 19.8-26.3 dB |
b7565386, band split in fp32 |
37.6-42.0 dB / 37.5-42.1 dB | 34.9-39.8 dB / 34.8-39.7 dB |
The Adreno 750 and the Adreno 660 return the same bits, and the time per unit does not change.
The time attentions take their softmax and probabilities x values in fp32. A time attention normalizes its scores over the 1100 frames of the window, so most of its probabilities lie far below 1/1100, and in fp16 every one below 6.1e-5 is subnormal. The Adreno 660 and 750 read those as zero and drop every product below 2^-14 inside the matmul with the values, so each time attention lost the tail of its probabilities, the same way in every layer, and the masks stayed 1.8-3.3 dB further from onnxruntime's CPU provider than on the desktop (musetric#988). Since this revision the scores of every time attention are cast to fp32, the softmax and the matmul with the values run in fp32, and the result is cast back to fp16; the attention's scale, 2^-3, moves onto the queries, which is exact. The band attentions normalize over 60 bands and stay in fp16. The same four units, WebGPU against the CPU provider of the same graph:
| Core | Desktop NVIDIA | Adreno 750 and 660 | Apple M3 (iPad Air) |
|---|---|---|---|
bcb0c0b4, time attention in fp16 |
37.6-42.0 dB | 34.9-39.8 dB | 37.3-41.9 dB |
| this revision, in fp32 | 43.2-45.1 dB | 43.5-44.6 dB | 42.7-45.3 dB |
Every device moves closer to the CPU provider, and the phones stay within 0.7 dB of the desktop on every unit. The weights file did not change.
Feed-forward blocks run on row chunks, and the fused qkv projection is
three projections. Written whole, one feed-forward is a single
[66000, 384] x [384, 1536] matmul, and a mobile GPU runs it as one
uninterruptible dispatch: 546 ms on an Adreno 660. Twenty-four of those plus
twenty-four more at 361 ms are 43 % of a window inside 48 of its 1938
dispatches, and nothing at the runtime level reaches inside one dispatch — a
flush threshold only decides how many ride in a submit. That is the floor a
compositor freeze sits on. Chunking the block over eight row groups is exact in
fp16 because rows of a matmul are independent; splitting the reduction axis
instead reorders the sums and costs roughly 66 dB a layer. The wide
[rows, 1536] intermediate is never materialized at full height either, so peak
GPU memory falls rather than rises. Unfusing qkv is the same move on the
second-longest matmul, and free, because the rearrange that follows split it
apart anyway. The q, k, v and output projections that remain then ran on four
row groups each, for the same reason. Since this revision the stream slabs below
already cut every matmul of a layer to a quarter of its rows, so a feed-forward
runs on two row groups of a slab and a projection on the whole slab: 8250 and
16 500 rows, as before.
Every transformer runs over four slabs of the stream. The time transformer
of each layer takes the bands in four slabs and the band transformer the frames,
each slab cut straight from the [1, T, 60, 384] stream, run through
attention, feed-forward and the output norm as [1, 16500, 384], and put back
by one Concat. The point is onnxruntime's allocation planner: it hands a
freed buffer only to a later tensor of the same static shape and keeps it for
that shape until the run ends, so every distinct large shape holds a pool of its
own for the whole run. Written whole, the two transformers of a layer see
[60, T, 384] and [T, 60, 384], the same size in different shapes, plus the
transposed and packed copies between them, and their pools sit idle in turn. A
band slab and a frame slab both hold 16 500 rows, so the norms, projections,
feed-forwards and residual adds of both transformers now share their buffers;
only the [b, h, n, d] view inside attention differs, and it is a quarter of its
former size. With the slabs alone a run held 1767 MiB of GPU buffers instead
of 3747 MiB. Nothing in a layer reduces over its batch axis, so the slabs change
no arithmetic: on WebGPU, on a desktop NVIDIA GPU and on the Adreno 750 and 660,
bcb0c0b4, which added them, returned the masks of b7565386 bit for bit.
The stream stays 3-D because a Linear on a 2-D input exports as Gemm,
whose fused bias would change the bits.
The rotary tables are constants. The rotary embedding exports its angle
cache, position times frequency, as a table that the graph slices and passes to
Cos and Sin. Converted to fp16, those angles reach about 1100 rad at the end
of the window, where the fp16 step is 0.5 rad, so every rotation far into the
window comes out wrong: 40.4-53.1 dB against torch on the validation songs
below, against 63.7-71.0 dB once folded. The cosines and sines lie in [-1, 1],
where fp16 keeps them to 5e-4, so the export computes them in fp32 and stores
the result instead of the angles.
Wide Concat/Split are re-treed to <=8-wide so every shader stays at <=9
storage buffers, under the strictest shipping cap (Dawn/Metal on macOS reports
maxStorageBuffersPerShaderStage = 10).
No normalization or softmax sees more than 65 535 rows. The onnxruntime
WebGPU kernels for RMSNormalization and Softmax run one workgroup per row
and reduce that row in workgroup-shared memory, so they carry no bounds check.
Past maxComputeWorkgroupsPerDimension (65 535, the WebGPU default) the
dispatch becomes a ceil(sqrt(rows))^2 square, and its spare workgroups write
past the end of the output. Written whole at this window, the transformer norms
see [60, 1100, 384] and [1100, 60, 384], 66 000 rows each, and the
band-attention softmax sees [1100, 8, 60, 60], 528 000 rows; in the stream
slabs a norm sees at most 16 500 rows and a band-attention softmax 132 000.
Where the backend clamps the
stray index instead of dropping the write, as Chrome does on Metal, an exact-size
output buffer (storageBufferCacheMode: 'simple', as in the snippet above) gets
its last row overwritten: RMSNormalization returns +inf there, and attention
turns every mask into NaN. The graph splits each such tensor along its batch axis
first, three chunks for each band-attention softmax of a slab, and concatenates
the results. Rows never interact in either kernel, so the split is exact.
GELU, the rotary embedding, the projection to heads and the query scale run
as one kernel each. onnxruntime-web runs every node as one dispatch over its
whole tensor, and the export spelled GELU as Div, Erf, Add, Mul and
Mul over the feed-forward's hidden layer, the interleaved rotary embedding as
Mul, two Slices, Neg, Concat, Mul and Add over every query and
key, each projection to heads as a MatMul and a Transpose that puts the
heads ahead of the sequence, and the query scale of the time attentions as a
Slice and a Mul per block of query rows. Since this revision they are one
Gelu, one RotaryEmbedding, one MatMul batched over the heads and one
Mul ahead of a Split, all standard ai.onnx operators. The projection
reshapes the stored weight and the rotary kernel takes every other column of the
stored tables, and onnxruntime folds both at load, so the weights file did not
change. A run goes from 4939 dispatches to 3475. On WebGPU the masks are the
same bits as those of 4aacb7a7 on a desktop NVIDIA GPU and on the Adreno 750
and 660; on the M3 they differ by rounding, and the four units above stay
42.6-45.2 dB from the CPU provider, as before. onnxruntime's CPU and CUDA
providers round the new kernels differently from the chains: 66 dB from
4aacb7a7 on the CPU provider, and slightly closer to the torch model on the
CUDA provider (Validation, below).
Apart from the rotary tables, which fix precision, these rewrites are compatibility, footprint and latency measures, and all of them are exact on the desktop and the Adreno GPUs; the single kernels round differently only on the M3 and on onnxruntime's CPU and CUDA providers. None changes a weight value; the qkv split only stores one projection matrix as the three slices the graph took from it anyway.
Why the window is 1100 and not 1101
On an Adreno 750, onnxruntime-web computes an fp16 MatMul with visibly less
precision whenever the reduction length K or the output width N is not a
multiple of four. Measured on that adapter against the CPU execution provider,
M = 4096, both operands dynamic:
| K | N | desktop | Adreno 750 |
|---|---|---|---|
| 1101 | 64 | 46.6 dB | 20.1 dB |
| 1100 | 64 | 46.4 dB | 46.3 dB |
| 1104 | 64 | 46.4 dB | 46.3 dB |
| 1102 | 64 | 46.5 dB | 20.9 dB |
| 384 | 1101 | 50.8 dB | 35.4 dB |
| 384 | 1100 | 50.8 dB | 50.7 dB |
A multiple of two is not enough. Both attention matmuls carry the window in
exactly that position — q @ kᵀ has N = T and attn @ v has K = T — so a
window of 1101 put every attention in every layer on the bad path, while the
projections (K = 384, N = 512 or 1536) stayed exact. End to end that left
the Adreno 750 well behind every other backend and cost nothing anywhere else.
Rounding the window down to 1100 brings that adapter level with the desktop; the price is one frame of context, 11.00 s instead of 11.01 s. Any future window should stay a multiple of four.
Validation
Against the upstream PyTorch model in fp32 on CUDA at the same window, the core on the CUDA execution provider, both masks applied to the window's STFT and inverted to vocals. Each song is scored on its loudest 1100-frame window: a quiet window measures rounding noise, not separation. The songs are every CC BY and CC BY-SA track of JamendoLyrics, so the check can be repeated.
| Song | Genre | License | Window | SNR (vocals) |
|---|---|---|---|---|
| Lower Loveday – Is It Right? | Indie | CC BY-SA | 156.7 s | 64.2 dB |
| Rxbyn – Bad Side | RNB | CC BY | 29.5 s | 64.5 dB |
| Cortez – Feel (Stripped) | Pop | CC BY | 195.8 s | 67.3 dB |
| I'M FRESH! YOU'RE PRETTY! – CHRISTMAS AVEC TOI | Pop | CC BY | 180.4 s | 68.3 dB |
| NANDOMALO – Esencia | Folk | CC BY-SA | 63.3 s | 71.1 dB |
| LOS ROMBOS – Fantasma | Folk | CC BY-SA | 67.1 s | 66.4 dB |
| Durch Dick und Dünn – Freifliegen | Rock | CC BY-SA | 140.8 s | 62.7 dB |
| Jonny M – Keine Lust | Reggae | CC BY-SA | 189.4 s | 65.8 dB |
| FLO – l'abandon | Country | CC BY | 163.7 s | 68.0 dB |
| KPTN – Le musée d'air contemporain | Jazz | CC BY | 80.0 s | 69.3 dB |
| LAW' – Les files d'attente | Pop | CC BY-SA | 38.6 s | 68.8 dB |
| LAW' – Mère nature | Rock | CC BY-SA | 140.2 s | 68.2 dB |
| WILSON WAY – Te Recuerdo | Hip-Hop | CC BY-SA | 83.1 s | 66.0 dB |
Worst / median / best: 62.7 / 67.3 / 71.1 dB, no NaN. The window column is where
the scored window starts in the song. The previous revision, 4aacb7a7,
measures 61.2 / 66.7 / 71.0 dB the same way, bcb0c0b4 61.5 / 67.0 / 71.0 dB,
b7565386 61.4 / 66.9 / 71.0 dB, and 6e8039b7 54.8 / 62.0 / 68.2 dB.
Re-run the parity gate on the exact published bytes before relying on it.
Speed and memory
This revision against 4aacb7a7, on 2026-10-04.
Memory, as musetric#946 measures it: peak GPU memory of a run 2.59 → 2.25 GiB on the desktop, 2.44 → 2.17 GiB on the Galaxy S24 Ultra and 2.47 → 2.25 GiB on the OnePlus 9RT; the Safari tab on the iPad Air 4.74 → 4.43 GiB over five chunks.
Time. The GPU time of a chunk, summed from timestamps written around every dispatch of one run: 1798 → 1611 ms on the desktop, 13.4 → 12.7 s on the Adreno 750, 39.6 → 37.2 s on the Adreno 660 and 14.0 → 12.7 s on the M3. As musetric runs the core, paced one submission at a time with the input in a GPU buffer and graph capture, three loads per device in A-B-B-A-A-B order, 60 s apart, each a first chunk and five more (one more on the 9RT, four on the iPad):
| runtime | chunk p50, before → now | best chunk, before → now | first chunk, before → now |
|---|---|---|---|
| RTX 3060 Laptop, Chrome | 2190 → 1900 ms | 2164 → 1887 ms | 5138 → 4670 ms |
| Galaxy S24 Ultra, Adreno 750, Chrome | 29 933 → 16 494 ms | 25 601 → 14 783 ms | 48 812 → 35 732 ms |
| OnePlus 9RT, Adreno 660, Chrome | 70 522 → 38 374 ms | 41 277 → 38 368 ms | 83 957 → 77 735 ms |
| iPad Air (M3), Safari 26.4 | 14 994 → 14 175 ms | 11 262 → 12 991 ms | 22 118 → 19 462 ms |
Under the pacer the Adreno 750's clock governor holds 629 MHz for half of a
chunk of this revision and 422-500 MHz for two thirds of one of 4aacb7a7,
which is most of its drop. The Adreno 660 runs a chunk either near 40 s or near
70 s as the heat moves it between states, so its medians carry the heat; its
best chunks and its hottest pair, 76.1 → 70.9 s at 44.5 and 44.9 °C, both fall
7 %. The iPad's chunks spread from 11 to 19 s with heat for either revision.
4aacb7a7 against bcb0c0b4, on 2026-10-03.
Memory, measured as below: the GPU buffers onnxruntime holds at the peak on the desktop 1767 → 1913 MiB; the whole GPU during a run 2282 → 2484 MiB on the Galaxy S24 Ultra and 2282 → 2434 MiB on the OnePlus 9RT; a 23-chunk track on the iPad Air peaks at 4927 MiB, against 4898 MiB.
Time. As musetric runs the core: paced one submission at a time, the input in a GPU buffer, both revisions with graph capture. Three loads per device in A-B-B-A-A-B order, 60 s apart, each a first chunk and five more (two more on the 9RT).
| runtime | chunk p50, before → now | first chunk, before → now |
|---|---|---|
| RTX 3060 Laptop, Chrome | 1979 → 2184 ms | 4600 → 5105 ms |
| Galaxy S24 Ultra, Adreno 750, Chrome | 27 751 → 29 881 ms | 39 689 → 49 552 ms |
| OnePlus 9RT, Adreno 660, Chrome | 73 804 → 76 055 ms | 99 442 → 96 746 ms |
The phones ran at 37-45 °C, past the point where both lose up to half their
speed; at the same 40 °C the Adreno 750 takes 27.8 s a chunk with bcb0c0b4 and
30.0 s with this revision. On the iPad, three loads of this revision run a chunk
in 16.6 s at the median.
bcb0c0b4 against b7565386, on 2026-10-02 and 2026-10-03.
Memory. One deterministic [1, 2050, 1100, 2] input, onnxruntime-web 1.30
on WebGPU with storageBufferCacheMode: 'simple' as the host sets it. On the
desktop the GPU buffers onnxruntime creates are counted at the peak of a run; on
the phones the whole-GPU total the driver reports through dumpsys gpu; on the
iPad the footprint of the Safari tab's process, which the system kills at
5120 MiB, in musetric's run with graph capture.
| runtime | peak memory, before → now |
|---|---|
| RTX 3060 Laptop, Chrome | 3747 MiB → 1767 MiB |
| Galaxy S24 Ultra, Adreno 750, Chrome | 4260 MiB → 2281 MiB |
| OnePlus 9RT, Adreno 660, Chrome | 4270 MiB → 2290 MiB |
| iPad Air (M3), Safari 26.4 | killed in the first run → a 23-chunk track, 4898 MiB at most |
The weights account for 436 MiB of each count. On the iPad the tab holds 2.4 GiB through most of the track; the peak comes in its first one or two minutes, when WebKit keeps about 2 GiB more and then gives it back on its own.
Time. As musetric runs each core: paced one submission at a time, the input
in a GPU buffer, b7565386 without graph capture and this revision with it.
Three loads per device in A-B-B-A-A-B order, 60 s apart, each a first chunk and
five more (two more on the 9RT); on the iPad three loads of this revision.
| runtime | chunk p50, before → now | best chunk, before → now | first chunk, before → now |
|---|---|---|---|
| RTX 3060 Laptop, Chrome | 3685 → 3512 ms | 3647 → 3451 ms | 4276 → 7820 ms |
| Galaxy S24 Ultra, Adreno 750, Chrome | 18 726 → 21 351 ms | 14 658 → 15 036 ms | 18 233 → 31 169 ms |
| OnePlus 9RT, Adreno 660, Chrome | 54 254 → 58 563 ms | 40 997 → 39 527 ms | 42 406 → 80 928 ms |
| iPad Air (M3), Safari 26.4 | killed → 15 676 ms | killed → 9250 ms | killed → 27 227 ms |
Both phones slow down as they heat, and the medians carry it: the first loads
of this revision started 2-4 °C warmer than those of b7565386. The best chunks
are the comparable numbers. With graph capture the first chunk records the core
and then replays it, so it takes about twice a later one. The desktop GPU held
780 MHz under the pacer on those days, so both cores ran slower there than on
other days. Building the session takes 0.2-0.3 s longer, since the graph is
larger.
The older measurement below compares the first revision of this core with the
core musetric used before it.
Against the vocals core musetric used before, musetric/vocal-separation-roformer-onnx
at 4720922, on 2026-09-25. One deterministic [1, 2050, 1100, 2] input
through the session setup of the host, paced one submission at a time: one
first run and five more per load, three loads of each core per phone in
A-B-B-A-A-B order, each load started once the battery was back at 34.0 °C
(S24) or 35.5 °C (9RT). Peak GPU memory is the whole-GPU total the driver
reports through dumpsys gpu; RAM is the PSS of the Chrome package.
| runtime | run p50, before → now | peak GPU memory | RAM |
|---|---|---|---|
| Galaxy S24 Ultra, Adreno 750, Chrome | 15.7 s → 15.1 s | 4.40 GB → 4.10 GB | 5.8 GB → 5.2 GB |
| OnePlus 9RT, Adreno 660, Chrome | 43.2 s → 40.9 s | 4.37 GB → 4.12 GB | 1.74 GB → 1.35 GB |
Single runs on the S24 spread from 13.5 s to 22 s with either core, so the difference there is inside the noise; on the 9RT they spread by less than 1 %.
Source & lineage
Code license and weight license are separate; ONNX conversion does not change the weight license. Documented only as far as it is verifiable.
- Architecture: Mel-Band RoFormer (arXiv:2310.01809).
- Reference implementation:
lucidrains/BS-RoFormer, MIT. - Training framework / config: ZFTurbo
Music-Source-Separation-Training. - Direct weight source:
Aname-Tommy/Mel-Band-Roformer_Duality@07a189ffdceb69db0ddacc5175569bef59850016,duality_v1.ckptwithconfig_v1.yaml, Apache-2.0. - Lineage, checked by comparing the weights tensor by tensor: the upstream model
is a fine-tune of
SYH99999/MelBandRoformerMergedSYHFTBeta1(MIT), which builds onKimberleyJSN/melbandroformer(MIT). - Export tooling:
scripts/onnx/roformerin musetric-toolkit:build_full_onnx.pywith--core-only --fuse-rmsnorm --attn-block 128 --all-fp16 --frames 1100 --split-rows 2 --stream-slabs 4, followed bysplit_concat_webgpu.py; it passesfp16_epsilon_audit.pyanddispatch_rows_audit.py, andreuse_external_data.pypoints the rebuilt graph at the weights file of the previous revision. The recipe isconverting.mdthere.
License & citation
Apache-2.0, inherited from the upstream weights. We do not claim authorship of the original weights; the conversion to ONNX is ours.
@article{wang2023melbandroformer,
title={Mel-Band RoFormer for Music Source Separation},
author={Wang, Ju-Chiang and Lu, Wei-Tsung and Won, Minz},
journal={arXiv preprint arXiv:2310.01809},
year={2023}
}