Add files using upload-large-folder tool

Bandit-v2/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Bandit-v2/config_dnr_bandit_v2_mus64.yaml

@@ -0,0 +1,77 @@
+cls: Bandit
+
+audio:
+  chunk_size: 384000
+  num_channels: 2
+  sample_rate: 48000
+  min_mean_abs: 0.000
+
+kwargs:
+  in_channels: 1
+  stems: ['speech', 'music', 'sfx']
+  band_type: musical
+  n_bands: 64
+  normalize_channel_independently: false
+  treat_channel_as_feature: true
+  n_sqm_modules: 8
+  emb_dim: 128
+  rnn_dim: 256
+  bidirectional: true
+  rnn_type: "GRU"
+  mlp_dim: 512
+  hidden_activation: "Tanh"
+  hidden_activation_kwargs: null
+  complex_mask: true
+  use_freq_weights: true
+  n_fft: 2048
+  win_length: 2048
+  hop_length: 512
+  window_fn: "hann_window"
+  wkwargs: null
+  power: null
+  center: true
+  normalized: true
+  pad_mode: "reflect"
+  onesided: true
+
+training:
+  batch_size: 4
+  gradient_accumulation_steps: 4
+  grad_clip: 0
+  instruments:
+  - speech
+  - music
+  - sfx
+  lr: 9.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: true # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.1 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+
+inference:
+  batch_size: 8
+  dim_t: 256
+  num_overlap: 4

MVSEP-MDX23-music-separation-model/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

MVSEP-MDX23-music-separation-model/README.md

@@ -0,0 +1,99 @@
+# MVSEP-MDX23-music-separation-model
+Model for [Sound demixing challenge 2023: Music Demixing Track - MDX'23](https://www.aicrowd.com/challenges/sound-demixing-challenge-2023). Model perform separation of music into 4 stems "bass", "drums", "vocals", "other". Model won 3rd place in challenge (Leaderboard C).
+
+Model based on [Demucs4](https://github.com/facebookresearch/demucs), [MDX](https://github.com/kuielab/mdx-net) neural net architectures and some MDX weights from [Ultimate Vocal Remover](https://github.com/Anjok07/ultimatevocalremovergui) project (thanks [Kimberley Jensen](https://github.com/KimberleyJensen) for great high quality vocal models). Thanks [@Ma5onic](https://github.com/Ma5onic) for web UI & helping with dataset augmentation techniques. Brought to you by [MVSep.com](https://mvsep.com).
+## Usage
+
+```
+    python inference.py --input_audio mixture1.wav mixture2.wav --output_folder ./results/
+```
+
+With this command audios with names "mixture1.wav" and "mixture2.wav" will be processed and results will be stored in `./results/` folder in WAV format.
+
+### All available keys
+* `--input_audio` - input audio location. You can provide multiple files at once. **Required**
+* `--output_folder` - output audio folder. **Required**
+* `--cpu` - choose CPU instead of GPU for processing. Can be very slow.
+* `--overlap_large` - overlap of splitted audio for light models. Closer to 1.0 - slower, but better quality. Default: 0.6.
+* `--overlap_small` - overlap of splitted audio for heavy models. Closer to 1.0 - slower, but better quality. Default: 0.5.
+* `--single_onnx` - only use single ONNX model for vocals. Can be useful if you have not enough GPU memory.
+* `--chunk_size` - chunk size for ONNX models. Set lower to reduce GPU memory consumption. Default: 1000000.
+* `--large_gpu` - it will store all models on GPU for faster processing of multiple audio files. Requires at least 11 GB of free GPU memory.
+* `--use_kim_model_1` - use first version of Kim model (as it was on contest).
+* `--only_vocals` - only create vocals and instrumental. Skip bass, drums, other. Processing will be faster.
+
+### Notes
+* If you have not enough GPU memory you can use CPU (`--cpu`), but it will be slow. Additionally you can use single ONNX (`--single_onnx`), but it will decrease quality a little bit. Also reduce of chunk size can help (`--chunk_size 200000`).
+* In current revision code requires less GPU memory, but it process multiple files slower. If you want old fast method use argument `--large_gpu`. It will require > 11 GB of GPU memory, but will work faster.
+* There is [Google.Collab version](https://colab.research.google.com/github/jarredou/MVSEP-MDX23-Colab_v2/blob/main/MVSep-MDX23-Colab.ipynb) of this code.  
+
+## Quality comparison
+
+Quality comparison with best separation models performed on [MultiSong Dataset](https://mvsep.com/quality_checker/leaderboard2.php?sort=bass). 
+
+| Algorithm     | SDR bass  | SDR drums  | SDR other  | SDR vocals  | SDR instrumental  |
+| ------------- |:---------:|:----------:|:----------:|:----------:|:------------------:|
+| MVSEP MDX23   | 12.5034   | 11.6870    | 6.5378     |  9.5138    | 15.8213            |
+| Demucs HT 4   | 12.1006   | 11.3037    | 5.7728     |  8.3555    | 13.9902            |
+| Demucs 3      | 10.6947   | 10.2744    | 5.3580     |  8.1335    | 14.4409            |
+| MDX B         | ---       | ----       | ---        |  8.5118    | 14.8192            |
+
+* Note: SDR - signal to distortion ratio. Larger is better.
+
+## GUI
+
+![GUI Window](https://github.com/ZFTurbo/MVSEP-MDX23-music-separation-model/blob/main/images/MVSep-Window.png)
+
+* Script for GUI (based on PyQt5): [gui.py](gui.py).
+* You can download [standalone program for Windows here](https://github.com/ZFTurbo/MVSEP-MDX23-music-separation-model/releases/download/v1.0.1/MVSep-MDX23_v1.0.1.zip) (~730 MB). Unzip archive and to start program double click `run.bat`. On first run it will download pytorch with CUDA support (~2.8 GB) and some Neural Net models.
+* Program will download all needed neural net models from internet at the first run.
+* GUI supports Drag & Drop of multiple files.
+* Progress bar available.
+
+## Web Interface
+executing `web-ui.py` with python will start the web interface locally on `localhost` (127.0.0.1).
+You'll see what port it is running on within the terminal output.
+
+![image](https://github.com/Ma5onic/MVSEP-MDX23-music-separation-model/assets/18509613/ae7130a5-60a4-4095-abbd-5290e84dcf7c)
+
+* Browser-Based user interface
+* Program will download all needed neural net models from internet at the first run.
+* supports Drag & Drop for audio upload (single file)
+
+![Web-UI Window](https://github.com/ZFTurbo/MVSEP-MDX23-music-separation-model/assets/18509613/4872f6aa-5896-44e9-8885-eaee1de3f4ee)
+
+
+## Changes
+
+### v1.0.1
+* Settings in GUI updated, now you can control all possible options
+* Kim vocal model updated from version 1 to version 2, you still can use version 1 using parameter `--use_kim_model_1`
+* Added possibility to generate only vocals/instrumental pair if you don't need bass, drums and other stems. Use parameter `--only_vocals`
+* Standalone program was updated. It has less size now. GUI will download torch/cuda on the first run. 
+
+## Citation
+
+* [arxiv paper](https://arxiv.org/abs/2305.07489)
+
+```
+@misc{solovyev2023benchmarks,
+      title={Benchmarks and leaderboards for sound demixing tasks}, 
+      author={Roman Solovyev and Alexander Stempkovskiy and Tatiana Habruseva},
+      year={2023},
+      eprint={2305.07489},
+      archivePrefix={arXiv},
+      primaryClass={cs.SD}
+}
+
+@article{fabbro2024sound,
+    title={The Sound Demixing Challenge 2023-Music Demixing Track.},
+    author={Fabbro, G., Uhlich, S., Lai, C.-H., Choi, W., Martínez-Ramírez, M., Liao, W., Gadelha, I., Ramos, G., Hsu, E., Rodrigues, H., Stöter, F.-R.,
+    Défossez, A., Luo, Y., Yu, J., Chakraborty, D., Mohanty, S., Solovyev, R., Stempkovskiy, A., Habruseva, T., Goswami, N., Harada, T., Kim, M.,
+    Lee, J. H., Dong, Y., Zhang, X., Liu, J., & Mitsufuji, Y},
+    journal={Trans. Int. Soc. Music. Inf. Retr.},
+    volume={7},
+    number={1},
+    pages={63--84},
+    year={2024}
+}
+```

MVSEP-MDX23-music-separation-model/demucs3/demucs.py

@@ -0,0 +1,447 @@
+# Copyright (c) Meta, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import math
+import typing as tp
+
+import julius
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from .states import capture_init
+from .utils import center_trim, unfold
+from .transformer import LayerScale
+
+
+class BLSTM(nn.Module):
+    """
+    BiLSTM with same hidden units as input dim.
+    If `max_steps` is not None, input will be splitting in overlapping
+    chunks and the LSTM applied separately on each chunk.
+    """
+    def __init__(self, dim, layers=1, max_steps=None, skip=False):
+        super().__init__()
+        assert max_steps is None or max_steps % 4 == 0
+        self.max_steps = max_steps
+        self.lstm = nn.LSTM(bidirectional=True, num_layers=layers, hidden_size=dim, input_size=dim)
+        self.linear = nn.Linear(2 * dim, dim)
+        self.skip = skip
+
+    def forward(self, x):
+        B, C, T = x.shape
+        y = x
+        framed = False
+        if self.max_steps is not None and T > self.max_steps:
+            width = self.max_steps
+            stride = width // 2
+            frames = unfold(x, width, stride)
+            nframes = frames.shape[2]
+            framed = True
+            x = frames.permute(0, 2, 1, 3).reshape(-1, C, width)
+
+        x = x.permute(2, 0, 1)
+
+        x = self.lstm(x)[0]
+        x = self.linear(x)
+        x = x.permute(1, 2, 0)
+        if framed:
+            out = []
+            frames = x.reshape(B, -1, C, width)
+            limit = stride // 2
+            for k in range(nframes):
+                if k == 0:
+                    out.append(frames[:, k, :, :-limit])
+                elif k == nframes - 1:
+                    out.append(frames[:, k, :, limit:])
+                else:
+                    out.append(frames[:, k, :, limit:-limit])
+            out = torch.cat(out, -1)
+            out = out[..., :T]
+            x = out
+        if self.skip:
+            x = x + y
+        return x
+
+
+def rescale_conv(conv, reference):
+    """Rescale initial weight scale. It is unclear why it helps but it certainly does.
+    """
+    std = conv.weight.std().detach()
+    scale = (std / reference)**0.5
+    conv.weight.data /= scale
+    if conv.bias is not None:
+        conv.bias.data /= scale
+
+
+def rescale_module(module, reference):
+    for sub in module.modules():
+        if isinstance(sub, (nn.Conv1d, nn.ConvTranspose1d, nn.Conv2d, nn.ConvTranspose2d)):
+            rescale_conv(sub, reference)
+
+
+class DConv(nn.Module):
+    """
+    New residual branches in each encoder layer.
+    This alternates dilated convolutions, potentially with LSTMs and attention.
+    Also before entering each residual branch, dimension is projected on a smaller subspace,
+    e.g. of dim `channels // compress`.
+    """
+    def __init__(self, channels: int, compress: float = 4, depth: int = 2, init: float = 1e-4,
+                 norm=True, attn=False, heads=4, ndecay=4, lstm=False, gelu=True,
+                 kernel=3, dilate=True):
+        """
+        Args:
+            channels: input/output channels for residual branch.
+            compress: amount of channel compression inside the branch.
+            depth: number of layers in the residual branch. Each layer has its own
+                projection, and potentially LSTM and attention.
+            init: initial scale for LayerNorm.
+            norm: use GroupNorm.
+            attn: use LocalAttention.
+            heads: number of heads for the LocalAttention.
+            ndecay: number of decay controls in the LocalAttention.
+            lstm: use LSTM.
+            gelu: Use GELU activation.
+            kernel: kernel size for the (dilated) convolutions.
+            dilate: if true, use dilation, increasing with the depth.
+        """
+
+        super().__init__()
+        assert kernel % 2 == 1
+        self.channels = channels
+        self.compress = compress
+        self.depth = abs(depth)
+        dilate = depth > 0
+
+        norm_fn: tp.Callable[[int], nn.Module]
+        norm_fn = lambda d: nn.Identity()  # noqa
+        if norm:
+            norm_fn = lambda d: nn.GroupNorm(1, d)  # noqa
+
+        hidden = int(channels / compress)
+
+        act: tp.Type[nn.Module]
+        if gelu:
+            act = nn.GELU
+        else:
+            act = nn.ReLU
+
+        self.layers = nn.ModuleList([])
+        for d in range(self.depth):
+            dilation = 2 ** d if dilate else 1
+            padding = dilation * (kernel // 2)
+            mods = [
+                nn.Conv1d(channels, hidden, kernel, dilation=dilation, padding=padding),
+                norm_fn(hidden), act(),
+                nn.Conv1d(hidden, 2 * channels, 1),
+                norm_fn(2 * channels), nn.GLU(1),
+                LayerScale(channels, init),
+            ]
+            if attn:
+                mods.insert(3, LocalState(hidden, heads=heads, ndecay=ndecay))
+            if lstm:
+                mods.insert(3, BLSTM(hidden, layers=2, max_steps=200, skip=True))
+            layer = nn.Sequential(*mods)
+            self.layers.append(layer)
+
+    def forward(self, x):
+        for layer in self.layers:
+            x = x + layer(x)
+        return x
+
+
+class LocalState(nn.Module):
+    """Local state allows to have attention based only on data (no positional embedding),
+    but while setting a constraint on the time window (e.g. decaying penalty term).
+
+    Also a failed experiments with trying to provide some frequency based attention.
+    """
+    def __init__(self, channels: int, heads: int = 4, nfreqs: int = 0, ndecay: int = 4):
+        super().__init__()
+        assert channels % heads == 0, (channels, heads)
+        self.heads = heads
+        self.nfreqs = nfreqs
+        self.ndecay = ndecay
+        self.content = nn.Conv1d(channels, channels, 1)
+        self.query = nn.Conv1d(channels, channels, 1)
+        self.key = nn.Conv1d(channels, channels, 1)
+        if nfreqs:
+            self.query_freqs = nn.Conv1d(channels, heads * nfreqs, 1)
+        if ndecay:
+            self.query_decay = nn.Conv1d(channels, heads * ndecay, 1)
+            # Initialize decay close to zero (there is a sigmoid), for maximum initial window.
+            self.query_decay.weight.data *= 0.01
+            assert self.query_decay.bias is not None  # stupid type checker
+            self.query_decay.bias.data[:] = -2
+        self.proj = nn.Conv1d(channels + heads * nfreqs, channels, 1)
+
+    def forward(self, x):
+        B, C, T = x.shape
+        heads = self.heads
+        indexes = torch.arange(T, device=x.device, dtype=x.dtype)
+        # left index are keys, right index are queries
+        delta = indexes[:, None] - indexes[None, :]
+
+        queries = self.query(x).view(B, heads, -1, T)
+        keys = self.key(x).view(B, heads, -1, T)
+        # t are keys, s are queries
+        dots = torch.einsum("bhct,bhcs->bhts", keys, queries)
+        dots /= keys.shape[2]**0.5
+        if self.nfreqs:
+            periods = torch.arange(1, self.nfreqs + 1, device=x.device, dtype=x.dtype)
+            freq_kernel = torch.cos(2 * math.pi * delta / periods.view(-1, 1, 1))
+            freq_q = self.query_freqs(x).view(B, heads, -1, T) / self.nfreqs ** 0.5
+            dots += torch.einsum("fts,bhfs->bhts", freq_kernel, freq_q)
+        if self.ndecay:
+            decays = torch.arange(1, self.ndecay + 1, device=x.device, dtype=x.dtype)
+            decay_q = self.query_decay(x).view(B, heads, -1, T)
+            decay_q = torch.sigmoid(decay_q) / 2
+            decay_kernel = - decays.view(-1, 1, 1) * delta.abs() / self.ndecay**0.5
+            dots += torch.einsum("fts,bhfs->bhts", decay_kernel, decay_q)
+
+        # Kill self reference.
+        dots.masked_fill_(torch.eye(T, device=dots.device, dtype=torch.bool), -100)
+        weights = torch.softmax(dots, dim=2)
+
+        content = self.content(x).view(B, heads, -1, T)
+        result = torch.einsum("bhts,bhct->bhcs", weights, content)
+        if self.nfreqs:
+            time_sig = torch.einsum("bhts,fts->bhfs", weights, freq_kernel)
+            result = torch.cat([result, time_sig], 2)
+        result = result.reshape(B, -1, T)
+        return x + self.proj(result)
+
+
+class Demucs(nn.Module):
+    @capture_init
+    def __init__(self,
+                 sources,
+                 # Channels
+                 audio_channels=2,
+                 channels=64,
+                 growth=2.,
+                 # Main structure
+                 depth=6,
+                 rewrite=True,
+                 lstm_layers=0,
+                 # Convolutions
+                 kernel_size=8,
+                 stride=4,
+                 context=1,
+                 # Activations
+                 gelu=True,
+                 glu=True,
+                 # Normalization
+                 norm_starts=4,
+                 norm_groups=4,
+                 # DConv residual branch
+                 dconv_mode=1,
+                 dconv_depth=2,
+                 dconv_comp=4,
+                 dconv_attn=4,
+                 dconv_lstm=4,
+                 dconv_init=1e-4,
+                 # Pre/post processing
+                 normalize=True,
+                 resample=True,
+                 # Weight init
+                 rescale=0.1,
+                 # Metadata
+                 samplerate=44100,
+                 segment=4 * 10):
+        """
+        Args:
+            sources (list[str]): list of source names
+            audio_channels (int): stereo or mono
+            channels (int): first convolution channels
+            depth (int): number of encoder/decoder layers
+            growth (float): multiply (resp divide) number of channels by that
+                for each layer of the encoder (resp decoder)
+            depth (int): number of layers in the encoder and in the decoder.
+            rewrite (bool): add 1x1 convolution to each layer.
+            lstm_layers (int): number of lstm layers, 0 = no lstm. Deactivated
+                by default, as this is now replaced by the smaller and faster small LSTMs
+                in the DConv branches.
+            kernel_size (int): kernel size for convolutions
+            stride (int): stride for convolutions
+            context (int): kernel size of the convolution in the
+                decoder before the transposed convolution. If > 1,
+                will provide some context from neighboring time steps.
+            gelu: use GELU activation function.
+            glu (bool): use glu instead of ReLU for the 1x1 rewrite conv.
+            norm_starts: layer at which group norm starts being used.
+                decoder layers are numbered in reverse order.
+            norm_groups: number of groups for group norm.
+            dconv_mode: if 1: dconv in encoder only, 2: decoder only, 3: both.
+            dconv_depth: depth of residual DConv branch.
+            dconv_comp: compression of DConv branch.
+            dconv_attn: adds attention layers in DConv branch starting at this layer.
+            dconv_lstm: adds a LSTM layer in DConv branch starting at this layer.
+            dconv_init: initial scale for the DConv branch LayerScale.
+            normalize (bool): normalizes the input audio on the fly, and scales back
+                the output by the same amount.
+            resample (bool): upsample x2 the input and downsample /2 the output.
+            rescale (int): rescale initial weights of convolutions
+                to get their standard deviation closer to `rescale`.
+            samplerate (int): stored as meta information for easing
+                future evaluations of the model.
+            segment (float): duration of the chunks of audio to ideally evaluate the model on.
+                This is used by `demucs.apply.apply_model`.
+        """
+
+        super().__init__()
+        self.audio_channels = audio_channels
+        self.sources = sources
+        self.kernel_size = kernel_size
+        self.context = context
+        self.stride = stride
+        self.depth = depth
+        self.resample = resample
+        self.channels = channels
+        self.normalize = normalize
+        self.samplerate = samplerate
+        self.segment = segment
+        self.encoder = nn.ModuleList()
+        self.decoder = nn.ModuleList()
+        self.skip_scales = nn.ModuleList()
+
+        if glu:
+            activation = nn.GLU(dim=1)
+            ch_scale = 2
+        else:
+            activation = nn.ReLU()
+            ch_scale = 1
+        if gelu:
+            act2 = nn.GELU
+        else:
+            act2 = nn.ReLU
+
+        in_channels = audio_channels
+        padding = 0
+        for index in range(depth):
+            norm_fn = lambda d: nn.Identity()  # noqa
+            if index >= norm_starts:
+                norm_fn = lambda d: nn.GroupNorm(norm_groups, d)  # noqa
+
+            encode = []
+            encode += [
+                nn.Conv1d(in_channels, channels, kernel_size, stride),
+                norm_fn(channels),
+                act2(),
+            ]
+            attn = index >= dconv_attn
+            lstm = index >= dconv_lstm
+            if dconv_mode & 1:
+                encode += [DConv(channels, depth=dconv_depth, init=dconv_init,
+                                 compress=dconv_comp, attn=attn, lstm=lstm)]
+            if rewrite:
+                encode += [
+                    nn.Conv1d(channels, ch_scale * channels, 1),
+                    norm_fn(ch_scale * channels), activation]
+            self.encoder.append(nn.Sequential(*encode))
+
+            decode = []
+            if index > 0:
+                out_channels = in_channels
+            else:
+                out_channels = len(self.sources) * audio_channels
+            if rewrite:
+                decode += [
+                    nn.Conv1d(channels, ch_scale * channels, 2 * context + 1, padding=context),
+                    norm_fn(ch_scale * channels), activation]
+            if dconv_mode & 2:
+                decode += [DConv(channels, depth=dconv_depth, init=dconv_init,
+                                 compress=dconv_comp, attn=attn, lstm=lstm)]
+            decode += [nn.ConvTranspose1d(channels, out_channels,
+                       kernel_size, stride, padding=padding)]
+            if index > 0:
+                decode += [norm_fn(out_channels), act2()]
+            self.decoder.insert(0, nn.Sequential(*decode))
+            in_channels = channels
+            channels = int(growth * channels)
+
+        channels = in_channels
+        if lstm_layers:
+            self.lstm = BLSTM(channels, lstm_layers)
+        else:
+            self.lstm = None
+
+        if rescale:
+            rescale_module(self, reference=rescale)
+
+    def valid_length(self, length):
+        """
+        Return the nearest valid length to use with the model so that
+        there is no time steps left over in a convolution, e.g. for all
+        layers, size of the input - kernel_size % stride = 0.
+
+        Note that input are automatically padded if necessary to ensure that the output
+        has the same length as the input.
+        """
+        if self.resample:
+            length *= 2
+
+        for _ in range(self.depth):
+            length = math.ceil((length - self.kernel_size) / self.stride) + 1
+            length = max(1, length)
+
+        for idx in range(self.depth):
+            length = (length - 1) * self.stride + self.kernel_size
+
+        if self.resample:
+            length = math.ceil(length / 2)
+        return int(length)
+
+    def forward(self, mix):
+        x = mix
+        length = x.shape[-1]
+
+        if self.normalize:
+            mono = mix.mean(dim=1, keepdim=True)
+            mean = mono.mean(dim=-1, keepdim=True)
+            std = mono.std(dim=-1, keepdim=True)
+            x = (x - mean) / (1e-5 + std)
+        else:
+            mean = 0
+            std = 1
+
+        delta = self.valid_length(length) - length
+        x = F.pad(x, (delta // 2, delta - delta // 2))
+
+        if self.resample:
+            x = julius.resample_frac(x, 1, 2)
+
+        saved = []
+        for encode in self.encoder:
+            x = encode(x)
+            saved.append(x)
+
+        if self.lstm:
+            x = self.lstm(x)
+
+        for decode in self.decoder:
+            skip = saved.pop(-1)
+            skip = center_trim(skip, x)
+            x = decode(x + skip)
+
+        if self.resample:
+            x = julius.resample_frac(x, 2, 1)
+        x = x * std + mean
+        x = center_trim(x, length)
+        x = x.view(x.size(0), len(self.sources), self.audio_channels, x.size(-1))
+        return x
+
+    def load_state_dict(self, state, strict=True):
+        # fix a mismatch with previous generation Demucs models.
+        for idx in range(self.depth):
+            for a in ['encoder', 'decoder']:
+                for b in ['bias', 'weight']:
+                    new = f'{a}.{idx}.3.{b}'
+                    old = f'{a}.{idx}.2.{b}'
+                    if old in state and new not in state:
+                        state[new] = state.pop(old)
+        super().load_state_dict(state, strict=strict)

MVSEP-MDX23-music-separation-model/demucs3/hdemucs.py

@@ -0,0 +1,782 @@
+# Copyright (c) Meta, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+"""
+This code contains the spectrogram and Hybrid version of Demucs.
+"""
+from copy import deepcopy
+import math
+import typing as tp
+
+from openunmix.filtering import wiener
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from .demucs import DConv, rescale_module
+from .states import capture_init
+from .spec import spectro, ispectro
+
+
+def pad1d(x: torch.Tensor, paddings: tp.Tuple[int, int], mode: str = 'constant', value: float = 0.):
+    """Tiny wrapper around F.pad, just to allow for reflect padding on small input.
+    If this is the case, we insert extra 0 padding to the right before the reflection happen."""
+    x0 = x
+    length = x.shape[-1]
+    padding_left, padding_right = paddings
+    if mode == 'reflect':
+        max_pad = max(padding_left, padding_right)
+        if length <= max_pad:
+            extra_pad = max_pad - length + 1
+            extra_pad_right = min(padding_right, extra_pad)
+            extra_pad_left = extra_pad - extra_pad_right
+            paddings = (padding_left - extra_pad_left, padding_right - extra_pad_right)
+            x = F.pad(x, (extra_pad_left, extra_pad_right))
+    out = F.pad(x, paddings, mode, value)
+    assert out.shape[-1] == length + padding_left + padding_right
+    assert (out[..., padding_left: padding_left + length] == x0).all()
+    return out
+
+
+class ScaledEmbedding(nn.Module):
+    """
+    Boost learning rate for embeddings (with `scale`).
+    Also, can make embeddings continuous with `smooth`.
+    """
+    def __init__(self, num_embeddings: int, embedding_dim: int,
+                 scale: float = 10., smooth=False):
+        super().__init__()
+        self.embedding = nn.Embedding(num_embeddings, embedding_dim)
+        if smooth:
+            weight = torch.cumsum(self.embedding.weight.data, dim=0)
+            # when summing gaussian, overscale raises as sqrt(n), so we nornalize by that.
+            weight = weight / torch.arange(1, num_embeddings + 1).to(weight).sqrt()[:, None]
+            self.embedding.weight.data[:] = weight
+        self.embedding.weight.data /= scale
+        self.scale = scale
+
+    @property
+    def weight(self):
+        return self.embedding.weight * self.scale
+
+    def forward(self, x):
+        out = self.embedding(x) * self.scale
+        return out
+
+
+class HEncLayer(nn.Module):
+    def __init__(self, chin, chout, kernel_size=8, stride=4, norm_groups=1, empty=False,
+                 freq=True, dconv=True, norm=True, context=0, dconv_kw={}, pad=True,
+                 rewrite=True):
+        """Encoder layer. This used both by the time and the frequency branch.
+
+        Args:
+            chin: number of input channels.
+            chout: number of output channels.
+            norm_groups: number of groups for group norm.
+            empty: used to make a layer with just the first conv. this is used
+                before merging the time and freq. branches.
+            freq: this is acting on frequencies.
+            dconv: insert DConv residual branches.
+            norm: use GroupNorm.
+            context: context size for the 1x1 conv.
+            dconv_kw: list of kwargs for the DConv class.
+            pad: pad the input. Padding is done so that the output size is
+                always the input size / stride.
+            rewrite: add 1x1 conv at the end of the layer.
+        """
+        super().__init__()
+        norm_fn = lambda d: nn.Identity()  # noqa
+        if norm:
+            norm_fn = lambda d: nn.GroupNorm(norm_groups, d)  # noqa
+        if pad:
+            pad = kernel_size // 4
+        else:
+            pad = 0
+        klass = nn.Conv1d
+        self.freq = freq
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.empty = empty
+        self.norm = norm
+        self.pad = pad
+        if freq:
+            kernel_size = [kernel_size, 1]
+            stride = [stride, 1]
+            pad = [pad, 0]
+            klass = nn.Conv2d
+        self.conv = klass(chin, chout, kernel_size, stride, pad)
+        if self.empty:
+            return
+        self.norm1 = norm_fn(chout)
+        self.rewrite = None
+        if rewrite:
+            self.rewrite = klass(chout, 2 * chout, 1 + 2 * context, 1, context)
+            self.norm2 = norm_fn(2 * chout)
+
+        self.dconv = None
+        if dconv:
+            self.dconv = DConv(chout, **dconv_kw)
+
+    def forward(self, x, inject=None):
+        """
+        `inject` is used to inject the result from the time branch into the frequency branch,
+        when both have the same stride.
+        """
+        if not self.freq and x.dim() == 4:
+            B, C, Fr, T = x.shape
+            x = x.view(B, -1, T)
+
+        if not self.freq:
+            le = x.shape[-1]
+            if not le % self.stride == 0:
+                x = F.pad(x, (0, self.stride - (le % self.stride)))
+        y = self.conv(x)
+        if self.empty:
+            return y
+        if inject is not None:
+            assert inject.shape[-1] == y.shape[-1], (inject.shape, y.shape)
+            if inject.dim() == 3 and y.dim() == 4:
+                inject = inject[:, :, None]
+            y = y + inject
+        y = F.gelu(self.norm1(y))
+        if self.dconv:
+            if self.freq:
+                B, C, Fr, T = y.shape
+                y = y.permute(0, 2, 1, 3).reshape(-1, C, T)
+            y = self.dconv(y)
+            if self.freq:
+                y = y.view(B, Fr, C, T).permute(0, 2, 1, 3)
+        if self.rewrite:
+            z = self.norm2(self.rewrite(y))
+            z = F.glu(z, dim=1)
+        else:
+            z = y
+        return z
+
+
+class MultiWrap(nn.Module):
+    """
+    Takes one layer and replicate it N times. each replica will act
+    on a frequency band. All is done so that if the N replica have the same weights,
+    then this is exactly equivalent to applying the original module on all frequencies.
+
+    This is a bit over-engineered to avoid edge artifacts when splitting
+    the frequency bands, but it is possible the naive implementation would work as well...
+    """
+    def __init__(self, layer, split_ratios):
+        """
+        Args:
+            layer: module to clone, must be either HEncLayer or HDecLayer.
+            split_ratios: list of float indicating which ratio to keep for each band.
+        """
+        super().__init__()
+        self.split_ratios = split_ratios
+        self.layers = nn.ModuleList()
+        self.conv = isinstance(layer, HEncLayer)
+        assert not layer.norm
+        assert layer.freq
+        assert layer.pad
+        if not self.conv:
+            assert not layer.context_freq
+        for k in range(len(split_ratios) + 1):
+            lay = deepcopy(layer)
+            if self.conv:
+                lay.conv.padding = (0, 0)
+            else:
+                lay.pad = False
+            for m in lay.modules():
+                if hasattr(m, 'reset_parameters'):
+                    m.reset_parameters()
+            self.layers.append(lay)
+
+    def forward(self, x, skip=None, length=None):
+        B, C, Fr, T = x.shape
+
+        ratios = list(self.split_ratios) + [1]
+        start = 0
+        outs = []
+        for ratio, layer in zip(ratios, self.layers):
+            if self.conv:
+                pad = layer.kernel_size // 4
+                if ratio == 1:
+                    limit = Fr
+                    frames = -1
+                else:
+                    limit = int(round(Fr * ratio))
+                    le = limit - start
+                    if start == 0:
+                        le += pad
+                    frames = round((le - layer.kernel_size) / layer.stride + 1)
+                    limit = start + (frames - 1) * layer.stride + layer.kernel_size
+                    if start == 0:
+                        limit -= pad
+                assert limit - start > 0, (limit, start)
+                assert limit <= Fr, (limit, Fr)
+                y = x[:, :, start:limit, :]
+                if start == 0:
+                    y = F.pad(y, (0, 0, pad, 0))
+                if ratio == 1:
+                    y = F.pad(y, (0, 0, 0, pad))
+                outs.append(layer(y))
+                start = limit - layer.kernel_size + layer.stride
+            else:
+                if ratio == 1:
+                    limit = Fr
+                else:
+                    limit = int(round(Fr * ratio))
+                last = layer.last
+                layer.last = True
+
+                y = x[:, :, start:limit]
+                s = skip[:, :, start:limit]
+                out, _ = layer(y, s, None)
+                if outs:
+                    outs[-1][:, :, -layer.stride:] += (
+                        out[:, :, :layer.stride] - layer.conv_tr.bias.view(1, -1, 1, 1))
+                    out = out[:, :, layer.stride:]
+                if ratio == 1:
+                    out = out[:, :, :-layer.stride // 2, :]
+                if start == 0:
+                    out = out[:, :, layer.stride // 2:, :]
+                outs.append(out)
+                layer.last = last
+                start = limit
+        out = torch.cat(outs, dim=2)
+        if not self.conv and not last:
+            out = F.gelu(out)
+        if self.conv:
+            return out
+        else:
+            return out, None
+
+
+class HDecLayer(nn.Module):
+    def __init__(self, chin, chout, last=False, kernel_size=8, stride=4, norm_groups=1, empty=False,
+                 freq=True, dconv=True, norm=True, context=1, dconv_kw={}, pad=True,
+                 context_freq=True, rewrite=True):
+        """
+        Same as HEncLayer but for decoder. See `HEncLayer` for documentation.
+        """
+        super().__init__()
+        norm_fn = lambda d: nn.Identity()  # noqa
+        if norm:
+            norm_fn = lambda d: nn.GroupNorm(norm_groups, d)  # noqa
+        if pad:
+            pad = kernel_size // 4
+        else:
+            pad = 0
+        self.pad = pad
+        self.last = last
+        self.freq = freq
+        self.chin = chin
+        self.empty = empty
+        self.stride = stride
+        self.kernel_size = kernel_size
+        self.norm = norm
+        self.context_freq = context_freq
+        klass = nn.Conv1d
+        klass_tr = nn.ConvTranspose1d
+        if freq:
+            kernel_size = [kernel_size, 1]
+            stride = [stride, 1]
+            klass = nn.Conv2d
+            klass_tr = nn.ConvTranspose2d
+        self.conv_tr = klass_tr(chin, chout, kernel_size, stride)
+        self.norm2 = norm_fn(chout)
+        if self.empty:
+            return
+        self.rewrite = None
+        if rewrite:
+            if context_freq:
+                self.rewrite = klass(chin, 2 * chin, 1 + 2 * context, 1, context)
+            else:
+                self.rewrite = klass(chin, 2 * chin, [1, 1 + 2 * context], 1,
+                                     [0, context])
+            self.norm1 = norm_fn(2 * chin)
+
+        self.dconv = None
+        if dconv:
+            self.dconv = DConv(chin, **dconv_kw)
+
+    def forward(self, x, skip, length):
+        if self.freq and x.dim() == 3:
+            B, C, T = x.shape
+            x = x.view(B, self.chin, -1, T)
+
+        if not self.empty:
+            x = x + skip
+
+            if self.rewrite:
+                y = F.glu(self.norm1(self.rewrite(x)), dim=1)
+            else:
+                y = x
+            if self.dconv:
+                if self.freq:
+                    B, C, Fr, T = y.shape
+                    y = y.permute(0, 2, 1, 3).reshape(-1, C, T)
+                y = self.dconv(y)
+                if self.freq:
+                    y = y.view(B, Fr, C, T).permute(0, 2, 1, 3)
+        else:
+            y = x
+            assert skip is None
+        z = self.norm2(self.conv_tr(y))
+        if self.freq:
+            if self.pad:
+                z = z[..., self.pad:-self.pad, :]
+        else:
+            z = z[..., self.pad:self.pad + length]
+            assert z.shape[-1] == length, (z.shape[-1], length)
+        if not self.last:
+            z = F.gelu(z)
+        return z, y
+
+
+class HDemucs(nn.Module):
+    """
+    Spectrogram and hybrid Demucs model.
+    The spectrogram model has the same structure as Demucs, except the first few layers are over the
+    frequency axis, until there is only 1 frequency, and then it moves to time convolutions.
+    Frequency layers can still access information across time steps thanks to the DConv residual.
+
+    Hybrid model have a parallel time branch. At some layer, the time branch has the same stride
+    as the frequency branch and then the two are combined. The opposite happens in the decoder.
+
+    Models can either use naive iSTFT from masking, Wiener filtering ([Ulhih et al. 2017]),
+    or complex as channels (CaC) [Choi et al. 2020]. Wiener filtering is based on
+    Open Unmix implementation [Stoter et al. 2019].
+
+    The loss is always on the temporal domain, by backpropagating through the above
+    output methods and iSTFT. This allows to define hybrid models nicely. However, this breaks
+    a bit Wiener filtering, as doing more iteration at test time will change the spectrogram
+    contribution, without changing the one from the waveform, which will lead to worse performance.
+    I tried using the residual option in OpenUnmix Wiener implementation, but it didn't improve.
+    CaC on the other hand provides similar performance for hybrid, and works naturally with
+    hybrid models.
+
+    This model also uses frequency embeddings are used to improve efficiency on convolutions
+    over the freq. axis, following [Isik et al. 2020] (https://arxiv.org/pdf/2008.04470.pdf).
+
+    Unlike classic Demucs, there is no resampling here, and normalization is always applied.
+    """
+    @capture_init
+    def __init__(self,
+                 sources,
+                 # Channels
+                 audio_channels=2,
+                 channels=48,
+                 channels_time=None,
+                 growth=2,
+                 # STFT
+                 nfft=4096,
+                 wiener_iters=0,
+                 end_iters=0,
+                 wiener_residual=False,
+                 cac=True,
+                 # Main structure
+                 depth=6,
+                 rewrite=True,
+                 hybrid=True,
+                 hybrid_old=False,
+                 # Frequency branch
+                 multi_freqs=None,
+                 multi_freqs_depth=2,
+                 freq_emb=0.2,
+                 emb_scale=10,
+                 emb_smooth=True,
+                 # Convolutions
+                 kernel_size=8,
+                 time_stride=2,
+                 stride=4,
+                 context=1,
+                 context_enc=0,
+                 # Normalization
+                 norm_starts=4,
+                 norm_groups=4,
+                 # DConv residual branch
+                 dconv_mode=1,
+                 dconv_depth=2,
+                 dconv_comp=4,
+                 dconv_attn=4,
+                 dconv_lstm=4,
+                 dconv_init=1e-4,
+                 # Weight init
+                 rescale=0.1,
+                 # Metadata
+                 samplerate=44100,
+                 segment=4 * 10):
+        """
+        Args:
+            sources (list[str]): list of source names.
+            audio_channels (int): input/output audio channels.
+            channels (int): initial number of hidden channels.
+            channels_time: if not None, use a different `channels` value for the time branch.
+            growth: increase the number of hidden channels by this factor at each layer.
+            nfft: number of fft bins. Note that changing this require careful computation of
+                various shape parameters and will not work out of the box for hybrid models.
+            wiener_iters: when using Wiener filtering, number of iterations at test time.
+            end_iters: same but at train time. For a hybrid model, must be equal to `wiener_iters`.
+            wiener_residual: add residual source before wiener filtering.
+            cac: uses complex as channels, i.e. complex numbers are 2 channels each
+                in input and output. no further processing is done before ISTFT.
+            depth (int): number of layers in the encoder and in the decoder.
+            rewrite (bool): add 1x1 convolution to each layer.
+            hybrid (bool): make a hybrid time/frequency domain, otherwise frequency only.
+            hybrid_old: some models trained for MDX had a padding bug. This replicates
+                this bug to avoid retraining them.
+            multi_freqs: list of frequency ratios for splitting frequency bands with `MultiWrap`.
+            multi_freqs_depth: how many layers to wrap with `MultiWrap`. Only the outermost
+                layers will be wrapped.
+            freq_emb: add frequency embedding after the first frequency layer if > 0,
+                the actual value controls the weight of the embedding.
+            emb_scale: equivalent to scaling the embedding learning rate
+            emb_smooth: initialize the embedding with a smooth one (with respect to frequencies).
+            kernel_size: kernel_size for encoder and decoder layers.
+            stride: stride for encoder and decoder layers.
+            time_stride: stride for the final time layer, after the merge.
+            context: context for 1x1 conv in the decoder.
+            context_enc: context for 1x1 conv in the encoder.
+            norm_starts: layer at which group norm starts being used.
+                decoder layers are numbered in reverse order.
+            norm_groups: number of groups for group norm.
+            dconv_mode: if 1: dconv in encoder only, 2: decoder only, 3: both.
+            dconv_depth: depth of residual DConv branch.
+            dconv_comp: compression of DConv branch.
+            dconv_attn: adds attention layers in DConv branch starting at this layer.
+            dconv_lstm: adds a LSTM layer in DConv branch starting at this layer.
+            dconv_init: initial scale for the DConv branch LayerScale.
+            rescale: weight recaling trick
+
+        """
+        super().__init__()
+        self.cac = cac
+        self.wiener_residual = wiener_residual
+        self.audio_channels = audio_channels
+        self.sources = sources
+        self.kernel_size = kernel_size
+        self.context = context
+        self.stride = stride
+        self.depth = depth
+        self.channels = channels
+        self.samplerate = samplerate
+        self.segment = segment
+
+        self.nfft = nfft
+        self.hop_length = nfft // 4
+        self.wiener_iters = wiener_iters
+        self.end_iters = end_iters
+        self.freq_emb = None
+        self.hybrid = hybrid
+        self.hybrid_old = hybrid_old
+        if hybrid_old:
+            assert hybrid, "hybrid_old must come with hybrid=True"
+        if hybrid:
+            assert wiener_iters == end_iters
+
+        self.encoder = nn.ModuleList()
+        self.decoder = nn.ModuleList()
+
+        if hybrid:
+            self.tencoder = nn.ModuleList()
+            self.tdecoder = nn.ModuleList()
+
+        chin = audio_channels
+        chin_z = chin  # number of channels for the freq branch
+        if self.cac:
+            chin_z *= 2
+        chout = channels_time or channels
+        chout_z = channels
+        freqs = nfft // 2
+
+        for index in range(depth):
+            lstm = index >= dconv_lstm
+            attn = index >= dconv_attn
+            norm = index >= norm_starts
+            freq = freqs > 1
+            stri = stride
+            ker = kernel_size
+            if not freq:
+                assert freqs == 1
+                ker = time_stride * 2
+                stri = time_stride
+
+            pad = True
+            last_freq = False
+            if freq and freqs <= kernel_size:
+                ker = freqs
+                pad = False
+                last_freq = True
+
+            kw = {
+                'kernel_size': ker,
+                'stride': stri,
+                'freq': freq,
+                'pad': pad,
+                'norm': norm,
+                'rewrite': rewrite,
+                'norm_groups': norm_groups,
+                'dconv_kw': {
+                    'lstm': lstm,
+                    'attn': attn,
+                    'depth': dconv_depth,
+                    'compress': dconv_comp,
+                    'init': dconv_init,
+                    'gelu': True,
+                }
+            }
+            kwt = dict(kw)
+            kwt['freq'] = 0
+            kwt['kernel_size'] = kernel_size
+            kwt['stride'] = stride
+            kwt['pad'] = True
+            kw_dec = dict(kw)
+            multi = False
+            if multi_freqs and index < multi_freqs_depth:
+                multi = True
+                kw_dec['context_freq'] = False
+
+            if last_freq:
+                chout_z = max(chout, chout_z)
+                chout = chout_z
+
+            enc = HEncLayer(chin_z, chout_z,
+                            dconv=dconv_mode & 1, context=context_enc, **kw)
+            if hybrid and freq:
+                tenc = HEncLayer(chin, chout, dconv=dconv_mode & 1, context=context_enc,
+                                 empty=last_freq, **kwt)
+                self.tencoder.append(tenc)
+
+            if multi:
+                enc = MultiWrap(enc, multi_freqs)
+            self.encoder.append(enc)
+            if index == 0:
+                chin = self.audio_channels * len(self.sources)
+                chin_z = chin
+                if self.cac:
+                    chin_z *= 2
+            dec = HDecLayer(chout_z, chin_z, dconv=dconv_mode & 2,
+                            last=index == 0, context=context, **kw_dec)
+            if multi:
+                dec = MultiWrap(dec, multi_freqs)
+            if hybrid and freq:
+                tdec = HDecLayer(chout, chin, dconv=dconv_mode & 2, empty=last_freq,
+                                 last=index == 0, context=context, **kwt)
+                self.tdecoder.insert(0, tdec)
+            self.decoder.insert(0, dec)
+
+            chin = chout
+            chin_z = chout_z
+            chout = int(growth * chout)
+            chout_z = int(growth * chout_z)
+            if freq:
+                if freqs <= kernel_size:
+                    freqs = 1
+                else:
+                    freqs //= stride
+            if index == 0 and freq_emb:
+                self.freq_emb = ScaledEmbedding(
+                    freqs, chin_z, smooth=emb_smooth, scale=emb_scale)
+                self.freq_emb_scale = freq_emb
+
+        if rescale:
+            rescale_module(self, reference=rescale)
+
+    def _spec(self, x):
+        hl = self.hop_length
+        nfft = self.nfft
+        x0 = x  # noqa
+
+        if self.hybrid:
+            # We re-pad the signal in order to keep the property
+            # that the size of the output is exactly the size of the input
+            # divided by the stride (here hop_length), when divisible.
+            # This is achieved by padding by 1/4th of the kernel size (here nfft).
+            # which is not supported by torch.stft.
+            # Having all convolution operations follow this convention allow to easily
+            # align the time and frequency branches later on.
+            assert hl == nfft // 4
+            le = int(math.ceil(x.shape[-1] / hl))
+            pad = hl // 2 * 3
+            if not self.hybrid_old:
+                x = pad1d(x, (pad, pad + le * hl - x.shape[-1]), mode='reflect')
+            else:
+                x = pad1d(x, (pad, pad + le * hl - x.shape[-1]))
+
+        z = spectro(x, nfft, hl)[..., :-1, :]
+        if self.hybrid:
+            assert z.shape[-1] == le + 4, (z.shape, x.shape, le)
+            z = z[..., 2:2+le]
+        return z
+
+    def _ispec(self, z, length=None, scale=0):
+        hl = self.hop_length // (4 ** scale)
+        z = F.pad(z, (0, 0, 0, 1))
+        if self.hybrid:
+            z = F.pad(z, (2, 2))
+            pad = hl // 2 * 3
+            if not self.hybrid_old:
+                le = hl * int(math.ceil(length / hl)) + 2 * pad
+            else:
+                le = hl * int(math.ceil(length / hl))
+            x = ispectro(z, hl, length=le)
+            if not self.hybrid_old:
+                x = x[..., pad:pad + length]
+            else:
+                x = x[..., :length]
+        else:
+            x = ispectro(z, hl, length)
+        return x
+
+    def _magnitude(self, z):
+        # return the magnitude of the spectrogram, except when cac is True,
+        # in which case we just move the complex dimension to the channel one.
+        if self.cac:
+            B, C, Fr, T = z.shape
+            m = torch.view_as_real(z).permute(0, 1, 4, 2, 3)
+            m = m.reshape(B, C * 2, Fr, T)
+        else:
+            m = z.abs()
+        return m
+
+    def _mask(self, z, m):
+        # Apply masking given the mixture spectrogram `z` and the estimated mask `m`.
+        # If `cac` is True, `m` is actually a full spectrogram and `z` is ignored.
+        niters = self.wiener_iters
+        if self.cac:
+            B, S, C, Fr, T = m.shape
+            out = m.view(B, S, -1, 2, Fr, T).permute(0, 1, 2, 4, 5, 3)
+            out = torch.view_as_complex(out.contiguous())
+            return out
+        if self.training:
+            niters = self.end_iters
+        if niters < 0:
+            z = z[:, None]
+            return z / (1e-8 + z.abs()) * m
+        else:
+            return self._wiener(m, z, niters)
+
+    def _wiener(self, mag_out, mix_stft, niters):
+        # apply wiener filtering from OpenUnmix.
+        init = mix_stft.dtype
+        wiener_win_len = 300
+        residual = self.wiener_residual
+
+        B, S, C, Fq, T = mag_out.shape
+        mag_out = mag_out.permute(0, 4, 3, 2, 1)
+        mix_stft = torch.view_as_real(mix_stft.permute(0, 3, 2, 1))
+
+        outs = []
+        for sample in range(B):
+            pos = 0
+            out = []
+            for pos in range(0, T, wiener_win_len):
+                frame = slice(pos, pos + wiener_win_len)
+                z_out = wiener(
+                    mag_out[sample, frame], mix_stft[sample, frame], niters,
+                    residual=residual)
+                out.append(z_out.transpose(-1, -2))
+            outs.append(torch.cat(out, dim=0))
+        out = torch.view_as_complex(torch.stack(outs, 0))
+        out = out.permute(0, 4, 3, 2, 1).contiguous()
+        if residual:
+            out = out[:, :-1]
+        assert list(out.shape) == [B, S, C, Fq, T]
+        return out.to(init)
+
+    def forward(self, mix):
+        x = mix
+        length = x.shape[-1]
+
+        z = self._spec(mix)
+        mag = self._magnitude(z)
+        x = mag
+
+        B, C, Fq, T = x.shape
+
+        # unlike previous Demucs, we always normalize because it is easier.
+        mean = x.mean(dim=(1, 2, 3), keepdim=True)
+        std = x.std(dim=(1, 2, 3), keepdim=True)
+        x = (x - mean) / (1e-5 + std)
+        # x will be the freq. branch input.
+
+        if self.hybrid:
+            # Prepare the time branch input.
+            xt = mix
+            meant = xt.mean(dim=(1, 2), keepdim=True)
+            stdt = xt.std(dim=(1, 2), keepdim=True)
+            xt = (xt - meant) / (1e-5 + stdt)
+
+        # okay, this is a giant mess I know...
+        saved = []  # skip connections, freq.
+        saved_t = []  # skip connections, time.
+        lengths = []  # saved lengths to properly remove padding, freq branch.
+        lengths_t = []  # saved lengths for time branch.
+        for idx, encode in enumerate(self.encoder):
+            lengths.append(x.shape[-1])
+            inject = None
+            if self.hybrid and idx < len(self.tencoder):
+                # we have not yet merged branches.
+                lengths_t.append(xt.shape[-1])
+                tenc = self.tencoder[idx]
+                xt = tenc(xt)
+                if not tenc.empty:
+                    # save for skip connection
+                    saved_t.append(xt)
+                else:
+                    # tenc contains just the first conv., so that now time and freq.
+                    # branches have the same shape and can be merged.
+                    inject = xt
+            x = encode(x, inject)
+            if idx == 0 and self.freq_emb is not None:
+                # add frequency embedding to allow for non equivariant convolutions
+                # over the frequency axis.
+                frs = torch.arange(x.shape[-2], device=x.device)
+                emb = self.freq_emb(frs).t()[None, :, :, None].expand_as(x)
+                x = x + self.freq_emb_scale * emb
+
+            saved.append(x)
+
+        x = torch.zeros_like(x)
+        if self.hybrid:
+            xt = torch.zeros_like(x)
+        # initialize everything to zero (signal will go through u-net skips).
+
+        for idx, decode in enumerate(self.decoder):
+            skip = saved.pop(-1)
+            x, pre = decode(x, skip, lengths.pop(-1))
+            # `pre` contains the output just before final transposed convolution,
+            # which is used when the freq. and time branch separate.
+
+            if self.hybrid:
+                offset = self.depth - len(self.tdecoder)
+            if self.hybrid and idx >= offset:
+                tdec = self.tdecoder[idx - offset]
+                length_t = lengths_t.pop(-1)
+                if tdec.empty:
+                    assert pre.shape[2] == 1, pre.shape
+                    pre = pre[:, :, 0]
+                    xt, _ = tdec(pre, None, length_t)
+                else:
+                    skip = saved_t.pop(-1)
+                    xt, _ = tdec(xt, skip, length_t)
+
+        # Let's make sure we used all stored skip connections.
+        assert len(saved) == 0
+        assert len(lengths_t) == 0
+        assert len(saved_t) == 0
+
+        S = len(self.sources)
+        x = x.view(B, S, -1, Fq, T)
+        x = x * std[:, None] + mean[:, None]
+
+        zout = self._mask(z, x)
+        x = self._ispec(zout, length)
+
+        if self.hybrid:
+            xt = xt.view(B, S, -1, length)
+            xt = xt * stdt[:, None] + meant[:, None]
+            x = xt + x
+        return x

MVSEP-MDX23-music-separation-model/demucs3/htdemucs.py

@@ -0,0 +1,648 @@
+# Copyright (c) Meta, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# First author is Simon Rouard.
+"""
+This code contains the spectrogram and Hybrid version of Demucs.
+"""
+import math
+
+from openunmix.filtering import wiener
+import torch
+from torch import nn
+from torch.nn import functional as F
+from fractions import Fraction
+from einops import rearrange
+
+from .transformer import CrossTransformerEncoder
+
+from .demucs import rescale_module
+from .states import capture_init
+from .spec import spectro, ispectro
+from .hdemucs import pad1d, ScaledEmbedding, HEncLayer, MultiWrap, HDecLayer
+
+
+class HTDemucs(nn.Module):
+    """
+    Spectrogram and hybrid Demucs model.
+    The spectrogram model has the same structure as Demucs, except the first few layers are over the
+    frequency axis, until there is only 1 frequency, and then it moves to time convolutions.
+    Frequency layers can still access information across time steps thanks to the DConv residual.
+
+    Hybrid model have a parallel time branch. At some layer, the time branch has the same stride
+    as the frequency branch and then the two are combined. The opposite happens in the decoder.
+
+    Models can either use naive iSTFT from masking, Wiener filtering ([Ulhih et al. 2017]),
+    or complex as channels (CaC) [Choi et al. 2020]. Wiener filtering is based on
+    Open Unmix implementation [Stoter et al. 2019].
+
+    The loss is always on the temporal domain, by backpropagating through the above
+    output methods and iSTFT. This allows to define hybrid models nicely. However, this breaks
+    a bit Wiener filtering, as doing more iteration at test time will change the spectrogram
+    contribution, without changing the one from the waveform, which will lead to worse performance.
+    I tried using the residual option in OpenUnmix Wiener implementation, but it didn't improve.
+    CaC on the other hand provides similar performance for hybrid, and works naturally with
+    hybrid models.
+
+    This model also uses frequency embeddings are used to improve efficiency on convolutions
+    over the freq. axis, following [Isik et al. 2020] (https://arxiv.org/pdf/2008.04470.pdf).
+
+    Unlike classic Demucs, there is no resampling here, and normalization is always applied.
+    """
+
+    @capture_init
+    def __init__(
+        self,
+        sources,
+        # Channels
+        audio_channels=2,
+        channels=48,
+        channels_time=None,
+        growth=2,
+        # STFT
+        nfft=4096,
+        wiener_iters=0,
+        end_iters=0,
+        wiener_residual=False,
+        cac=True,
+        # Main structure
+        depth=4,
+        rewrite=True,
+        # Frequency branch
+        multi_freqs=None,
+        multi_freqs_depth=3,
+        freq_emb=0.2,
+        emb_scale=10,
+        emb_smooth=True,
+        # Convolutions
+        kernel_size=8,
+        time_stride=2,
+        stride=4,
+        context=1,
+        context_enc=0,
+        # Normalization
+        norm_starts=4,
+        norm_groups=4,
+        # DConv residual branch
+        dconv_mode=1,
+        dconv_depth=2,
+        dconv_comp=8,
+        dconv_init=1e-3,
+        # Before the Transformer
+        bottom_channels=0,
+        # Transformer
+        t_layers=5,
+        t_emb="sin",
+        t_hidden_scale=4.0,
+        t_heads=8,
+        t_dropout=0.0,
+        t_max_positions=10000,
+        t_norm_in=True,
+        t_norm_in_group=False,
+        t_group_norm=False,
+        t_norm_first=True,
+        t_norm_out=True,
+        t_max_period=10000.0,
+        t_weight_decay=0.0,
+        t_lr=None,
+        t_layer_scale=True,
+        t_gelu=True,
+        t_weight_pos_embed=1.0,
+        t_sin_random_shift=0,
+        t_cape_mean_normalize=True,
+        t_cape_augment=True,
+        t_cape_glob_loc_scale=[5000.0, 1.0, 1.4],
+        t_sparse_self_attn=False,
+        t_sparse_cross_attn=False,
+        t_mask_type="diag",
+        t_mask_random_seed=42,
+        t_sparse_attn_window=500,
+        t_global_window=100,
+        t_sparsity=0.95,
+        t_auto_sparsity=False,
+        # ------ Particuliar parameters
+        t_cross_first=False,
+        # Weight init
+        rescale=0.1,
+        # Metadata
+        samplerate=44100,
+        segment=10,
+        use_train_segment=True,
+    ):
+        """
+        Args:
+            sources (list[str]): list of source names.
+            audio_channels (int): input/output audio channels.
+            channels (int): initial number of hidden channels.
+            channels_time: if not None, use a different `channels` value for the time branch.
+            growth: increase the number of hidden channels by this factor at each layer.
+            nfft: number of fft bins. Note that changing this require careful computation of
+                various shape parameters and will not work out of the box for hybrid models.
+            wiener_iters: when using Wiener filtering, number of iterations at test time.
+            end_iters: same but at train time. For a hybrid model, must be equal to `wiener_iters`.
+            wiener_residual: add residual source before wiener filtering.
+            cac: uses complex as channels, i.e. complex numbers are 2 channels each
+                in input and output. no further processing is done before ISTFT.
+            depth (int): number of layers in the encoder and in the decoder.
+            rewrite (bool): add 1x1 convolution to each layer.
+            multi_freqs: list of frequency ratios for splitting frequency bands with `MultiWrap`.
+            multi_freqs_depth: how many layers to wrap with `MultiWrap`. Only the outermost
+                layers will be wrapped.
+            freq_emb: add frequency embedding after the first frequency layer if > 0,
+                the actual value controls the weight of the embedding.
+            emb_scale: equivalent to scaling the embedding learning rate
+            emb_smooth: initialize the embedding with a smooth one (with respect to frequencies).
+            kernel_size: kernel_size for encoder and decoder layers.
+            stride: stride for encoder and decoder layers.
+            time_stride: stride for the final time layer, after the merge.
+            context: context for 1x1 conv in the decoder.
+            context_enc: context for 1x1 conv in the encoder.
+            norm_starts: layer at which group norm starts being used.
+                decoder layers are numbered in reverse order.
+            norm_groups: number of groups for group norm.
+            dconv_mode: if 1: dconv in encoder only, 2: decoder only, 3: both.
+            dconv_depth: depth of residual DConv branch.
+            dconv_comp: compression of DConv branch.
+            dconv_attn: adds attention layers in DConv branch starting at this layer.
+            dconv_lstm: adds a LSTM layer in DConv branch starting at this layer.
+            dconv_init: initial scale for the DConv branch LayerScale.
+            bottom_channels: if >0 it adds a linear layer (1x1 Conv) before and after the
+                transformer in order to change the number of channels
+            t_layers: number of layers in each branch (waveform and spec) of the transformer
+            t_emb: "sin", "cape" or "scaled"
+            t_hidden_scale: the hidden scale of the Feedforward parts of the transformer
+                for instance if C = 384 (the number of channels in the transformer) and
+                t_hidden_scale = 4.0 then the intermediate layer of the FFN has dimension
+                384 * 4 = 1536
+            t_heads: number of heads for the transformer
+            t_dropout: dropout in the transformer
+            t_max_positions: max_positions for the "scaled" positional embedding, only
+                useful if t_emb="scaled"
+            t_norm_in: (bool) norm before addinf positional embedding and getting into the
+                transformer layers
+            t_norm_in_group: (bool) if True while t_norm_in=True, the norm is on all the
+                timesteps (GroupNorm with group=1)
+            t_group_norm: (bool) if True, the norms of the Encoder Layers are on all the
+                timesteps (GroupNorm with group=1)
+            t_norm_first: (bool) if True the norm is before the attention and before the FFN
+            t_norm_out: (bool) if True, there is a GroupNorm (group=1) at the end of each layer
+            t_max_period: (float) denominator in the sinusoidal embedding expression
+            t_weight_decay: (float) weight decay for the transformer
+            t_lr: (float) specific learning rate for the transformer
+            t_layer_scale: (bool) Layer Scale for the transformer
+            t_gelu: (bool) activations of the transformer are GeLU if True, ReLU else
+            t_weight_pos_embed: (float) weighting of the positional embedding
+            t_cape_mean_normalize: (bool) if t_emb="cape", normalisation of positional embeddings
+                see: https://arxiv.org/abs/2106.03143
+            t_cape_augment: (bool) if t_emb="cape", must be True during training and False
+                during the inference, see: https://arxiv.org/abs/2106.03143
+            t_cape_glob_loc_scale: (list of 3 floats) if t_emb="cape", CAPE parameters
+                see: https://arxiv.org/abs/2106.03143
+            t_sparse_self_attn: (bool) if True, the self attentions are sparse
+            t_sparse_cross_attn: (bool) if True, the cross-attentions are sparse (don't use it
+                unless you designed really specific masks)
+            t_mask_type: (str) can be "diag", "jmask", "random", "global" or any combination
+                with '_' between: i.e. "diag_jmask_random" (note that this is permutation
+                invariant i.e. "diag_jmask_random" is equivalent to "jmask_random_diag")
+            t_mask_random_seed: (int) if "random" is in t_mask_type, controls the seed
+                that generated the random part of the mask
+            t_sparse_attn_window: (int) if "diag" is in t_mask_type, for a query (i), and
+                a key (j), the mask is True id |i-j|<=t_sparse_attn_window
+            t_global_window: (int) if "global" is in t_mask_type, mask[:t_global_window, :]
+                and mask[:, :t_global_window] will be True
+            t_sparsity: (float) if "random" is in t_mask_type, t_sparsity is the sparsity
+                level of the random part of the mask.
+            t_cross_first: (bool) if True cross attention is the first layer of the
+                transformer (False seems to be better)
+            rescale: weight rescaling trick
+            use_train_segment: (bool) if True, the actual size that is used during the
+                training is used during inference.
+        """
+        super().__init__()
+        self.cac = cac
+        self.wiener_residual = wiener_residual
+        self.audio_channels = audio_channels
+        self.sources = sources
+        self.kernel_size = kernel_size
+        self.context = context
+        self.stride = stride
+        self.depth = depth
+        self.bottom_channels = bottom_channels
+        self.channels = channels
+        self.samplerate = samplerate
+        self.segment = segment
+        self.use_train_segment = use_train_segment
+        self.nfft = nfft
+        self.hop_length = nfft // 4
+        self.wiener_iters = wiener_iters
+        self.end_iters = end_iters
+        self.freq_emb = None
+        assert wiener_iters == end_iters
+
+        self.encoder = nn.ModuleList()
+        self.decoder = nn.ModuleList()
+
+        self.tencoder = nn.ModuleList()
+        self.tdecoder = nn.ModuleList()
+
+        chin = audio_channels
+        chin_z = chin  # number of channels for the freq branch
+        if self.cac:
+            chin_z *= 2
+        chout = channels_time or channels
+        chout_z = channels
+        freqs = nfft // 2
+
+        for index in range(depth):
+            norm = index >= norm_starts
+            freq = freqs > 1
+            stri = stride
+            ker = kernel_size
+            if not freq:
+                assert freqs == 1
+                ker = time_stride * 2
+                stri = time_stride
+
+            pad = True
+            last_freq = False
+            if freq and freqs <= kernel_size:
+                ker = freqs
+                pad = False
+                last_freq = True
+
+            kw = {
+                "kernel_size": ker,
+                "stride": stri,
+                "freq": freq,
+                "pad": pad,
+                "norm": norm,
+                "rewrite": rewrite,
+                "norm_groups": norm_groups,
+                "dconv_kw": {
+                    "depth": dconv_depth,
+                    "compress": dconv_comp,
+                    "init": dconv_init,
+                    "gelu": True,
+                },
+            }
+            kwt = dict(kw)
+            kwt["freq"] = 0
+            kwt["kernel_size"] = kernel_size
+            kwt["stride"] = stride
+            kwt["pad"] = True
+            kw_dec = dict(kw)
+            multi = False
+            if multi_freqs and index < multi_freqs_depth:
+                multi = True
+                kw_dec["context_freq"] = False
+
+            if last_freq:
+                chout_z = max(chout, chout_z)
+                chout = chout_z
+
+            enc = HEncLayer(
+                chin_z, chout_z, dconv=dconv_mode & 1, context=context_enc, **kw
+            )
+            if freq:
+                tenc = HEncLayer(
+                    chin,
+                    chout,
+                    dconv=dconv_mode & 1,
+                    context=context_enc,
+                    empty=last_freq,
+                    **kwt
+                )
+                self.tencoder.append(tenc)
+
+            if multi:
+                enc = MultiWrap(enc, multi_freqs)
+            self.encoder.append(enc)
+            if index == 0:
+                chin = self.audio_channels * len(self.sources)
+                chin_z = chin
+                if self.cac:
+                    chin_z *= 2
+            dec = HDecLayer(
+                chout_z,
+                chin_z,
+                dconv=dconv_mode & 2,
+                last=index == 0,
+                context=context,
+                **kw_dec
+            )
+            if multi:
+                dec = MultiWrap(dec, multi_freqs)
+            if freq:
+                tdec = HDecLayer(
+                    chout,
+                    chin,
+                    dconv=dconv_mode & 2,
+                    empty=last_freq,
+                    last=index == 0,
+                    context=context,
+                    **kwt
+                )
+                self.tdecoder.insert(0, tdec)
+            self.decoder.insert(0, dec)
+
+            chin = chout
+            chin_z = chout_z
+            chout = int(growth * chout)
+            chout_z = int(growth * chout_z)
+            if freq:
+                if freqs <= kernel_size:
+                    freqs = 1
+                else:
+                    freqs //= stride
+            if index == 0 and freq_emb:
+                self.freq_emb = ScaledEmbedding(
+                    freqs, chin_z, smooth=emb_smooth, scale=emb_scale
+                )
+                self.freq_emb_scale = freq_emb
+
+        if rescale:
+            rescale_module(self, reference=rescale)
+
+        transformer_channels = channels * growth ** (depth - 1)
+        if bottom_channels:
+            self.channel_upsampler = nn.Conv1d(transformer_channels, bottom_channels, 1)
+            self.channel_downsampler = nn.Conv1d(
+                bottom_channels, transformer_channels, 1
+            )
+            self.channel_upsampler_t = nn.Conv1d(
+                transformer_channels, bottom_channels, 1
+            )
+            self.channel_downsampler_t = nn.Conv1d(
+                bottom_channels, transformer_channels, 1
+            )
+
+            transformer_channels = bottom_channels
+
+        if t_layers > 0:
+            self.crosstransformer = CrossTransformerEncoder(
+                dim=transformer_channels,
+                emb=t_emb,
+                hidden_scale=t_hidden_scale,
+                num_heads=t_heads,
+                num_layers=t_layers,
+                cross_first=t_cross_first,
+                dropout=t_dropout,
+                max_positions=t_max_positions,
+                norm_in=t_norm_in,
+                norm_in_group=t_norm_in_group,
+                group_norm=t_group_norm,
+                norm_first=t_norm_first,
+                norm_out=t_norm_out,
+                max_period=t_max_period,
+                weight_decay=t_weight_decay,
+                lr=t_lr,
+                layer_scale=t_layer_scale,
+                gelu=t_gelu,
+                sin_random_shift=t_sin_random_shift,
+                weight_pos_embed=t_weight_pos_embed,
+                cape_mean_normalize=t_cape_mean_normalize,
+                cape_augment=t_cape_augment,
+                cape_glob_loc_scale=t_cape_glob_loc_scale,
+                sparse_self_attn=t_sparse_self_attn,
+                sparse_cross_attn=t_sparse_cross_attn,
+                mask_type=t_mask_type,
+                mask_random_seed=t_mask_random_seed,
+                sparse_attn_window=t_sparse_attn_window,
+                global_window=t_global_window,
+                sparsity=t_sparsity,
+                auto_sparsity=t_auto_sparsity,
+            )
+        else:
+            self.crosstransformer = None
+
+    def _spec(self, x):
+        hl = self.hop_length
+        nfft = self.nfft
+        x0 = x  # noqa
+
+        # We re-pad the signal in order to keep the property
+        # that the size of the output is exactly the size of the input
+        # divided by the stride (here hop_length), when divisible.
+        # This is achieved by padding by 1/4th of the kernel size (here nfft).
+        # which is not supported by torch.stft.
+        # Having all convolution operations follow this convention allow to easily
+        # align the time and frequency branches later on.
+        assert hl == nfft // 4
+        le = int(math.ceil(x.shape[-1] / hl))
+        pad = hl // 2 * 3
+        x = pad1d(x, (pad, pad + le * hl - x.shape[-1]), mode="reflect")
+
+        z = spectro(x, nfft, hl)[..., :-1, :]
+        assert z.shape[-1] == le + 4, (z.shape, x.shape, le)
+        z = z[..., 2: 2 + le]
+        return z
+
+    def _ispec(self, z, length=None, scale=0):
+        hl = self.hop_length // (4**scale)
+        z = F.pad(z, (0, 0, 0, 1))
+        z = F.pad(z, (2, 2))
+        pad = hl // 2 * 3
+        le = hl * int(math.ceil(length / hl)) + 2 * pad
+        x = ispectro(z, hl, length=le)
+        x = x[..., pad: pad + length]
+        return x
+
+    def _magnitude(self, z):
+        # return the magnitude of the spectrogram, except when cac is True,
+        # in which case we just move the complex dimension to the channel one.
+        if self.cac:
+            B, C, Fr, T = z.shape
+            m = torch.view_as_real(z).permute(0, 1, 4, 2, 3)
+            m = m.reshape(B, C * 2, Fr, T)
+        else:
+            m = z.abs()
+        return m
+
+    def _mask(self, z, m):
+        # Apply masking given the mixture spectrogram `z` and the estimated mask `m`.
+        # If `cac` is True, `m` is actually a full spectrogram and `z` is ignored.
+        niters = self.wiener_iters
+        if self.cac:
+            B, S, C, Fr, T = m.shape
+            out = m.view(B, S, -1, 2, Fr, T).permute(0, 1, 2, 4, 5, 3)
+            out = torch.view_as_complex(out.contiguous())
+            return out
+        if self.training:
+            niters = self.end_iters
+        if niters < 0:
+            z = z[:, None]
+            return z / (1e-8 + z.abs()) * m
+        else:
+            return self._wiener(m, z, niters)
+
+    def _wiener(self, mag_out, mix_stft, niters):
+        # apply wiener filtering from OpenUnmix.
+        init = mix_stft.dtype
+        wiener_win_len = 300
+        residual = self.wiener_residual
+
+        B, S, C, Fq, T = mag_out.shape
+        mag_out = mag_out.permute(0, 4, 3, 2, 1)
+        mix_stft = torch.view_as_real(mix_stft.permute(0, 3, 2, 1))
+
+        outs = []
+        for sample in range(B):
+            pos = 0
+            out = []
+            for pos in range(0, T, wiener_win_len):
+                frame = slice(pos, pos + wiener_win_len)
+                z_out = wiener(
+                    mag_out[sample, frame],
+                    mix_stft[sample, frame],
+                    niters,
+                    residual=residual,
+                )
+                out.append(z_out.transpose(-1, -2))
+            outs.append(torch.cat(out, dim=0))
+        out = torch.view_as_complex(torch.stack(outs, 0))
+        out = out.permute(0, 4, 3, 2, 1).contiguous()
+        if residual:
+            out = out[:, :-1]
+        assert list(out.shape) == [B, S, C, Fq, T]
+        return out.to(init)
+
+    def valid_length(self, length: int):
+        """
+        Return a length that is appropriate for evaluation.
+        In our case, always return the training length, unless
+        it is smaller than the given length, in which case this
+        raises an error.
+        """
+        if not self.use_train_segment:
+            return length
+        training_length = int(self.segment * self.samplerate)
+        if training_length < length:
+            raise ValueError(
+                    f"Given length {length} is longer than "
+                    f"training length {training_length}")
+        return training_length
+
+    def forward(self, mix):
+        length = mix.shape[-1]
+        length_pre_pad = None
+        if self.use_train_segment:
+            if self.training:
+                self.segment = Fraction(mix.shape[-1], self.samplerate)
+            else:
+                training_length = int(self.segment * self.samplerate)
+                if mix.shape[-1] < training_length:
+                    length_pre_pad = mix.shape[-1]
+                    mix = F.pad(mix, (0, training_length - length_pre_pad))
+        z = self._spec(mix)
+        mag = self._magnitude(z)
+        x = mag
+
+        B, C, Fq, T = x.shape
+
+        # unlike previous Demucs, we always normalize because it is easier.
+        mean = x.mean(dim=(1, 2, 3), keepdim=True)
+        std = x.std(dim=(1, 2, 3), keepdim=True)
+        x = (x - mean) / (1e-5 + std)
+        # x will be the freq. branch input.
+
+        # Prepare the time branch input.
+        xt = mix
+        meant = xt.mean(dim=(1, 2), keepdim=True)
+        stdt = xt.std(dim=(1, 2), keepdim=True)
+        xt = (xt - meant) / (1e-5 + stdt)
+
+        # okay, this is a giant mess I know...
+        saved = []  # skip connections, freq.
+        saved_t = []  # skip connections, time.
+        lengths = []  # saved lengths to properly remove padding, freq branch.
+        lengths_t = []  # saved lengths for time branch.
+        for idx, encode in enumerate(self.encoder):
+            lengths.append(x.shape[-1])
+            inject = None
+            if idx < len(self.tencoder):
+                # we have not yet merged branches.
+                lengths_t.append(xt.shape[-1])
+                tenc = self.tencoder[idx]
+                xt = tenc(xt)
+                if not tenc.empty:
+                    # save for skip connection
+                    saved_t.append(xt)
+                else:
+                    # tenc contains just the first conv., so that now time and freq.
+                    # branches have the same shape and can be merged.
+                    inject = xt
+            x = encode(x, inject)
+            if idx == 0 and self.freq_emb is not None:
+                # add frequency embedding to allow for non equivariant convolutions
+                # over the frequency axis.
+                frs = torch.arange(x.shape[-2], device=x.device)
+                emb = self.freq_emb(frs).t()[None, :, :, None].expand_as(x)
+                x = x + self.freq_emb_scale * emb
+
+            saved.append(x)
+        if self.crosstransformer:
+            if self.bottom_channels:
+                b, c, f, t = x.shape
+                x = rearrange(x, "b c f t-> b c (f t)")
+                x = self.channel_upsampler(x)
+                x = rearrange(x, "b c (f t)-> b c f t", f=f)
+                xt = self.channel_upsampler_t(xt)
+
+            x, xt = self.crosstransformer(x, xt)
+
+            if self.bottom_channels:
+                x = rearrange(x, "b c f t-> b c (f t)")
+                x = self.channel_downsampler(x)
+                x = rearrange(x, "b c (f t)-> b c f t", f=f)
+                xt = self.channel_downsampler_t(xt)
+
+        for idx, decode in enumerate(self.decoder):
+            skip = saved.pop(-1)
+            x, pre = decode(x, skip, lengths.pop(-1))
+            # `pre` contains the output just before final transposed convolution,
+            # which is used when the freq. and time branch separate.
+
+            offset = self.depth - len(self.tdecoder)
+            if idx >= offset:
+                tdec = self.tdecoder[idx - offset]
+                length_t = lengths_t.pop(-1)
+                if tdec.empty:
+                    assert pre.shape[2] == 1, pre.shape
+                    pre = pre[:, :, 0]
+                    xt, _ = tdec(pre, None, length_t)
+                else:
+                    skip = saved_t.pop(-1)
+                    xt, _ = tdec(xt, skip, length_t)
+
+        # Let's make sure we used all stored skip connections.
+        assert len(saved) == 0
+        assert len(lengths_t) == 0
+        assert len(saved_t) == 0
+
+        S = len(self.sources)
+        x = x.view(B, S, -1, Fq, T)
+        x = x * std[:, None] + mean[:, None]
+
+        zout = self._mask(z, x)
+        if self.use_train_segment:
+            if self.training:
+                x = self._ispec(zout, length)
+            else:
+                x = self._ispec(zout, training_length)
+        else:
+            x = self._ispec(zout, length)
+
+        if self.use_train_segment:
+            if self.training:
+                xt = xt.view(B, S, -1, length)
+            else:
+                xt = xt.view(B, S, -1, training_length)
+        else:
+            xt = xt.view(B, S, -1, length)
+        xt = xt * stdt[:, None] + meant[:, None]
+        x = xt + x
+        if length_pre_pad:
+            x = x[..., :length_pre_pad]
+        return x

MVSEP-MDX23-music-separation-model/demucs3/spec.py

@@ -0,0 +1,41 @@
+# Copyright (c) Meta, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+"""Conveniance wrapper to perform STFT and iSTFT"""
+
+import torch as th
+
+
+def spectro(x, n_fft=512, hop_length=None, pad=0):
+    *other, length = x.shape
+    x = x.reshape(-1, length)
+    z = th.stft(x,
+                n_fft * (1 + pad),
+                hop_length or n_fft // 4,
+                window=th.hann_window(n_fft).to(x),
+                win_length=n_fft,
+                normalized=True,
+                center=True,
+                return_complex=True,
+                pad_mode='reflect')
+    _, freqs, frame = z.shape
+    return z.view(*other, freqs, frame)
+
+
+def ispectro(z, hop_length=None, length=None, pad=0):
+    *other, freqs, frames = z.shape
+    n_fft = 2 * freqs - 2
+    z = z.view(-1, freqs, frames)
+    win_length = n_fft // (1 + pad)
+    x = th.istft(z,
+                 n_fft,
+                 hop_length,
+                 window=th.hann_window(win_length).to(z.real),
+                 win_length=win_length,
+                 normalized=True,
+                 length=length,
+                 center=True)
+    _, length = x.shape
+    return x.view(*other, length)

MVSEP-MDX23-music-separation-model/demucs3/states.py

@@ -0,0 +1,148 @@
+# Copyright (c) Meta, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+"""
+Utilities to save and load models.
+"""
+from contextlib import contextmanager
+
+import functools
+import hashlib
+import inspect
+import io
+from pathlib import Path
+import warnings
+
+from omegaconf import OmegaConf
+from diffq import DiffQuantizer, UniformQuantizer, restore_quantized_state
+import torch
+
+
+def get_quantizer(model, args, optimizer=None):
+    """Return the quantizer given the XP quantization args."""
+    quantizer = None
+    if args.diffq:
+        quantizer = DiffQuantizer(
+            model, min_size=args.min_size, group_size=args.group_size)
+        if optimizer is not None:
+            quantizer.setup_optimizer(optimizer)
+    elif args.qat:
+        quantizer = UniformQuantizer(
+                model, bits=args.qat, min_size=args.min_size)
+    return quantizer
+
+
+def load_model(path_or_package, strict=False):
+    """Load a model from the given serialized model, either given as a dict (already loaded)
+    or a path to a file on disk."""
+    if isinstance(path_or_package, dict):
+        package = path_or_package
+    elif isinstance(path_or_package, (str, Path)):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            path = path_or_package
+            package = torch.load(path, 'cpu')
+    else:
+        raise ValueError(f"Invalid type for {path_or_package}.")
+
+    klass = package["klass"]
+    args = package["args"]
+    kwargs = package["kwargs"]
+
+    if strict:
+        model = klass(*args, **kwargs)
+    else:
+        sig = inspect.signature(klass)
+        for key in list(kwargs):
+            if key not in sig.parameters:
+                warnings.warn("Dropping inexistant parameter " + key)
+                del kwargs[key]
+        model = klass(*args, **kwargs)
+
+    state = package["state"]
+
+    set_state(model, state)
+    return model
+
+
+def get_state(model, quantizer, half=False):
+    """Get the state from a model, potentially with quantization applied.
+    If `half` is True, model are stored as half precision, which shouldn't impact performance
+    but half the state size."""
+    if quantizer is None:
+        dtype = torch.half if half else None
+        state = {k: p.data.to(device='cpu', dtype=dtype) for k, p in model.state_dict().items()}
+    else:
+        state = quantizer.get_quantized_state()
+        state['__quantized'] = True
+    return state
+
+
+def set_state(model, state, quantizer=None):
+    """Set the state on a given model."""
+    if state.get('__quantized'):
+        if quantizer is not None:
+            quantizer.restore_quantized_state(model, state['quantized'])
+        else:
+            restore_quantized_state(model, state)
+    else:
+        model.load_state_dict(state)
+    return state
+
+
+def save_with_checksum(content, path):
+    """Save the given value on disk, along with a sha256 hash.
+    Should be used with the output of either `serialize_model` or `get_state`."""
+    buf = io.BytesIO()
+    torch.save(content, buf)
+    sig = hashlib.sha256(buf.getvalue()).hexdigest()[:8]
+
+    path = path.parent / (path.stem + "-" + sig + path.suffix)
+    path.write_bytes(buf.getvalue())
+
+
+def serialize_model(model, training_args, quantizer=None, half=True):
+    args, kwargs = model._init_args_kwargs
+    klass = model.__class__
+
+    state = get_state(model, quantizer, half)
+    return {
+        'klass': klass,
+        'args': args,
+        'kwargs': kwargs,
+        'state': state,
+        'training_args': OmegaConf.to_container(training_args, resolve=True),
+    }
+
+
+def copy_state(state):
+    return {k: v.cpu().clone() for k, v in state.items()}
+
+
+@contextmanager
+def swap_state(model, state):
+    """
+    Context manager that swaps the state of a model, e.g:
+
+        # model is in old state
+        with swap_state(model, new_state):
+            # model in new state
+        # model back to old state
+    """
+    old_state = copy_state(model.state_dict())
+    model.load_state_dict(state, strict=False)
+    try:
+        yield
+    finally:
+        model.load_state_dict(old_state)
+
+
+def capture_init(init):
+    @functools.wraps(init)
+    def __init__(self, *args, **kwargs):
+        self._init_args_kwargs = (args, kwargs)
+        init(self, *args, **kwargs)
+
+    return __init__

MVSEP-MDX23-music-separation-model/demucs3/transformer.py

@@ -0,0 +1,839 @@
+# Copyright (c) 2019-present, Meta, Inc.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+# First author is Simon Rouard.
+
+import random
+import typing as tp
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import math
+from einops import rearrange
+
+
+def create_sin_embedding(
+    length: int, dim: int, shift: int = 0, device="cpu", max_period=10000
+):
+    # We aim for TBC format
+    assert dim % 2 == 0
+    pos = shift + torch.arange(length, device=device).view(-1, 1, 1)
+    half_dim = dim // 2
+    adim = torch.arange(dim // 2, device=device).view(1, 1, -1)
+    phase = pos / (max_period ** (adim / (half_dim - 1)))
+    return torch.cat(
+        [
+            torch.cos(phase),
+            torch.sin(phase),
+        ],
+        dim=-1,
+    )
+
+
+def create_2d_sin_embedding(d_model, height, width, device="cpu", max_period=10000):
+    """
+    :param d_model: dimension of the model
+    :param height: height of the positions
+    :param width: width of the positions
+    :return: d_model*height*width position matrix
+    """
+    if d_model % 4 != 0:
+        raise ValueError(
+            "Cannot use sin/cos positional encoding with "
+            "odd dimension (got dim={:d})".format(d_model)
+        )
+    pe = torch.zeros(d_model, height, width)
+    # Each dimension use half of d_model
+    d_model = int(d_model / 2)
+    div_term = torch.exp(
+        torch.arange(0.0, d_model, 2) * -(math.log(max_period) / d_model)
+    )
+    pos_w = torch.arange(0.0, width).unsqueeze(1)
+    pos_h = torch.arange(0.0, height).unsqueeze(1)
+    pe[0:d_model:2, :, :] = (
+        torch.sin(pos_w * div_term).transpose(0, 1).unsqueeze(1).repeat(1, height, 1)
+    )
+    pe[1:d_model:2, :, :] = (
+        torch.cos(pos_w * div_term).transpose(0, 1).unsqueeze(1).repeat(1, height, 1)
+    )
+    pe[d_model::2, :, :] = (
+        torch.sin(pos_h * div_term).transpose(0, 1).unsqueeze(2).repeat(1, 1, width)
+    )
+    pe[d_model + 1:: 2, :, :] = (
+        torch.cos(pos_h * div_term).transpose(0, 1).unsqueeze(2).repeat(1, 1, width)
+    )
+
+    return pe[None, :].to(device)
+
+
+def create_sin_embedding_cape(
+    length: int,
+    dim: int,
+    batch_size: int,
+    mean_normalize: bool,
+    augment: bool,  # True during training
+    max_global_shift: float = 0.0,  # delta max
+    max_local_shift: float = 0.0,  # epsilon max
+    max_scale: float = 1.0,
+    device: str = "cpu",
+    max_period: float = 10000.0,
+):
+    # We aim for TBC format
+    assert dim % 2 == 0
+    pos = 1.0 * torch.arange(length).view(-1, 1, 1)  # (length, 1, 1)
+    pos = pos.repeat(1, batch_size, 1)  # (length, batch_size, 1)
+    if mean_normalize:
+        pos -= torch.nanmean(pos, dim=0, keepdim=True)
+
+    if augment:
+        delta = np.random.uniform(
+            -max_global_shift, +max_global_shift, size=[1, batch_size, 1]
+        )
+        delta_local = np.random.uniform(
+            -max_local_shift, +max_local_shift, size=[length, batch_size, 1]
+        )
+        log_lambdas = np.random.uniform(
+            -np.log(max_scale), +np.log(max_scale), size=[1, batch_size, 1]
+        )
+        pos = (pos + delta + delta_local) * np.exp(log_lambdas)
+
+    pos = pos.to(device)
+
+    half_dim = dim // 2
+    adim = torch.arange(dim // 2, device=device).view(1, 1, -1)
+    phase = pos / (max_period ** (adim / (half_dim - 1)))
+    return torch.cat(
+        [
+            torch.cos(phase),
+            torch.sin(phase),
+        ],
+        dim=-1,
+    ).float()
+
+
+def get_causal_mask(length):
+    pos = torch.arange(length)
+    return pos > pos[:, None]
+
+
+def get_elementary_mask(
+    T1,
+    T2,
+    mask_type,
+    sparse_attn_window,
+    global_window,
+    mask_random_seed,
+    sparsity,
+    device,
+):
+    """
+    When the input of the Decoder has length T1 and the output T2
+    The mask matrix has shape (T2, T1)
+    """
+    assert mask_type in ["diag", "jmask", "random", "global"]
+
+    if mask_type == "global":
+        mask = torch.zeros(T2, T1, dtype=torch.bool)
+        mask[:, :global_window] = True
+        line_window = int(global_window * T2 / T1)
+        mask[:line_window, :] = True
+
+    if mask_type == "diag":
+
+        mask = torch.zeros(T2, T1, dtype=torch.bool)
+        rows = torch.arange(T2)[:, None]
+        cols = (
+            (T1 / T2 * rows + torch.arange(-sparse_attn_window, sparse_attn_window + 1))
+            .long()
+            .clamp(0, T1 - 1)
+        )
+        mask.scatter_(1, cols, torch.ones(1, dtype=torch.bool).expand_as(cols))
+
+    elif mask_type == "jmask":
+        mask = torch.zeros(T2 + 2, T1 + 2, dtype=torch.bool)
+        rows = torch.arange(T2 + 2)[:, None]
+        t = torch.arange(0, int((2 * T1) ** 0.5 + 1))
+        t = (t * (t + 1) / 2).int()
+        t = torch.cat([-t.flip(0)[:-1], t])
+        cols = (T1 / T2 * rows + t).long().clamp(0, T1 + 1)
+        mask.scatter_(1, cols, torch.ones(1, dtype=torch.bool).expand_as(cols))
+        mask = mask[1:-1, 1:-1]
+
+    elif mask_type == "random":
+        gene = torch.Generator(device=device)
+        gene.manual_seed(mask_random_seed)
+        mask = (
+            torch.rand(T1 * T2, generator=gene, device=device).reshape(T2, T1)
+            > sparsity
+        )
+
+    mask = mask.to(device)
+    return mask
+
+
+def get_mask(
+    T1,
+    T2,
+    mask_type,
+    sparse_attn_window,
+    global_window,
+    mask_random_seed,
+    sparsity,
+    device,
+):
+    """
+    Return a SparseCSRTensor mask that is a combination of elementary masks
+    mask_type can be a combination of multiple masks: for instance "diag_jmask_random"
+    """
+    from xformers.sparse import SparseCSRTensor
+    # create a list
+    mask_types = mask_type.split("_")
+
+    all_masks = [
+        get_elementary_mask(
+            T1,
+            T2,
+            mask,
+            sparse_attn_window,
+            global_window,
+            mask_random_seed,
+            sparsity,
+            device,
+        )
+        for mask in mask_types
+    ]
+
+    final_mask = torch.stack(all_masks).sum(axis=0) > 0
+
+    return SparseCSRTensor.from_dense(final_mask[None])
+
+
+class ScaledEmbedding(nn.Module):
+    def __init__(
+        self,
+        num_embeddings: int,
+        embedding_dim: int,
+        scale: float = 1.0,
+        boost: float = 3.0,
+    ):
+        super().__init__()
+        self.embedding = nn.Embedding(num_embeddings, embedding_dim)
+        self.embedding.weight.data *= scale / boost
+        self.boost = boost
+
+    @property
+    def weight(self):
+        return self.embedding.weight * self.boost
+
+    def forward(self, x):
+        return self.embedding(x) * self.boost
+
+
+class LayerScale(nn.Module):
+    """Layer scale from [Touvron et al 2021] (https://arxiv.org/pdf/2103.17239.pdf).
+    This rescales diagonaly residual outputs close to 0 initially, then learnt.
+    """
+
+    def __init__(self, channels: int, init: float = 0, channel_last=False):
+        """
+        channel_last = False corresponds to (B, C, T) tensors
+        channel_last = True corresponds to (T, B, C) tensors
+        """
+        super().__init__()
+        self.channel_last = channel_last
+        self.scale = nn.Parameter(torch.zeros(channels, requires_grad=True))
+        self.scale.data[:] = init
+
+    def forward(self, x):
+        if self.channel_last:
+            return self.scale * x
+        else:
+            return self.scale[:, None] * x
+
+
+class MyGroupNorm(nn.GroupNorm):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def forward(self, x):
+        """
+        x: (B, T, C)
+        if num_groups=1: Normalisation on all T and C together for each B
+        """
+        x = x.transpose(1, 2)
+        return super().forward(x).transpose(1, 2)
+
+
+class MyTransformerEncoderLayer(nn.TransformerEncoderLayer):
+    def __init__(
+        self,
+        d_model,
+        nhead,
+        dim_feedforward=2048,
+        dropout=0.1,
+        activation=F.relu,
+        group_norm=0,
+        norm_first=False,
+        norm_out=False,
+        layer_norm_eps=1e-5,
+        layer_scale=False,
+        init_values=1e-4,
+        device=None,
+        dtype=None,
+        sparse=False,
+        mask_type="diag",
+        mask_random_seed=42,
+        sparse_attn_window=500,
+        global_window=50,
+        auto_sparsity=False,
+        sparsity=0.95,
+        batch_first=False,
+    ):
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__(
+            d_model=d_model,
+            nhead=nhead,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout,
+            activation=activation,
+            layer_norm_eps=layer_norm_eps,
+            batch_first=batch_first,
+            norm_first=norm_first,
+            device=device,
+            dtype=dtype,
+        )
+        self.sparse = sparse
+        self.auto_sparsity = auto_sparsity
+        if sparse:
+            if not auto_sparsity:
+                self.mask_type = mask_type
+                self.sparse_attn_window = sparse_attn_window
+                self.global_window = global_window
+            self.sparsity = sparsity
+        if group_norm:
+            self.norm1 = MyGroupNorm(int(group_norm), d_model, eps=layer_norm_eps, **factory_kwargs)
+            self.norm2 = MyGroupNorm(int(group_norm), d_model, eps=layer_norm_eps, **factory_kwargs)
+
+        self.norm_out = None
+        if self.norm_first & norm_out:
+            self.norm_out = MyGroupNorm(num_groups=int(norm_out), num_channels=d_model)
+        self.gamma_1 = (
+            LayerScale(d_model, init_values, True) if layer_scale else nn.Identity()
+        )
+        self.gamma_2 = (
+            LayerScale(d_model, init_values, True) if layer_scale else nn.Identity()
+        )
+
+        if sparse:
+            self.self_attn = MultiheadAttention(
+                d_model, nhead, dropout=dropout, batch_first=batch_first,
+                auto_sparsity=sparsity if auto_sparsity else 0,
+            )
+            self.__setattr__("src_mask", torch.zeros(1, 1))
+            self.mask_random_seed = mask_random_seed
+
+    def forward(self, src, src_mask=None, src_key_padding_mask=None):
+        """
+        if batch_first = False, src shape is (T, B, C)
+        the case where batch_first=True is not covered
+        """
+        device = src.device
+        x = src
+        T, B, C = x.shape
+        if self.sparse and not self.auto_sparsity:
+            assert src_mask is None
+            src_mask = self.src_mask
+            if src_mask.shape[-1] != T:
+                src_mask = get_mask(
+                    T,
+                    T,
+                    self.mask_type,
+                    self.sparse_attn_window,
+                    self.global_window,
+                    self.mask_random_seed,
+                    self.sparsity,
+                    device,
+                )
+                self.__setattr__("src_mask", src_mask)
+
+        if self.norm_first:
+            x = x + self.gamma_1(
+                self._sa_block(self.norm1(x), src_mask, src_key_padding_mask)
+            )
+            x = x + self.gamma_2(self._ff_block(self.norm2(x)))
+
+            if self.norm_out:
+                x = self.norm_out(x)
+        else:
+            x = self.norm1(
+                x + self.gamma_1(self._sa_block(x, src_mask, src_key_padding_mask))
+            )
+            x = self.norm2(x + self.gamma_2(self._ff_block(x)))
+
+        return x
+
+
+class CrossTransformerEncoderLayer(nn.Module):
+    def __init__(
+        self,
+        d_model: int,
+        nhead: int,
+        dim_feedforward: int = 2048,
+        dropout: float = 0.1,
+        activation=F.relu,
+        layer_norm_eps: float = 1e-5,
+        layer_scale: bool = False,
+        init_values: float = 1e-4,
+        norm_first: bool = False,
+        group_norm: bool = False,
+        norm_out: bool = False,
+        sparse=False,
+        mask_type="diag",
+        mask_random_seed=42,
+        sparse_attn_window=500,
+        global_window=50,
+        sparsity=0.95,
+        auto_sparsity=None,
+        device=None,
+        dtype=None,
+        batch_first=False,
+    ):
+        factory_kwargs = {"device": device, "dtype": dtype}
+        super().__init__()
+
+        self.sparse = sparse
+        self.auto_sparsity = auto_sparsity
+        if sparse:
+            if not auto_sparsity:
+                self.mask_type = mask_type
+                self.sparse_attn_window = sparse_attn_window
+                self.global_window = global_window
+            self.sparsity = sparsity
+
+        self.cross_attn: nn.Module
+        self.cross_attn = nn.MultiheadAttention(
+            d_model, nhead, dropout=dropout, batch_first=batch_first)
+        # Implementation of Feedforward model
+        self.linear1 = nn.Linear(d_model, dim_feedforward, **factory_kwargs)
+        self.dropout = nn.Dropout(dropout)
+        self.linear2 = nn.Linear(dim_feedforward, d_model, **factory_kwargs)
+
+        self.norm_first = norm_first
+        self.norm1: nn.Module
+        self.norm2: nn.Module
+        self.norm3: nn.Module
+        if group_norm:
+            self.norm1 = MyGroupNorm(int(group_norm), d_model, eps=layer_norm_eps, **factory_kwargs)
+            self.norm2 = MyGroupNorm(int(group_norm), d_model, eps=layer_norm_eps, **factory_kwargs)
+            self.norm3 = MyGroupNorm(int(group_norm), d_model, eps=layer_norm_eps, **factory_kwargs)
+        else:
+            self.norm1 = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
+            self.norm2 = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
+            self.norm3 = nn.LayerNorm(d_model, eps=layer_norm_eps, **factory_kwargs)
+
+        self.norm_out = None
+        if self.norm_first & norm_out:
+            self.norm_out = MyGroupNorm(num_groups=int(norm_out), num_channels=d_model)
+
+        self.gamma_1 = (
+            LayerScale(d_model, init_values, True) if layer_scale else nn.Identity()
+        )
+        self.gamma_2 = (
+            LayerScale(d_model, init_values, True) if layer_scale else nn.Identity()
+        )
+
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(dropout)
+
+        # Legacy string support for activation function.
+        if isinstance(activation, str):
+            self.activation = self._get_activation_fn(activation)
+        else:
+            self.activation = activation
+
+        if sparse:
+            self.cross_attn = MultiheadAttention(
+                d_model, nhead, dropout=dropout, batch_first=batch_first,
+                auto_sparsity=sparsity if auto_sparsity else 0)
+            if not auto_sparsity:
+                self.__setattr__("mask", torch.zeros(1, 1))
+                self.mask_random_seed = mask_random_seed
+
+    def forward(self, q, k, mask=None):
+        """
+        Args:
+            q: tensor of shape (T, B, C)
+            k: tensor of shape (S, B, C)
+            mask: tensor of shape (T, S)
+
+        """
+        device = q.device
+        T, B, C = q.shape
+        S, B, C = k.shape
+        if self.sparse and not self.auto_sparsity:
+            assert mask is None
+            mask = self.mask
+            if mask.shape[-1] != S or mask.shape[-2] != T:
+                mask = get_mask(
+                    S,
+                    T,
+                    self.mask_type,
+                    self.sparse_attn_window,
+                    self.global_window,
+                    self.mask_random_seed,
+                    self.sparsity,
+                    device,
+                )
+                self.__setattr__("mask", mask)
+
+        if self.norm_first:
+            x = q + self.gamma_1(self._ca_block(self.norm1(q), self.norm2(k), mask))
+            x = x + self.gamma_2(self._ff_block(self.norm3(x)))
+            if self.norm_out:
+                x = self.norm_out(x)
+        else:
+            x = self.norm1(q + self.gamma_1(self._ca_block(q, k, mask)))
+            x = self.norm2(x + self.gamma_2(self._ff_block(x)))
+
+        return x
+
+    # self-attention block
+    def _ca_block(self, q, k, attn_mask=None):
+        x = self.cross_attn(q, k, k, attn_mask=attn_mask, need_weights=False)[0]
+        return self.dropout1(x)
+
+    # feed forward block
+    def _ff_block(self, x):
+        x = self.linear2(self.dropout(self.activation(self.linear1(x))))
+        return self.dropout2(x)
+
+    def _get_activation_fn(self, activation):
+        if activation == "relu":
+            return F.relu
+        elif activation == "gelu":
+            return F.gelu
+
+        raise RuntimeError("activation should be relu/gelu, not {}".format(activation))
+
+
+# ----------------- MULTI-BLOCKS MODELS: -----------------------
+
+
+class CrossTransformerEncoder(nn.Module):
+    def __init__(
+        self,
+        dim: int,
+        emb: str = "sin",
+        hidden_scale: float = 4.0,
+        num_heads: int = 8,
+        num_layers: int = 6,
+        cross_first: bool = False,
+        dropout: float = 0.0,
+        max_positions: int = 1000,
+        norm_in: bool = True,
+        norm_in_group: bool = False,
+        group_norm: int = False,
+        norm_first: bool = False,
+        norm_out: bool = False,
+        max_period: float = 10000.0,
+        weight_decay: float = 0.0,
+        lr: tp.Optional[float] = None,
+        layer_scale: bool = False,
+        gelu: bool = True,
+        sin_random_shift: int = 0,
+        weight_pos_embed: float = 1.0,
+        cape_mean_normalize: bool = True,
+        cape_augment: bool = True,
+        cape_glob_loc_scale: list = [5000.0, 1.0, 1.4],
+        sparse_self_attn: bool = False,
+        sparse_cross_attn: bool = False,
+        mask_type: str = "diag",
+        mask_random_seed: int = 42,
+        sparse_attn_window: int = 500,
+        global_window: int = 50,
+        auto_sparsity: bool = False,
+        sparsity: float = 0.95,
+    ):
+        super().__init__()
+        """
+        """
+        assert dim % num_heads == 0
+
+        hidden_dim = int(dim * hidden_scale)
+
+        self.num_layers = num_layers
+        # classic parity = 1 means that if idx%2 == 1 there is a
+        # classical encoder else there is a cross encoder
+        self.classic_parity = 1 if cross_first else 0
+        self.emb = emb
+        self.max_period = max_period
+        self.weight_decay = weight_decay
+        self.weight_pos_embed = weight_pos_embed
+        self.sin_random_shift = sin_random_shift
+        if emb == "cape":
+            self.cape_mean_normalize = cape_mean_normalize
+            self.cape_augment = cape_augment
+            self.cape_glob_loc_scale = cape_glob_loc_scale
+        if emb == "scaled":
+            self.position_embeddings = ScaledEmbedding(max_positions, dim, scale=0.2)
+
+        self.lr = lr
+
+        activation: tp.Any = F.gelu if gelu else F.relu
+
+        self.norm_in: nn.Module
+        self.norm_in_t: nn.Module
+        if norm_in:
+            self.norm_in = nn.LayerNorm(dim)
+            self.norm_in_t = nn.LayerNorm(dim)
+        elif norm_in_group:
+            self.norm_in = MyGroupNorm(int(norm_in_group), dim)
+            self.norm_in_t = MyGroupNorm(int(norm_in_group), dim)
+        else:
+            self.norm_in = nn.Identity()
+            self.norm_in_t = nn.Identity()
+
+        # spectrogram layers
+        self.layers = nn.ModuleList()
+        # temporal layers
+        self.layers_t = nn.ModuleList()
+
+        kwargs_common = {
+            "d_model": dim,
+            "nhead": num_heads,
+            "dim_feedforward": hidden_dim,
+            "dropout": dropout,
+            "activation": activation,
+            "group_norm": group_norm,
+            "norm_first": norm_first,
+            "norm_out": norm_out,
+            "layer_scale": layer_scale,
+            "mask_type": mask_type,
+            "mask_random_seed": mask_random_seed,
+            "sparse_attn_window": sparse_attn_window,
+            "global_window": global_window,
+            "sparsity": sparsity,
+            "auto_sparsity": auto_sparsity,
+            "batch_first": True,
+        }
+
+        kwargs_classic_encoder = dict(kwargs_common)
+        kwargs_classic_encoder.update({
+            "sparse": sparse_self_attn,
+        })
+        kwargs_cross_encoder = dict(kwargs_common)
+        kwargs_cross_encoder.update({
+            "sparse": sparse_cross_attn,
+        })
+
+        for idx in range(num_layers):
+            if idx % 2 == self.classic_parity:
+
+                self.layers.append(MyTransformerEncoderLayer(**kwargs_classic_encoder))
+                self.layers_t.append(
+                    MyTransformerEncoderLayer(**kwargs_classic_encoder)
+                )
+
+            else:
+                self.layers.append(CrossTransformerEncoderLayer(**kwargs_cross_encoder))
+
+                self.layers_t.append(
+                    CrossTransformerEncoderLayer(**kwargs_cross_encoder)
+                )
+
+    def forward(self, x, xt):
+        B, C, Fr, T1 = x.shape
+        pos_emb_2d = create_2d_sin_embedding(
+            C, Fr, T1, x.device, self.max_period
+        )  # (1, C, Fr, T1)
+        pos_emb_2d = rearrange(pos_emb_2d, "b c fr t1 -> b (t1 fr) c")
+        x = rearrange(x, "b c fr t1 -> b (t1 fr) c")
+        x = self.norm_in(x)
+        x = x + self.weight_pos_embed * pos_emb_2d
+
+        B, C, T2 = xt.shape
+        xt = rearrange(xt, "b c t2 -> b t2 c")  # now T2, B, C
+        pos_emb = self._get_pos_embedding(T2, B, C, x.device)
+        pos_emb = rearrange(pos_emb, "t2 b c -> b t2 c")
+        xt = self.norm_in_t(xt)
+        xt = xt + self.weight_pos_embed * pos_emb
+
+        for idx in range(self.num_layers):
+            if idx % 2 == self.classic_parity:
+                x = self.layers[idx](x)
+                xt = self.layers_t[idx](xt)
+            else:
+                old_x = x
+                x = self.layers[idx](x, xt)
+                xt = self.layers_t[idx](xt, old_x)
+
+        x = rearrange(x, "b (t1 fr) c -> b c fr t1", t1=T1)
+        xt = rearrange(xt, "b t2 c -> b c t2")
+        return x, xt
+
+    def _get_pos_embedding(self, T, B, C, device):
+        if self.emb == "sin":
+            shift = random.randrange(self.sin_random_shift + 1)
+            pos_emb = create_sin_embedding(
+                T, C, shift=shift, device=device, max_period=self.max_period
+            )
+        elif self.emb == "cape":
+            if self.training:
+                pos_emb = create_sin_embedding_cape(
+                    T,
+                    C,
+                    B,
+                    device=device,
+                    max_period=self.max_period,
+                    mean_normalize=self.cape_mean_normalize,
+                    augment=self.cape_augment,
+                    max_global_shift=self.cape_glob_loc_scale[0],
+                    max_local_shift=self.cape_glob_loc_scale[1],
+                    max_scale=self.cape_glob_loc_scale[2],
+                )
+            else:
+                pos_emb = create_sin_embedding_cape(
+                    T,
+                    C,
+                    B,
+                    device=device,
+                    max_period=self.max_period,
+                    mean_normalize=self.cape_mean_normalize,
+                    augment=False,
+                )
+
+        elif self.emb == "scaled":
+            pos = torch.arange(T, device=device)
+            pos_emb = self.position_embeddings(pos)[:, None]
+
+        return pos_emb
+
+    def make_optim_group(self):
+        group = {"params": list(self.parameters()), "weight_decay": self.weight_decay}
+        if self.lr is not None:
+            group["lr"] = self.lr
+        return group
+
+
+# Attention Modules
+
+
+class MultiheadAttention(nn.Module):
+    def __init__(
+        self,
+        embed_dim,
+        num_heads,
+        dropout=0.0,
+        bias=True,
+        add_bias_kv=False,
+        add_zero_attn=False,
+        kdim=None,
+        vdim=None,
+        batch_first=False,
+        auto_sparsity=None,
+    ):
+        super().__init__()
+        assert auto_sparsity is not None, "sanity check"
+        self.num_heads = num_heads
+        self.q = torch.nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.k = torch.nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.v = torch.nn.Linear(embed_dim, embed_dim, bias=bias)
+        self.attn_drop = torch.nn.Dropout(dropout)
+        self.proj = torch.nn.Linear(embed_dim, embed_dim, bias)
+        self.proj_drop = torch.nn.Dropout(dropout)
+        self.batch_first = batch_first
+        self.auto_sparsity = auto_sparsity
+
+    def forward(
+        self,
+        query,
+        key,
+        value,
+        key_padding_mask=None,
+        need_weights=True,
+        attn_mask=None,
+        average_attn_weights=True,
+    ):
+
+        if not self.batch_first:  # N, B, C
+            query = query.permute(1, 0, 2)  # B, N_q, C
+            key = key.permute(1, 0, 2)  # B, N_k, C
+            value = value.permute(1, 0, 2)  # B, N_k, C
+        B, N_q, C = query.shape
+        B, N_k, C = key.shape
+
+        q = (
+            self.q(query)
+            .reshape(B, N_q, self.num_heads, C // self.num_heads)
+            .permute(0, 2, 1, 3)
+        )
+        q = q.flatten(0, 1)
+        k = (
+            self.k(key)
+            .reshape(B, N_k, self.num_heads, C // self.num_heads)
+            .permute(0, 2, 1, 3)
+        )
+        k = k.flatten(0, 1)
+        v = (
+            self.v(value)
+            .reshape(B, N_k, self.num_heads, C // self.num_heads)
+            .permute(0, 2, 1, 3)
+        )
+        v = v.flatten(0, 1)
+
+        if self.auto_sparsity:
+            assert attn_mask is None
+            x = dynamic_sparse_attention(q, k, v, sparsity=self.auto_sparsity)
+        else:
+            x = scaled_dot_product_attention(q, k, v, attn_mask, dropout=self.attn_drop)
+        x = x.reshape(B, self.num_heads, N_q, C // self.num_heads)
+
+        x = x.transpose(1, 2).reshape(B, N_q, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        if not self.batch_first:
+            x = x.permute(1, 0, 2)
+        return x, None
+
+
+def scaled_query_key_softmax(q, k, att_mask):
+    from xformers.ops import masked_matmul
+    q = q / (k.size(-1)) ** 0.5
+    att = masked_matmul(q, k.transpose(-2, -1), att_mask)
+    att = torch.nn.functional.softmax(att, -1)
+    return att
+
+
+def scaled_dot_product_attention(q, k, v, att_mask, dropout):
+    att = scaled_query_key_softmax(q, k, att_mask=att_mask)
+    att = dropout(att)
+    y = att @ v
+    return y
+
+
+def _compute_buckets(x, R):
+    qq = torch.einsum('btf,bfhi->bhti', x, R)
+    qq = torch.cat([qq, -qq], dim=-1)
+    buckets = qq.argmax(dim=-1)
+
+    return buckets.permute(0, 2, 1).byte().contiguous()
+
+
+def dynamic_sparse_attention(query, key, value, sparsity, infer_sparsity=True, attn_bias=None):
+    # assert False, "The code for the custom sparse kernel is not ready for release yet."
+    from xformers.ops import find_locations, sparse_memory_efficient_attention
+    n_hashes = 32
+    proj_size = 4
+    query, key, value = [x.contiguous() for x in [query, key, value]]
+    with torch.no_grad():
+        R = torch.randn(1, query.shape[-1], n_hashes, proj_size // 2, device=query.device)
+        bucket_query = _compute_buckets(query, R)
+        bucket_key = _compute_buckets(key, R)
+        row_offsets, column_indices = find_locations(
+            bucket_query, bucket_key, sparsity, infer_sparsity)
+    return sparse_memory_efficient_attention(
+        query, key, value, row_offsets, column_indices, attn_bias)

MVSEP-MDX23-music-separation-model/demucs3/utils.py

@@ -0,0 +1,141 @@
+# Copyright (c) Meta, Inc. and its affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+from collections import defaultdict
+from contextlib import contextmanager
+import math
+import os
+import tempfile
+import typing as tp
+
+import torch
+from torch.nn import functional as F
+from torch.utils.data import Subset
+
+
+def unfold(a, kernel_size, stride):
+    """Given input of size [*OT, T], output Tensor of size [*OT, F, K]
+    with K the kernel size, by extracting frames with the given stride.
+
+    This will pad the input so that `F = ceil(T / K)`.
+
+    see https://github.com/pytorch/pytorch/issues/60466
+    """
+    *shape, length = a.shape
+    n_frames = math.ceil(length / stride)
+    tgt_length = (n_frames - 1) * stride + kernel_size
+    a = F.pad(a, (0, tgt_length - length))
+    strides = list(a.stride())
+    assert strides[-1] == 1, 'data should be contiguous'
+    strides = strides[:-1] + [stride, 1]
+    return a.as_strided([*shape, n_frames, kernel_size], strides)
+
+
+def center_trim(tensor: torch.Tensor, reference: tp.Union[torch.Tensor, int]):
+    """
+    Center trim `tensor` with respect to `reference`, along the last dimension.
+    `reference` can also be a number, representing the length to trim to.
+    If the size difference != 0 mod 2, the extra sample is removed on the right side.
+    """
+    ref_size: int
+    if isinstance(reference, torch.Tensor):
+        ref_size = reference.size(-1)
+    else:
+        ref_size = reference
+    delta = tensor.size(-1) - ref_size
+    if delta < 0:
+        raise ValueError("tensor must be larger than reference. " f"Delta is {delta}.")
+    if delta:
+        tensor = tensor[..., delta // 2:-(delta - delta // 2)]
+    return tensor
+
+
+def pull_metric(history: tp.List[dict], name: str):
+    out = []
+    for metrics in history:
+        metric = metrics
+        for part in name.split("."):
+            metric = metric[part]
+        out.append(metric)
+    return out
+
+
+def EMA(beta: float = 1):
+    """
+    Exponential Moving Average callback.
+    Returns a single function that can be called to repeatidly update the EMA
+    with a dict of metrics. The callback will return
+    the new averaged dict of metrics.
+
+    Note that for `beta=1`, this is just plain averaging.
+    """
+    fix: tp.Dict[str, float] = defaultdict(float)
+    total: tp.Dict[str, float] = defaultdict(float)
+
+    def _update(metrics: dict, weight: float = 1) -> dict:
+        nonlocal total, fix
+        for key, value in metrics.items():
+            total[key] = total[key] * beta + weight * float(value)
+            fix[key] = fix[key] * beta + weight
+        return {key: tot / fix[key] for key, tot in total.items()}
+    return _update
+
+
+def sizeof_fmt(num: float, suffix: str = 'B'):
+    """
+    Given `num` bytes, return human readable size.
+    Taken from https://stackoverflow.com/a/1094933
+    """
+    for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
+        if abs(num) < 1024.0:
+            return "%3.1f%s%s" % (num, unit, suffix)
+        num /= 1024.0
+    return "%.1f%s%s" % (num, 'Yi', suffix)
+
+
+@contextmanager
+def temp_filenames(count: int, delete=True):
+    names = []
+    try:
+        for _ in range(count):
+            names.append(tempfile.NamedTemporaryFile(delete=False).name)
+        yield names
+    finally:
+        if delete:
+            for name in names:
+                os.unlink(name)
+
+
+def random_subset(dataset, max_samples: int, seed: int = 42):
+    if max_samples >= len(dataset):
+        return dataset
+
+    generator = torch.Generator().manual_seed(seed)
+    perm = torch.randperm(len(dataset), generator=generator)
+    return Subset(dataset, perm[:max_samples].tolist())
+
+
+class DummyPoolExecutor:
+    class DummyResult:
+        def __init__(self, func, *args, **kwargs):
+            self.func = func
+            self.args = args
+            self.kwargs = kwargs
+
+        def result(self):
+            return self.func(*self.args, **self.kwargs)
+
+    def __init__(self, workers=0):
+        pass
+
+    def submit(self, func, *args, **kwargs):
+        return DummyPoolExecutor.DummyResult(func, *args, **kwargs)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        return

MVSEP-MDX23-music-separation-model/gui.py

@@ -0,0 +1,411 @@
+# coding: utf-8
+__author__ = 'Roman Solovyev (ZFTurbo), IPPM RAS'
+
+if __name__ == '__main__':
+    import os
+
+    gpu_use = "0"
+    print('GPU use: {}'.format(gpu_use))
+    os.environ["CUDA_VISIBLE_DEVICES"] = "{}".format(gpu_use)
+
+import time
+import os
+import numpy as np
+from PyQt5.QtCore import *
+from PyQt5 import QtCore
+from PyQt5.QtWidgets import *
+from PyQt5.QtGui import *
+import sys
+from inference import predict_with_model, __VERSION__
+import torch
+
+
+root = dict()
+
+
+class Worker(QObject):
+    finished = pyqtSignal()
+    progress = pyqtSignal(int)
+
+    def __init__(self, options):
+        super().__init__()
+        self.options = options
+
+    def run(self):
+        global root
+        # Here we pass the update_progress (uncalled!)
+        self.options['update_percent_func'] = self.update_progress
+        predict_with_model(self.options)
+        root['button_start'].setDisabled(False)
+        root['button_finish'].setDisabled(True)
+        root['start_proc'] = False
+        self.finished.emit()
+
+    def update_progress(self, percent):
+        self.progress.emit(percent)
+
+
+class Ui_Dialog(object):
+    def setupUi(self, Dialog):
+        global root
+
+        Dialog.setObjectName("Settings")
+        Dialog.resize(370, 320)
+
+        self.checkbox_cpu = QCheckBox("Use CPU instead of GPU?", Dialog)
+        self.checkbox_cpu.move(30, 10)
+        self.checkbox_cpu.resize(320, 40)
+        if root['cpu']:
+            self.checkbox_cpu.setChecked(True)
+
+        self.checkbox_single_onnx = QCheckBox("Use single ONNX?", Dialog)
+        self.checkbox_single_onnx.move(30, 40)
+        self.checkbox_single_onnx.resize(320, 40)
+        if root['single_onnx']:
+            self.checkbox_single_onnx.setChecked(True)
+
+        self.checkbox_large_gpu = QCheckBox("Use large GPU?", Dialog)
+        self.checkbox_large_gpu.move(30, 70)
+        self.checkbox_large_gpu.resize(320, 40)
+        if root['large_gpu']:
+            self.checkbox_large_gpu.setChecked(True)
+
+        self.checkbox_kim_1 = QCheckBox("Use old Kim Vocal model?", Dialog)
+        self.checkbox_kim_1.move(30, 100)
+        self.checkbox_kim_1.resize(320, 40)
+        if root['use_kim_model_1']:
+            self.checkbox_kim_1.setChecked(True)
+
+        self.checkbox_only_vocals = QCheckBox("Generate only vocals/instrumental?", Dialog)
+        self.checkbox_only_vocals.move(30, 130)
+        self.checkbox_only_vocals.resize(320, 40)
+        if root['only_vocals']:
+            self.checkbox_only_vocals.setChecked(True)
+
+        self.chunk_size_label = QLabel(Dialog)
+        self.chunk_size_label.setText('Chunk size')
+        self.chunk_size_label.move(30, 160)
+        self.chunk_size_label.resize(320, 40)
+
+        self.chunk_size_valid = QIntValidator(bottom=100000, top=10000000)
+        self.chunk_size = QLineEdit(Dialog)
+        self.chunk_size.setFixedWidth(140)
+        self.chunk_size.move(130, 170)
+        self.chunk_size.setValidator(self.chunk_size_valid)
+        self.chunk_size.setText(str(root['chunk_size']))
+
+        self.overlap_large_label = QLabel(Dialog)
+        self.overlap_large_label.setText('Overlap large')
+        self.overlap_large_label.move(30, 190)
+        self.overlap_large_label.resize(320, 40)
+
+        self.overlap_large_valid = QDoubleValidator(bottom=0.001, top=0.999, decimals=10)
+        self.overlap_large_valid.setNotation(QDoubleValidator.Notation.StandardNotation)
+        self.overlap_large = QLineEdit(Dialog)
+        self.overlap_large.setFixedWidth(140)
+        self.overlap_large.move(130, 200)
+        self.overlap_large.setValidator(self.overlap_large_valid)
+        self.overlap_large.setText(str(root['overlap_large']))
+
+        self.overlap_small_label = QLabel(Dialog)
+        self.overlap_small_label.setText('Overlap small')
+        self.overlap_small_label.move(30, 220)
+        self.overlap_small_label.resize(320, 40)
+
+        self.overlap_small_valid = QDoubleValidator(0.001, 0.999, 10)
+        self.overlap_small_valid.setNotation(QDoubleValidator.Notation.StandardNotation)
+        self.overlap_small = QLineEdit(Dialog)
+        self.overlap_small.setFixedWidth(140)
+        self.overlap_small.move(130, 230)
+        self.overlap_small.setValidator(self.overlap_small_valid)
+        self.overlap_small.setText(str(root['overlap_small']))
+
+        self.pushButton_save = QPushButton(Dialog)
+        self.pushButton_save.setObjectName("pushButton_save")
+        self.pushButton_save.move(30, 280)
+        self.pushButton_save.resize(150, 35)
+
+        self.pushButton_cancel = QPushButton(Dialog)
+        self.pushButton_cancel.setObjectName("pushButton_cancel")
+        self.pushButton_cancel.move(190, 280)
+        self.pushButton_cancel.resize(150, 35)
+
+        self.retranslateUi(Dialog)
+        QtCore.QMetaObject.connectSlotsByName(Dialog)
+        self.Dialog = Dialog
+
+        # connect the two functions
+        self.pushButton_save.clicked.connect(self.return_save)
+        self.pushButton_cancel.clicked.connect(self.return_cancel)
+
+    def retranslateUi(self, Dialog):
+        _translate = QtCore.QCoreApplication.translate
+        Dialog.setWindowTitle(_translate("Settings", "Settings"))
+        self.pushButton_cancel.setText(_translate("Settings", "Cancel"))
+        self.pushButton_save.setText(_translate("Settings", "Save settings"))
+
+    def return_save(self):
+        global root
+        # print("save")
+        root['cpu'] = self.checkbox_cpu.isChecked()
+        root['single_onnx'] = self.checkbox_single_onnx.isChecked()
+        root['large_gpu'] = self.checkbox_large_gpu.isChecked()
+        root['use_kim_model_1'] = self.checkbox_kim_1.isChecked()
+        root['only_vocals'] = self.checkbox_only_vocals.isChecked()
+
+        chunk_size_text = self.chunk_size.text()
+        state = self.chunk_size_valid.validate(chunk_size_text, 0)
+        if state[0] == QValidator.State.Acceptable:
+            root['chunk_size'] = chunk_size_text
+
+        overlap_large_text = self.overlap_large.text()
+        # locale problems... it wants comma instead of dot
+        if 0:
+            state = self.overlap_large_valid.validate(overlap_large_text, 0)
+            if state[0] == QValidator.State.Acceptable:
+                root['overlap_large'] = float(overlap_large_text)
+        else:
+            root['overlap_large'] = float(overlap_large_text)
+
+        overlap_small_text = self.overlap_small.text()
+        if 0:
+            state = self.overlap_small_valid.validate(overlap_small_text, 0)
+            if state[0] == QValidator.State.Acceptable:
+                root['overlap_small'] = float(overlap_small_text)
+        else:
+            root['overlap_small'] = float(overlap_small_text)
+
+        self.Dialog.close()
+
+    def return_cancel(self):
+        global root
+        # print("cancel")
+        self.Dialog.close()
+
+
+class MyWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.initUI()
+
+    def initUI(self):
+        self.resize(560, 360)
+        self.move(300, 300)
+        self.setWindowTitle('MVSEP music separation model')
+        self.setAcceptDrops(True)
+
+    def dragEnterEvent(self, event):
+        if event.mimeData().hasUrls():
+            event.accept()
+        else:
+            event.ignore()
+
+    def dropEvent(self, event):
+        global root
+        files = [u.toLocalFile() for u in event.mimeData().urls()]
+        txt = ''
+        root['input_files'] = []
+        for f in files:
+            root['input_files'].append(f)
+            txt += f + '\n'
+        root['input_files_list_text_area'].insertPlainText(txt)
+        root['progress_bar'].setValue(0)
+
+    def execute_long_task(self):
+        global root
+
+        if len(root['input_files']) == 0 and 1:
+            QMessageBox.about(root['w'], "Error", "No input files specified!")
+            return
+
+        root['progress_bar'].show()
+        root['button_start'].setDisabled(True)
+        root['button_finish'].setDisabled(False)
+        root['start_proc'] = True
+
+        options = {
+            'input_audio': root['input_files'],
+            'output_folder': root['output_folder'],
+            'cpu': root['cpu'],
+            'single_onnx': root['single_onnx'],
+            'large_gpu': root['large_gpu'],
+            'chunk_size': root['chunk_size'],
+            'overlap_large': root['overlap_large'],
+            'overlap_small': root['overlap_small'],
+            'use_kim_model_1': root['use_kim_model_1'],
+            'only_vocals': root['only_vocals'],
+        }
+
+        self.update_progress(0)
+        self.thread = QThread()
+        self.worker = Worker(options)
+        self.worker.moveToThread(self.thread)
+
+        self.thread.started.connect(self.worker.run)
+        self.worker.finished.connect(self.thread.quit)
+        self.worker.finished.connect(self.worker.deleteLater)
+        self.thread.finished.connect(self.thread.deleteLater)
+        self.worker.progress.connect(self.update_progress)
+
+        self.thread.start()
+
+    def stop_separation(self):
+        global root
+        self.thread.terminate()
+        root['button_start'].setDisabled(False)
+        root['button_finish'].setDisabled(True)
+        root['start_proc'] = False
+        root['progress_bar'].hide()
+
+    def update_progress(self, progress):
+        global root
+        root['progress_bar'].setValue(progress)
+
+    def open_settings(self):
+        global root
+        dialog = QDialog()
+        dialog.ui = Ui_Dialog()
+        dialog.ui.setupUi(dialog)
+        dialog.exec_()
+
+
+def dialog_select_input_files():
+    global root
+    files, _ = QFileDialog.getOpenFileNames(
+        None,
+        "QFileDialog.getOpenFileNames()",
+        "",
+        "All Files (*);;Audio Files (*.wav, *.mp3, *.flac)",
+    )
+    if files:
+        txt = ''
+        root['input_files'] = []
+        for f in files:
+            root['input_files'].append(f)
+            txt += f + '\n'
+        root['input_files_list_text_area'].insertPlainText(txt)
+        root['progress_bar'].setValue(0)
+    return files
+
+
+def dialog_select_output_folder():
+    global root
+    foldername = QFileDialog.getExistingDirectory(
+        None,
+        "Select Directory"
+    )
+    root['output_folder'] = foldername + '/'
+    root['output_folder_line_edit'].setText(root['output_folder'])
+    return foldername
+
+
+def create_dialog():
+    global root
+    app = QApplication(sys.argv)
+
+    w = MyWidget()
+
+    root['input_files'] = []
+    root['output_folder'] = os.path.dirname(os.path.abspath(__file__)) + '/results/'
+    root['cpu'] = False
+    root['large_gpu'] = False
+    root['single_onnx'] = False
+    root['chunk_size'] = 1000000
+    root['overlap_large'] = 0.6
+    root['overlap_small'] = 0.5
+    root['use_kim_model_1'] = False
+    root['only_vocals'] = False
+
+    t = torch.cuda.get_device_properties(0).total_memory / (1024 * 1024 * 1024)
+    if t > 11.5:
+        print('You have enough GPU memory ({:.2f} GB), so we set fast GPU mode. You can change in settings!'.format(t))
+        root['large_gpu'] = True
+        root['single_onnx'] = False
+    elif t < 8:
+        root['large_gpu'] = False
+        root['single_onnx'] = True
+        root['chunk_size'] = 500000
+
+    button_select_input_files = QPushButton(w)
+    button_select_input_files.setText("Input audio files")
+    button_select_input_files.clicked.connect(dialog_select_input_files)
+    button_select_input_files.setFixedHeight(35)
+    button_select_input_files.setFixedWidth(150)
+    button_select_input_files.move(30, 20)
+
+    input_files_list_text_area = QTextEdit(w)
+    input_files_list_text_area.setReadOnly(True)
+    input_files_list_text_area.setLineWrapMode(QTextEdit.NoWrap)
+    font = input_files_list_text_area.font()
+    font.setFamily("Courier")
+    font.setPointSize(10)
+    input_files_list_text_area.move(30, 60)
+    input_files_list_text_area.resize(500, 100)
+
+    button_select_output_folder = QPushButton(w)
+    button_select_output_folder.setText("Output folder")
+    button_select_output_folder.setFixedHeight(35)
+    button_select_output_folder.setFixedWidth(150)
+    button_select_output_folder.clicked.connect(dialog_select_output_folder)
+    button_select_output_folder.move(30, 180)
+
+    output_folder_line_edit = QLineEdit(w)
+    output_folder_line_edit.setReadOnly(True)
+    font = output_folder_line_edit.font()
+    font.setFamily("Courier")
+    font.setPointSize(10)
+    output_folder_line_edit.move(30, 220)
+    output_folder_line_edit.setFixedWidth(500)
+    output_folder_line_edit.setText(root['output_folder'])
+
+    progress_bar = QProgressBar(w)
+    # progress_bar.move(30, 310)
+    progress_bar.setValue(0)
+    progress_bar.setGeometry(30, 310, 500, 35)
+    progress_bar.setAlignment(QtCore.Qt.AlignCenter)
+    progress_bar.hide()
+    root['progress_bar'] = progress_bar
+
+    button_start = QPushButton('Start separation', w)
+    button_start.clicked.connect(w.execute_long_task)
+    button_start.setFixedHeight(35)
+    button_start.setFixedWidth(150)
+    button_start.move(30, 270)
+
+    button_finish = QPushButton('Stop separation', w)
+    button_finish.clicked.connect(w.stop_separation)
+    button_finish.setFixedHeight(35)
+    button_finish.setFixedWidth(150)
+    button_finish.move(200, 270)
+    button_finish.setDisabled(True)
+
+    button_settings = QPushButton('⚙', w)
+    button_settings.clicked.connect(w.open_settings)
+    button_settings.setFixedHeight(35)
+    button_settings.setFixedWidth(35)
+    button_settings.move(495, 270)
+    button_settings.setDisabled(False)
+
+    mvsep_link = QLabel(w)
+    mvsep_link.setOpenExternalLinks(True)
+    font = mvsep_link.font()
+    font.setFamily("Courier")
+    font.setPointSize(10)
+    mvsep_link.move(415, 30)
+    mvsep_link.setText('Powered by <a href="https://mvsep.com">MVSep.com</a>')
+
+    root['w'] = w
+    root['input_files_list_text_area'] = input_files_list_text_area
+    root['output_folder_line_edit'] = output_folder_line_edit
+    root['button_start'] = button_start
+    root['button_finish'] = button_finish
+    root['button_settings'] = button_settings
+
+    # w.showMaximized()
+    w.show()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    print('Version: {}'.format(__VERSION__))
+    create_dialog()

MVSEP-MDX23-music-separation-model/inference.py

@@ -0,0 +1,914 @@
+# coding: utf-8
+__author__ = 'https://github.com/ZFTurbo/'
+
+if __name__ == '__main__':
+    import os
+
+    gpu_use = "0"
+    print('GPU use: {}'.format(gpu_use))
+    os.environ["CUDA_VISIBLE_DEVICES"] = "{}".format(gpu_use)
+
+
+import numpy as np
+import torch
+import torch.nn as nn
+import os
+import argparse
+import soundfile as sf
+
+from demucs.states import load_model
+from demucs import pretrained
+from demucs.apply import apply_model
+import onnxruntime as ort
+from time import time
+import librosa
+import hashlib
+
+
+__VERSION__ = '1.0.1'
+
+
+class Conv_TDF_net_trim_model(nn.Module):
+    def __init__(self, device, target_name, L, n_fft, hop=1024):
+
+        super(Conv_TDF_net_trim_model, self).__init__()
+
+        self.dim_c = 4
+        self.dim_f, self.dim_t = 3072, 256
+        self.n_fft = n_fft
+        self.hop = hop
+        self.n_bins = self.n_fft // 2 + 1
+        self.chunk_size = hop * (self.dim_t - 1)
+        self.window = torch.hann_window(window_length=self.n_fft, periodic=True).to(device)
+        self.target_name = target_name
+
+        out_c = self.dim_c * 4 if target_name == '*' else self.dim_c
+        self.freq_pad = torch.zeros([1, out_c, self.n_bins - self.dim_f, self.dim_t]).to(device)
+
+        self.n = L // 2
+
+    def stft(self, x):
+        x = x.reshape([-1, self.chunk_size])
+        x = torch.stft(x, n_fft=self.n_fft, hop_length=self.hop, window=self.window, center=True, return_complex=True)
+        x = torch.view_as_real(x)
+        x = x.permute([0, 3, 1, 2])
+        x = x.reshape([-1, 2, 2, self.n_bins, self.dim_t]).reshape([-1, self.dim_c, self.n_bins, self.dim_t])
+        return x[:, :, :self.dim_f]
+
+    def istft(self, x, freq_pad=None):
+        freq_pad = self.freq_pad.repeat([x.shape[0], 1, 1, 1]) if freq_pad is None else freq_pad
+        x = torch.cat([x, freq_pad], -2)
+        x = x.reshape([-1, 2, 2, self.n_bins, self.dim_t]).reshape([-1, 2, self.n_bins, self.dim_t])
+        x = x.permute([0, 2, 3, 1])
+        x = x.contiguous()
+        x = torch.view_as_complex(x)
+        x = torch.istft(x, n_fft=self.n_fft, hop_length=self.hop, window=self.window, center=True)
+        return x.reshape([-1, 2, self.chunk_size])
+
+    def forward(self, x):
+        x = self.first_conv(x)
+        x = x.transpose(-1, -2)
+
+        ds_outputs = []
+        for i in range(self.n):
+            x = self.ds_dense[i](x)
+            ds_outputs.append(x)
+            x = self.ds[i](x)
+
+        x = self.mid_dense(x)
+        for i in range(self.n):
+            x = self.us[i](x)
+            x *= ds_outputs[-i - 1]
+            x = self.us_dense[i](x)
+
+        x = x.transpose(-1, -2)
+        x = self.final_conv(x)
+        return x
+
+
+def get_models(name, device, load=True, vocals_model_type=0):
+    if vocals_model_type == 2:
+        model_vocals = Conv_TDF_net_trim_model(
+            device=device,
+            target_name='vocals',
+            L=11,
+            n_fft=7680
+        )
+    elif vocals_model_type == 3:
+        model_vocals = Conv_TDF_net_trim_model(
+            device=device,
+            target_name='vocals',
+            L=11,
+            n_fft=6144
+        )
+
+    return [model_vocals]
+
+
+def demix_base(mix, device, models, infer_session):
+    start_time = time()
+    sources = []
+    n_sample = mix.shape[1]
+    for model in models:
+        trim = model.n_fft // 2
+        gen_size = model.chunk_size - 2 * trim
+        pad = gen_size - n_sample % gen_size
+        mix_p = np.concatenate(
+            (
+                np.zeros((2, trim)),
+                mix,
+                np.zeros((2, pad)),
+                np.zeros((2, trim))
+            ), 1
+        )
+
+        mix_waves = []
+        i = 0
+        while i < n_sample + pad:
+            waves = np.array(mix_p[:, i:i + model.chunk_size])
+            mix_waves.append(waves)
+            i += gen_size
+        mix_waves = np.array(mix_waves)  # Convert the list to a single numpy.ndarray
+        mix_waves = torch.tensor(mix_waves, dtype=torch.float32).to(device)
+
+    with torch.no_grad():
+        _ort = infer_session
+        stft_res = model.stft(mix_waves)
+        res = _ort.run(None, {'input': stft_res.cpu().numpy()})[0]
+        ten = torch.tensor(res).to(device)  # Move result tensor to device
+        tar_waves = model.istft(ten)  # This operation is performed on the GPU
+        tar_waves = tar_waves.cpu()  # Move the result back to CPU only after all computations
+        tar_signal = tar_waves[:, :, trim:-trim].transpose(0, 1).reshape(2, -1).numpy()[:, :-pad]
+
+        sources.append(tar_signal)
+    # print('Time demix base: {:.2f} sec'.format(time() - start_time))
+    return np.array(sources)
+
+
+def demix_full(mix, device, chunk_size, models, infer_session, overlap=0.75):
+    start_time = time()
+
+    step = int(chunk_size * (1 - overlap))
+    # print('Initial shape: {} Chunk size: {} Step: {} Device: {}'.format(mix.shape, chunk_size, step, device))
+    result = np.zeros((1, 2, mix.shape[-1]), dtype=np.float32)
+    divider = np.zeros((1, 2, mix.shape[-1]), dtype=np.float32)
+
+    total = 0
+    for i in range(0, mix.shape[-1], step):
+        total += 1
+
+        start = i
+        end = min(i + chunk_size, mix.shape[-1])
+        # print('Chunk: {} Start: {} End: {}'.format(total, start, end))
+        mix_part = mix[:, start:end]
+        sources = demix_base(mix_part, device, models, infer_session)
+        # print(sources.shape)
+        result[..., start:end] += sources
+        divider[..., start:end] += 1
+    sources = result / divider
+    # print('Final shape: {} Overall time: {:.2f}'.format(sources.shape, time() - start_time))
+    return sources
+
+
+class EnsembleDemucsMDXMusicSeparationModel:
+    def __init__(self, options):
+        """
+            options - user options
+        """
+        # print(options)
+
+        if torch.cuda.is_available():
+            device = 'cuda:0'
+        else:
+            device = 'cpu'
+        if 'cpu' in options:
+            if options['cpu']:
+                device = 'cpu'
+        print('Use device: {}'.format(device))
+        self.single_onnx = False
+        if 'single_onnx' in options:
+            if options['single_onnx']:
+                self.single_onnx = True
+                print('Use single vocal ONNX')
+
+        self.kim_model_1 = False
+        if 'use_kim_model_1' in options:
+            if options['use_kim_model_1']:
+                self.kim_model_1 = True
+        if self.kim_model_1:
+            print('Use Kim model 1')
+        else:
+            print('Use Kim model 2')
+
+        self.overlap_large = float(options['overlap_large'])
+        self.overlap_small = float(options['overlap_small'])
+        if self.overlap_large > 0.99:
+            self.overlap_large = 0.99
+        if self.overlap_large < 0.0:
+            self.overlap_large = 0.0
+        if self.overlap_small > 0.99:
+            self.overlap_small = 0.99
+        if self.overlap_small < 0.0:
+            self.overlap_small = 0.0
+
+        model_folder = os.path.dirname(os.path.realpath(__file__)) + '/models/'
+        remote_url = 'https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/04573f0d-f3cf25b2.th'
+        model_path = model_folder + '04573f0d-f3cf25b2.th'
+        if not os.path.isfile(model_path):
+            torch.hub.download_url_to_file(remote_url, model_folder + '04573f0d-f3cf25b2.th')
+        model_vocals = load_model(model_path)
+        model_vocals.to(device)
+        self.model_vocals_only = model_vocals
+
+        self.models = []
+        self.weights_vocals = np.array([10, 1, 8, 9])
+        self.weights_bass = np.array([19, 4, 5, 8])
+        self.weights_drums = np.array([18, 2, 4, 9])
+        self.weights_other = np.array([14, 2, 5, 10])
+
+        model1 = pretrained.get_model('htdemucs_ft')
+        model1.to(device)
+        self.models.append(model1)
+
+        model2 = pretrained.get_model('htdemucs')
+        model2.to(device)
+        self.models.append(model2)
+
+        model3 = pretrained.get_model('htdemucs_6s')
+        model3.to(device)
+        self.models.append(model3)
+
+        model4 = pretrained.get_model('hdemucs_mmi')
+        model4.to(device)
+        self.models.append(model4)
+
+        if 0:
+            for model in self.models:
+                print(model.sources)
+        '''
+        ['drums', 'bass', 'other', 'vocals']
+        ['drums', 'bass', 'other', 'vocals']
+        ['drums', 'bass', 'other', 'vocals', 'guitar', 'piano']
+        ['drums', 'bass', 'other', 'vocals']
+        '''
+
+        if device == 'cpu':
+            chunk_size = 200000000
+            providers = ["CPUExecutionProvider"]
+        else:
+            chunk_size = 1000000
+            providers = ["CUDAExecutionProvider"]
+        if 'chunk_size' in options:
+            chunk_size = int(options['chunk_size'])
+
+        # MDX-B model 1 initialization
+        self.chunk_size = chunk_size
+        self.mdx_models1 = get_models('tdf_extra', load=False, device=device, vocals_model_type=2)
+        if self.kim_model_1:
+            model_path_onnx1 = model_folder + 'Kim_Vocal_1.onnx'
+            remote_url_onnx1 = 'https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/Kim_Vocal_1.onnx'
+        else:
+            model_path_onnx1 = model_folder + 'Kim_Vocal_2.onnx'
+            remote_url_onnx1 = 'https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/Kim_Vocal_2.onnx'
+        if not os.path.isfile(model_path_onnx1):
+            torch.hub.download_url_to_file(remote_url_onnx1, model_path_onnx1)
+        print('Model path: {}'.format(model_path_onnx1))
+        print('Device: {} Chunk size: {}'.format(device, chunk_size))
+        self.infer_session1 = ort.InferenceSession(
+            model_path_onnx1,
+            providers=providers,
+            provider_options=[{"device_id": 0}],
+        )
+
+        if self.single_onnx is False:
+            # MDX-B model 2  initialization
+            self.chunk_size = chunk_size
+            self.mdx_models2 = get_models('tdf_extra', load=False, device=device, vocals_model_type=2)
+            root_path = os.path.dirname(os.path.realpath(__file__)) + '/'
+            model_path_onnx2 = model_folder + 'Kim_Inst.onnx'
+            remote_url_onnx2 = 'https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/Kim_Inst.onnx'
+            if not os.path.isfile(model_path_onnx2):
+                torch.hub.download_url_to_file(remote_url_onnx2, model_path_onnx2)
+            print('Model path: {}'.format(model_path_onnx2))
+            print('Device: {} Chunk size: {}'.format(device, chunk_size))
+            self.infer_session2 = ort.InferenceSession(
+                model_path_onnx2,
+                providers=providers,
+                provider_options=[{"device_id": 0}],
+            )
+
+        self.device = device
+        pass
+        
+    @property
+    def instruments(self):
+        """ DO NOT CHANGE """
+        return ['bass', 'drums', 'other', 'vocals']
+
+    def raise_aicrowd_error(self, msg):
+        """ Will be used by the evaluator to provide logs, DO NOT CHANGE """
+        raise NameError(msg)
+    
+    def separate_music_file(
+            self,
+            mixed_sound_array,
+            sample_rate,
+            update_percent_func=None,
+            current_file_number=0,
+            total_files=0,
+            only_vocals=False,
+    ):
+        """
+        Implements the sound separation for a single sound file
+        Inputs: Outputs from soundfile.read('mixture.wav')
+            mixed_sound_array
+            sample_rate
+
+        Outputs:
+            separated_music_arrays: Dictionary numpy array of each separated instrument
+            output_sample_rates: Dictionary of sample rates separated sequence
+        """
+
+        # print('Update percent func: {}'.format(update_percent_func))
+
+        separated_music_arrays = {}
+        output_sample_rates = {}
+
+        audio = np.expand_dims(mixed_sound_array.T, axis=0)
+        audio = torch.from_numpy(audio).type('torch.FloatTensor').to(self.device)
+
+        overlap_large = self.overlap_large
+        overlap_small = self.overlap_small
+
+        # Get Demics vocal only
+        model = self.model_vocals_only
+        shifts = 1
+        overlap = overlap_large
+        vocals_demucs = 0.5 * apply_model(model, audio, shifts=shifts, overlap=overlap)[0][3].cpu().numpy()
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.10) / total_files
+            update_percent_func(int(val))
+
+        vocals_demucs += 0.5 * -apply_model(model, -audio, shifts=shifts, overlap=overlap)[0][3].cpu().numpy()
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.20) / total_files
+            update_percent_func(int(val))
+
+        overlap = overlap_large
+        sources1 = demix_full(
+            mixed_sound_array.T,
+            self.device,
+            self.chunk_size,
+            self.mdx_models1,
+            self.infer_session1,
+            overlap=overlap
+        )[0]
+
+        vocals_mdxb1 = sources1
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.30) / total_files
+            update_percent_func(int(val))
+
+        if self.single_onnx is False:
+            sources2 = -demix_full(
+                -mixed_sound_array.T,
+                self.device,
+                self.chunk_size,
+                self.mdx_models2,
+                self.infer_session2,
+                overlap=overlap
+            )[0]
+
+            # it's instrumental so need to invert
+            instrum_mdxb2 = sources2
+            vocals_mdxb2 = mixed_sound_array.T - instrum_mdxb2
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.40) / total_files
+            update_percent_func(int(val))
+
+        # Ensemble vocals for MDX and Demucs
+        if self.single_onnx is False:
+            weights = np.array([12, 8, 3])
+            vocals = (weights[0] * vocals_mdxb1.T + weights[1] * vocals_mdxb2.T + weights[2] * vocals_demucs.T) / weights.sum()
+        else:
+            weights = np.array([6, 1])
+            vocals = (weights[0] * vocals_mdxb1.T + weights[1] * vocals_demucs.T) / weights.sum()
+
+        # vocals
+        separated_music_arrays['vocals'] = vocals
+        output_sample_rates['vocals'] = sample_rate
+
+        if not only_vocals:
+            # Generate instrumental
+            instrum = mixed_sound_array - vocals
+
+            audio = np.expand_dims(instrum.T, axis=0)
+            audio = torch.from_numpy(audio).type('torch.FloatTensor').to(self.device)
+
+            all_outs = []
+            for i, model in enumerate(self.models):
+                if i == 0:
+                    overlap = overlap_small
+                elif i > 0:
+                    overlap = overlap_large
+                out = 0.5 * apply_model(model, audio, shifts=shifts, overlap=overlap)[0].cpu().numpy() \
+                      + 0.5 * -apply_model(model, -audio, shifts=shifts, overlap=overlap)[0].cpu().numpy()
+
+                if update_percent_func is not None:
+                    val = 100 * (current_file_number + 0.50 + i * 0.10) / total_files
+                    update_percent_func(int(val))
+
+                if i == 2:
+                    # ['drums', 'bass', 'other', 'vocals', 'guitar', 'piano']
+                    out[2] = out[2] + out[4] + out[5]
+                    out = out[:4]
+
+                out[0] = self.weights_drums[i] * out[0]
+                out[1] = self.weights_bass[i] * out[1]
+                out[2] = self.weights_other[i] * out[2]
+                out[3] = self.weights_vocals[i] * out[3]
+
+                all_outs.append(out)
+            out = np.array(all_outs).sum(axis=0)
+            out[0] = out[0] / self.weights_drums.sum()
+            out[1] = out[1] / self.weights_bass.sum()
+            out[2] = out[2] / self.weights_other.sum()
+            out[3] = out[3] / self.weights_vocals.sum()
+
+            # other
+            res = mixed_sound_array - vocals - out[0].T - out[1].T
+            res = np.clip(res, -1, 1)
+            separated_music_arrays['other'] = (2 * res + out[2].T) / 3.0
+            output_sample_rates['other'] = sample_rate
+
+            # drums
+            res = mixed_sound_array - vocals - out[1].T - out[2].T
+            res = np.clip(res, -1, 1)
+            separated_music_arrays['drums'] = (res + 2 * out[0].T.copy()) / 3.0
+            output_sample_rates['drums'] = sample_rate
+
+            # bass
+            res = mixed_sound_array - vocals - out[0].T - out[2].T
+            res = np.clip(res, -1, 1)
+            separated_music_arrays['bass'] = (res + 2 * out[1].T) / 3.0
+            output_sample_rates['bass'] = sample_rate
+
+            bass = separated_music_arrays['bass']
+            drums = separated_music_arrays['drums']
+            other = separated_music_arrays['other']
+
+            separated_music_arrays['other'] = mixed_sound_array - vocals - bass - drums
+            separated_music_arrays['drums'] = mixed_sound_array - vocals - bass - other
+            separated_music_arrays['bass'] = mixed_sound_array - vocals - drums - other
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.95) / total_files
+            update_percent_func(int(val))
+
+        return separated_music_arrays, output_sample_rates
+
+
+class EnsembleDemucsMDXMusicSeparationModelLowGPU:
+    def __init__(self, options):
+        """
+            options - user options
+        """
+        # print(options)
+
+        if torch.cuda.is_available():
+            device = 'cuda:0'
+        else:
+            device = 'cpu'
+        if 'cpu' in options:
+            if options['cpu']:
+                device = 'cpu'
+        print('Use device: {}'.format(device))
+        self.single_onnx = False
+        if 'single_onnx' in options:
+            if options['single_onnx']:
+                self.single_onnx = True
+                print('Use single vocal ONNX')
+
+        self.kim_model_1 = False
+        if 'use_kim_model_1' in options:
+            if options['use_kim_model_1']:
+                self.kim_model_1 = True
+        if self.kim_model_1:
+            print('Use Kim model 1')
+        else:
+            print('Use Kim model 2')
+
+        self.overlap_large = float(options['overlap_large'])
+        self.overlap_small = float(options['overlap_small'])
+        if self.overlap_large > 0.99:
+            self.overlap_large = 0.99
+        if self.overlap_large < 0.0:
+            self.overlap_large = 0.0
+        if self.overlap_small > 0.99:
+            self.overlap_small = 0.99
+        if self.overlap_small < 0.0:
+            self.overlap_small = 0.0
+
+        self.weights_vocals = np.array([10, 1, 8, 9])
+        self.weights_bass = np.array([19, 4, 5, 8])
+        self.weights_drums = np.array([18, 2, 4, 9])
+        self.weights_other = np.array([14, 2, 5, 10])
+
+        if device == 'cpu':
+            chunk_size = 200000000
+            self.providers = ["CPUExecutionProvider"]
+        else:
+            chunk_size = 1000000
+            self.providers = ["CUDAExecutionProvider"]
+        if 'chunk_size' in options:
+            chunk_size = int(options['chunk_size'])
+        self.chunk_size = chunk_size
+        self.device = device
+        pass
+
+    @property
+    def instruments(self):
+        """ DO NOT CHANGE """
+        return ['bass', 'drums', 'other', 'vocals']
+
+    def raise_aicrowd_error(self, msg):
+        """ Will be used by the evaluator to provide logs, DO NOT CHANGE """
+        raise NameError(msg)
+
+    def separate_music_file(
+            self,
+            mixed_sound_array,
+            sample_rate,
+            update_percent_func=None,
+            current_file_number=0,
+            total_files=0,
+            only_vocals=False
+    ):
+        """
+        Implements the sound separation for a single sound file
+        Inputs: Outputs from soundfile.read('mixture.wav')
+            mixed_sound_array
+            sample_rate
+
+        Outputs:
+            separated_music_arrays: Dictionary numpy array of each separated instrument
+            output_sample_rates: Dictionary of sample rates separated sequence
+        """
+
+        # print('Update percent func: {}'.format(update_percent_func))
+
+        separated_music_arrays = {}
+        output_sample_rates = {}
+
+        audio = np.expand_dims(mixed_sound_array.T, axis=0)
+        audio = torch.from_numpy(audio).type('torch.FloatTensor').to(self.device)
+
+        overlap_large = self.overlap_large
+        overlap_small = self.overlap_small
+
+        # Get Demucs vocal only
+        model_folder = os.path.dirname(os.path.realpath(__file__)) + '/models/'
+        remote_url = 'https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/04573f0d-f3cf25b2.th'
+        model_path = model_folder + '04573f0d-f3cf25b2.th'
+        if not os.path.isfile(model_path):
+            torch.hub.download_url_to_file(remote_url, model_folder + '04573f0d-f3cf25b2.th')
+        model_vocals = load_model(model_path)
+        model_vocals.to(self.device)
+        shifts = 1
+        overlap = overlap_large
+        vocals_demucs = 0.5 * apply_model(model_vocals, audio, shifts=shifts, overlap=overlap)[0][3].cpu().numpy()
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.10) / total_files
+            update_percent_func(int(val))
+
+        vocals_demucs += 0.5 * -apply_model(model_vocals, -audio, shifts=shifts, overlap=overlap)[0][3].cpu().numpy()
+        model_vocals = model_vocals.cpu()
+        del model_vocals
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.20) / total_files
+            update_percent_func(int(val))
+
+        # MDX-B model 1 initialization
+        mdx_models1 = get_models('tdf_extra', load=False, device=self.device, vocals_model_type=2)
+        if self.kim_model_1:
+            model_path_onnx1 = model_folder + 'Kim_Vocal_1.onnx'
+            remote_url_onnx1 = 'https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/Kim_Vocal_1.onnx'
+        else:
+            model_path_onnx1 = model_folder + 'Kim_Vocal_2.onnx'
+            remote_url_onnx1 = 'https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/Kim_Vocal_2.onnx'
+        if not os.path.isfile(model_path_onnx1):
+            torch.hub.download_url_to_file(remote_url_onnx1, model_path_onnx1)
+        print('Model path: {}'.format(model_path_onnx1))
+        print('Device: {} Chunk size: {}'.format(self.device, self.chunk_size))
+        infer_session1 = ort.InferenceSession(
+            model_path_onnx1,
+            providers=self.providers,
+            provider_options=[{"device_id": 0}],
+        )
+        overlap = overlap_large
+        sources1 = demix_full(
+            mixed_sound_array.T,
+            self.device,
+            self.chunk_size,
+            mdx_models1,
+            infer_session1,
+            overlap=overlap
+        )[0]
+        vocals_mdxb1 = sources1
+        del infer_session1
+        del mdx_models1
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.30) / total_files
+            update_percent_func(int(val))
+
+        if self.single_onnx is False:
+            # MDX-B model 2  initialization
+            mdx_models2 = get_models('tdf_extra', load=False, device=self.device, vocals_model_type=2)
+            root_path = os.path.dirname(os.path.realpath(__file__)) + '/'
+            model_path_onnx2 = model_folder + 'Kim_Inst.onnx'
+            remote_url_onnx2 = 'https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/Kim_Inst.onnx'
+            if not os.path.isfile(model_path_onnx2):
+                torch.hub.download_url_to_file(remote_url_onnx2, model_path_onnx2)
+            print('Model path: {}'.format(model_path_onnx2))
+            print('Device: {} Chunk size: {}'.format(self.device, self.chunk_size))
+            infer_session2 = ort.InferenceSession(
+                model_path_onnx2,
+                providers=self.providers,
+                provider_options=[{"device_id": 0}],
+            )
+
+            overlap = overlap_large
+            sources2 = -demix_full(
+                -mixed_sound_array.T,
+                self.device,
+                self.chunk_size,
+                mdx_models2,
+                infer_session2,
+                overlap=overlap
+            )[0]
+
+            # it's instrumental so need to invert
+            instrum_mdxb2 = sources2
+            vocals_mdxb2 = mixed_sound_array.T - instrum_mdxb2
+            del infer_session2
+            del mdx_models2
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.40) / total_files
+            update_percent_func(int(val))
+
+        # Ensemble vocals for MDX and Demucs
+        if self.single_onnx is False:
+            weights = np.array([12, 8, 3])
+            vocals = (weights[0] * vocals_mdxb1.T + weights[1] * vocals_mdxb2.T + weights[2] * vocals_demucs.T) / weights.sum()
+        else:
+            weights = np.array([6, 1])
+            vocals = (weights[0] * vocals_mdxb1.T + weights[1] * vocals_demucs.T) / weights.sum()
+
+        # Generate instrumental
+        instrum = mixed_sound_array - vocals
+
+        audio = np.expand_dims(instrum.T, axis=0)
+        audio = torch.from_numpy(audio).type('torch.FloatTensor').to(self.device)
+
+        all_outs = []
+
+        i = 0
+        overlap = overlap_small
+        model = pretrained.get_model('htdemucs_ft')
+        model.to(self.device)
+        out = 0.5 * apply_model(model, audio, shifts=shifts, overlap=overlap)[0].cpu().numpy() \
+              + 0.5 * -apply_model(model, -audio, shifts=shifts, overlap=overlap)[0].cpu().numpy()
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.50 + i * 0.10) / total_files
+            update_percent_func(int(val))
+
+        out[0] = self.weights_drums[i] * out[0]
+        out[1] = self.weights_bass[i] * out[1]
+        out[2] = self.weights_other[i] * out[2]
+        out[3] = self.weights_vocals[i] * out[3]
+        all_outs.append(out)
+        model = model.cpu()
+        del model
+
+        i = 1
+        overlap = overlap_large
+        model = pretrained.get_model('htdemucs')
+        model.to(self.device)
+        out = 0.5 * apply_model(model, audio, shifts=shifts, overlap=overlap)[0].cpu().numpy() \
+              + 0.5 * -apply_model(model, -audio, shifts=shifts, overlap=overlap)[0].cpu().numpy()
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.50 + i * 0.10) / total_files
+            update_percent_func(int(val))
+
+        out[0] = self.weights_drums[i] * out[0]
+        out[1] = self.weights_bass[i] * out[1]
+        out[2] = self.weights_other[i] * out[2]
+        out[3] = self.weights_vocals[i] * out[3]
+        all_outs.append(out)
+        model = model.cpu()
+        del model
+
+        i = 2
+        overlap = overlap_large
+        model = pretrained.get_model('htdemucs_6s')
+        model.to(self.device)
+        out = 0.5 * apply_model(model, audio, shifts=shifts, overlap=overlap)[0].cpu().numpy() \
+              + 0.5 * -apply_model(model, -audio, shifts=shifts, overlap=overlap)[0].cpu().numpy()
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.50 + i * 0.10) / total_files
+            update_percent_func(int(val))
+
+        # More stems need to add
+        out[2] = out[2] + out[4] + out[5]
+        out = out[:4]
+        out[0] = self.weights_drums[i] * out[0]
+        out[1] = self.weights_bass[i] * out[1]
+        out[2] = self.weights_other[i] * out[2]
+        out[3] = self.weights_vocals[i] * out[3]
+        all_outs.append(out)
+        model = model.cpu()
+        del model
+
+        i = 3
+        model = pretrained.get_model('hdemucs_mmi')
+        model.to(self.device)
+        out = 0.5 * apply_model(model, audio, shifts=shifts, overlap=overlap)[0].cpu().numpy() \
+              + 0.5 * -apply_model(model, -audio, shifts=shifts, overlap=overlap)[0].cpu().numpy()
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.50 + i * 0.10) / total_files
+            update_percent_func(int(val))
+
+        out[0] = self.weights_drums[i] * out[0]
+        out[1] = self.weights_bass[i] * out[1]
+        out[2] = self.weights_other[i] * out[2]
+        out[3] = self.weights_vocals[i] * out[3]
+        all_outs.append(out)
+        model = model.cpu()
+        del model
+
+        out = np.array(all_outs).sum(axis=0)
+        out[0] = out[0] / self.weights_drums.sum()
+        out[1] = out[1] / self.weights_bass.sum()
+        out[2] = out[2] / self.weights_other.sum()
+        out[3] = out[3] / self.weights_vocals.sum()
+
+        # vocals
+        separated_music_arrays['vocals'] = vocals
+        output_sample_rates['vocals'] = sample_rate
+
+        # other
+        res = mixed_sound_array - vocals - out[0].T - out[1].T
+        res = np.clip(res, -1, 1)
+        separated_music_arrays['other'] = (2 * res + out[2].T) / 3.0
+        output_sample_rates['other'] = sample_rate
+
+        # drums
+        res = mixed_sound_array - vocals - out[1].T - out[2].T
+        res = np.clip(res, -1, 1)
+        separated_music_arrays['drums'] = (res + 2 * out[0].T.copy()) / 3.0
+        output_sample_rates['drums'] = sample_rate
+
+        # bass
+        res = mixed_sound_array - vocals - out[0].T - out[2].T
+        res = np.clip(res, -1, 1)
+        separated_music_arrays['bass'] = (res + 2 * out[1].T) / 3.0
+        output_sample_rates['bass'] = sample_rate
+
+        bass = separated_music_arrays['bass']
+        drums = separated_music_arrays['drums']
+        other = separated_music_arrays['other']
+
+        separated_music_arrays['other'] = mixed_sound_array - vocals - bass - drums
+        separated_music_arrays['drums'] = mixed_sound_array - vocals - bass - other
+        separated_music_arrays['bass'] = mixed_sound_array - vocals - drums - other
+
+        if update_percent_func is not None:
+            val = 100 * (current_file_number + 0.95) / total_files
+            update_percent_func(int(val))
+
+        return separated_music_arrays, output_sample_rates
+
+
+def predict_with_model(options):
+    for input_audio in options['input_audio']:
+        if not os.path.isfile(input_audio):
+            print('Error. No such file: {}. Please check path!'.format(input_audio))
+            return
+    output_folder = options['output_folder']
+    if not os.path.isdir(output_folder):
+        os.mkdir(output_folder)
+
+    only_vocals = False
+    if 'only_vocals' in options:
+        if options['only_vocals'] is True:
+            print('Generate only vocals and instrumental')
+            only_vocals = True
+
+    model = None
+    if 'large_gpu' in options:
+        if options['large_gpu'] is True:
+            print('Use fast large GPU memory version of code')
+            model = EnsembleDemucsMDXMusicSeparationModel(options)
+    if model is None:
+        print('Use low GPU memory version of code')
+        model = EnsembleDemucsMDXMusicSeparationModelLowGPU(options)
+
+    update_percent_func = None
+    if 'update_percent_func' in options:
+        update_percent_func = options['update_percent_func']
+
+    for i, input_audio in enumerate(options['input_audio']):
+        print('Go for: {}'.format(input_audio))
+        audio, sr = librosa.load(input_audio, mono=False, sr=44100)
+        if len(audio.shape) == 1:
+            audio = np.stack([audio, audio], axis=0)
+        print("Input audio: {} Sample rate: {}".format(audio.shape, sr))
+        result, sample_rates = model.separate_music_file(
+            audio.T,
+            sr,
+            update_percent_func,
+            i,
+            len(options['input_audio']),
+            only_vocals,
+        )
+        all_instrum = model.instruments
+        if only_vocals:
+            all_instrum = ['vocals']
+        for instrum in all_instrum:
+            output_name = os.path.splitext(os.path.basename(input_audio))[0] + '_{}.wav'.format(instrum)
+            sf.write(output_folder + '/' + output_name, result[instrum], sample_rates[instrum], subtype='FLOAT')
+            print('File created: {}'.format(output_folder + '/' + output_name))
+
+        # instrumental part 1
+        inst = audio.T - result['vocals']
+        output_name = os.path.splitext(os.path.basename(input_audio))[0] + '_{}.wav'.format('instrum')
+        sf.write(output_folder + '/' + output_name, inst, sr, subtype='FLOAT')
+        print('File created: {}'.format(output_folder + '/' + output_name))
+
+        if not only_vocals:
+            # instrumental part 2
+            inst2 = result['bass'] + result['drums'] + result['other']
+            output_name = os.path.splitext(os.path.basename(input_audio))[0] + '_{}.wav'.format('instrum2')
+            sf.write(output_folder + '/' + output_name, inst2, sr, subtype='FLOAT')
+            print('File created: {}'.format(output_folder + '/' + output_name))
+
+    if update_percent_func is not None:
+        val = 100
+        update_percent_func(int(val))
+
+
+def md5(fname):
+    hash_md5 = hashlib.md5()
+    with open(fname, "rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            hash_md5.update(chunk)
+    return hash_md5.hexdigest()
+
+
+if __name__ == '__main__':
+    start_time = time()
+
+    print("Version: {}".format(__VERSION__))
+    m = argparse.ArgumentParser()
+    m.add_argument("--input_audio", "-i", nargs='+', type=str, help="Input audio location. You can provide multiple files at once", required=True)
+    m.add_argument("--output_folder", "-r", type=str, help="Output audio folder", required=True)
+    m.add_argument("--cpu", action='store_true', help="Choose CPU instead of GPU for processing. Can be very slow.")
+    m.add_argument("--overlap_large", "-ol", type=float, help="Overlap of splited audio for light models. Closer to 1.0 - slower", required=False, default=0.6)
+    m.add_argument("--overlap_small", "-os", type=float, help="Overlap of splited audio for heavy models. Closer to 1.0 - slower", required=False, default=0.5)
+    m.add_argument("--single_onnx", action='store_true', help="Only use single ONNX model for vocals. Can be useful if you have not enough GPU memory.")
+    m.add_argument("--chunk_size", "-cz", type=int, help="Chunk size for ONNX models. Set lower to reduce GPU memory consumption. Default: 1000000", required=False, default=1000000)
+    m.add_argument("--large_gpu", action='store_true', help="It will store all models on GPU for faster processing of multiple audio files. Requires 11 and more GB of free GPU memory.")
+    m.add_argument("--use_kim_model_1", action='store_true', help="Use first version of Kim model (as it was on contest).")
+    m.add_argument("--only_vocals", action='store_true', help="Only create vocals and instrumental. Skip bass, drums, other")
+
+    options = m.parse_args().__dict__
+    print("Options: ".format(options))
+    for el in options:
+        print('{}: {}'.format(el, options[el]))
+    predict_with_model(options)
+    print('Time: {:.0f} sec'.format(time() - start_time))
+    print('Presented by https://mvsep.com')
+
+
+"""
+Example:
+    python inference.py
+    --input_audio mixture.wav mixture1.wav
+    --output_folder ./results/
+    --cpu
+    --overlap_large 0.25
+    --overlap_small 0.25
+    --chunk_size 500000
+"""

MVSEP-MDX23-music-separation-model/models/.gitkeep

@@ -0,0 +1 @@
+

MVSEP-MDX23-music-separation-model/requirements.txt

@@ -0,0 +1,11 @@
+numpy
+soundfile
+scipy
+torch<2.6
+tqdm
+librosa
+demucs
+onnxruntime-gpu
+PyQt5
+gradio==3.27.0
+matplotlib

MVSEP-MDX23-music-separation-model/web-ui.py

@@ -0,0 +1,172 @@
+# This script is licensed under the "GNU Affero General Public License v3.0"
+# See https://choosealicense.com/licenses/agpl-3.0/ for details.
+import os
+import time
+import numpy as np
+import tempfile
+from scipy.io import wavfile
+import gradio as gr
+from inference import EnsembleDemucsMDXMusicSeparationModel, predict_with_model
+import torch
+import librosa
+import librosa.display
+import matplotlib.pyplot as plt
+import asyncio
+
+# prevent connection from being closed after inference (windows Error)
+if os.name == 'nt':
+    # Change  event loop policy to SelectorEventLoop instead of the default ProactorEventLoop
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+
+if torch.cuda.is_available():
+    print("CUDA is available!")
+else:
+    print("CUDA is not available.")
+
+def check_file_readiness(filepath):
+    # If the loop finished, it means the file size has not changed for 5 seconds
+    # which indicates that the file is ready
+    num_same_size_checks = 0
+    last_size = -1
+    while num_same_size_checks < 5:
+        current_size = os.path.getsize(filepath)
+        if current_size == last_size:
+            num_same_size_checks += 1
+        else:
+            num_same_size_checks = 0
+            last_size = current_size
+        time.sleep(0.5)
+    return True
+
+def generate_spectrogram(audio_file_path):
+    y, sr = librosa.load(audio_file_path)
+    plt.figure(figsize=(10, 4))
+    S = librosa.feature.melspectrogram(y=y, sr=sr, n_mels=128, fmax=8000)
+    librosa.display.specshow(librosa.power_to_db(S, ref=np.max),
+                             y_axis='mel', fmax=22050, x_axis='time')
+    plt.colorbar(format='%+2.0f dB')
+    plt.title('Mel spectrogram')
+    plt.tight_layout()
+    image_path = tempfile.mktemp('.png')
+    plt.savefig(image_path)
+    plt.close()
+    return image_path
+
+def generate_spectrograms(audio_files):
+    output_spectrograms = []
+    for audio_file in audio_files:
+        output_spectrograms.append(generate_spectrogram(audio_file))
+    return tuple(output_spectrograms)
+
+def separate_music_file_wrapper(input_audio, use_cpu, use_single_onnx, large_overlap, small_overlap, chunk_size, use_large_gpu):
+    print(f"type(input_audio): {type(input_audio)}, input_audio: {input_audio[:10]}") # truncate printout
+    sample_rate, audio_data = input_audio
+    output_file = "input_audio.wav"
+    if isinstance(audio_data, np.ndarray):
+        audio_data = audio_data.astype(np.int16)
+    wavfile.write(output_file, sample_rate, audio_data)
+
+
+    input_files = [output_file]
+
+    options = {
+        'input_audio': input_files,
+        'output_folder': 'results',
+        'cpu': use_cpu,
+        'single_onnx': use_single_onnx,
+        'overlap_large': large_overlap,
+        'overlap_small': small_overlap,
+        'chunk_size': chunk_size,
+        'large_gpu': use_large_gpu,
+    }
+
+    print(f'use_cpu: {use_cpu}, use_large_gpu: {use_large_gpu}')
+    predict_with_model(options)
+
+    # Clear GPU cache once the separation finishes
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+    output_files = {}
+    for f in input_files:
+        audio_file_name = os.path.splitext(os.path.basename(f))[0]
+        output_files["vocals"] = os.path.join(options['output_folder'], audio_file_name + "_vocals.wav")
+        output_files["instrumental"] = os.path.join(options['output_folder'], audio_file_name + "_instrum.wav")
+        output_files["instrumental2"] = os.path.join(options['output_folder'], audio_file_name + "_instrum2.wav") # For the second instrumental output
+        output_files["bass"] = os.path.join(options['output_folder'], audio_file_name + "_bass.wav")
+        output_files["drums"] = os.path.join(options['output_folder'], audio_file_name + "_drums.wav")
+        output_files["other"] = os.path.join(options['output_folder'], audio_file_name + "_other.wav")
+
+    # Check the readiness of the files
+    output_files_ready = []
+    for k, v in output_files.items():
+        if os.path.exists(v) and check_file_readiness(v):
+            output_files_ready.append(v)
+        else:
+            empty_data = np.zeros((44100, 2)) # 2 channels, 1 second of silence at 44100Hz
+            empty_file = tempfile.mktemp('.wav')
+            wavfile.write(empty_file, 44100, empty_data.astype(np.int16))  # Cast to int16 as wavfile does not support float32
+            output_files_ready.append(empty_file)
+    
+    # Generate spectrograms right after separating the audio
+    output_spectrograms = generate_spectrograms(output_files_ready)
+
+    #print(len(output_files_ready)) # should print 6
+    #print(len(output_spectrograms)) # should print 6
+    return tuple(output_files_ready) + output_spectrograms
+
+separation_description = """
+# MVSEP-MDX23 Web-UI
+Web-UI created by [Ma5onic](https://github.com/Ma5onic)
+
+Models created by [KimberleyJensen](https://github.com/KimberleyJensen) & [Alexandre Défossez](https://github.com/adefossez)
+
+Separation method created by [ZFTurbo](https://github.com/ZFTurbo) and [MVSep.cpm](https://mvsep.com/)
+- Further reading: [Benchmarks and leaderboards for sound demixing tasks - arxiv paper](https://arxiv.org/abs/2305.07489)
+
+## Options:
+- **Use CPU Only:** Select this if you have not enough GPU memory. It will be slower.
+- **Use Single ONNX:** Select this to use a single ONNX model. It will decrease quality but can help with GPU memory usage.
+- **Large Overlap:** The overlap for large chunks. Adjust as needed.
+- **Small Overlap:** The overlap for small chunks. Adjust as needed.
+- **Chunk Size:** The size of chunks to be processed at a time. Reduce this if facing memory issues.
+- **Use Fast Large GPU Version:** Select this for best separation results (requires > 11 GB of GPU memory).
+"""
+
+theme = gr.themes.Base(
+    primary_hue="cyan",
+    secondary_hue="cyan",
+)
+
+with gr.Blocks(theme=theme, title="MVSEP MDX23 music separation model") as demo:
+    gr.Markdown(separation_description)
+    input_audio = gr.Audio(label="Upload Audio", interactive=True)
+    use_cpu = gr.Checkbox(label="Use CPU Only", value=False)
+    use_single_onnx = gr.Checkbox(label="Use Single ONNX", value=False)
+    large_overlap = gr.Number(label="Large Overlap", value=0.6)
+    small_overlap = gr.Number(label="Small Overlap", value=0.5)
+    chunk_size = gr.Number(label="Chunk Size", value=1000000)
+    use_large_gpu = gr.Checkbox(label="Large GPU Version (Generates better results but requires GPU RAM above 11Gb)", value=True)
+    process_button = gr.Button("Process Audio", variant="primary")
+
+    vocals = gr.Audio(label="Vocals")
+    vocals_spectrogram = gr.Image(label="Vocals Spectrogram")
+    instrumental = gr.Audio(label="Instrumental")
+    instrumental_spectrogram = gr.Image(label="Instrumental Spectrogram")
+    instrumental2 = gr.Audio(label="Instrumental 2")
+    instrumental2_spectrogram = gr.Image(label="Instrumental 2 Spectrogram")
+    bass = gr.Audio(label="Bass")
+    bass_spectrogram = gr.Image(label="Bass Spectrogram")
+    drums = gr.Audio(label="Drums")
+    drums_spectrogram = gr.Image(label="Drums Spectrogram")
+    other = gr.Audio(label="Other")
+    other_spectrogram = gr.Image(label="Other Spectrogram")
+    
+    process_button.click(
+        separate_music_file_wrapper,
+        inputs=[input_audio, use_cpu, use_single_onnx, large_overlap, small_overlap, chunk_size, use_large_gpu],
+        outputs=[vocals, instrumental, instrumental2, bass, drums, other, vocals_spectrogram, instrumental_spectrogram, instrumental2_spectrogram, bass_spectrogram, drums_spectrogram, other_spectrogram],
+    )
+
+demo.queue().launch(debug=True, share=False)

Politrees/UVR_resources/.gitattributes

@@ -0,0 +1,190 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+Demucs_models/04573f0d-f3cf25b2.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/0d19c1c6-0f06f20e.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/14fc6a69-a89dd0ee.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/1ef250f1-592467ce.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/305bc58f-18378783.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/42e558d4-196e0e1b.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/464b36d7-e5a9386e.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/5c90dfd2-34c22ccb.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/5d2d6c55-db83574e.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/6b9c2ca1-3fd82607.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/75fc33f5-1941ce65.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/7d865c68-3d5dd56b.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/7ecf8ec1-70f50cc9.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/7fd6ef75-a905dd85.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/83fc094f-4a16d450.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/902315c2-b39ce9c9.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/92cfc3b6-ef3bcb9c.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/955717e8-8726e21a.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/9a6b4851-03af0aa6.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/a1d90b5c-ae9d2452.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/b72baf4e-8778635e.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/c511e2ab-fe698775.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/cfa93e08-61801ae1.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/d12395a8-e57c48e6.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/demucs_extra-3646af93.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/demucs_extra.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/demucs_unittest-09ebc15f.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/demucs-e07c671f.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/demucs.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/demucs48_hq-28a1282c.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/e51eebcc-c1b80bdd.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/ebf34a2db.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/f7e0c4bc-ba3fe64a.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/fa0cb7f9-100d8bf4.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/light_extra.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/light.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/tasnet_extra-df3777b2.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/tasnet_extra.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/tasnet-beb46fac.th filter=lfs diff=lfs merge=lfs -text
+Demucs_models/tasnet.th filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/100-Reverb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/101-LargeHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/102-SmallHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/103-Strings.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/104-PianoHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/105-OrchRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/106-VocalRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/107-MediumRm.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/108-LargeRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/109-CoolPlate.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/110-ShortPlt.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/111-VocalPlt.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/112-SoftAmb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/113-RoomAmb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/114-Cathedral.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/115-LongCave.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/116-GarageDr.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/117-RockKick.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-1/118-RockSnare.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/200-R1_Reverb1.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/201-R1_LargeHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/202-R1_SmallHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/203-R1_Strings.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/204-R1_PianoHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/205-R1_OrchRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/206-R1_VocalRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/207-R1_MediumRm.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/208-R1_LargeRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/209-R1_CoolPlate.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/210-R1_ShortPlt.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/211-R1_VocalPlt.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/212-R1_SoftAmb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/213-R1_RoomAmb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/214-R1_Cathedral.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/215-R1_LongCave.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/216-R1_GarageDr.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/217-R1_RockKick.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/218-R1_RockSnare.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/220-R2_Reverb2.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/221-R2_LargeHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/222-R2_SmallHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/223-R2_Strings.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/224-R2_PianoHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/225-R2_OrchRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/226-R2_VocalRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/227-R2_MediumRm.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/228-R2_LargeRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/229-R2_CoolPlate.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/230-R2_ShortPlt.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/231-R2_VocalPlt.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/232-R2_SoftAmb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/233-R2_RoomAmb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/234-R2_Cathedral.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/235-R2_LongCave.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/236-R2_GarageDr.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/237-R2_RockKick.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-2/238-R2_RockSnare.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/301-LargeHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/302-SmallHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/303-Strings.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/304-PianoHall.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/305-OrchRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/306-VocalRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/307-MediumRm.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/308-LargeRoom.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/309-CoolPlate.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/310-ShortPlt.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/311-VocalPlt.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/312-SoftAmb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/313-RoomAmb.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/314-Cathedral.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/315-LongCave.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/316-GarageDr.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/317-RockKick.wav filter=lfs diff=lfs merge=lfs -text
+impulse/VS8F-3/318-RockSnare.wav filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v1/demucs_extra.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v1/demucs.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v1/light_extra.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v1/light.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v1/tasnet_extra.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v1/tasnet.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v2/demucs_extra-3646af93.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v2/demucs_unittest-09ebc15f.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v2/demucs-e07c671f.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v2/demucs48_hq-28a1282c.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v2/tasnet_extra-df3777b2.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v2/tasnet-beb46fac.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/0d19c1c6-0f06f20e.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/14fc6a69-a89dd0ee.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/1ef250f1-592467ce.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/305bc58f-18378783.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/42e558d4-196e0e1b.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/464b36d7-e5a9386e.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/5d2d6c55-db83574e.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/6b9c2ca1-3fd82607.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/7d865c68-3d5dd56b.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/7ecf8ec1-70f50cc9.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/7fd6ef75-a905dd85.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/83fc094f-4a16d450.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/902315c2-b39ce9c9.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/9a6b4851-03af0aa6.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/a1d90b5c-ae9d2452.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/b72baf4e-8778635e.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/c511e2ab-fe698775.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/cfa93e08-61801ae1.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/e51eebcc-c1b80bdd.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/ebf34a2db.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v3/fa0cb7f9-100d8bf4.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v4/04573f0d-f3cf25b2.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v4/5c90dfd2-34c22ccb.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v4/75fc33f5-1941ce65.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v4/92cfc3b6-ef3bcb9c.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v4/955717e8-8726e21a.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v4/d12395a8-e57c48e6.th filter=lfs diff=lfs merge=lfs -text
+models/Demucs/Demucs_v4/f7e0c4bc-ba3fe64a.th filter=lfs diff=lfs merge=lfs -text

Politrees/UVR_resources/README.md

@@ -0,0 +1,18 @@
+---
+license: mit
+tags:
+- uvr
+- uvr5
+- ultimatevocalremover
+- demucs
+- vr-arch
+- mdx-net
+- mdx23c
+- roformer 
+- scnet
+- bandit
+---
+
+<div align="center">
+  <h1><big><big><big>Made for <a href="https://github.com/Politrees/UVR_resources">UVR_resources on GitHub</a></big></big></big></h1>
+</div>

Politrees/UVR_resources/models/Apollo/apollo_edm_big_by_essid.yaml

@@ -0,0 +1,114 @@
+exp: 
+  dir: ./exps # directory to save the experiment
+  name: bluearchive # name of the experiment
+
+datas:
+  _target_: look2hear.datas.DataModule
+  dataset_type: 1 # 1 or 2. see README for more details
+  sr: 44100 # sample rate
+  segments: 4 # cropped audio in seconds. chunksize = sr * segments
+  num_steps: 1000 # number of samples to be used for training in one epoch.
+  batch_size: 1 # batch size
+  num_workers: 0 # number of workers for data loading
+  pin_memory: true # pin memory for data loading
+
+  stems:
+    original: original # key for the original audio files, don't change it
+    codec: codec # key for the codec audio files, don't change it
+
+  train:
+    dir: # dataset where the training audio files are stored 
+    - output # list of directories
+    original_format: wav # the format of the original audio files
+    codec_format: mp3 # the format of the codec audio files
+
+  valid:
+    dir: # dataset where the validation audio files are stored
+    - output_v # list of directories
+    original_format: wav # the format of the original audio files
+    codec_format: mp3 # the format of the codec audio files
+
+model:
+  _target_: look2hear.models.apollo.Apollo
+  sr: 44100 # sample rate
+  win: 20 # window size in milliseconds
+  feature_dim: 256 # feature dimension
+  layer: 6 # number of layers
+
+discriminator:
+  _target_: look2hear.discriminators.frequencydis.MultiFrequencyDiscriminator
+  nch: 2
+  window: [32, 64, 128, 256, 512, 1024, 2048]
+
+optimizer_g:
+  _target_: torch.optim.AdamW
+  lr: 0.001
+  weight_decay: 0.01
+
+optimizer_d:
+  _target_: torch.optim.AdamW
+  lr: 0.0001
+  weight_decay: 0.01
+  betas: [0.5, 0.99]
+
+scheduler_g:
+  _target_: torch.optim.lr_scheduler.StepLR
+  step_size: 2
+  gamma: 0.98
+
+scheduler_d:
+  _target_: torch.optim.lr_scheduler.StepLR
+  step_size: 2
+  gamma: 0.98
+
+loss_g:
+  _target_: look2hear.losses.gan_losses.MultiFrequencyGenLoss
+  eps: 1e-8
+
+loss_d:
+  _target_: look2hear.losses.gan_losses.MultiFrequencyDisLoss
+  eps: 1e-8
+
+metrics:
+  _target_: look2hear.losses.MultiSrcNegSDR
+  sdr_type: sisdr # metric for validation, one of [snr, sisdr, sdsdr]
+
+system:
+  _target_: look2hear.system.audio_litmodule.AudioLightningModule
+
+# comment out the early_topping content below, if you do not wish to have early_topping
+early_stopping:
+  _target_: pytorch_lightning.callbacks.EarlyStopping
+  monitor: val_loss # metric to monitor
+  patience: 50 # number of epochs with no improvement after which training will be stopped
+  mode: min
+  verbose: true
+
+checkpoint:
+  _target_: pytorch_lightning.callbacks.ModelCheckpoint
+  dirpath: ${exp.dir}/${exp.name}/checkpoints
+  monitor: val_loss # metric to monitor
+  mode: min
+  verbose: true
+  save_top_k: 10 # number of best models to save
+  save_last: true # save the last checkpoint
+  filename: '{epoch}-{val_loss:.4f}'
+
+logger:
+  _target_: pytorch_lightning.loggers.WandbLogger
+  name: ${exp.name}
+  save_dir: ${exp.dir}/${exp.name}/logs
+  offline: false # if true, the logs will not be uploaded to wandb
+  project: Audio-Restoration
+
+trainer:
+  _target_: pytorch_lightning.Trainer
+  devices: [0] # number of GPUs to use
+  max_epochs: 1000 # max number of epochs
+  sync_batchnorm: true
+  default_root_dir: ${exp.dir}/${exp.name}/
+  accelerator: cuda
+  limit_train_batches: 1.0
+  fast_dev_run: false
+  precision: bf16 # [16, bf16, 32, 64]
+  enable_model_summary: true

Politrees/UVR_resources/models/Apollo/apollo_edm_by_essid.yaml

@@ -0,0 +1,114 @@
+exp: 
+  dir: ./exps # directory to save the experiment
+  name: bluearchive # name of the experiment
+
+datas:
+  _target_: look2hear.datas.DataModule
+  dataset_type: 1 # 1 or 2. see README for more details
+  sr: 44100 # sample rate
+  segments: 4 # cropped audio in seconds. chunksize = sr * segments
+  num_steps: 1000 # number of samples to be used for training in one epoch.
+  batch_size: 1 # batch size
+  num_workers: 0 # number of workers for data loading
+  pin_memory: true # pin memory for data loading
+
+  stems:
+    original: original # key for the original audio files, don't change it
+    codec: codec # key for the codec audio files, don't change it
+
+  train:
+    dir: # dataset where the training audio files are stored 
+    - output # list of directories
+    original_format: wav # the format of the original audio files
+    codec_format: mp3 # the format of the codec audio files
+
+  valid:
+    dir: # dataset where the validation audio files are stored
+    - output_v # list of directories
+    original_format: wav # the format of the original audio files
+    codec_format: mp3 # the format of the codec audio files
+
+model:
+  _target_: look2hear.models.apollo.Apollo
+  sr: 44100 # sample rate
+  win: 20 # window size in milliseconds
+  feature_dim: 128 # feature dimension
+  layer: 6 # number of layers
+
+discriminator:
+  _target_: look2hear.discriminators.frequencydis.MultiFrequencyDiscriminator
+  nch: 2
+  window: [32, 64, 128, 256, 512, 1024, 2048]
+
+optimizer_g:
+  _target_: torch.optim.AdamW
+  lr: 0.001
+  weight_decay: 0.01
+
+optimizer_d:
+  _target_: torch.optim.AdamW
+  lr: 0.0001
+  weight_decay: 0.01
+  betas: [0.5, 0.99]
+
+scheduler_g:
+  _target_: torch.optim.lr_scheduler.StepLR
+  step_size: 2
+  gamma: 0.98
+
+scheduler_d:
+  _target_: torch.optim.lr_scheduler.StepLR
+  step_size: 2
+  gamma: 0.98
+
+loss_g:
+  _target_: look2hear.losses.gan_losses.MultiFrequencyGenLoss
+  eps: 1e-8
+
+loss_d:
+  _target_: look2hear.losses.gan_losses.MultiFrequencyDisLoss
+  eps: 1e-8
+
+metrics:
+  _target_: look2hear.losses.MultiSrcNegSDR
+  sdr_type: sisdr # metric for validation, one of [snr, sisdr, sdsdr]
+
+system:
+  _target_: look2hear.system.audio_litmodule.AudioLightningModule
+
+# comment out the early_topping content below, if you do not wish to have early_topping
+early_stopping:
+  _target_: pytorch_lightning.callbacks.EarlyStopping
+  monitor: val_loss # metric to monitor
+  patience: 50 # number of epochs with no improvement after which training will be stopped
+  mode: min
+  verbose: true
+
+checkpoint:
+  _target_: pytorch_lightning.callbacks.ModelCheckpoint
+  dirpath: ${exp.dir}/${exp.name}/checkpoints
+  monitor: val_loss # metric to monitor
+  mode: min
+  verbose: true
+  save_top_k: 10 # number of best models to save
+  save_last: true # save the last checkpoint
+  filename: '{epoch}-{val_loss:.4f}'
+
+logger:
+  _target_: pytorch_lightning.loggers.WandbLogger
+  name: ${exp.name}
+  save_dir: ${exp.dir}/${exp.name}/logs
+  offline: false # if true, the logs will not be uploaded to wandb
+  project: Audio-Restoration
+
+trainer:
+  _target_: pytorch_lightning.Trainer
+  devices: [0] # number of GPUs to use
+  max_epochs: 1000 # max number of epochs
+  sync_batchnorm: true
+  default_root_dir: ${exp.dir}/${exp.name}/
+  accelerator: cuda
+  limit_train_batches: 1.0
+  fast_dev_run: false
+  precision: bf16 # [16, bf16, 32, 64]
+  enable_model_summary: true

Politrees/UVR_resources/models/MDX23C/config_dereverb_mdx23c.yaml

@@ -0,0 +1,135 @@
+audio:
+  chunk_size: 261120
+  dim_f: 4096
+  dim_t: 256
+  hop_length: 1024
+  n_fft: 8192
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  act: gelu
+  bottleneck_factor: 4
+  growth: 128
+  norm: InstanceNorm
+  num_blocks_per_scale: 2
+  num_channels: 128
+  num_scales: 5
+  num_subbands: 4
+  scale:
+  - 2
+  - 2
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - dry
+  - No dry
+  lr: 1.0e-06
+  patience: 4
+  reduce_factor: 0.93
+  target_instrument: null
+  num_epochs: 40
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adamw
+  read_metadata_procs: 8 # Number of processes to use during metadata reading for dataset. Can speed up metadata generation
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: false # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.05 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+
+    # pedalboard chorus block
+    pedalboard_chorus: 0.001
+    pedalboard_chorus_rate_hz_min: 1.0
+    pedalboard_chorus_rate_hz_max: 7.0
+    pedalboard_chorus_depth_min: 0.25
+    pedalboard_chorus_depth_max: 0.95
+    pedalboard_chorus_centre_delay_ms_min: 3
+    pedalboard_chorus_centre_delay_ms_max: 10
+    pedalboard_chorus_feedback_min: 0.0
+    pedalboard_chorus_feedback_max: 0.01
+    pedalboard_chorus_mix_min: 0.1
+    pedalboard_chorus_mix_max: 0.9
+
+    # pedalboard phazer block
+    pedalboard_phazer: 0.001
+    pedalboard_phazer_rate_hz_min: 1.0
+    pedalboard_phazer_rate_hz_max: 10.0
+    pedalboard_phazer_depth_min: 0.25
+    pedalboard_phazer_depth_max: 0.95
+    pedalboard_phazer_centre_frequency_hz_min: 200
+    pedalboard_phazer_centre_frequency_hz_max: 12000
+    pedalboard_phazer_feedback_min: 0.0
+    pedalboard_phazer_feedback_max: 0.5
+    pedalboard_phazer_mix_min: 0.1
+    pedalboard_phazer_mix_max: 0.9
+
+    # pedalboard pitch shift block
+    pedalboard_pitch_shift: 0.01
+    pedalboard_pitch_shift_semitones_min: -7
+    pedalboard_pitch_shift_semitones_max: 7
+
+    # pedalboard resample block
+    pedalboard_resample: 0.001
+    pedalboard_resample_target_sample_rate_min: 4000
+    pedalboard_resample_target_sample_rate_max: 44100
+
+    mp3_compression_min_bitrate: 32
+    mp3_compression_max_bitrate: 320
+    mp3_compression_backend: "lameenc"
+
+  dry:
+    # pedalboard distortion block
+    pedalboard_distortion: 0.001
+    pedalboard_distortion_drive_db_min: 1.0
+    pedalboard_distortion_drive_db_max: 25.0
+    
+    tanh_distortion: 0.05
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.7
+    # pedalboard bitcrash block
+    pedalboard_bitcrash: 0.005
+    pedalboard_bitcrash_bit_depth_min: 4
+    pedalboard_bitcrash_bit_depth_max: 16
+
+    seven_band_parametric_eq: 0.24
+    seven_band_parametric_eq_min_gain_db: -9
+    seven_band_parametric_eq_max_gain_db: 9
+    
+    gaussian_noise: 0.005
+    gaussian_noise_min_amplitude: 0.001
+    gaussian_noise_max_amplitude: 0.01
+    
+    time_stretch: 0.01
+    time_stretch_min_rate: 0.8
+    time_stretch_max_rate: 1.25
+  other:
+    seven_band_parametric_eq: 0.24
+    seven_band_parametric_eq_min_gain_db: -9
+    seven_band_parametric_eq_max_gain_db: 9
+
+inference:
+  batch_size: 2
+  dim_t: 256
+  num_overlap: 4

Politrees/UVR_resources/models/MDX23C/config_drumsep_mdx23c.yaml

@@ -0,0 +1,87 @@
+audio:
+  chunk_size: 130560
+  dim_f: 1024
+  dim_t: 256
+  hop_length: 512
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  act: gelu
+  bottleneck_factor: 4
+  growth: 128
+  norm: InstanceNorm
+  num_blocks_per_scale: 2
+  num_channels: 128
+  num_scales: 5
+  num_subbands: 4
+  scale:
+  - 2
+  - 2
+
+training:
+  batch_size: 12
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - kick
+  - snare
+  - toms
+  - hh
+  - ride
+  - crash
+  lr: 9.0e-05
+  patience: 30
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1268
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+  # apply mp3 compression to mixture only (emulate downloading mp3 from internet)
+  mp3_compression_on_mixture: 0.0
+  mp3_compression_on_mixture_bitrate_min: 32
+  mp3_compression_on_mixture_bitrate_max: 320
+  mp3_compression_on_mixture_backend: "lameenc"
+
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.01 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+    mp3_compression: 0.0
+    mp3_compression_min_bitrate: 32
+    mp3_compression_max_bitrate: 320
+    mp3_compression_backend: "lameenc"
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -3
+    pitch_shift_max_semitones: 3
+    seven_band_parametric_eq: 0.5
+    seven_band_parametric_eq_min_gain_db: -6
+    seven_band_parametric_eq_max_gain_db: 6
+    tanh_distortion: 0.2
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.5
+    
+inference:
+  batch_size: 1
+  dim_t: 256
+  num_overlap: 4

Politrees/UVR_resources/models/MDX23C/config_mdx23c_similarity.yaml

@@ -0,0 +1,47 @@
+audio:
+  chunk_size: 130560
+  dim_f: 1024
+  dim_t: 256
+  hop_length: 512
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  act: gelu
+  bottleneck_factor: 4
+  growth: 128
+  norm: InstanceNorm
+  num_blocks_per_scale: 2
+  num_channels: 128
+  num_scales: 5
+  num_subbands: 4
+  scale:
+  - 2
+  - 2
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 3
+  grad_clip: 0
+  instruments:
+  - Similarity
+  - Difference
+  lr: 1.0
+  patience: 15
+  reduce_factor: 0.95
+  target_instrument: Similarity
+  num_epochs: 1000
+  num_steps: 2235
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: prodigy
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 8
+  dim_t: 256
+  num_overlap: 8

Politrees/UVR_resources/models/MDX23C/model_2_stem_061321.yaml

@@ -0,0 +1,36 @@
+audio:
+  chunk_size: 260096
+  dim_f: 4096
+  dim_t: 256
+  hop_length: 2048
+  n_fft: 12288
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+model:
+  act: gelu
+  bottleneck_factor: 4
+  growth: 64
+  norm: InstanceNorm
+  num_blocks_per_scale: 2
+  num_channels: 128
+  num_scales: 5
+  num_subbands: 4
+  scale:
+  - 2
+  - 2
+  name: epoch_10.ckpt
+training:
+  batch_size: 16
+  grad_clip: 0
+  instruments:
+  - Vocals
+  - Instrumental
+  lr: 5.0e-05
+  target_instrument: null
+  num_epochs: 100
+  num_steps: 1000
+inference:
+  batch_size: 1
+  dim_t: 256
+  num_overlap: 8

Politrees/UVR_resources/models/MDX23C/model_2_stem_full_band_8k.yaml

@@ -0,0 +1,43 @@
+audio:
+  chunk_size: 261120
+  dim_f: 4096
+  dim_t: 256
+  hop_length: 1024
+  n_fft: 8192
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+model:
+  act: gelu
+  bottleneck_factor: 4
+  growth: 128
+  norm: InstanceNorm
+  num_blocks_per_scale: 2
+  num_channels: 128
+  num_scales: 5
+  num_subbands: 4
+  scale:
+  - 2
+  - 2
+training:
+  batch_size: 6
+  grad_clip: 0
+  instruments:
+  - Vocals
+  - Instrumental
+  lr: 1.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: 1
+  augmentation_type: simple1
+  augmentation_mix: true
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+inference:
+  batch_size: 1
+  dim_t: 256
+  num_overlap: 8

Politrees/UVR_resources/models/Roformer/BandSplit/config_BandSplit-Roformer_FNO_by-Unwa.yaml

@@ -0,0 +1,136 @@
+audio:
+  chunk_size: 749259
+  dim_f: 1024
+  dim_t: 1700 # don't work (use in model)
+  hop_length: 441 # don't work (use in model)
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 256
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.
+  ff_dropout: 0.
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+  mlp_expansion_factor: 4
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments: ['vocals', 'other']
+  patience: 3
+  reduce_factor: 0.95
+  target_instrument: other
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: simple1
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: true # Mix several stems of the same type with some probability
+  augmentation_loudness: true # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0.5
+  augmentation_loudness_max: 1.5
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  # optimizer: prodigy
+  optimizer: adam
+  # lr: 1.0
+  lr: 1.0e-5
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 2
+  dim_t: 1700
+  num_overlap: 2
+  normalize: false

Politrees/UVR_resources/models/Roformer/BandSplit/config_BandSplit-Roformer_Karaoke_Frazer_by-becruily.yaml

@@ -0,0 +1,129 @@
+audio:
+  chunk_size: 882000
+  dim_f: 1024
+  dim_t: 801
+  hop_length: 441
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 256
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  freqs_per_bands: !!python/tuple
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 2
+  - 4
+  - 4
+  - 4
+  - 4
+  - 4
+  - 4
+  - 4
+  - 4
+  - 4
+  - 4
+  - 4
+  - 4
+  - 12
+  - 12
+  - 12
+  - 12
+  - 12
+  - 12
+  - 12
+  - 12
+  - 24
+  - 24
+  - 24
+  - 24
+  - 24
+  - 24
+  - 24
+  - 24
+  - 48
+  - 48
+  - 48
+  - 48
+  - 48
+  - 48
+  - 48
+  - 48
+  - 128
+  - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0
+  ff_dropout: 0
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 512
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: false
+  mlp_expansion_factor: 4
+
+training:
+  batch_size: 1
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - Vocals
+  - Instrumental
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: Vocals
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  # optimizer: prodigy
+  optimizer: adam
+  lr: 1.0e-5
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 2
+  dim_t: 2001
+  num_overlap: 4
+  normalize: false

Politrees/UVR_resources/models/Roformer/BandSplit/config_BandSplit-Roformer_Resurrection_Instrumental_by-Unwa.yaml

@@ -0,0 +1,138 @@
+audio:
+  chunk_size: 749259
+  dim_f: 1024
+  dim_t: 1700 # don't work (use in model)
+  hop_length: 441 # don't work (use in model)
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 256
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.
+  ff_dropout: 0.
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+  mlp_expansion_factor: 4
+  use_torch_checkpoint: False # it allows to greatly reduce GPU memory consumption during training (not fully tested)
+  skip_connection: False # Enable skip connection between transformer blocks - can solve problem with gradients and probably faster training
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments: ['vocals', 'other']
+  patience: 3
+  reduce_factor: 0.95
+  target_instrument: other
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: simple1
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: true # Mix several stems of the same type with some probability
+  augmentation_loudness: true # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0.5
+  augmentation_loudness_max: 1.5
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  # optimizer: prodigy
+  optimizer: adam
+  # lr: 1.0
+  lr: 1.0e-5
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 2
+  dim_t: 1700
+  num_overlap: 2
+  normalize: false

Politrees/UVR_resources/models/Roformer/BandSplit/config_BandSplit-Roformer_Resurrection_Vocals_by-Unwa.yaml

@@ -0,0 +1,138 @@
+audio:
+  chunk_size: 785920
+  dim_f: 1024
+  dim_t: 1536 # don't work (use in model)
+  hop_length: 441 # don't work (use in model)
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 256
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.
+  ff_dropout: 0.
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 512
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+  mlp_expansion_factor: 4
+  use_torch_checkpoint: False # it allows to greatly reduce GPU memory consumption during training (not fully tested)
+  skip_connection: False # Enable skip connection between transformer blocks - can solve problem with gradients and probably faster training
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments: ['vocals', 'other']
+  patience: 3
+  reduce_factor: 0.95
+  target_instrument: vocals
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: simple1
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: true # Mix several stems of the same type with some probability
+  augmentation_loudness: true # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0.5
+  augmentation_loudness_max: 1.5
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  # optimizer: prodigy
+  optimizer: adam
+  # lr: 1.0
+  lr: 1.0e-5
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 2
+  dim_t: 1536
+  num_overlap: 2
+  normalize: false

Politrees/UVR_resources/models/Roformer/BandSplit/config_BandSplit-Roformer_SW_by-jarredou.yaml

@@ -0,0 +1,197 @@
+audio:
+  chunk_size: 588800 #882000
+  dim_f: 1024
+  dim_t: 801 # don't work (use in model)
+  hop_length: 441 # don't work (use in model)
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 256
+  depth: 12
+  stereo: true
+  num_stems: 6
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 512
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+  mlp_expansion_factor: 4
+  use_torch_checkpoint: False # it allows to greatly reduce GPU memory consumption during training (not fully tested)
+  skip_connection: False # Enable skip connection between transformer blocks - can solve problem with gradients and probably faster training
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments: ['bass', 'drums', 'other', 'vocals', 'guitar', 'piano']
+  patience: 3
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: simple1
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: true # Mix several stems of the same type with some probability
+  augmentation_loudness: true # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0.5
+  augmentation_loudness_max: 1.5
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  # optimizer: prodigy
+  optimizer: adam
+  # lr: 1.0
+  lr: 1.0e-5
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.1 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+
+  vocals:
+      pitch_shift: 0.1
+      pitch_shift_min_semitones: -5
+      pitch_shift_max_semitones: 5
+      seven_band_parametric_eq: 0.1
+      seven_band_parametric_eq_min_gain_db: -9
+      seven_band_parametric_eq_max_gain_db: 9
+      tanh_distortion: 0.1
+      tanh_distortion_min: 0.1
+      tanh_distortion_max: 0.7
+  bass:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -2
+    pitch_shift_max_semitones: 2
+    seven_band_parametric_eq: 0.1
+    seven_band_parametric_eq_min_gain_db: -3
+    seven_band_parametric_eq_max_gain_db: 6
+    tanh_distortion: 0.1
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.5
+  drums:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -5
+    pitch_shift_max_semitones: 5
+    seven_band_parametric_eq: 0.1
+    seven_band_parametric_eq_min_gain_db: -9
+    seven_band_parametric_eq_max_gain_db: 9
+    tanh_distortion: 0.1
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.6
+  other:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -4
+    pitch_shift_max_semitones: 4
+    gaussian_noise: 0.1
+    gaussian_noise_min_amplitude: 0.001
+    gaussian_noise_max_amplitude: 0.015
+    time_stretch: 0.1
+    time_stretch_min_rate: 0.8
+    time_stretch_max_rate: 1.25
+
+
+inference:
+  batch_size: 1
+  dim_t: 1101
+  num_overlap: 2
+  normalize: false

Politrees/UVR_resources/models/Roformer/BandSplit/config_BandSplit_Roformer_4stems_FT_by_SYH99999.yaml

@@ -0,0 +1,196 @@
+audio:
+  chunk_size: 485100
+  dim_f: 1024
+  dim_t: 801 # don't work (use in model)
+  hop_length: 441 # don't work (use in model)
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 8
+  stereo: true
+  num_stems: 4
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+  mlp_expansion_factor: 2
+  use_torch_checkpoint: False # it allows to greatly reduce GPU memory consumption during training (not fully tested)
+  skip_connection: False # Enable skip connection between transformer blocks - can solve problem with gradients and probably faster training
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments: ['drums', 'bass', 'other', 'vocals']
+  patience: 3
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: simple1
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: true # Mix several stems of the same type with some probability
+  augmentation_loudness: true # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0.5
+  augmentation_loudness_max: 1.5
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  # optimizer: prodigy
+  optimizer: adam
+  # lr: 1.0
+  lr: 1.0e-5
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.1 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+
+  vocals:
+      pitch_shift: 0.1
+      pitch_shift_min_semitones: -5
+      pitch_shift_max_semitones: 5
+      seven_band_parametric_eq: 0.1
+      seven_band_parametric_eq_min_gain_db: -9
+      seven_band_parametric_eq_max_gain_db: 9
+      tanh_distortion: 0.1
+      tanh_distortion_min: 0.1
+      tanh_distortion_max: 0.7
+  bass:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -2
+    pitch_shift_max_semitones: 2
+    seven_band_parametric_eq: 0.1
+    seven_band_parametric_eq_min_gain_db: -3
+    seven_band_parametric_eq_max_gain_db: 6
+    tanh_distortion: 0.1
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.5
+  drums:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -5
+    pitch_shift_max_semitones: 5
+    seven_band_parametric_eq: 0.1
+    seven_band_parametric_eq_min_gain_db: -9
+    seven_band_parametric_eq_max_gain_db: 9
+    tanh_distortion: 0.1
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.6
+  other:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -4
+    pitch_shift_max_semitones: 4
+    gaussian_noise: 0.1
+    gaussian_noise_min_amplitude: 0.001
+    gaussian_noise_max_amplitude: 0.015
+    time_stretch: 0.1
+    time_stretch_min_rate: 0.8
+    time_stretch_max_rate: 1.25
+
+
+inference:
+  batch_size: 2
+  dim_t: 2048
+  num_overlap: 4

Politrees/UVR_resources/models/Roformer/BandSplit/config_bs_roformer_chorus_male_female.yaml

@@ -0,0 +1,125 @@
+audio:
+  chunk_size: 352800
+  dim_f: 1024
+  dim_t: 801 # don't work (use in model)
+  hop_length: 441 # don't work (use in model)
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 8
+  stereo: true
+  num_stems: 2
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.0
+  ff_dropout: 0.0
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+
+training:
+  batch_size: 1
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - male
+  - female
+  lr: 1.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: true # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 1
+  dim_t: 801
+  num_overlap: 2

Politrees/UVR_resources/models/Roformer/BandSplit/config_bs_roformer_deverb_8_384dim_10depth.yaml

@@ -0,0 +1,137 @@
+audio:
+  chunk_size: 352768
+  dim_f: 1024
+  dim_t: 801
+  hop_length: 441
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  dim: 384
+  depth: 10
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+
+training:
+  batch_size: 1
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - noreverb
+  - reverb
+  lr: 5.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: noreverb
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: false # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+inference:
+  batch_size: 4
+  dim_t: 801
+  num_overlap: 4

Politrees/UVR_resources/models/Roformer/BandSplit/config_bs_roformer_ep_317_sdr_12.9755.yaml

@@ -0,0 +1,133 @@
+audio:
+  chunk_size: 352800
+  dim_f: 1024
+  dim_t: 801 # don't work (use in model)
+  hop_length: 441 # don't work (use in model)
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  dim: 512
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+
+training:
+  batch_size: 16
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - Vocals
+  - Instrumental
+  lr: 5.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: Vocals
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: simple1
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: true # Mix several stems of the same type with some probability
+  augmentation_loudness: true # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0.5
+  augmentation_loudness_max: 1.5
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 1
+  dim_t: 801
+  num_overlap: 4

Politrees/UVR_resources/models/Roformer/BandSplit/config_bs_roformer_ep_368_sdr_12.9628.yaml

@@ -0,0 +1,133 @@
+audio:
+  chunk_size: 352800
+  dim_f: 1024
+  dim_t: 801 # don't work (use in model)
+  hop_length: 441 # don't work (use in model)
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  dim: 512
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+
+training:
+  batch_size: 16
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - Vocals
+  - Instrumental
+  lr: 5.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: Vocals
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: simple1
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: true # Mix several stems of the same type with some probability
+  augmentation_loudness: true # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0.5
+  augmentation_loudness_max: 1.5
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 1
+  dim_t: 801
+  num_overlap: 4

Politrees/UVR_resources/models/Roformer/BandSplit/config_bs_roformer_ep_937_sdr_10.5309.yaml

@@ -0,0 +1,138 @@
+audio:
+  chunk_size: 131584
+  dim_f: 1024
+  dim_t: 256
+  hop_length: 512
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  dim: 384
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 512
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+
+training:
+  batch_size: 4
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - No Drum-Bass
+  - Drum-Bass
+  lr: 5.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: No Drum-Bass
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+inference:
+  batch_size: 1
+  dim_t: 512
+  num_overlap: 4

Politrees/UVR_resources/models/Roformer/BandSplit/config_bs_roformer_inst_exp_vrl.yaml

@@ -0,0 +1,124 @@
+audio:
+  chunk_size: 485100 #352800 #485100
+  dim_f: 1024
+  dim_t: 801
+  hop_length: 441
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0
+  ff_dropout: 0
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+training:
+  batch_size: 1
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - Vocals
+  - Instrumental
+  lr: 1.0e-04
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: Instrumental
+  num_epochs: 1
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adamw
+  other_fix: true # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 1
+  dim_t: 1101
+  num_overlap: 2

Politrees/UVR_resources/models/Roformer/BandSplit/config_bs_roformer_revive_by_unwa.yaml

@@ -0,0 +1,134 @@
+audio:
+  chunk_size: 485100 #352800 #485100
+  dim_f: 1024
+  dim_t: 1101
+  hop_length: 441
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.
+
+model:
+  dim: 512
+  depth: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  freqs_per_bands: !!python/tuple
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 2
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 4
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 12
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 24
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 48
+    - 128
+    - 129
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.
+  ff_dropout: 0.
+  flash_attn: true
+  dim_freqs_in: 1025
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+
+training:
+  batch_size: 1
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  lr: 1.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: vocals
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: null
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: false # Mix several stems of the same type with some probability
+  augmentation_loudness: false # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0
+  augmentation_loudness_max: 0
+  q: 0.95
+  coarse_loss_clip: false
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: true # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 2
+  dim_t: 1101
+  num_overlap: 2

Politrees/UVR_resources/models/Roformer/MelBand/config_MelBand-Roformer_BVE_by-Gonza.yaml

@@ -0,0 +1,75 @@
+audio:
+  chunk_size: 485100
+  dim_f: 1024
+  dim_t: 256
+  hop_length: 411
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 6
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0
+  ff_dropout: 0
+  flash_attn: true
+  dim_freqs_in: 1025
+  sample_rate: 44100  # needed for mel filter bank from librosa
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+    - 4096
+    - 2048
+    - 1024
+    - 512
+    - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: true
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - Lead
+    - Back
+  lr: 5.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: Lead
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type:
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: false # Mix several stems of the same type with some probability
+  augmentation_loudness: false # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0
+  augmentation_loudness_max: 0
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: false
+
+inference:
+  batch_size: 1
+  dim_t: 1101
+  num_overlap: 8

Politrees/UVR_resources/models/Roformer/MelBand/config_MelBand-Roformer_Duality_v1_by-Aname.yaml

@@ -0,0 +1,72 @@
+audio:
+  chunk_size: 661500
+  dim_f: 1024
+  dim_t: 1101
+  hop_length: 441
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 6
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0
+  ff_dropout: 0
+  flash_attn: True
+  dim_freqs_in: 1025
+  sample_rate: 44100  # needed for mel filter bank from librosa
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: False
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+
+training:
+  batch_size: 4
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  lr: 1.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: vocals
+  num_epochs: 1000
+  num_steps: 1000
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type: null
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: false # Mix several stems of the same type with some probability
+  augmentation_loudness: false # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0
+  augmentation_loudness_max: 0
+  q: 0.95
+  coarse_loss_clip: false
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: true # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 4
+  dim_t: 1101
+  num_overlap: 4

Politrees/UVR_resources/models/Roformer/MelBand/config_MelBand-Roformer_Karaoke_Fusion_Total_by-Gonza.yaml

@@ -0,0 +1,75 @@
+audio:
+  chunk_size: 485100
+  dim_f: 1024
+  dim_t: 256
+  hop_length: 411
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 6
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0
+  ff_dropout: 0
+  flash_attn: true
+  dim_freqs_in: 1025
+  sample_rate: 44100  # needed for mel filter bank from librosa
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+    - 4096
+    - 2048
+    - 1024
+    - 512
+    - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: true
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - Vocals
+    - Instrumental
+  lr: 1.0
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: Vocals
+  num_epochs: 100
+  num_steps: 200
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type:
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: false # Mix several stems of the same type with some probability
+  augmentation_loudness: false # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0
+  augmentation_loudness_max: 0
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: prodigy
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: false
+
+inference:
+  batch_size: 1
+  dim_t: 1101
+  num_overlap: 8

Politrees/UVR_resources/models/Roformer/MelBand/config_MelBand-Roformer_Karaoke_Fusion_by-Gonza.yaml

@@ -0,0 +1,83 @@
+audio:
+  chunk_size: 485100
+  dim_f: 1024
+  dim_t: 256
+  hop_length: 411
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 6
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0
+  ff_dropout: 0
+  flash_attn: true
+  dim_freqs_in: 1025
+  sample_rate: 44100  # needed for mel filter bank from librosa
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+    - 4096
+    - 2048
+    - 1024
+    - 512
+    - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: true
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - Vocals
+    - Instrumental
+  lr: 1.0
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: Vocals
+  num_epochs: 150
+  num_steps: 100
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type:
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: false # Mix several stems of the same type with some probability
+  augmentation_loudness: false # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0
+  augmentation_loudness_max: 0
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: prodigy
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: false
+
+lora:
+  r: 4
+  lora_alpha: 8 # alpha / rank > 1
+  lora_dropout: 0.01
+  merge_weights: True
+  fan_in_fan_out: False
+  enable_lora: [True]
+
+inference:
+  batch_size: 1
+  dim_t: 1101
+  num_overlap: 8

Politrees/UVR_resources/models/Roformer/MelBand/config_MelBand-Roformer_Karaoke_Fusion_v2_by-Gonza.yaml

@@ -0,0 +1,83 @@
+audio:
+  chunk_size: 485100
+  dim_f: 1024
+  dim_t: 256
+  hop_length: 411
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 6
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0
+  ff_dropout: 0
+  flash_attn: true
+  dim_freqs_in: 1025
+  sample_rate: 44100  # needed for mel filter bank from librosa
+  stft_n_fft: 2048
+  stft_hop_length: 441
+  stft_win_length: 2048
+  stft_normalized: false
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+    - 4096
+    - 2048
+    - 1024
+    - 512
+    - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: true
+
+training:
+  batch_size: 2
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - Vocals
+    - Instrumental
+  lr: 1.0
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: Vocals
+  num_epochs: 100
+  num_steps: 100
+  augmentation: false # enable augmentations by audiomentations and pedalboard
+  augmentation_type:
+  use_mp3_compress: false # Deprecated
+  augmentation_mix: false # Mix several stems of the same type with some probability
+  augmentation_loudness: false # randomly change loudness of each stem
+  augmentation_loudness_type: 1 # Type 1 or 2
+  augmentation_loudness_min: 0
+  augmentation_loudness_max: 0
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: prodigy
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+lora:
+  r: 8
+  lora_alpha: 16 # alpha / rank > 1
+  lora_dropout: 0.05
+  merge_weights: False
+  fan_in_fan_out: False
+  enable_lora: [True]
+
+augmentations:
+  enable: false
+
+inference:
+  batch_size: 1
+  dim_t: 1101
+  num_overlap: 8

Politrees/UVR_resources/models/Roformer/MelBand/config_MelBand_Roformer_4stems_FT_Large_by_SYH99999.yaml

@@ -0,0 +1,69 @@
+audio:
+  chunk_size: 485100
+  dim_f: 1024
+  dim_t: 1101
+  hop_length: 882
+  n_fft: 2048
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dim: 384
+  depth: 8
+  stereo: true
+  num_stems: 4
+  linear_transformer_depth: 0
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.0
+  ff_dropout: 0.0
+  flash_attn: true
+  dim_freqs_in: 2049
+  sample_rate: 44100  # needed for mel filter bank from librosa
+  stft_n_fft: 4096
+  stft_hop_length: 882
+  stft_win_length: 4096
+  stft_normalized: False
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+  mlp_expansion_factor: 4
+  use_torch_checkpoint: False # it allows to greatly reduce GPU memory consumption during training (not fully tested)
+  skip_connection: True # Enable skip connection between transformer blocks - can solve problem with gradients and probably faster training
+
+training:
+  batch_size: 1
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments: ['drums', 'bass', 'other', 'vocals']
+  lr: 1.0
+  patience: 3
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: false
+  ema_momentum: 0.999
+  optimizer: prodigy
+  read_metadata_procs: 8 # Number of processes to use during metadata reading for dataset. Can speed up metadata generation
+  normalize: false
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+inference:
+  batch_size: 4
+  dim_t: 1101
+  num_overlap: 4
+  normalize: false

Politrees/UVR_resources/models/Roformer/MelBand/config_MelBand_Roformer_4stems_Large_v1_by_Aname.yaml

@@ -0,0 +1,167 @@
+audio:
+  chunk_size: 661500
+  dim_f: 1024
+  dim_t: 1101
+  hop_length: 882
+  n_fft: 4096
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.0001
+
+model:
+  dim: 384
+  depth: 8
+  stereo: true
+  num_stems: 4
+  linear_transformer_depth: 0
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.0
+  ff_dropout: 0.0
+  flash_attn: true
+  dim_freqs_in: 2049
+  sample_rate: 44100  # needed for mel filter bank from librosa
+  stft_n_fft: 4096
+  stft_hop_length: 882
+  stft_win_length: 4096
+  stft_normalized: False
+  mask_estimator_depth: 2
+  multi_stft_resolution_loss_weight: 1.0
+  multi_stft_resolutions_window_sizes: !!python/tuple
+  - 4096
+  - 2048
+  - 1024
+  - 512
+  - 256
+  multi_stft_hop_size: 147
+  multi_stft_normalized: False
+  mlp_expansion_factor: 4
+  use_torch_checkpoint: False # it allows to greatly reduce GPU memory consumption during training (not fully tested)
+  skip_connection: True # Enable skip connection between transformer blocks - can solve problem with gradients and probably faster training
+
+training:
+  batch_size: 1
+  gradient_accumulation_steps: 4
+  grad_clip: 0
+  instruments: ['drums', 'bass', 'other', 'vocals']
+  lr: 2.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 300
+  q: 0.95
+  coarse_loss_clip: false
+  ema_momentum: 0.999
+  optimizer: adamw
+  read_metadata_procs: 8 # Number of processes to use during metadata reading for dataset. Can speed up metadata generation
+  normalize: false
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: false # enable or disable all augmentations (to fast disable if needed)
+  loudness: false # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+    - 0.002
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+  # apply mp3 compression to mixture only (emulate downloading mp3 from internet)
+  mp3_compression_on_mixture: 0.01
+  mp3_compression_on_mixture_bitrate_min: 32
+  mp3_compression_on_mixture_bitrate_max: 320
+  mp3_compression_on_mixture_backend: "lameenc"
+
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.01 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+
+  vocals:
+      pitch_shift: 1.0
+      pitch_shift_min_semitones: -12
+      pitch_shift_max_semitones: 12
+      seven_band_parametric_eq: 0.5
+      seven_band_parametric_eq_min_gain_db: -80
+      seven_band_parametric_eq_max_gain_db: 9
+      tanh_distortion: 0.5
+      tanh_distortion_min: 0.1
+      tanh_distortion_max: 1
+      time_stretch: 1.0
+      time_stretch_min_rate: 0.5
+      time_stretch_max_rate: 2
+  bass:
+    pitch_shift: 1.0
+    pitch_shift_min_semitones: -6
+    pitch_shift_max_semitones: 6
+    seven_band_parametric_eq: 0.4
+    seven_band_parametric_eq_min_gain_db: -32
+    seven_band_parametric_eq_max_gain_db: 6
+    tanh_distortion: 1.0
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.5
+    time_stretch: 1.0
+    time_stretch_min_rate: 0.5
+    time_stretch_max_rate: 1.5
+  drums:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -6
+    pitch_shift_max_semitones: 6
+    seven_band_parametric_eq: 0.5
+    seven_band_parametric_eq_min_gain_db: -24
+    seven_band_parametric_eq_max_gain_db: 12
+    tanh_distortion: 0.3
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.6
+    time_stretch: 1.0
+    time_stretch_min_rate: 0.333
+    time_stretch_max_rate: 1.5
+  other:
+    pitch_shift: 1.0
+    pitch_shift_min_semitones: -12
+    pitch_shift_max_semitones: 12
+    gaussian_noise: 0.4
+    gaussian_noise_min_amplitude: 0.001
+    gaussian_noise_max_amplitude: 0.15
+    time_stretch: 0.01
+    time_stretch_min_rate: 0.25
+    time_stretch_max_rate: 1.5
+
+inference:
+  batch_size: 1
+  dim_t: 256
+  num_overlap: 4
+  normalize: false
+
+loss_multistft:
+  fft_sizes:
+  - 1024
+  - 2048
+  - 4096
+  hop_sizes:
+  - 147
+  - 256
+  - 512
+  win_lengths:
+  - 1024
+  - 2048
+  - 4096
+  window: "hann_window"
+  scale: "mel"
+  n_bins: 128
+  sample_rate: 44100
+  perceptual_weighting: true
+  w_sc: 16.0
+  w_log_mag: 16.0
+  w_lin_mag: 16.0
+  w_phs: 0.0
+  mag_distance: "L1"

Politrees/UVR_resources/models/SCnet/config_musdb18_scnet.yaml

@@ -0,0 +1,83 @@
+audio:
+  chunk_size: 485100 # 44100 * 11
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  sources:
+    - drums
+    - bass
+    - other
+    - vocals
+  audio_channels: 2
+  dims:
+    - 4
+    - 32
+    - 64
+    - 128
+  nfft: 4096
+  hop_size: 1024
+  win_size: 4096
+  normalized: True
+  band_SR:
+    - 0.175
+    - 0.392
+    - 0.433
+  band_stride:
+    - 1
+    - 4
+    - 16
+  band_kernel:
+    - 3
+    - 4
+    - 16
+  conv_depths:
+    - 3
+    - 2
+    - 1
+  compress: 4
+  conv_kernel: 3
+  num_dplayer: 6
+  expand: 1
+
+training:
+  batch_size: 10
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - Drums
+    - Bass
+    - Other
+    - Vocals
+  lr: 5.0e-04
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adam
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs:
+    !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+inference:
+  batch_size: 8
+  dim_t: 256
+  num_overlap: 4
+  normalize: true

Politrees/UVR_resources/models/SCnet/config_musdb18_scnet_large.yaml

@@ -0,0 +1,88 @@
+audio:
+  chunk_size: 485100 # 44100 * 11
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  sources:
+    - drums
+    - bass
+    - other
+    - vocals
+  audio_channels: 2
+  dims:
+    - 4
+    - 64
+    - 128
+    - 256
+  nfft: 4096
+  hop_size: 1024
+  win_size: 4096
+  normalized: True
+  band_SR:
+    - 0.225
+    - 0.372
+    - 0.403
+  band_stride:
+    - 1
+    - 4
+    - 16
+  band_kernel:
+    - 3
+    - 4
+    - 16
+  conv_depths:
+    - 3
+    - 2
+    - 1
+  compress: 4
+  conv_kernel: 3
+  num_dplayer: 6
+  expand: 1
+
+training:
+  batch_size: 6
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - Drums
+    - Bass
+    - Other
+    - Vocals
+  # lr: 1.0e-04
+  lr: 1.0
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: prodigy
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs:
+    !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.1 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+
+inference:
+  batch_size: 8
+  dim_t: 256
+  num_overlap: 4
+  normalize: false

Politrees/UVR_resources/models/SCnet/config_musdb18_scnet_large_starrytong.yaml

@@ -0,0 +1,88 @@
+audio:
+  chunk_size: 485100 # 44100 * 11
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  sources:
+    - drums
+    - bass
+    - other
+    - vocals
+  audio_channels: 2
+  dims:
+    - 4
+    - 64
+    - 128
+    - 256
+  nfft: 4096
+  hop_size: 1024
+  win_size: 4096
+  normalized: True
+  band_SR:
+    - 0.225
+    - 0.372
+    - 0.403
+  band_stride:
+    - 1
+    - 4
+    - 16
+  band_kernel:
+    - 3
+    - 4
+    - 16
+  conv_depths:
+    - 3
+    - 2
+    - 1
+  compress: 4
+  conv_kernel: 3
+  num_dplayer: 6
+  expand: 1
+
+training:
+  batch_size: 6
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - Drums
+    - Bass
+    - Other
+    - Vocals
+  # lr: 1.0e-04
+  lr: 1.0
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: prodigy
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+augmentations:
+  enable: true # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs:
+    !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.1 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+
+inference:
+  batch_size: 8
+  dim_t: 256
+  num_overlap: 4
+  normalize: true

Politrees/UVR_resources/models/SCnet/config_musdb18_scnet_xl.yaml

@@ -0,0 +1,207 @@
+audio:
+  chunk_size: 485100 # 44100 * 11
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  sources:
+    - drums
+    - bass
+    - other
+    - vocals
+  audio_channels: 2
+  dims:
+    - 4
+    - 64
+    - 128
+    - 256
+  nfft: 4096
+  hop_size: 1024
+  win_size: 4096
+  normalized: True
+  band_SR:
+    - 0.230
+    - 0.370
+    - 0.400
+  band_stride:
+    - 1
+    - 4
+    - 16
+  band_kernel:
+    - 3
+    - 4
+    - 16
+  conv_depths:
+    - 3
+    - 2
+    - 1
+  compress: 4
+  conv_kernel: 3
+  num_dplayer: 8
+  expand: 1
+
+training:
+  batch_size: 4
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - Drums
+    - Bass
+    - Other
+    - Vocals
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  # optimizer: prodigy
+  optimizer: adam
+  lr: 1.0e-05
+  # lr: 1.0
+  normalize: false # perform normalization on input of model (use the same for inference!)
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: true # enable or disable usage of mixed precision (float16) - usually it must be true
+
+
+augmentations:
+  enable: false # enable or disable all augmentations (to fast disable if needed)
+  loudness: true # randomly change loudness of each stem on the range (loudness_min; loudness_max)
+  loudness_min: 0.5
+  loudness_max: 1.5
+  mixup: true # mix several stems of same type with some probability (only works for dataset types: 1, 2, 3)
+  mixup_probs: !!python/tuple # 2 additional stems of the same type (1st with prob 0.2, 2nd with prob 0.02)
+    - 0.2
+    - 0.02
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+  # apply mp3 compression to mixture only (emulate downloading mp3 from internet)
+  mp3_compression_on_mixture: 0.01
+  mp3_compression_on_mixture_bitrate_min: 32
+  mp3_compression_on_mixture_bitrate_max: 320
+  mp3_compression_on_mixture_backend: "lameenc"
+
+  all:
+    channel_shuffle: 0.5 # Set 0 or lower to disable
+    random_inverse: 0.1 # inverse track (better lower probability)
+    random_polarity: 0.5 # polarity change (multiply waveform to -1)
+
+    mp3_compression: 0.01
+    mp3_compression_min_bitrate: 32
+    mp3_compression_max_bitrate: 320
+    mp3_compression_backend: "lameenc"
+
+    # pedalboard reverb block
+    pedalboard_reverb: 0.01
+    pedalboard_reverb_room_size_min: 0.1
+    pedalboard_reverb_room_size_max: 0.9
+    pedalboard_reverb_damping_min: 0.1
+    pedalboard_reverb_damping_max: 0.9
+    pedalboard_reverb_wet_level_min: 0.1
+    pedalboard_reverb_wet_level_max: 0.9
+    pedalboard_reverb_dry_level_min: 0.1
+    pedalboard_reverb_dry_level_max: 0.9
+    pedalboard_reverb_width_min: 0.9
+    pedalboard_reverb_width_max: 1.0
+
+    # pedalboard chorus block
+    pedalboard_chorus: 0.01
+    pedalboard_chorus_rate_hz_min: 1.0
+    pedalboard_chorus_rate_hz_max: 7.0
+    pedalboard_chorus_depth_min: 0.25
+    pedalboard_chorus_depth_max: 0.95
+    pedalboard_chorus_centre_delay_ms_min: 3
+    pedalboard_chorus_centre_delay_ms_max: 10
+    pedalboard_chorus_feedback_min: 0.0
+    pedalboard_chorus_feedback_max: 0.5
+    pedalboard_chorus_mix_min: 0.1
+    pedalboard_chorus_mix_max: 0.9
+
+    # pedalboard phazer block
+    pedalboard_phazer: 0.01
+    pedalboard_phazer_rate_hz_min: 1.0
+    pedalboard_phazer_rate_hz_max: 10.0
+    pedalboard_phazer_depth_min: 0.25
+    pedalboard_phazer_depth_max: 0.95
+    pedalboard_phazer_centre_frequency_hz_min: 200
+    pedalboard_phazer_centre_frequency_hz_max: 12000
+    pedalboard_phazer_feedback_min: 0.0
+    pedalboard_phazer_feedback_max: 0.5
+    pedalboard_phazer_mix_min: 0.1
+    pedalboard_phazer_mix_max: 0.9
+
+    # pedalboard distortion block
+    pedalboard_distortion: 0.01
+    pedalboard_distortion_drive_db_min: 1.0
+    pedalboard_distortion_drive_db_max: 25.0
+
+    # pedalboard pitch shift block
+    pedalboard_pitch_shift: 0.01
+    pedalboard_pitch_shift_semitones_min: -7
+    pedalboard_pitch_shift_semitones_max: 7
+
+    # pedalboard resample block
+    pedalboard_resample: 0.01
+    pedalboard_resample_target_sample_rate_min: 4000
+    pedalboard_resample_target_sample_rate_max: 44100
+
+    # pedalboard bitcrash block
+    pedalboard_bitcrash: 0.01
+    pedalboard_bitcrash_bit_depth_min: 4
+    pedalboard_bitcrash_bit_depth_max: 16
+
+    # pedalboard mp3 compressor block
+    pedalboard_mp3_compressor: 0.01
+    pedalboard_mp3_compressor_pedalboard_mp3_compressor_min: 0
+    pedalboard_mp3_compressor_pedalboard_mp3_compressor_max: 9.999
+
+  vocals:
+      pitch_shift: 0.1
+      pitch_shift_min_semitones: -5
+      pitch_shift_max_semitones: 5
+      seven_band_parametric_eq: 0.25
+      seven_band_parametric_eq_min_gain_db: -9
+      seven_band_parametric_eq_max_gain_db: 9
+      tanh_distortion: 0.1
+      tanh_distortion_min: 0.1
+      tanh_distortion_max: 0.7
+  bass:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -2
+    pitch_shift_max_semitones: 2
+    seven_band_parametric_eq: 0.25
+    seven_band_parametric_eq_min_gain_db: -3
+    seven_band_parametric_eq_max_gain_db: 6
+    tanh_distortion: 0.2
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.5
+  drums:
+    pitch_shift: 0.33
+    pitch_shift_min_semitones: -5
+    pitch_shift_max_semitones: 5
+    seven_band_parametric_eq: 0.25
+    seven_band_parametric_eq_min_gain_db: -9
+    seven_band_parametric_eq_max_gain_db: 9
+    tanh_distortion: 0.33
+    tanh_distortion_min: 0.1
+    tanh_distortion_max: 0.6
+  other:
+    pitch_shift: 0.1
+    pitch_shift_min_semitones: -4
+    pitch_shift_max_semitones: 4
+    gaussian_noise: 0.1
+    gaussian_noise_min_amplitude: 0.001
+    gaussian_noise_max_amplitude: 0.015
+    time_stretch: 0.01
+    time_stretch_min_rate: 0.8
+    time_stretch_max_rate: 1.25
+
+inference:
+  batch_size: 4
+  dim_t: 256
+  num_overlap: 4
+  normalize: false