init data

.gitattributes

@@ -56,3 +56,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data_pipeline/ssl/km_xlsr_1024_18l filter=lfs diff=lfs merge=lfs -text
+data_pipeline/ssl/km_xlsr_512_18l filter=lfs diff=lfs merge=lfs -text
+rap_songs.csv filter=lfs diff=lfs merge=lfs -text

data_pipeline/asr/faster_whisper_mp.py

@@ -0,0 +1,179 @@
+import sys
+import os
+#from tqdm import tqdm
+import torch
+import torch.multiprocessing as mp
+import threading
+#import librosa
+#import numpy as np
+from faster_whisper import WhisperModel
+#import whisper
+import glob
+import fcntl
+import argparse
+import traceback
+from tqdm import tqdm
+import numpy as np
+import librosa
+import soxr
+import multiprocessing
+
+def normalize_audio(y, target_dbfs=0):
+    max_amplitude = np.max(np.abs(y))
+    if max_amplitude < 0.1:
+        return y
+
+    target_amplitude = 10.0**(target_dbfs / 20.0)
+    scale_factor = target_amplitude / max_amplitude
+
+    normalized_audio = y * scale_factor
+
+    return normalized_audio
+file_lock = multiprocessing.Lock()
+
+def inference(rank, ckpt_path, text_path, queue: mp.Queue):
+    device = f"cuda"
+    model = WhisperModel(ckpt_path, device=device, device_index=rank, compute_type="float16")
+    puncs = list(",.?!")
+    buffer = ""
+    def write_to_file(data):
+        with file_lock:
+            with open(text_path, 'a') as f:
+                f.write(data)
+
+    
+    with torch.no_grad():
+        while True:
+            #print(texts)
+            filename = queue.get()
+            if filename is None:
+                write_to_file(buffer)
+                break
+            filename = filename[0]
+
+            try:
+                audio_path = filename
+                audio, sr = librosa.load(audio_path, sr=None)
+                audio = normalize_audio(audio, -6)
+                audio = soxr.resample(
+                    audio,
+                    sr,
+                    16000
+                )
+                segments, info = model.transcribe(audio, beam_size=3, vad_filter=True, condition_on_previous_text=False)
+                text = ""
+
+                for segment in segments:
+                    text_segment = segment.text
+                    text_segment.strip()
+                    if len(text_segment) == 0:
+                        continue
+                    if not text_segment[-1] in puncs:
+                        text_segment += ","
+                    text = text + " " + text_segment
+                text = text.replace("  ", " ")
+                text = text.strip()
+                if len(text) == 0:
+                    continue
+                if text[-1] == ",":
+                    text = text[:-1] + "."
+
+                buffer += f"{filename}|{text}|{info.language}|{info.language_probability}\n"
+                if len(buffer) > 10000:
+                    write_to_file(buffer)
+                    buffer = ""
+            
+            except Exception as e:
+                print(filename)
+                traceback.print_exc()
+
+
+def setInterval(interval):
+    def decorator(function):
+        def wrapper(*args, **kwargs):
+            stopped = threading.Event()
+
+            def loop():  # executed in another thread
+                while not stopped.wait(interval):  # until stopped
+                    function(*args, **kwargs)
+
+            t = threading.Thread(target=loop)
+            t.daemon = True  # stop if the program exits
+            t.start()
+            return stopped
+
+        return wrapper
+
+    return decorator
+
+last_batches = None
+
+@setInterval(5)
+def QueueWatcher(queue, bar):
+    global last_batches
+    curr_batches = queue.qsize()
+    bar.update(last_batches-curr_batches)
+    last_batches = curr_batches
+
+if __name__ == "__main__":
+    #audio_dir = sys.argv[1]
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--filelist_or_dir", type=str, required=True)
+    parser.add_argument("--text_path", type=str, required=True, help="Dir to save output")
+    parser.add_argument("--jobs", type=int, required=False, default=2, help="Path to save checkpoints")
+    parser.add_argument("--ckpt_path", type=str, required=False, default="large-v3")
+    parser.add_argument("--log_dir", type=str, required=False, default="large-v3", help="For aml compability")
+    parser.add_argument("--model_dir", type=str, required=False, default="large-v3", help="For aml compability")
+    args = parser.parse_args()
+
+    mp.set_start_method('spawn',force=True)
+
+    filelist_or_dir = args.filelist_or_dir
+    text_path = args.text_path
+    jobs = args.jobs
+    ckpt_path = args.ckpt_path
+    os.makedirs(text_path, exist_ok=True)
+    model = WhisperModel(ckpt_path, device='cpu') # download model in one thread
+    del(model)
+    
+    if os.path.isfile(filelist_or_dir):
+        filelist_name = filelist_or_dir.split('/')[-1].split('.')[0]
+        generator = open(filelist_or_dir).read().splitlines()
+        text_path = os.path.join(text_path, f"{filelist_name}_text.txt")
+    else:
+        filelist_name = "single"
+        generator = glob.glob(f"{filelist_or_dir}/*.wav")
+        text_path = os.path.join(text_path, "text.txt")
+
+    os.system(f"rm {text_path}")
+
+    gpu_num = torch.cuda.device_count()
+
+    processes = []
+    queue = mp.Queue()
+    for thread_num in range(jobs):
+        
+        rank = thread_num % gpu_num
+        p = mp.Process(target=inference, args=(rank, ckpt_path, text_path, queue))
+        p.start()
+        processes.append(p)
+
+    accum = []
+    tmp_file = []
+
+    for filename in generator:
+        accum.append(filename)
+        if len(accum) == 1:
+            queue.put(accum.copy())
+            accum.clear()
+
+
+    for _ in range(jobs):
+        queue.put(None)
+
+    last_batches = queue.qsize()
+    bar = tqdm(total=last_batches, desc='whisper')
+    queue_watcher = QueueWatcher(queue, bar)
+    for p in processes:
+        p.join()
+    queue_watcher.set()

data_pipeline/ckpts/bs_roformer/model_bs_roformer_ep_317_sdr_12.9755.ckpt

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

data_pipeline/ckpts/bs_roformer/model_bs_roformer_ep_317_sdr_12.9755.yaml

@@ -0,0 +1,126 @@
+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: 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.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: 2
+  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
+  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: 4
+  dim_t: 801
+  num_overlap: 2

data_pipeline/ckpts/dnsmos_p808.onnx

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

data_pipeline/ckpts/wav2vec2_xlsr_300m.pth

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

data_pipeline/duration/duration_mutagen.py

@@ -0,0 +1,39 @@
+import os
+import glob
+import sys
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+import numpy as np
+from mutagen.wave import WAVE # mutagen for reading wav metadata
+
+filelist_or_dir = sys.argv[1] # filelist including absolute path or data root path
+
+total_duration = 0.
+durations = []
+
+
+def get_wav_duration(file_path):
+    try:
+        duration = WAVE(file_path).info.length
+        return duration
+    except Exception as e:
+        print('Error occurred:', e)
+        return None
+
+if os.path.isdir(filelist_or_dir):
+    filelist = [os.path.join(filelist_or_dir, filename) for filename in glob.glob(os.path.join(filelist_or_dir, '**/*.wav'), recursive=True)]
+else:
+    filelist = open(filelist_or_dir, 'r').read().splitlines()
+for wav_path in tqdm(filelist):
+    try:
+        duration = get_wav_duration(wav_path)
+        total_duration += duration
+        durations.append(duration)
+    except Exception as e:
+        print(e)
+
+print(f"total_duration: {total_duration}, avg_duration: {total_duration / len(durations)}")
+
+#plt.hist(durations, bins=50, range=(0, 50))
+#plt.savefig(os.path.join(os.path.dirname(data_root), "durations.png"))
+#np.save(os.path.join(os.path.dirname(data_root), "1.npy"), np.array(durations))

data_pipeline/g2p_en.py

@@ -0,0 +1,138 @@
+""" from https://github.com/keithito/tacotron """
+
+'''
+Cleaners are transformations that run over the input text at both training and eval time.
+
+Cleaners can be selected by passing a comma-delimited list of cleaner names as the "cleaners"
+hyperparameter. Some cleaners are English-specific. You'll typically want to use:
+  1. "english_cleaners" for English text
+  2. "transliteration_cleaners" for non-English text that can be transliterated to ASCII using
+     the Unidecode library (https://pypi.python.org/pypi/Unidecode)
+  3. "basic_cleaners" if you do not want to transliterate (in this case, you should also update
+     the symbols in symbols.py to match your data).
+'''
+
+import re
+from unidecode import unidecode
+from phonemizer import phonemize
+from phonemizer.backend import EspeakBackend
+import matplotlib.pyplot as plt
+import traceback
+import sys
+import os
+from tqdm import tqdm
+import numpy as np
+
+
+# Regular expression matching whitespace:
+_whitespace_re = re.compile(r'\s+')
+
+# List of (regular expression, replacement) pairs for abbreviations:
+_abbreviations = [(re.compile('\\b%s\\.' % x[0], re.IGNORECASE), x[1]) for x in [
+  ('mrs', 'misess'),
+  ('mr', 'mister'),
+  ('dr', 'doctor'),
+  ('st', 'saint'),
+  ('co', 'company'),
+  ('jr', 'junior'),
+  ('maj', 'major'),
+  ('gen', 'general'),
+  ('drs', 'doctors'),
+  ('rev', 'reverend'),
+  ('lt', 'lieutenant'),
+  ('hon', 'honorable'),
+  ('sgt', 'sergeant'),
+  ('capt', 'captain'),
+  ('esq', 'esquire'),
+  ('ltd', 'limited'),
+  ('col', 'colonel'),
+  ('ft', 'fort'),
+]]
+
+
+def expand_abbreviations(text):
+  for regex, replacement in _abbreviations:
+    text = re.sub(regex, replacement, text)
+  return text
+
+
+def expand_numbers(text):
+  return normalize_numbers(text)
+
+
+def lowercase(text):
+  return text.lower()
+
+
+def collapse_whitespace(text):
+  return re.sub(_whitespace_re, ' ', text)
+
+
+def convert_to_ascii(text):
+  return unidecode(text)
+
+
+def basic_cleaners(text):
+  '''Basic pipeline that lowercases and collapses whitespace without transliteration.'''
+  text = lowercase(text)
+  text = collapse_whitespace(text)
+  return text
+
+
+def transliteration_cleaners(text):
+  '''Pipeline for non-English text that transliterates to ASCII.'''
+  text = convert_to_ascii(text)
+  text = lowercase(text)
+  text = collapse_whitespace(text)
+  return text
+
+
+def english_cleaners(text):
+  '''Pipeline for English text, including abbreviation expansion.'''
+  text = convert_to_ascii(text)
+  text = lowercase(text)
+  text = expand_abbreviations(text)
+  phonemes = phonemize(text, language='en-us', backend='espeak', strip=True)
+  phonemes = collapse_whitespace(phonemes)
+  return phonemes
+
+
+def english_cleaners2(text):
+  '''Pipeline for English text, including abbreviation expansion. + punctuation + stress'''
+
+
+if __name__ == '__main__':
+  text_file = sys.argv[1]
+  phoneme_file = sys.argv[2]
+
+  backend = EspeakBackend('en-us', preserve_punctuation=True, with_stress=True)
+
+  buffer = ""
+
+  out_file = open(phoneme_file, 'w')
+  for line in tqdm(open(text_file, errors='ignore').read().splitlines()):
+    try:
+      filepath, text, language, confidence = line.split('|')
+      confidence = float(confidence)
+      filename = os.path.basename(filepath).split('.')[0]
+      duration = float(filename.split('_')[-1]) / 1000
+
+      if language == "en":
+        phone = convert_to_ascii(text)
+        phone = lowercase(phone)
+        phone = expand_abbreviations(phone)
+
+        phone = backend.phonemize([phone], strip=True)[0]
+        phone = collapse_whitespace(phone)
+        ratio = len(phone) / duration
+      else:
+        phone = "[blank]"
+        ratio = 0
+      buffer += f"{filepath}|{text}|{phone}|{language}|{confidence:.3f}|{ratio:.3f}\n"
+      if len(buffer) > 100000:
+        out_file.write(buffer)
+        buffer = ""
+    except Exception as e:
+      print(filename, line, e)
+      continue
+  out_file.write(buffer)

data_pipeline/g2p_es.py

@@ -0,0 +1,143 @@
+import re
+from unidecode import unidecode
+from transformers import T5ForConditionalGeneration, AutoTokenizer
+import matplotlib.pyplot as plt
+import traceback
+import sys
+import os
+from tqdm import tqdm
+import numpy as np
+
+
+# Regular expression matching whitespace:
+_whitespace_re = re.compile(r'\s+')
+
+# List of (regular expression, replacement) pairs for abbreviations:
+_abbreviations = [(re.compile('\\b%s\\.' % x[0], re.IGNORECASE), x[1]) for x in [
+  ('mrs', 'misess'),
+  ('mr', 'mister'),
+  ('dr', 'doctor'),
+  ('st', 'saint'),
+  ('co', 'company'),
+  ('jr', 'junior'),
+  ('maj', 'major'),
+  ('gen', 'general'),
+  ('drs', 'doctors'),
+  ('rev', 'reverend'),
+  ('lt', 'lieutenant'),
+  ('hon', 'honorable'),
+  ('sgt', 'sergeant'),
+  ('capt', 'captain'),
+  ('esq', 'esquire'),
+  ('ltd', 'limited'),
+  ('col', 'colonel'),
+  ('ft', 'fort'),
+]]
+
+
+def expand_abbreviations(text):
+  for regex, replacement in _abbreviations:
+    text = re.sub(regex, replacement, text)
+  return text
+
+
+def expand_numbers(text):
+  return normalize_numbers(text)
+
+
+def lowercase(text):
+  return text.lower()
+
+
+def collapse_whitespace(text):
+  return re.sub(_whitespace_re, ' ', text)
+
+
+def convert_to_ascii(text):
+  return unidecode(text)
+
+puncs_to_remove = ["♪", "#", "¿", "¡", "-", "*"]
+puncs_to_remove = "".join(puncs_to_remove)
+def normalize(text):
+  text = text.translate(str.maketrans('', '', puncs_to_remove))
+  text = text.strip()
+  return text
+
+
+def basic_cleaners(text):
+  '''Basic pipeline that lowercases and collapses whitespace without transliteration.'''
+  text = lowercase(text)
+  text = collapse_whitespace(text)
+  return text
+
+
+def transliteration_cleaners(text):
+  '''Pipeline for non-English text that transliterates to ASCII.'''
+  text = convert_to_ascii(text)
+  text = lowercase(text)
+  text = collapse_whitespace(text)
+  return text
+
+
+def english_cleaners(text):
+  '''Pipeline for English text, including abbreviation expansion.'''
+  text = convert_to_ascii(text)
+  text = lowercase(text)
+  text = expand_abbreviations(text)
+  phonemes = phonemize(text, language='en-us', backend='espeak', strip=True)
+  phonemes = collapse_whitespace(phonemes)
+  return phonemes
+
+
+def english_cleaners2(text):
+  '''Pipeline for English text, including abbreviation expansion. + punctuation + stress'''
+
+
+if __name__ == '__main__':
+  text_file = sys.argv[1]
+  phoneme_file = sys.argv[2]
+
+
+  model = T5ForConditionalGeneration.from_pretrained('charsiu/g2p_multilingual_byT5_tiny_16_layers_100')
+  #model.cuda()
+  tokenizer = AutoTokenizer.from_pretrained('google/byt5-small')
+
+  buffer = ""
+
+  out_file = open(phoneme_file, 'w')
+  for line in tqdm(open(text_file, errors='ignore').read().splitlines()):
+    try:
+      filepath, text, language, confidence = line.split('|')
+      confidence = float(confidence)
+      filename = os.path.basename(filepath).split('.')[0]
+      duration = float(filename.split('_')[-1]) / 1000
+
+      if language == "es":
+        #text = convert_to_ascii(text)
+        text = normalize(text)
+        text = lowercase(text)
+        print(text)
+
+        words = text.split(' ')
+        words = ['<spa>: '+i for i in words]
+        out = tokenizer(words,padding=True,add_special_tokens=False,return_tensors='pt')
+
+        preds = model.generate(**out,num_beams=1,max_length=50) # We do not find beam search helpful. Greedy decoding is enough. 
+        phone = tokenizer.batch_decode(preds.tolist(),skip_special_tokens=True)
+        phone = " ".join(phone)
+        print(phone)
+
+        phone = collapse_whitespace(phone)
+        ratio = len(phone) / duration
+      else:
+        phone = "[blank]"
+        ratio = 0
+      buffer += f"{filepath}|{text}|{phone}|{language}|{confidence:.3f}|{ratio:.3f}\n"
+      if len(buffer) > 100000:
+        out_file.write(buffer)
+        buffer = ""
+      #break
+    except Exception as e:
+      print(filename, line, e)
+      continue
+  out_file.write(buffer)

data_pipeline/merge_metrics.py

@@ -0,0 +1,64 @@
+
+import re
+from unidecode import unidecode
+from phonemizer import phonemize
+from phonemizer.backend import EspeakBackend
+import matplotlib.pyplot as plt
+import traceback
+import argparse
+import os
+from tqdm import tqdm
+import numpy as np
+
+
+if __name__ == '__main__':
+  parser = argparse.ArgumentParser()
+  parser.add_argument("--phone", type=str, required=True)
+  parser.add_argument("--mos", type=str, required=True)
+  parser.add_argument("--spk", type=str, required=True)
+  parser.add_argument("--output", type=str, required=True)
+  args = parser.parse_args()
+
+  ratios = []
+
+  mos_file = open(args.mos, 'r').read().splitlines()
+  mos = {}
+  for line in mos_file:
+    try:
+      file_path, mos_score = line.split('|')
+      filename = os.path.basename(file_path).split('.')[0]
+      mos[filename] = float(mos_score)
+    except:
+      print(line)
+
+  spk_file = open(args.spk).read().splitlines()
+  spk = {}
+  for line in spk_file:
+    try:
+      file_path, score = line.split('|')
+      filename = os.path.basename(file_path).split('.')[0]
+      spk[filename] = float(score)
+    except:
+      print(line)
+
+  buffer = ""
+  out_file = open(args.output, 'w')
+  for line in tqdm(open(args.phone, errors='ignore').read().splitlines()):
+    try:
+      filepath, text, phone, language, confidence, ratio = line.split('|')
+      confidence = float(confidence)
+      ratio = float(ratio)
+      filename = os.path.basename(filepath).split('.')[0]
+      mos_score = mos[filename]
+      spk_score = spk[filename]
+
+      buffer += f"{filepath}|{text}|{phone}|{mos_score:.3f}|{language}|{confidence:.3f}|{spk_score:.3f}|{ratio:.3f}\n"
+      if len(buffer) > 100000:
+        out_file.write(buffer)
+        buffer = ""
+      ratios.append(ratio)
+    except Exception as e:
+      print(e, line)
+      traceback.print_exc()
+      continue
+  out_file.write(buffer)

data_pipeline/pipeline.sh

@@ -0,0 +1,54 @@
+#input_dir=$PWD/$1
+input_dir=$1
+output_root=$2
+stage=${3:-0}
+stop_stage=${4:-2}
+
+echo "from ${input_dir} to ${output_root}"
+python3 --version
+
+set -euo pipefail
+
+# seperation & segmentation
+if [ ${stage} -le 0 ] && [ ${stop_stage} -ge 0 ]; then
+echo "Seperating..."
+cd seperation
+python3 inference_mp.py --filelist_or_dir $output_root/wav --out_dir $output_root --jobs 2 --ckpt_path /data/v-ziqianning/SingingTTS/data_pipeline/ckpts/bs_roformer
+cd -
+fi
+
+if [ ${stage} -le 1 ] && [ ${stop_stage} -ge 1 ]; then
+echo "Segmenting..."
+cd vad
+python3 vad_webrtcvad.py --filelist_or_dir ${input_dir}/vocal --out_dir ${output_root}/ --jobs 16
+cd -
+fi
+
+# ssl
+if [ ${stage} -le 2 ] && [ ${stop_stage} -ge 2 ]; then
+echo "Extracting SSL..."
+cd ssl
+python3 extract_xlsr.py $output_root/vocal_cut $output_root 2    # vocal
+python3 extract_xlsr_6l.py $output_root/vocal_cut $output_root 2 # bgm
+cd -
+fi
+
+if [ ${stage} -le 3 ] && [ ${stop_stage} -ge 3 ]; then
+echo "Quality Metrics..."
+cd quality
+python3 dnsmos_mp.py --filelist_or_dir $output_root/vocal_cut --text_path $output_root --jobs 8 --ckpt_path /data/v-ziqianning/SingingTTS/data_pipeline/ckpts
+python3 pyannote_mp.py --filelist_or_dir $output_root/vocal_cut --text_path $output_root --jobs 8 
+cd -
+fi
+
+if [ ${stage} -le 4 ] && [ ${stop_stage} -ge 4 ]; then
+echo "Extracting lyrics..."
+cd asr
+python3 faster_whisper_mp.py --filelist_or_dir $output_root/vocal_cut --text_path $output_root --jobs 2
+cd -
+fi
+
+if [ ${stage} -le 5 ] && [ ${stop_stage} -ge 5 ]; then
+python3 g2p_en.py $output_root/text.txt $output_root/phoneme.txt
+python3 merge_metrics.py --phone $output_root/phoneme.txt --mos $output_root/dnsmos.txt --spk $output_root/spk.txt --output $output_root/data.txt
+fi

data_pipeline/quality/dnsmos_mp.py

@@ -0,0 +1,266 @@
+import sys
+import os
+import torch
+import torch.multiprocessing as mp
+import threading
+import numpy as np
+import glob
+import argparse
+import librosa
+import soxr
+from tqdm import tqdm
+import traceback
+import multiprocessing
+#from speechmos import dnsmos
+import onnxruntime as ort
+os.environ["OMP_NUM_THREADS"] = "1"
+#os.environ["MKL_NUM_THREADS"] = "1"
+
+file_lock = multiprocessing.Lock()
+
+SR = 16000
+INPUT_LENGTH = 9.01
+dnsmos = None
+
+
+class DNSMOS:
+    def __init__(self, primary_model_path, p808_model_path, rank) -> None:
+        self.primary_model_path = primary_model_path
+        sess_opt = ort.SessionOptions()
+        sess_opt.intra_op_num_threads = 1
+        sess_opt.inter_op_num_threads = 1
+        sess_opt.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+        #providers = [("CUDAExecutionProvider", {"device_id": torch.cuda.current_device(),})]
+        #providers = ["CUDAExecutionProvider"]
+        #providers = ["CPUExecutionProvider"]
+        providers = [
+            ('CUDAExecutionProvider', {
+                'device_id': rank,
+            }),
+            'CPUExecutionProvider',
+        ]
+        #self.onnx_sess = ort.InferenceSession(self.primary_model_path, sess_opt, providers=providers)
+        self.p808_onnx_sess = ort.InferenceSession(p808_model_path, sess_opt, providers=providers)
+        #print(self.p808_onnx_sess.get_providers())
+
+    def audio_melspec(self, audio, n_mels=120, frame_size=320, hop_length=160, sr=16000, to_db=True):
+        mel_spec = librosa.feature.melspectrogram(
+            y=audio, sr=sr, n_fft=frame_size + 1, hop_length=hop_length, n_mels=n_mels)
+        if to_db:
+            mel_spec = (librosa.power_to_db(mel_spec, ref=np.max) + 40) / 40
+        return mel_spec.T
+
+    def get_polyfit_val(self, sig, bak, ovr, is_personalized_MOS):
+        if is_personalized_MOS:
+            p_ovr = np.poly1d(
+                [-0.00533021, 0.005101, 1.18058466, -0.11236046])
+            p_sig = np.poly1d(
+                [-0.01019296, 0.02751166, 1.19576786, -0.24348726])
+            p_bak = np.poly1d(
+                [-0.04976499, 0.44276479, -0.1644611, 0.96883132])
+        else:
+            p_ovr = np.poly1d([-0.06766283, 1.11546468, 0.04602535])
+            p_sig = np.poly1d([-0.08397278, 1.22083953, 0.0052439])
+            p_bak = np.poly1d([-0.13166888, 1.60915514, -0.39604546])
+
+        sig_poly = p_sig(sig)
+        bak_poly = p_bak(bak)
+        ovr_poly = p_ovr(ovr)
+
+        return sig_poly, bak_poly, ovr_poly
+
+    def __call__(self, sample, fs, is_personalized_MOS):
+        clip_dict = {}
+        if isinstance(sample, np.ndarray):
+            audio = sample
+            if not ((audio >= -1).all() and (audio <= 1).all()):
+                raise ValueError("np.ndarray values must be between -1 and 1.")
+        elif isinstance(sample, str) and os.path.isfile(sample):
+            audio, _ = librosa.load(sample, sr=fs)
+            clip_dict['filename'] = sample
+        else:
+            raise ValueError(
+                f"Input must be a numpy array or a path to an audio file.")
+
+        len_samples = int(INPUT_LENGTH * fs)
+        while len(audio) < len_samples:
+            audio = np.append(audio, audio)
+
+        num_hops = int(np.floor(len(audio) / fs) - INPUT_LENGTH) + 1
+        hop_len_samples = fs
+        predicted_mos_sig_seg = []
+        predicted_mos_bak_seg = []
+        predicted_mos_ovr_seg = []
+        predicted_p808_mos = []
+
+        for idx in range(num_hops):
+            audio_seg = audio[int(idx * hop_len_samples): int((idx + INPUT_LENGTH) * hop_len_samples)]
+            if len(audio_seg) < len_samples:
+                continue
+
+            input_features = np.array(audio_seg).astype(
+                'float32')[np.newaxis, :]
+            p808_input_features = np.array(self.audio_melspec(
+                audio=audio_seg[:-160])).astype('float32')[np.newaxis, :, :]
+            oi = {'input_1': input_features}
+            p808_oi = {'input_1': p808_input_features}
+            p808_mos = self.p808_onnx_sess.run(None, p808_oi)[0][0][0]
+            #mos_sig_raw, mos_bak_raw, mos_ovr_raw = self.onnx_sess.run(None, oi)[
+            #    0][0]
+            #mos_sig, mos_bak, mos_ovr = self.get_polyfit_val(
+            #    mos_sig_raw, mos_bak_raw, mos_ovr_raw, is_personalized_MOS)
+            #predicted_mos_sig_seg.append(mos_sig)
+            #predicted_mos_bak_seg.append(mos_bak)
+            #predicted_mos_ovr_seg.append(mos_ovr)
+            predicted_p808_mos.append(p808_mos)
+
+        #clip_dict['ovrl_mos'] = np.mean(predicted_mos_ovr_seg)
+        #clip_dict['sig_mos'] = np.mean(predicted_mos_sig_seg)
+        #clip_dict['bak_mos'] = np.mean(predicted_mos_bak_seg)
+        clip_dict['p808_mos'] = np.mean(predicted_p808_mos)
+        return clip_dict
+
+def normalize_audio(y, target_dbfs=0):
+    max_amplitude = np.max(np.abs(y))
+    if max_amplitude < 0.1:
+        return y
+
+    target_amplitude = 10.0**(target_dbfs / 20.0)
+    scale_factor = target_amplitude / max_amplitude
+    #print(max_amplitude, target_amplitude, scale_factor)
+
+    normalized_audio = y * scale_factor
+
+    return normalized_audio
+
+
+def inference(rank, ckpt_dir, text_path, queue: mp.Queue):
+    p808_model_path = os.path.join(ckpt_dir, 'dnsmos_p808.onnx')
+    primary_model_path = os.path.join(ckpt_dir, 'sig_bak_ovr.onnx')
+    dnsmos = DNSMOS(primary_model_path, p808_model_path, rank)
+
+    def write_to_file(data):
+        with file_lock:
+            with open(text_path, 'a') as f:
+                f.write(data)
+
+    buffer = ""
+    
+    with torch.no_grad():
+        while True:
+            #print(texts)
+            filename = queue.get()
+            if filename is None:
+                write_to_file(buffer)
+                break
+            try:
+                filename = filename[0]
+                audio_path = filename
+                wav, sr = librosa.load(audio_path, sr=None)
+                wav = normalize_audio(wav, -6)
+                wav = soxr.resample(
+                    wav,          # 1D(mono) or 2D(frames, channels) array input
+                    sr,      # input samplerate
+                    16000       # target samplerate
+                )
+                if wav.min() < -1 or wav.min() > 1:
+                    print(audio_path)
+                mos_dict = dnsmos(wav, 16000, False)
+                p808_mos = mos_dict['p808_mos']
+                buffer += f"{filename}|{p808_mos:3}\n"
+                if len(buffer) > 10000:
+                    write_to_file(buffer)
+                    buffer = ""
+            except Exception as e:
+                print(audio_path)
+                traceback.print_exc()
+
+
+def setInterval(interval):
+    def decorator(function):
+        def wrapper(*args, **kwargs):
+            stopped = threading.Event()
+
+            def loop():  # executed in another thread
+                while not stopped.wait(interval):  # until stopped
+                    function(*args, **kwargs)
+
+            t = threading.Thread(target=loop)
+            t.daemon = True  # stop if the program exits
+            t.start()
+            return stopped
+
+        return wrapper
+
+    return decorator
+
+last_batches = None
+
+@setInterval(5)
+def QueueWatcher(queue, bar):
+    global last_batches
+    curr_batches = queue.qsize()
+    bar.update(last_batches-curr_batches)
+    last_batches = curr_batches
+
+
+if __name__ == "__main__":
+    #audio_dir = sys.argv[1]
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--filelist_or_dir", type=str, required=True)
+    parser.add_argument("--text_path", type=str, required=True, help="Dir to save output")
+    parser.add_argument("--jobs", type=int, required=False, default=2)
+    parser.add_argument("--log_dir", type=str, required=False, help="For aml compatibility")
+    parser.add_argument("--model_dir", type=str, required=False, help="For aml compatibility")
+    parser.add_argument("--ckpt_path", type=str, required=False, default=".")
+    args = parser.parse_args()
+
+    mp.set_start_method('spawn',force=True)
+
+    filelist_or_dir = args.filelist_or_dir
+    text_path = args.text_path
+    jobs = args.jobs
+    ckpt_path = args.ckpt_path
+    os.makedirs(text_path, exist_ok=True)
+    
+    if os.path.isfile(filelist_or_dir):
+        filelist_name = filelist_or_dir.split('/')[-1].split('.')[0]
+        generator = open(filelist_or_dir).read().splitlines()
+        text_path = os.path.join(text_path, f"{filelist_name}_dnsmos.txt")
+    else:
+        filelist_name = "single"
+        generator = glob.glob(f"{filelist_or_dir}/*.wav")
+        text_path = os.path.join(text_path, "dnsmos.txt")
+
+    os.system(f"rm {text_path}")
+
+    gpu_num = torch.cuda.device_count()
+
+    processes = []
+    queue = mp.Queue()
+    for thread_num in range(jobs):
+        
+        rank = thread_num % gpu_num
+        p = mp.Process(target=inference, args=(rank, ckpt_path, text_path, queue))
+        p.start()
+        processes.append(p)
+
+    accum = []
+    tmp_file = []
+
+    for filename in generator:
+        accum.append(filename)
+        if len(accum) == 1:
+            queue.put(accum.copy())
+            accum.clear()
+
+
+    for _ in range(jobs):
+        queue.put(None)
+
+    last_batches = queue.qsize()
+    bar = tqdm(total=last_batches, desc='dnsmos')
+    queue_watcher = QueueWatcher(queue, bar)
+    for p in processes:
+        p.join()
+    queue_watcher.set()

data_pipeline/quality/pyannote_mp.py

@@ -0,0 +1,152 @@
+import sys
+import os
+import torch
+import torch.multiprocessing as mp
+import multiprocessing
+import threading
+import numpy as np
+import glob
+import argparse
+from tqdm import tqdm
+from collections import defaultdict
+import traceback
+from pyannote.audio import Pipeline
+
+file_lock = multiprocessing.Lock()
+
+
+def inference(rank, text_path, queue: mp.Queue):
+    device=f"cuda:{rank}"
+    pipeline = Pipeline.from_pretrained(
+        "pyannote/speaker-diarization-3.1",
+        use_auth_token="Your huggingface token")
+    pipeline.to(torch.device(device))
+
+    def write_to_file(data):
+        with file_lock:
+            with open(text_path, 'a') as f:
+                f.write(data)
+
+    buffer = ""
+    
+    with torch.no_grad():
+        while True:
+            #print(texts)
+            filename = queue.get()
+            if filename is None:
+                write_to_file(buffer)
+                break
+            try:
+                filename = filename[0]
+                audio_path = filename
+
+                spks = defaultdict(float)
+                total_duration = 0.
+
+                diarization = pipeline(audio_path)
+                for turn, _, speaker in diarization.itertracks(yield_label=True):
+                    duration = turn.end - turn.start
+                    spks[speaker] += duration
+                    total_duration += duration
+
+                if len(spks) == 0:
+                    percentage = 0.
+                else:
+                    sorted_spks = sorted(spks.items(), key=lambda s:s[1], reverse=True)
+                    percentage = sorted_spks[0][1] / total_duration
+
+                buffer += f"{filename}|{percentage:3}\n"
+                if len(buffer) > 10000:
+                    write_to_file(buffer)
+                    buffer = ""
+            except Exception as e:
+                #print(sorted_spks)
+                traceback.print_exc()
+
+
+def setInterval(interval):
+    def decorator(function):
+        def wrapper(*args, **kwargs):
+            stopped = threading.Event()
+
+            def loop():  # executed in another thread
+                while not stopped.wait(interval):  # until stopped
+                    function(*args, **kwargs)
+
+            t = threading.Thread(target=loop)
+            t.daemon = True  # stop if the program exits
+            t.start()
+            return stopped
+
+        return wrapper
+
+    return decorator
+
+last_batches = None
+
+@setInterval(5)
+def QueueWatcher(queue, bar):
+    global last_batches
+    curr_batches = queue.qsize()
+    bar.update(last_batches-curr_batches)
+    last_batches = curr_batches
+
+
+if __name__ == "__main__":
+    #audio_dir = sys.argv[1]
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--filelist_or_dir", type=str, required=True)
+    parser.add_argument("--text_path", type=str, required=True, help="Dir to save output")
+    parser.add_argument("--jobs", type=int, required=False, default=2)
+    parser.add_argument("--log_dir", type=str, required=False, help="For aml compatibility")
+    parser.add_argument("--model_dir", type=str, required=False, help="For aml compatibility")
+    args = parser.parse_args()
+
+    mp.set_start_method('spawn',force=True)
+
+    filelist_or_dir = args.filelist_or_dir
+    text_path = args.text_path
+    jobs = args.jobs
+    os.makedirs(text_path, exist_ok=True)
+    
+    if os.path.isfile(filelist_or_dir):
+        filelist_name = filelist_or_dir.split('/')[-1].split('.')[0]
+        generator = open(filelist_or_dir).read().splitlines()
+        text_path = os.path.join(text_path, f"{filelist_name}_spk.txt")
+    else:
+        filelist_name = "single"
+        generator = glob.glob(f"{filelist_or_dir}/*.wav")
+        text_path = os.path.join(text_path, "spk.txt")
+
+    os.system(f"rm {text_path}")
+
+    gpu_num = torch.cuda.device_count()
+
+    processes = []
+    queue = mp.Queue()
+    for thread_num in range(jobs):
+        
+        rank = thread_num % gpu_num
+        p = mp.Process(target=inference, args=(rank, text_path, queue))
+        p.start()
+        processes.append(p)
+
+    accum = []
+    tmp_file = []
+
+    for filename in generator:
+        accum.append(filename)
+        if len(accum) == 1:
+            queue.put(accum.copy())
+            accum.clear()
+
+
+    for _ in range(jobs):
+        queue.put(None)
+
+    last_batches = queue.qsize()
+    bar = tqdm(total=last_batches, desc='pyannote')
+    queue_watcher = QueueWatcher(queue, bar)
+    for p in processes:
+        p.join()
+    queue_watcher.set()

data_pipeline/requirements.txt

@@ -0,0 +1,27 @@
+torch
+numpy
+pandas
+scipy
+soundfile
+ml_collections
+tqdm
+segmentation_models_pytorch==0.3.3
+timm==0.9.2
+audiomentations==0.24.0
+pedalboard==0.8.1
+omegaconf==2.2.3
+beartype==0.14.1
+rotary_embedding_torch==0.3.5
+einops==0.6.1
+librosa
+demucs==4.0.0
+transformers==4.35.0
+torchmetrics==0.11.4
+spafe==0.3.2
+protobuf==3.20.3
+torch_audiomentations
+asteroid==0.7.0
+auraloss
+pyannote.audio
+webrtcvad
+faster-whisper==0.10.1

data_pipeline/seperation/README.md

@@ -0,0 +1,139 @@
+# Music Source Separation Universal Training Code
+
+Repository for training models for music source separation. Repository is based on [kuielab code](https://github.com/kuielab/sdx23/tree/mdx_AB/my_submission/src) for [SDX23 challenge](https://github.com/kuielab/sdx23/tree/mdx_AB/my_submission/src). The main idea of this repository is to create training code, which is easy to modify for experiments. Brought to you by [MVSep.com](https://mvsep.com).
+
+## Models
+
+Model can be chosen with `--model_type` arg.
+
+Available models for training:
+* MDX23C based on [KUIELab TFC TDF v3 architecture](https://github.com/kuielab/sdx23/). Key: `mdx23c`.
+* Demucs4HT [[Paper](https://arxiv.org/abs/2211.08553)]. Key: `htdemucs`.
+* VitLarge23 based on [Segmentation Models Pytorch](https://github.com/qubvel/segmentation_models.pytorch). Key: `segm_models`. 
+* Band Split RoFormer [[Paper](https://arxiv.org/abs/2309.02612), [Repository](https://github.com/lucidrains/BS-RoFormer)] . Key: `bs_roformer`. 
+* Mel-Band RoFormer [[Paper](https://arxiv.org/abs/2310.01809), [Repository](https://github.com/lucidrains/BS-RoFormer)]. Key: `mel_band_roformer`.
+* Swin Upernet [[Paper](https://arxiv.org/abs/2103.14030)] Key: `swin_upernet`.
+* BandIt Plus [[Paper](https://arxiv.org/abs/2309.02539), [Repository](https://github.com/karnwatcharasupat/bandit)] Key: `bandit`.
+* SCNet [[Paper](https://arxiv.org/abs/2401.13276), [Official Repository](https://github.com/starrytong/SCNet), [Unofficial Repository](https://github.com/amanteur/SCNet-PyTorch)] Key: `scnet`.
+
+ **Note 1**: For `segm_models` there are many different encoders is possible. [Look here](https://github.com/qubvel/segmentation_models.pytorch#encoders-).
+ 
+ **Note 2**: Thanks to [@lucidrains](https://github.com/lucidrains) for recreating the RoFormer models based on papers.
+
+## How to train
+
+To train model you need to:
+
+1) Choose model type with key `--model_type`. Possible values: `mdx23c`, `htdemucs`, `segm_models`, `mel_band_roformer`, `bs_roformer`.
+2) Choose location of config for model `--config_path` `<config path>`. You can find examples of configs in [configs folder](configs/). Prefixes `config_musdb18_` are examples for [MUSDB18 dataset](https://sigsep.github.io/datasets/musdb.html).
+3) If you have some check-point from the same model or from the similar model you can use it with: `--start_check_point` `<weights path>`
+4) Choose path where to store results of training `--results_path` `<results folder path>`
+
+#### Example
+```bash
+python train.py \ 
+    --model_type mel_band_roformer \ 
+    --config_path configs/config_mel_band_roformer_vocals.yaml \
+    --start_check_point results/model.ckpt \
+    --results_path results/ \
+    --data_path 'datasets/dataset1' 'datasets/dataset2' \
+    --valid_path datasets/musdb18hq/test \
+    --num_workers 4 \
+    --device_ids 0
+```
+
+All available training parameters you can find [here](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/train.py#L109).
+
+## How to inference
+
+#### Example
+
+```bash
+python inference.py \  
+    --model_type mdx23c \
+    --config_path configs/config_mdx23c_musdb18.yaml \
+    --start_check_point results/last_mdx23c.ckpt \
+    --input_folder input/wavs/ \
+    --store_dir separation_results/
+```
+
+All available inference parameters you can find [here](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/inference.py#L54).
+
+## Useful notes
+
+* All batch sizes in config are adjusted to use with single NVIDIA A6000 48GB. If you have less memory please adjust correspodningly in model config `training.batch_size` and `training.gradient_accumulation_steps`.
+* It's usually always better to start with old weights even if shapes not fully match. Code supports loading weights for not fully same models (but it must have the same architecture). Training will be much faster. 
+
+## Code description
+
+* `configs/config_*.yaml` - configuration files for models
+* `models/*` - set of available models for training and inference 
+* `dataset.py` - dataset which creates new samples for training
+* `inference.py` - process folder with music files and separate them
+* `train.py` - main training code
+* `utils.py` - common functions used by train/valid 
+* `valid.py` - validation of model with metrics
+
+
+## Pre-trained models
+
+If you trained some good models, please, share them. You can post config and model weights [in this issue](https://github.com/ZFTurbo/Music-Source-Separation-Training/issues/1).
+
+### Vocal models
+|                            Model Type                            | Instruments |   Metrics (SDR)   | Config | Checkpoint |
+|:----------------------------------------------------------------:|:-------------:|:-----------------:|:-----:|:-----:|
+|                              MDX23C                              | vocals / other | SDR vocals: 10.17 | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/config_vocals_mdx23c.yaml) | [Weights](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/model_vocals_mdx23c_sdr_10.17.ckpt) |
+|                   HTDemucs4 (MVSep finetuned)                    | vocals / other | SDR vocals: 8.78  | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/config_vocals_htdemucs.yaml) | [Weights](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/model_vocals_htdemucs_sdr_8.78.ckpt) |
+|                     Segm Models (VitLarge23)                     | vocals / other | SDR vocals: 9.77  | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/config_vocals_segm_models.yaml) | [Weights](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/model_vocals_segm_models_sdr_9.77.ckpt) |
+|                        Mel Band RoFormer                         | vocals (*) / other | SDR vocals: 8.42  | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/config_vocals_mel_band_roformer.yaml) | [Weights](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.0/model_vocals_mel_band_roformer_sdr_8.42.ckpt) |
+|                           Swin Upernet                           | vocals / other | SDR vocals: 7.57  | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.2/config_vocals_swin_upernet.yaml) | [Weights](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.2/model_swin_upernet_ep_56_sdr_10.6703.ckpt) |
+| BS Roformer ([viperx](https://github.com/playdasegunda) edition) | vocals / other | SDR vocals: 10.87 | [Config](https://raw.githubusercontent.com/ZFTurbo/Music-Source-Separation-Training/main/configs/viperx/model_bs_roformer_ep_317_sdr_12.9755.yaml) | [Weights](https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/model_bs_roformer_ep_317_sdr_12.9755.ckpt) |
+|              Mel Band Roformer ([viperx](https://github.com/playdasegunda) edition)              | vocals / other | SDR vocals: 9.67  | [Config](https://raw.githubusercontent.com/ZFTurbo/Music-Source-Separation-Training/main/configs/viperx/model_mel_band_roformer_ep_3005_sdr_11.4360.yaml) | [Weights](https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/model_mel_band_roformer_ep_3005_sdr_11.4360.ckpt) |
+
+**Note**: Metrics measured on [Multisong Dataset](https://mvsep.com/en/quality_checker).
+
+### Single stem models
+|                Model Type                 | Instruments |  Metrics (SDR)   | Config | Checkpoint |
+|:-----------------------------------------:|:-------------:|:----------------:|:-----:|:-----:|
+|            HTDemucs4 FT Drums             | drums | SDR drums: 11.13 | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/configs/config_musdb18_htdemucs.yaml) | [Weights](https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/f7e0c4bc-ba3fe64a.th) |
+|             HTDemucs4 FT Bass             | bass | SDR bass: 11.96  | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/configs/config_musdb18_htdemucs.yaml) | [Weights](https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/d12395a8-e57c48e6.th) |
+|            HTDemucs4 FT Other             | other | SDR other: 5.85  | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/configs/config_musdb18_htdemucs.yaml) | [Weights](https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/92cfc3b6-ef3bcb9c.th) |
+| HTDemucs4 FT Vocals (Official repository) | vocals | SDR vocals: 8.38 | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/configs/config_musdb18_htdemucs.yaml) | [Weights](https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/04573f0d-f3cf25b2.th) |
+|     BS Roformer ([viperx](https://github.com/playdasegunda) edition)      | other | SDR other: 6.85  | [Config](https://raw.githubusercontent.com/ZFTurbo/Music-Source-Separation-Training/main/configs/viperx/model_bs_roformer_ep_937_sdr_10.5309.yaml) | [Weights](https://github.com/TRvlvr/model_repo/releases/download/all_public_uvr_models/model_bs_roformer_ep_937_sdr_10.5309.ckpt) |
+
+**Note**: All models output 4 stems, but quality is best only on target stem (all other stems are dummy).
+
+### Multi-stem models
+
+|     Model Type      | Instruments |                                                                 Metrics (SDR)                                                                  | Config | Checkpoint |
+|:-------------------:|:-------------:|:----------------------------------------------------------------------------------------------------------------------------------------------:|:-----:|:-----:|
+|     MDX23C~~*~~     | bass / drums / vocals / other | MUSDB test avg: 7.15 (bass: 5.77, drums: 7.93 vocals: 9.23 other: 5.68) Multisong avg: 7.02 (bass: 8.40, drums: 7.73 vocals: 7.36 other: 4.57) | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.1/config_musdb18_mdx23c.yaml) | [Weights](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v1.0.1/model_mdx23c_ep_168_sdr_7.0207.ckpt) |
+|     BandIt Plus     | speech / music / effects |                                         DnR test avg: 11.50 (speech: 15.64, music: 9.18 effects: 9.69)                                         | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v.1.0.3/config_dnr_bandit_bsrnn_multi_mus64.yaml) | [Weights](https://github.com/ZFTurbo/Music-Source-Separation-Training/releases/download/v.1.0.3/model_bandit_plus_dnr_sdr_11.47.chpt) |
+|      HTDemucs4      | bass / drums / vocals / other |                                    Multisong avg: 9.16 (bass: 11.76, drums: 10.88 vocals: 8.24 other: 5.74)                                    | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/configs/config_musdb18_htdemucs.yaml) | [Weights](https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/955717e8-8726e21a.th) |
+| HTDemucs4 (6 stems) | bass / drums / vocals / other / piano / guitar |                              Multisong (bass: 11.22, drums: 10.22 vocals: 8.05 other: --- piano: --- guitar: ---)                              | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/configs/config_htdemucs_6stems.yaml) | [Weights](https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/5c90dfd2-34c22ccb.th) |
+|     Demucs3 mmi     | bass / drums / vocals / other |                                    Multisong avg: 8.88 (bass: 11.17, drums: 10.70 vocals: 8.22 other: 5.42)                                    | [Config](https://github.com/ZFTurbo/Music-Source-Separation-Training/blob/main/configs/config_musdb18_demucs3_mmi.yaml) | [Weights](https://dl.fbaipublicfiles.com/demucs/hybrid_transformer/75fc33f5-1941ce65.th) |
+
+~~*~~ **Note**: Model was trained only on MUSDB18HQ dataset (100 songs train data)
+
+## Dataset types
+
+Look here: [Dataset types](docs/dataset_types.md)
+
+## Augmentations
+
+Look here: [Augmentations](docs/augmentations.md)
+
+## 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}
+}
+```

data_pipeline/seperation/configs/config_dnr_bandit_bsrnn_multi_mus64.yaml

@@ -0,0 +1,78 @@
+name: "MultiMaskMultiSourceBandSplitRNN"
+audio:
+  chunk_size: 264600
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  in_channel: 1
+  stems: ['speech', 'music', 'effects']
+  band_specs: "musical"
+  n_bands: 64
+  fs: 44100
+  require_no_overlap: false
+  require_no_gap: true
+  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
+  n_fft: 2048
+  win_length: 2048
+  hop_length: 512
+  window_fn: "hann_window"
+  wkwargs: null
+  power: null
+  center: true
+  normalized: true
+  pad_mode: "constant"
+  onesided: true
+
+training:
+  batch_size: 4
+  gradient_accumulation_steps: 4
+  grad_clip: 0
+  instruments:
+  - speech
+  - music
+  - effects
+  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: 1
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_htdemucs_6stems.yaml

@@ -0,0 +1,127 @@
+audio:
+  chunk_size: 485100 # samplerate * segment
+  min_mean_abs: 0.001
+  hop_length: 1024
+
+training:
+  batch_size: 8
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  segment: 11
+  shift: 1
+  samplerate: 44100
+  channels: 2
+  normalize: true
+  instruments: ['drums', 'bass', 'other', 'vocals', 'guitar', 'piano']
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  optimizer: adam
+  lr: 9.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  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: [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:
+  num_overlap: 4
+  batch_size: 8
+
+model: htdemucs
+
+htdemucs:  # see demucs/htdemucs.py for a detailed description
+  # Channels
+  channels: 48
+  channels_time:
+  growth: 2
+  # STFT
+  num_subbands: 1
+  nfft: 4096
+  wiener_iters: 0
+  end_iters: 0
+  wiener_residual: false
+  cac: true
+  # Main structure
+  depth: 4
+  rewrite: true
+  # Frequency Branch
+  multi_freqs: []
+  multi_freqs_depth: 3
+  freq_emb: 0.2
+  emb_scale: 10
+  emb_smooth: true
+  # Convolutions
+  kernel_size: 8
+  stride: 4
+  time_stride: 2
+  context: 1
+  context_enc: 0
+  # normalization
+  norm_starts: 4
+  norm_groups: 4
+  # DConv residual branch
+  dconv_mode: 3
+  dconv_depth: 2
+  dconv_comp: 8
+  dconv_init: 1e-3
+  # Before the Transformer
+  bottom_channels: 0
+  # CrossTransformer
+  # ------ Common to all
+  # Regular parameters
+  t_layers: 5
+  t_hidden_scale: 4.0
+  t_heads: 8
+  t_dropout: 0.0
+  t_layer_scale: True
+  t_gelu: True
+  # ------------- Positional Embedding
+  t_emb: sin
+  t_max_positions: 10000 # for the scaled embedding
+  t_max_period: 10000.0
+  t_weight_pos_embed: 1.0
+  t_cape_mean_normalize: True
+  t_cape_augment: True
+  t_cape_glob_loc_scale: [5000.0, 1.0, 1.4]
+  t_sin_random_shift: 0
+  # ------------- norm before a transformer encoder
+  t_norm_in: True
+  t_norm_in_group: False
+  # ------------- norm inside the encoder
+  t_group_norm: False
+  t_norm_first: True
+  t_norm_out: True
+  # ------------- optim
+  t_weight_decay: 0.0
+  t_lr:
+  # ------------- sparsity
+  t_sparse_self_attn: False
+  t_sparse_cross_attn: False
+  t_mask_type: diag
+  t_mask_random_seed: 42
+  t_sparse_attn_window: 400
+  t_global_window: 100
+  t_sparsity: 0.95
+  t_auto_sparsity: False
+  # Cross Encoder First (False)
+  t_cross_first: False
+  # Weight init
+  rescale: 0.1
+

data_pipeline/seperation/configs/config_musdb18_bs_roformer.yaml

@@ -0,0 +1,134 @@
+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: 192
+  depth: 6
+  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: 10
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - bass
+  - drums
+  - other
+  lr: 5.0e-05
+  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: 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
+
+inference:
+  batch_size: 1
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_musdb18_demucs3_mmi.yaml

@@ -0,0 +1,72 @@
+audio:
+  chunk_size: 485100 # samplerate * segment
+  min_mean_abs: 0.000
+  hop_length: 1024
+
+training:
+  batch_size: 8
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  segment: 11
+  shift: 1
+  samplerate: 44100
+  channels: 2
+  normalize: true
+  instruments: ['drums', 'bass', 'other', 'vocals']
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  optimizer: adam
+  lr: 9.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  other_fix: false # it's needed for checking on multisong dataset if other is actually instrumental
+  use_amp: false # 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
+
+inference:
+  num_overlap: 4
+  batch_size: 8
+
+model: hdemucs
+
+hdemucs:  # see demucs/hdemucs.py for a detailed description
+  channels: 48
+  channels_time: null
+  growth: 2
+  nfft: 4096
+  wiener_iters: 0
+  end_iters: 0
+  wiener_residual: False
+  cac: True
+  depth: 6
+  rewrite: True
+  hybrid: True
+  hybrid_old: False
+  multi_freqs: []
+  multi_freqs_depth: 3
+  freq_emb: 0.2
+  emb_scale: 10
+  emb_smooth: True
+  kernel_size: 8
+  stride: 4
+  time_stride: 2
+  context: 1
+  context_enc: 0
+  norm_starts: 4
+  norm_groups: 4
+  dconv_mode: 1
+  dconv_depth: 2
+  dconv_comp: 4
+  dconv_attn: 4
+  dconv_lstm: 4
+  dconv_init: 0.001
+  rescale: 0.1

data_pipeline/seperation/configs/config_musdb18_htdemucs.yaml

@@ -0,0 +1,119 @@
+audio:
+  chunk_size: 485100 # samplerate * segment
+  min_mean_abs: 0.001
+  hop_length: 1024
+
+training:
+  batch_size: 8
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  segment: 11
+  shift: 1
+  samplerate: 44100
+  channels: 2
+  normalize: true
+  instruments: ['drums', 'bass', 'other', 'vocals']
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  optimizer: adam
+  lr: 9.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  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
+
+inference:
+  num_overlap: 4
+  batch_size: 8
+
+model: htdemucs
+
+htdemucs:  # see demucs/htdemucs.py for a detailed description
+  # Channels
+  channels: 48
+  channels_time:
+  growth: 2
+  # STFT
+  num_subbands: 1
+  nfft: 4096
+  wiener_iters: 0
+  end_iters: 0
+  wiener_residual: false
+  cac: true
+  # Main structure
+  depth: 4
+  rewrite: true
+  # Frequency Branch
+  multi_freqs: []
+  multi_freqs_depth: 3
+  freq_emb: 0.2
+  emb_scale: 10
+  emb_smooth: true
+  # Convolutions
+  kernel_size: 8
+  stride: 4
+  time_stride: 2
+  context: 1
+  context_enc: 0
+  # normalization
+  norm_starts: 4
+  norm_groups: 4
+  # DConv residual branch
+  dconv_mode: 3
+  dconv_depth: 2
+  dconv_comp: 8
+  dconv_init: 1e-3
+  # Before the Transformer
+  bottom_channels: 512
+  # CrossTransformer
+  # ------ Common to all
+  # Regular parameters
+  t_layers: 5
+  t_hidden_scale: 4.0
+  t_heads: 8
+  t_dropout: 0.0
+  t_layer_scale: True
+  t_gelu: True
+  # ------------- Positional Embedding
+  t_emb: sin
+  t_max_positions: 10000 # for the scaled embedding
+  t_max_period: 10000.0
+  t_weight_pos_embed: 1.0
+  t_cape_mean_normalize: True
+  t_cape_augment: True
+  t_cape_glob_loc_scale: [5000.0, 1.0, 1.4]
+  t_sin_random_shift: 0
+  # ------------- norm before a transformer encoder
+  t_norm_in: True
+  t_norm_in_group: False
+  # ------------- norm inside the encoder
+  t_group_norm: False
+  t_norm_first: True
+  t_norm_out: True
+  # ------------- optim
+  t_weight_decay: 0.0
+  t_lr:
+  # ------------- sparsity
+  t_sparse_self_attn: False
+  t_sparse_cross_attn: False
+  t_mask_type: diag
+  t_mask_random_seed: 42
+  t_sparse_attn_window: 400
+  t_global_window: 100
+  t_sparsity: 0.95
+  t_auto_sparsity: False
+  # Cross Encoder First (False)
+  t_cross_first: False
+  # Weight init
+  rescale: 0.1
+

data_pipeline/seperation/configs/config_musdb18_mdx23c.yaml

@@ -0,0 +1,182 @@
+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
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - bass
+  - drums
+  - other
+  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: 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.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: 1
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_musdb18_mel_band_roformer.yaml

@@ -0,0 +1,73 @@
+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: 192
+  depth: 8
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  flash_attn: True
+  dim_freqs_in: 1025
+  sample_rate: 44100 # needed for mel filter bank from librosa
+  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: 7
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - vocals
+    - bass
+    - drums
+    - other
+  lr: 5.0e-05
+  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: 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
+
+inference:
+  batch_size: 1
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_musdb18_scnet.yaml

@@ -0,0 +1,64 @@
+audio:
+  chunk_size: 264600
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  dims: [4, 32, 64, 128]
+  bandsplit_ratios: [.175, .392, .433]
+  downsample_strides: [1, 4, 16]
+  n_conv_modules: [3, 2, 1]
+  n_rnn_layers: 6
+  rnn_hidden_dim: 128
+  n_sources: 4
+
+  n_fft: 4096
+  hop_length: 1024
+  win_length: 4096
+  stft_normalized: false
+
+  use_mamba: true
+  d_state: 16
+  d_conv: 4
+  d_expand: 2
+
+training:
+  batch_size: 10
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+    - vocals
+    - bass
+    - drums
+    - other
+  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: 1
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_musdb18_segm_models.yaml

@@ -0,0 +1,92 @@
+audio:
+  chunk_size: 261632
+  dim_f: 4096
+  dim_t: 512
+  hop_length: 512
+  n_fft: 8192
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  encoder_name: tu-maxvit_large_tf_512 # look here for possibilities: https://github.com/qubvel/segmentation_models.pytorch#encoders-
+  decoder_type: unet # unet, fpn
+  act: gelu
+  num_channels: 128
+  num_subbands: 8
+
+training:
+  batch_size: 7
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - bass
+  - drums
+  - other
+  lr: 5.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 2000
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  optimizer: adamw
+  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.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"
+
+  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
+  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: 1
+  dim_t: 512
+  num_overlap: 4

data_pipeline/seperation/configs/config_vocals_bandit_bsrnn_multi_mus64.yaml

@@ -0,0 +1,73 @@
+name: "MultiMaskMultiSourceBandSplitRNN"
+audio:
+  chunk_size: 264600
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  in_channel: 1
+  stems: ['vocals', 'other']
+  band_specs: "musical"
+  n_bands: 64
+  fs: 44100
+  require_no_overlap: false
+  require_no_gap: true
+  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
+  n_fft: 2048
+  win_length: 2048
+  hop_length: 512
+  window_fn: "hann_window"
+  wkwargs: null
+  power: null
+  center: true
+  normalized: true
+  pad_mode: "constant"
+  onesided: true
+
+training:
+  batch_size: 4
+  gradient_accumulation_steps: 4
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  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
+
+inference:
+  batch_size: 1
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_vocals_bs_roformer.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: 192
+  depth: 6
+  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: 10
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  lr: 5.0e-05
+  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: 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: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_vocals_htdemucs.yaml

@@ -0,0 +1,123 @@
+audio:
+  chunk_size: 485100 # samplerate * segment
+  min_mean_abs: 0.001
+  hop_length: 1024
+
+training:
+  batch_size: 10
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  segment: 11
+  shift: 1
+  samplerate: 44100
+  channels: 2
+  normalize: true
+  instruments: ['vocals', 'other']
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 1000
+  optimizer: adam
+  lr: 9.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  q: 0.95
+  coarse_loss_clip: true
+  ema_momentum: 0.999
+  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: [0.2, 0.02]
+  mixup_loudness_min: 0.5
+  mixup_loudness_max: 1.5
+
+inference:
+  num_overlap: 2
+  batch_size: 8
+
+model: htdemucs
+
+htdemucs:  # see demucs/htdemucs.py for a detailed description
+  # Channels
+  channels: 48
+  channels_time:
+  growth: 2
+  # STFT
+  num_subbands: 1
+  nfft: 4096
+  wiener_iters: 0
+  end_iters: 0
+  wiener_residual: false
+  cac: true
+  # Main structure
+  depth: 4
+  rewrite: true
+  # Frequency Branch
+  multi_freqs: []
+  multi_freqs_depth: 3
+  freq_emb: 0.2
+  emb_scale: 10
+  emb_smooth: true
+  # Convolutions
+  kernel_size: 8
+  stride: 4
+  time_stride: 2
+  context: 1
+  context_enc: 0
+  # normalization
+  norm_starts: 4
+  norm_groups: 4
+  # DConv residual branch
+  dconv_mode: 3
+  dconv_depth: 2
+  dconv_comp: 8
+  dconv_init: 1e-3
+  # Before the Transformer
+  bottom_channels: 512
+  # CrossTransformer
+  # ------ Common to all
+  # Regular parameters
+  t_layers: 5
+  t_hidden_scale: 4.0
+  t_heads: 8
+  t_dropout: 0.0
+  t_layer_scale: True
+  t_gelu: True
+  # ------------- Positional Embedding
+  t_emb: sin
+  t_max_positions: 10000 # for the scaled embedding
+  t_max_period: 10000.0
+  t_weight_pos_embed: 1.0
+  t_cape_mean_normalize: True
+  t_cape_augment: True
+  t_cape_glob_loc_scale: [5000.0, 1.0, 1.4]
+  t_sin_random_shift: 0
+  # ------------- norm before a transformer encoder
+  t_norm_in: True
+  t_norm_in_group: False
+  # ------------- norm inside the encoder
+  t_group_norm: False
+  t_norm_first: True
+  t_norm_out: True
+  # ------------- optim
+  t_weight_decay: 0.0
+  t_lr:
+  # ------------- sparsity
+  t_sparse_self_attn: False
+  t_sparse_cross_attn: False
+  t_mask_type: diag
+  t_mask_random_seed: 42
+  t_sparse_attn_window: 400
+  t_global_window: 100
+  t_sparsity: 0.95
+  t_auto_sparsity: False
+  # Cross Encoder First (False)
+  t_cross_first: False
+  # Weight init
+  rescale: 0.1
+

data_pipeline/seperation/configs/config_vocals_mdx23c.yaml

@@ -0,0 +1,95 @@
+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
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  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
+
+  # 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"
+
+  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
+  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: 1
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_vocals_mel_band_roformer.yaml

@@ -0,0 +1,77 @@
+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: 192
+  depth: 8
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  flash_attn: True
+  dim_freqs_in: 1025
+  sample_rate: 44100  # needed for mel filter bank from librosa
+  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: 7
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  lr: 5.0e-05
+  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: 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: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_vocals_scnet.yaml

@@ -0,0 +1,71 @@
+audio:
+  chunk_size: 264600
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  sources: ['vocals', 'other']
+  audio_channels: 2
+  # dims: [4, 32, 64, 128] # small version
+  dims: [4, 64, 128, 256]
+  nfft: 4096
+  hop_size: 1024
+  win_size: 4096
+  normalized: True
+  band_configs: {
+    'low': { 'SR': .175, 'stride': 1, 'kernel': 3 },
+    'mid': { 'SR': .392, 'stride': 4, 'kernel': 4 },
+    'high': { 'SR': .433, 'stride': 16, 'kernel': 16 }
+  }
+  conv_depths: [3, 2, 1]
+  compress: 4
+  conv_kernel: 3
+  # Dual-path RNN
+  num_dplayer: 6
+  expand: 1
+  # mamba
+  use_mamba: False
+  mamba_config: {
+    'd_stat': 16,
+    'd_conv': 4,
+    'd_expand': 2
+  }
+
+training:
+  batch_size: 4
+  gradient_accumulation_steps: 2
+  grad_clip: 0
+  instruments:
+    - vocals
+    - other
+  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: 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
+
+inference:
+  batch_size: 8
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_vocals_scnet_unofficial.yaml

@@ -0,0 +1,62 @@
+audio:
+  chunk_size: 264600
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.000
+
+model:
+  dims: [4, 32, 64, 128]
+  bandsplit_ratios: [.175, .392, .433]
+  downsample_strides: [1, 4, 16]
+  n_conv_modules: [3, 2, 1]
+  n_rnn_layers: 6
+  rnn_hidden_dim: 128
+  n_sources: 2
+
+  n_fft: 4096
+  hop_length: 1024
+  win_length: 4096
+  stft_normalized: false
+
+  use_mamba: false
+  d_state: 16
+  d_conv: 4
+  d_expand: 2
+
+training:
+  batch_size: 10
+  gradient_accumulation_steps: 2
+  grad_clip: 0
+  instruments:
+    - vocals
+    - other
+  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: 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
+
+inference:
+  batch_size: 8
+  dim_t: 256
+  num_overlap: 4

data_pipeline/seperation/configs/config_vocals_segm_models.yaml

@@ -0,0 +1,78 @@
+audio:
+  chunk_size: 261632
+  dim_f: 4096
+  dim_t: 512
+  hop_length: 512
+  n_fft: 8192
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  encoder_name: tu-maxvit_large_tf_512 # look here for possibilities: https://github.com/qubvel/segmentation_models.pytorch#encoders-
+  decoder_type: unet # unet, fpn
+  act: gelu
+  num_channels: 128
+  num_subbands: 8
+
+loss_multistft:
+  fft_sizes:
+  - 1024
+  - 2048
+  - 4096
+  hop_sizes:
+  - 512
+  - 1024
+  - 2048
+  win_lengths:
+  - 1024
+  - 2048
+  - 4096
+  window: "hann_window"
+  scale: "mel"
+  n_bins: 128
+  sample_rate: 44100
+  perceptual_weighting: true
+  w_sc: 1.0
+  w_log_mag: 1.0
+  w_lin_mag: 0.0
+  w_phs: 0.0
+  mag_distance: "L1"
+
+
+training:
+  batch_size: 8
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  lr: 5.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: null
+  num_epochs: 1000
+  num_steps: 2000
+  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
+
+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

data_pipeline/seperation/configs/config_vocals_swin_upernet.yaml

@@ -0,0 +1,50 @@
+audio:
+  chunk_size: 261632
+  dim_f: 4096
+  dim_t: 512
+  hop_length: 512
+  n_fft: 8192
+  num_channels: 2
+  sample_rate: 44100
+  min_mean_abs: 0.001
+
+model:
+  act: gelu
+  num_channels: 16
+  num_subbands: 8
+
+training:
+  batch_size: 14
+  gradient_accumulation_steps: 4
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  lr: 3.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: adamw
+  other_fix: true # it's needed for checking on multisong dataset if other is actually instrumental
+
+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

data_pipeline/seperation/configs/viperx/model_bs_roformer_ep_317_sdr_12.9755.yaml

@@ -0,0 +1,126 @@
+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: 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.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: 2
+  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
+  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: 4
+  dim_t: 801
+  num_overlap: 2

data_pipeline/seperation/configs/viperx/model_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:
+  - vocals
+  - other
+  lr: 5.0e-05
+  patience: 2
+  reduce_factor: 0.95
+  target_instrument: other
+  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: 512
+  num_overlap: 2

data_pipeline/seperation/configs/viperx/model_mel_band_roformer_ep_3005_sdr_11.4360.yaml

@@ -0,0 +1,65 @@
+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: 12
+  stereo: true
+  num_stems: 1
+  time_transformer_depth: 1
+  freq_transformer_depth: 1
+  linear_transformer_depth: 0
+  num_bands: 60
+  dim_head: 64
+  heads: 8
+  attn_dropout: 0.1
+  ff_dropout: 0.1
+  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: 1
+  gradient_accumulation_steps: 8
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  lr: 4.0e-05
+  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: 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: 4
+  dim_t: 801
+  num_overlap: 2

data_pipeline/seperation/dataset.py

@@ -0,0 +1,566 @@
+# coding: utf-8
+__author__ = 'Roman Solovyev (ZFTurbo): https://github.com/ZFTurbo/'
+
+
+import os
+import random
+import numpy as np
+import torch
+import soundfile as sf
+import pickle
+import time
+from tqdm import tqdm
+from glob import glob
+import audiomentations as AU
+import pedalboard as PB
+import warnings
+warnings.filterwarnings("ignore")
+
+
+def load_chunk(path, length, chunk_size, offset=None):
+    if chunk_size <= length:
+        if offset is None:
+            offset = np.random.randint(length - chunk_size + 1)
+        x = sf.read(path, dtype='float32', start=offset, frames=chunk_size)[0]
+    else:
+        x = sf.read(path, dtype='float32')[0]
+        pad = np.zeros([chunk_size - length, 2])
+        x = np.concatenate([x, pad])
+    return x.T
+
+
+class MSSDataset(torch.utils.data.Dataset):
+    def __init__(self, config, data_path, metadata_path="metadata.pkl", dataset_type=1, batch_size=None):
+        self.config = config
+        self.dataset_type = dataset_type # 1, 2, 3 or 4
+        self.instruments = instruments = config.training.instruments
+        if batch_size is None:
+            batch_size = config.training.batch_size
+        self.batch_size = batch_size
+        self.file_types = ['wav', 'flac']
+
+        # Augmentation block
+        self.aug = False
+        if 'augmentations' in config:
+            if config['augmentations'].enable is True:
+                print('Use augmentation for training')
+                self.aug = True
+        else:
+            print('There is no augmentations block in config. Augmentations disabled for training...')
+
+        # metadata_path = data_path + '/metadata'
+        try:
+            metadata = pickle.load(open(metadata_path, 'rb'))
+            print('Loading songs data from cache: {}. If you updated dataset remove {} before training!'.format(metadata_path, os.path.basename(metadata_path)))
+        except Exception:
+            print('Collecting metadata for', str(data_path), 'Dataset type:', self.dataset_type)
+            if self.dataset_type in [1, 4]:
+                metadata = []
+                track_paths = []
+                if type(data_path) == list:
+                    for tp in data_path:
+                        track_paths += sorted(glob(tp + '/*'))
+                else:
+                    track_paths += sorted(glob(data_path + '/*'))
+
+                track_paths = [path for path in track_paths if os.path.basename(path)[0] != '.' and os.path.isdir(path)]
+                for path in tqdm(track_paths):
+                    # Check lengths of all instruments (it can be different in some cases)
+                    lengths_arr = []
+                    for instr in instruments:
+                        length = -1
+                        for extension in self.file_types:
+                            path_to_audio_file = path + '/{}.{}'.format(instr, extension)
+                            if os.path.isfile(path_to_audio_file):
+                                length = len(sf.read(path_to_audio_file)[0])
+                                break
+                        if length == -1:
+                            print('Cant find file "{}" in folder {}'.format(instr, path))
+                            continue
+                        lengths_arr.append(length)
+                    lengths_arr = np.array(lengths_arr)
+                    if lengths_arr.min() != lengths_arr.max():
+                        print('Warning: lengths of stems are different for path: {}. ({} != {})'.format(
+                            path,
+                            lengths_arr.min(),
+                            lengths_arr.max())
+                        )
+                    # We use minimum to allow overflow for soundfile read in non-equal length cases
+                    metadata.append((path, lengths_arr.min()))
+            elif self.dataset_type == 2:
+                metadata = dict()
+                for instr in self.instruments:
+                    metadata[instr] = []
+                    track_paths = []
+                    if type(data_path) == list:
+                        for tp in data_path:
+                            track_paths += sorted(glob(tp + '/{}/*.wav'.format(instr)))
+                            track_paths += sorted(glob(tp + '/{}/*.flac'.format(instr)))
+                    else:
+                        track_paths += sorted(glob(data_path + '/{}/*.wav'.format(instr)))
+                        track_paths += sorted(glob(data_path + '/{}/*.flac'.format(instr)))
+
+                    for path in tqdm(track_paths):
+                        length = len(sf.read(path)[0])
+                        metadata[instr].append((path, length))
+            elif self.dataset_type == 3:
+                import pandas as pd
+                if type(data_path) != list:
+                    data_path = [data_path]
+
+                metadata = dict()
+                for i in range(len(data_path)):
+                    print('Reading tracks from: {}'.format(data_path[i]))
+                    df = pd.read_csv(data_path[i])
+
+                    skipped = 0
+                    for instr in self.instruments:
+                        part = df[df['instrum'] == instr].copy()
+                        print('Tracks found for {}: {}'.format(instr, len(part)))
+                    for instr in self.instruments:
+                        part = df[df['instrum'] == instr].copy()
+                        metadata[instr] = []
+                        track_paths = list(part['path'].values)
+                        for path in tqdm(track_paths):
+                            if not os.path.isfile(path):
+                                print('Cant find track: {}'.format(path))
+                                skipped += 1
+                                continue
+                            # print(path)
+                            try:
+                                length = len(sf.read(path)[0])
+                            except:
+                                print('Problem with path: {}'.format(path))
+                                skipped += 1
+                                continue
+                            metadata[instr].append((path, length))
+                    if skipped > 0:
+                        print('Missing tracks: {} from {}'.format(skipped, len(df)))
+            else:
+                print('Unknown dataset type: {}. Must be 1, 2 or 3'.format(self.dataset_type))
+                exit()
+
+            pickle.dump(metadata, open(metadata_path, 'wb'))
+
+        if self.dataset_type in [1, 4]:
+            if len(metadata) > 0:
+                print('Found tracks in dataset: {}'.format(len(metadata)))
+            else:
+                print('No tracks found for training. Check paths you provided!')
+                exit()
+        else:
+            for instr in self.instruments:
+                print('Found tracks for {} in dataset: {}'.format(instr, len(metadata[instr])))
+        self.metadata = metadata
+        self.chunk_size = config.audio.chunk_size
+        self.min_mean_abs = config.audio.min_mean_abs
+
+    def __len__(self):
+        return self.config.training.num_steps * self.batch_size
+
+    def load_source(self, metadata, instr):
+        while True:
+            if self.dataset_type in [1, 4]:
+                track_path, track_length = random.choice(metadata)
+                for extension in self.file_types:
+                    path_to_audio_file = track_path + '/{}.{}'.format(instr, extension)
+                    if os.path.isfile(path_to_audio_file):
+                        try:
+                            source = load_chunk(path_to_audio_file, track_length, self.chunk_size)
+                        except Exception as e:
+                            # Sometimes error during FLAC reading, catch it and use zero stem
+                            print('Error: {} Path: {}'.format(e, path_to_audio_file))
+                            source = np.zeros((2, self.chunk_size), dtype=np.float32)
+                        break
+            else:
+                track_path, track_length = random.choice(metadata[instr])
+                try:
+                    source = load_chunk(track_path, track_length, self.chunk_size)
+                except Exception as e:
+                    # Sometimes error during FLAC reading, catch it and use zero stem
+                    print('Error: {} Path: {}'.format(e, track_path))
+                    source = np.zeros((2, self.chunk_size), dtype=np.float32)
+
+            if np.abs(source).mean() >= self.min_mean_abs:  # remove quiet chunks
+                break
+        if self.aug:
+            source = self.augm_data(source, instr)
+        return torch.tensor(source, dtype=torch.float32)
+
+    def load_random_mix(self):
+        res = []
+        for instr in self.instruments:
+            s1 = self.load_source(self.metadata, instr)
+            # Mixup augmentation. Multiple mix of same type of stems
+            if self.aug:
+                if 'mixup' in self.config['augmentations']:
+                    if self.config['augmentations'].mixup:
+                        mixup = [s1]
+                        for prob in self.config.augmentations.mixup_probs:
+                            if random.uniform(0, 1) < prob:
+                                s2 = self.load_source(self.metadata, instr)
+                                mixup.append(s2)
+                        mixup = torch.stack(mixup, dim=0)
+                        loud_values = np.random.uniform(
+                            low=self.config.augmentations.loudness_min,
+                            high=self.config.augmentations.loudness_max,
+                            size=(len(mixup),)
+                        )
+                        loud_values = torch.tensor(loud_values, dtype=torch.float32)
+                        mixup *= loud_values[:, None, None]
+                        s1 = mixup.mean(dim=0, dtype=torch.float32)
+            res.append(s1)
+        res = torch.stack(res)
+        return res
+
+    def load_aligned_data(self):
+        track_path, track_length = random.choice(self.metadata)
+        res = []
+        for i in self.instruments:
+            attempts = 10
+            while attempts:
+                for extension in self.file_types:
+                    path_to_audio_file = track_path + '/{}.{}'.format(i, extension)
+                    if os.path.isfile(path_to_audio_file):
+                        try:
+                            source = load_chunk(path_to_audio_file, track_length, self.chunk_size)
+                        except Exception as e:
+                            # Sometimes error during FLAC reading, catch it and use zero stem
+                            print('Error: {} Path: {}'.format(e, path_to_audio_file))
+                            source = np.zeros((2, self.chunk_size), dtype=np.float32)
+                        break
+                if np.abs(source).mean() >= self.min_mean_abs:  # remove quiet chunks
+                    break
+                attempts -= 1
+                if attempts <= 0:
+                    print('Attempts max!', track_path)
+            res.append(source)
+        res = np.stack(res, axis=0)
+        if self.aug:
+            for i, instr in enumerate(self.instruments):
+                res[i] = self.augm_data(res[i], instr)
+        return torch.tensor(res, dtype=torch.float32)
+
+    def augm_data(self, source, instr):
+        # source.shape = (2, 261120) - first channels, second length
+        source_shape = source.shape
+        applied_augs = []
+        if 'all' in self.config['augmentations']:
+            augs = self.config['augmentations']['all']
+        else:
+            augs = dict()
+
+        # We need to add to all augmentations specific augs for stem. And rewrite values if needed
+        if instr in self.config['augmentations']:
+            for el in self.config['augmentations'][instr]:
+                augs[el] = self.config['augmentations'][instr][el]
+
+        # Channel shuffle
+        if 'channel_shuffle' in augs:
+            if augs['channel_shuffle'] > 0:
+                if random.uniform(0, 1) < augs['channel_shuffle']:
+                    source = source[::-1].copy()
+                    applied_augs.append('channel_shuffle')
+        # Random inverse
+        if 'random_inverse' in augs:
+            if augs['random_inverse'] > 0:
+                if random.uniform(0, 1) < augs['random_inverse']:
+                    source = source[:, ::-1].copy()
+                    applied_augs.append('random_inverse')
+        # Random polarity (multiply -1)
+        if 'random_polarity' in augs:
+            if augs['random_polarity'] > 0:
+                if random.uniform(0, 1) < augs['random_polarity']:
+                    source = -source.copy()
+                    applied_augs.append('random_polarity')
+        # Random pitch shift
+        if 'pitch_shift' in augs:
+            if augs['pitch_shift'] > 0:
+                if random.uniform(0, 1) < augs['pitch_shift']:
+                    apply_aug = AU.PitchShift(
+                        min_semitones=augs['pitch_shift_min_semitones'],
+                        max_semitones=augs['pitch_shift_max_semitones'],
+                        p=1.0
+                    )
+                    source = apply_aug(samples=source, sample_rate=44100)
+                    applied_augs.append('pitch_shift')
+        # Random seven band parametric eq
+        if 'seven_band_parametric_eq' in augs:
+            if augs['seven_band_parametric_eq'] > 0:
+                if random.uniform(0, 1) < augs['seven_band_parametric_eq']:
+                    apply_aug = AU.SevenBandParametricEQ(
+                        min_gain_db=augs['seven_band_parametric_eq_min_gain_db'],
+                        max_gain_db=augs['seven_band_parametric_eq_max_gain_db'],
+                        p=1.0
+                    )
+                    source = apply_aug(samples=source, sample_rate=44100)
+                    applied_augs.append('seven_band_parametric_eq')
+        # Random tanh distortion
+        if 'tanh_distortion' in augs:
+            if augs['tanh_distortion'] > 0:
+                if random.uniform(0, 1) < augs['tanh_distortion']:
+                    apply_aug = AU.TanhDistortion(
+                        min_distortion=augs['tanh_distortion_min'],
+                        max_distortion=augs['tanh_distortion_max'],
+                        p=1.0
+                    )
+                    source = apply_aug(samples=source, sample_rate=44100)
+                    applied_augs.append('tanh_distortion')
+        # Random MP3 Compression
+        if 'mp3_compression' in augs:
+            if augs['mp3_compression'] > 0:
+                if random.uniform(0, 1) < augs['mp3_compression']:
+                    apply_aug = AU.Mp3Compression(
+                        min_bitrate=augs['mp3_compression_min_bitrate'],
+                        max_bitrate=augs['mp3_compression_max_bitrate'],
+                        backend=augs['mp3_compression_backend'],
+                        p=1.0
+                    )
+                    source = apply_aug(samples=source, sample_rate=44100)
+                    applied_augs.append('mp3_compression')
+        # Random AddGaussianNoise
+        if 'gaussian_noise' in augs:
+            if augs['gaussian_noise'] > 0:
+                if random.uniform(0, 1) < augs['gaussian_noise']:
+                    apply_aug = AU.AddGaussianNoise(
+                        min_amplitude=augs['gaussian_noise_min_amplitude'],
+                        max_amplitude=augs['gaussian_noise_max_amplitude'],
+                        p=1.0
+                    )
+                    source = apply_aug(samples=source, sample_rate=44100)
+                    applied_augs.append('gaussian_noise')
+        # Random TimeStretch
+        if 'time_stretch' in augs:
+            if augs['time_stretch'] > 0:
+                if random.uniform(0, 1) < augs['time_stretch']:
+                    apply_aug = AU.TimeStretch(
+                        min_rate=augs['time_stretch_min_rate'],
+                        max_rate=augs['time_stretch_max_rate'],
+                        leave_length_unchanged=True,
+                        p=1.0
+                    )
+                    source = apply_aug(samples=source, sample_rate=44100)
+                    applied_augs.append('time_stretch')
+
+        # Possible fix of shape
+        if source_shape != source.shape:
+            source = source[..., :source_shape[-1]]
+
+        # Random Reverb
+        if 'pedalboard_reverb' in augs:
+            if augs['pedalboard_reverb'] > 0:
+                if random.uniform(0, 1) < augs['pedalboard_reverb']:
+                    room_size = random.uniform(
+                        augs['pedalboard_reverb_room_size_min'],
+                        augs['pedalboard_reverb_room_size_max'],
+                    )
+                    damping = random.uniform(
+                        augs['pedalboard_reverb_damping_min'],
+                        augs['pedalboard_reverb_damping_max'],
+                    )
+                    wet_level = random.uniform(
+                        augs['pedalboard_reverb_wet_level_min'],
+                        augs['pedalboard_reverb_wet_level_max'],
+                    )
+                    dry_level = random.uniform(
+                        augs['pedalboard_reverb_dry_level_min'],
+                        augs['pedalboard_reverb_dry_level_max'],
+                    )
+                    width = random.uniform(
+                        augs['pedalboard_reverb_width_min'],
+                        augs['pedalboard_reverb_width_max'],
+                    )
+                    board = PB.Pedalboard([PB.Reverb(
+                        room_size=room_size,  # 0.1 - 0.9
+                        damping=damping,  # 0.1 - 0.9
+                        wet_level=wet_level,  # 0.1 - 0.9
+                        dry_level=dry_level,  # 0.1 - 0.9
+                        width=width,  # 0.9 - 1.0
+                        freeze_mode=0.0,
+                    )])
+                    source = board(source, 44100)
+                    applied_augs.append('pedalboard_reverb')
+
+        # Random Chorus
+        if 'pedalboard_chorus' in augs:
+            if augs['pedalboard_chorus'] > 0:
+                if random.uniform(0, 1) < augs['pedalboard_chorus']:
+                    rate_hz = random.uniform(
+                        augs['pedalboard_chorus_rate_hz_min'],
+                        augs['pedalboard_chorus_rate_hz_max'],
+                    )
+                    depth = random.uniform(
+                        augs['pedalboard_chorus_depth_min'],
+                        augs['pedalboard_chorus_depth_max'],
+                    )
+                    centre_delay_ms = random.uniform(
+                        augs['pedalboard_chorus_centre_delay_ms_min'],
+                        augs['pedalboard_chorus_centre_delay_ms_max'],
+                    )
+                    feedback = random.uniform(
+                        augs['pedalboard_chorus_feedback_min'],
+                        augs['pedalboard_chorus_feedback_max'],
+                    )
+                    mix = random.uniform(
+                        augs['pedalboard_chorus_mix_min'],
+                        augs['pedalboard_chorus_mix_max'],
+                    )
+                    board = PB.Pedalboard([PB.Chorus(
+                        rate_hz=rate_hz,
+                        depth=depth,
+                        centre_delay_ms=centre_delay_ms,
+                        feedback=feedback,
+                        mix=mix,
+                    )])
+                    source = board(source, 44100)
+                    applied_augs.append('pedalboard_chorus')
+
+        # Random Phazer
+        if 'pedalboard_phazer' in augs:
+            if augs['pedalboard_phazer'] > 0:
+                if random.uniform(0, 1) < augs['pedalboard_phazer']:
+                    rate_hz = random.uniform(
+                        augs['pedalboard_phazer_rate_hz_min'],
+                        augs['pedalboard_phazer_rate_hz_max'],
+                    )
+                    depth = random.uniform(
+                        augs['pedalboard_phazer_depth_min'],
+                        augs['pedalboard_phazer_depth_max'],
+                    )
+                    centre_frequency_hz = random.uniform(
+                        augs['pedalboard_phazer_centre_frequency_hz_min'],
+                        augs['pedalboard_phazer_centre_frequency_hz_max'],
+                    )
+                    feedback = random.uniform(
+                        augs['pedalboard_phazer_feedback_min'],
+                        augs['pedalboard_phazer_feedback_max'],
+                    )
+                    mix = random.uniform(
+                        augs['pedalboard_phazer_mix_min'],
+                        augs['pedalboard_phazer_mix_max'],
+                    )
+                    board = PB.Pedalboard([PB.Phaser(
+                        rate_hz=rate_hz,
+                        depth=depth,
+                        centre_frequency_hz=centre_frequency_hz,
+                        feedback=feedback,
+                        mix=mix,
+                    )])
+                    source = board(source, 44100)
+                    applied_augs.append('pedalboard_phazer')
+
+        # Random Distortion
+        if 'pedalboard_distortion' in augs:
+            if augs['pedalboard_distortion'] > 0:
+                if random.uniform(0, 1) < augs['pedalboard_distortion']:
+                    drive_db = random.uniform(
+                        augs['pedalboard_distortion_drive_db_min'],
+                        augs['pedalboard_distortion_drive_db_max'],
+                    )
+                    board = PB.Pedalboard([PB.Distortion(
+                        drive_db=drive_db,
+                    )])
+                    source = board(source, 44100)
+                    applied_augs.append('pedalboard_distortion')
+
+        # Random PitchShift
+        if 'pedalboard_pitch_shift' in augs:
+            if augs['pedalboard_pitch_shift'] > 0:
+                if random.uniform(0, 1) < augs['pedalboard_pitch_shift']:
+                    semitones = random.uniform(
+                        augs['pedalboard_pitch_shift_semitones_min'],
+                        augs['pedalboard_pitch_shift_semitones_max'],
+                    )
+                    board = PB.Pedalboard([PB.PitchShift(
+                        semitones=semitones
+                    )])
+                    source = board(source, 44100)
+                    applied_augs.append('pedalboard_pitch_shift')
+
+        # Random Resample
+        if 'pedalboard_resample' in augs:
+            if augs['pedalboard_resample'] > 0:
+                if random.uniform(0, 1) < augs['pedalboard_resample']:
+                    target_sample_rate = random.uniform(
+                        augs['pedalboard_resample_target_sample_rate_min'],
+                        augs['pedalboard_resample_target_sample_rate_max'],
+                    )
+                    board = PB.Pedalboard([PB.Resample(
+                        target_sample_rate=target_sample_rate
+                    )])
+                    source = board(source, 44100)
+                    applied_augs.append('pedalboard_resample')
+
+        # Random Bitcrash
+        if 'pedalboard_bitcrash' in augs:
+            if augs['pedalboard_bitcrash'] > 0:
+                if random.uniform(0, 1) < augs['pedalboard_bitcrash']:
+                    bit_depth = random.uniform(
+                        augs['pedalboard_bitcrash_bit_depth_min'],
+                        augs['pedalboard_bitcrash_bit_depth_max'],
+                    )
+                    board = PB.Pedalboard([PB.Bitcrush(
+                        bit_depth=bit_depth
+                    )])
+                    source = board(source, 44100)
+                    applied_augs.append('pedalboard_bitcrash')
+
+        # Random MP3Compressor
+        if 'pedalboard_mp3_compressor' in augs:
+            if augs['pedalboard_mp3_compressor'] > 0:
+                if random.uniform(0, 1) < augs['pedalboard_mp3_compressor']:
+                    vbr_quality = random.uniform(
+                        augs['pedalboard_mp3_compressor_pedalboard_mp3_compressor_min'],
+                        augs['pedalboard_mp3_compressor_pedalboard_mp3_compressor_max'],
+                    )
+                    board = PB.Pedalboard([PB.MP3Compressor(
+                        vbr_quality=vbr_quality
+                    )])
+                    source = board(source, 44100)
+                    applied_augs.append('pedalboard_mp3_compressor')
+
+        # print(applied_augs)
+        return source
+
+    def __getitem__(self, index):
+        if self.dataset_type in [1, 2, 3]:
+            res = self.load_random_mix()
+        else:
+            res = self.load_aligned_data()
+
+        # Randomly change loudness of each stem
+        if self.aug:
+            if 'loudness' in self.config['augmentations']:
+                if self.config['augmentations']['loudness']:
+                    loud_values = np.random.uniform(
+                        low=self.config['augmentations']['loudness_min'],
+                        high=self.config['augmentations']['loudness_max'],
+                        size=(len(res),)
+                    )
+                    loud_values = torch.tensor(loud_values, dtype=torch.float32)
+                    res *= loud_values[:, None, None]
+
+        mix = res.sum(0)
+
+        if self.aug:
+            if 'mp3_compression_on_mixture' in self.config['augmentations']:
+                apply_aug = AU.Mp3Compression(
+                    min_bitrate=self.config['augmentations']['mp3_compression_on_mixture_bitrate_min'],
+                    max_bitrate=self.config['augmentations']['mp3_compression_on_mixture_bitrate_max'],
+                    backend=self.config['augmentations']['mp3_compression_on_mixture_backend'],
+                    p=self.config['augmentations']['mp3_compression_on_mixture']
+                )
+                mix_conv = mix.cpu().numpy().astype(np.float32)
+                required_shape = mix_conv.shape
+                mix = apply_aug(samples=mix_conv, sample_rate=44100)
+                # Sometimes it gives longer audio (so we cut)
+                if mix.shape != required_shape:
+                    mix = mix[..., :required_shape[-1]]
+                mix = torch.tensor(mix, dtype=torch.float32)
+
+        # If we need only given stem (for roformers)
+        if self.config.training.target_instrument is not None:
+            index = self.config.training.instruments.index(self.config.training.target_instrument)
+            return res[index], mix
+
+        return res, mix

data_pipeline/seperation/docs/augmentations.md

@@ -0,0 +1,146 @@
+### Augmentations 
+
+Augmentations allows to change stems on the fly increasing the size of dataset by creating new samples from old samples. 
+Now control for augmentations is done from config file. Below you can find the example of full config, 
+which includes all available augmentations:
+
+```config
+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.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
+```   
+
+You can copypaste it into your config to use augmentations.
+Notes: 
+* To completely disable all augmentations you can either remove `augmentations` section from config or set `enable` to `false`.
+* If you want to disable some augmentation, just set it to zero.
+* Augmentations in `all` subsections applied to all stems
+* Augmentations in `vocals`, `bass` etc subsections applied only to corresponding stems. You can create such subsections for all stems which are given in `training.instruments`.

data_pipeline/seperation/docs/bs_roformer_info.md

@@ -0,0 +1,145 @@
+### Batch sizes for BSRoformer 
+
+You can use table below to choose BS Roformer `batch_size` parameter for training based on your GPUs. Batch size values provided for single GPU. If you have several GPUs you need to multiply value on number of GPUs. 
+
+| chunk_size | dim | depth | batch_size (A6000 48GB) | batch_size (3090/4090 24GB) | batch_size (16GB) |
+|:----------:|:---:|:-----:|:-----------------------:|:---------------------------:|:-----------------:|
+|   131584   | 128 |   6   |           10            |              5              |         3         |
+|   131584   | 256 |   6   |            8            |              4              |         2         |
+|   131584   | 384 |   6   |            7            |              3              |         2         |
+|   131584   | 512 |   6   |            6            |              3              |         2         |
+|   131584   | 256 |   8   |            6            |              3              |         2         |
+|   131584   | 256 |  12   |            4            |              2              |         1         |
+|   263168   | 128 |   6   |            4            |              2              |         1         |
+|   263168   | 256 |   6   |            3            |              1              |         1         |
+|   352800   | 128 |   6   |            2            |              1              |         -         |
+|   352800   | 256 |   6   |            2            |              1              |         -         |
+|   352800   | 384 |  12   |            1            |              -              |         -         |
+|   352800   | 512 |  12   |            -            |              -              |         -         |
+
+
+Parameters obtained with initial config:
+
+```
+audio:
+  chunk_size: 131584
+  dim_f: 1024
+  dim_t: 515
+  hop_length: 512
+  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
+  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: false
+  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: 1
+  gradient_accumulation_steps: 1
+  grad_clip: 0
+  instruments:
+  - vocals
+  - other
+  lr: 3.0e-05
+  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: 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
+```

data_pipeline/seperation/docs/changes.md

@@ -0,0 +1,20 @@
+### Changes 
+
+#### v1.0.2
+
+* Added multi GPU validation (earlier validation was performed on single GPU)
+* `training.batch_size` in config now must be set for single GPU (if you use multiple GPUs it will be automatically multiplied by number of GPUs)
+
+#### v1.0.3
+
+* Added "spawn" fix for multiprocessing
+* Function `get_model_from_config` now takes path of config as input.
+* On latest version of pytorch some problems with torch.backends.cudnn.benchmark = True - big slow down. Fixed version 2.0.1 in requirements.txt
+* `--valid_path` parameter for train.py now can accept several validation folders instead of one. Added warning if validation folder is empty.
+* Small fix for AMP usage in Demucs models taken from config
+* Support for Demucs3 mmi model was added
+* GPU memory consumption was reduced during inference and validation.
+* Some changes to repair click problems on the edges of segment.
+* Added support to train on FLAC files. Some more error checks added.
+* viperx's Roformer weights and configs added
+* `--extract_instrumental` argument added to inference.py

data_pipeline/seperation/docs/dataset_types.md

@@ -0,0 +1,75 @@
+### Dataset types for training
+
+* **Type 1 (MUSDB)**: different folders. Each folder contains all needed stems in format _< stem name >.wav_. The same as in MUSDBHQ18 dataset. In latest code releases it's possible to use `flac` instead of `wav`. 
+
+Example:
+```
+--- Song 1:
+------ vocals.wav  
+------ bass.wav 
+------ drums.wav
+------ other.wav
+--- Song 2:
+------ vocals.wav  
+------ bass.wav 
+------ drums.wav
+------ other.wav
+--- Song 3:
+...........
+```
+
+* **Type 2 (Stems)**: each folder is "stem name". Folder contains wav files which consists only of required stem.
+```
+--- vocals:
+------ vocals_1.wav
+------ vocals_2.wav
+------ vocals_3.wav
+------ vocals_4.wav
+------ ...
+--- bass:
+------ bass_1.wav
+------ bass_2.wav
+------ bass_3.wav
+------ bass_4.wav
+------ ...
+...........
+```
+
+* **Type 3 (CSV file)**:
+
+You can provide CSV-file (or list of CSV-files) with following structure:
+```
+instrum,path
+vocals,/path/to/dataset/vocals_1.wav
+vocals,/path/to/dataset2/vocals_v2.wav
+vocals,/path/to/dataset3/vocals_some.wav
+...
+drums,/path/to/dataset/drums_good.wav
+...
+```
+
+* **Type 4 (MUSDB Aligned)**:
+
+The same as Type 1, but during training all instruments will be from the same position of song. 
+
+### Dataset for validation
+
+* The validation dataset must be the same structure as type 1 datasets (regardless of what type of dataset you're using for training), but also each folder must include `mixture.wav` for each song. `mixture.wav` - is the sum of all stems for song.
+
+Example:
+```
+--- Song 1:
+------ vocals.wav  
+------ bass.wav 
+------ drums.wav
+------ other.wav
+------ mixture.wav
+--- Song 2:
+------ vocals.wav  
+------ bass.wav 
+------ drums.wav
+------ other.wav
+------ mixture.wav
+--- Song 3:
+...........
+```

data_pipeline/seperation/inference.py

@@ -0,0 +1,116 @@
+# coding: utf-8
+__author__ = 'Roman Solovyev (ZFTurbo): https://github.com/ZFTurbo/'
+
+import argparse
+import time
+import librosa
+from tqdm import tqdm
+import sys
+import os
+import glob
+import torch
+import numpy as np
+import soundfile as sf
+import torch.nn as nn
+from utils import demix_track, demix_track_demucs, get_model_from_config
+
+import warnings
+warnings.filterwarnings("ignore")
+
+
+def run_folder(model, args, config, device, verbose=False):
+    start_time = time.time()
+    model.eval()
+    all_mixtures_path = glob.glob(args.input_folder + '/*.*')
+    print('Total files found: {}'.format(len(all_mixtures_path)))
+
+    instruments = config.training.instruments
+    if config.training.target_instrument is not None:
+        instruments = [config.training.target_instrument]
+
+    if not os.path.isdir(args.store_dir):
+        os.mkdir(args.store_dir)
+
+    if not verbose:
+        all_mixtures_path = tqdm(all_mixtures_path)
+
+    for path in all_mixtures_path:
+        if not verbose:
+            all_mixtures_path.set_postfix({'track': os.path.basename(path)})
+        try:
+            # mix, sr = sf.read(path)
+            mix, sr = librosa.load(path, sr=44100, mono=False)
+            mix = mix.T
+        except Exception as e:
+            print('Can read track: {}'.format(path))
+            print('Error message: {}'.format(str(e)))
+            continue
+
+        # Convert mono to stereo if needed
+        if len(mix.shape) == 1:
+            mix = np.stack([mix, mix], axis=-1)
+
+        mixture = torch.tensor(mix.T, dtype=torch.float32)
+        if args.model_type == 'htdemucs':
+            res = demix_track_demucs(config, model, mixture, device)
+        else:
+            res = demix_track(config, model, mixture, device)
+        for instr in instruments:
+            sf.write("{}/{}_{}.wav".format(args.store_dir, os.path.basename(path)[:-4], instr), res[instr].T, sr, subtype='FLOAT')
+
+        if 'vocals' in instruments and args.extract_instrumental:
+            instrum_file_name = "{}/{}_{}.wav".format(args.store_dir, os.path.basename(path)[:-4], 'instrumental')
+            sf.write(instrum_file_name, mix - res['vocals'].T, sr, subtype='FLOAT')
+
+    time.sleep(1)
+    print("Elapsed time: {:.2f} sec".format(time.time() - start_time))
+
+
+def proc_folder(args):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model_type", type=str, default='mdx23c', help="One of mdx23c, htdemucs, segm_models, mel_band_roformer, bs_roformer, swin_upernet, bandit")
+    parser.add_argument("--config_path", type=str, help="path to config file")
+    parser.add_argument("--start_check_point", type=str, default='', help="Initial checkpoint to valid weights")
+    parser.add_argument("--input_folder", type=str, help="folder with mixtures to process")
+    parser.add_argument("--store_dir", default="", type=str, help="path to store results as wav file")
+    parser.add_argument("--model-dir", default="", type=str, help="path to store results as wav file")
+    parser.add_argument("--log-dir", default="", type=str, help="path to store results as wav file")
+    parser.add_argument("--device_ids", nargs='+', type=int, default=0, help='list of gpu ids')
+    parser.add_argument("--extract_instrumental", action='store_true', help="invert vocals to get instrumental if provided")
+    print(f"cuda{torch.cuda.is_available()}")
+    if args is None:
+        args = parser.parse_args()
+    else:
+        args = parser.parse_args(args)
+
+    torch.backends.cudnn.benchmark = True
+
+    model, config = get_model_from_config(args.model_type, args.config_path)
+    if args.start_check_point != '':
+        print('Start from checkpoint: {}'.format(args.start_check_point))
+        state_dict = torch.load(args.start_check_point, map_location='cpu')
+        if args.model_type == 'htdemucs':
+            # Fix for htdemucs pround etrained models
+            if 'state' in state_dict:
+                state_dict = state_dict['state']
+        model.load_state_dict(state_dict)
+    print("Instruments: {}".format(config.training.instruments))
+
+    if torch.cuda.is_available():
+        device_ids = args.device_ids
+        if type(device_ids)==int:
+            device = torch.device(f'cuda:{device_ids}')
+            model = model.to(device)
+        else:
+            device = torch.device(f'cuda:{device_ids[0]}')
+            model = nn.DataParallel(model, device_ids=device_ids).to(device)
+    else:
+        device = 'cpu'
+        print('CUDA is not avilable. Run inference on CPU. It will be very slow...')
+        model = model.to(device)
+
+    run_folder(model, args, config, device, verbose=False)
+
+
+if __name__ == "__main__":
+    proc_folder(None)

data_pipeline/seperation/inference.sh

@@ -0,0 +1,11 @@
+input_dir=$1
+output_dir=$2
+ckpt_dir=$3
+
+python3 inference.py \
+    --model_type bs_roformer \
+    --config_path ${ckpt_dir}/model_bs_roformer_ep_317_sdr_12.9755.yaml \
+    --start_check_point ${ckpt_dir}/model_bs_roformer_ep_317_sdr_12.9755.ckpt \
+    --input_folder ${input_dir} \
+    --store_dir ${output_dir} \
+    --extract_instrumental

data_pipeline/seperation/inference_mp.py

@@ -0,0 +1,154 @@
+import torch
+import torch.multiprocessing as mp
+import os, sys
+import threading
+from tqdm import tqdm
+import soundfile as sf
+import threading
+import librosa
+import numpy as np
+from utils import demix_track, demix_track_demucs, get_model_from_config
+import traceback
+import glob
+import argparse
+
+import warnings
+warnings.filterwarnings("ignore")
+
+def normalize_audio(y, target_dbfs=0):
+    max_amplitude = np.max(np.abs(y))
+    if max_amplitude < 0.1:
+        return y
+
+    target_amplitude = 10.0**(target_dbfs / 20.0)
+    scale_factor = target_amplitude / max_amplitude
+
+    normalized_audio = y * scale_factor
+
+    return normalized_audio
+
+def inference(rank, ckpt_root, out_dir, queue: mp.Queue):
+    #print(f"thread {rank} start")
+    device = f"cuda:{rank}"
+    config = f"{ckpt_root}/model_bs_roformer_ep_317_sdr_12.9755.yaml"
+    ckpt = f"{ckpt_root}/model_bs_roformer_ep_317_sdr_12.9755.ckpt"
+    model, config = get_model_from_config("bs_roformer", config)
+    state_dict = torch.load(ckpt, map_location='cpu')
+    model.load_state_dict(state_dict)
+    model = model.to(device)
+    model.eval()
+
+    
+    with torch.no_grad():
+        while True:
+            #print(texts)
+            filename = queue.get()
+            if filename is None:
+                break
+            filepath = filename[0]
+            filename = filepath.split('/')[-1]
+            try:
+                mix, sr = librosa.load(filepath, sr=44100, mono=False)
+                #mix = normalize_audio(mix, -6)
+                mix = mix.T
+                if len(mix.shape) == 1:
+                    mix = np.stack([mix, mix], axis=-1)
+
+                mixture = torch.tensor(mix.T, dtype=torch.float32)
+                res = demix_track(config, model, mixture, device)
+                sf.write("{}/{}".format(os.path.join(out_dir, "vocal"), filename), res['vocals'].T.mean(-1), sr, subtype='FLOAT')
+                sf.write("{}/{}".format(os.path.join(out_dir, "bgm"), filename), mix.mean(-1) - res['vocals'].T.mean(-1), sr, subtype='FLOAT')
+
+                
+            except Exception as e:
+                traceback.print_exc()
+                continue
+
+
+
+def setInterval(interval):
+    def decorator(function):
+        def wrapper(*args, **kwargs):
+            stopped = threading.Event()
+
+            def loop():  # executed in another thread
+                while not stopped.wait(interval):  # until stopped
+                    function(*args, **kwargs)
+
+            t = threading.Thread(target=loop)
+            t.daemon = True  # stop if the program exits
+            t.start()
+            return stopped
+
+        return wrapper
+
+    return decorator
+
+last_batches = None
+
+@setInterval(3)
+def QueueWatcher(queue, bar):
+    global last_batches
+    curr_batches = queue.qsize()
+    bar.update(last_batches-curr_batches)
+    last_batches = curr_batches
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--filelist_or_dir", type=str, required=True, help="Path to save checkpoints")
+    parser.add_argument("--out_dir", type=str, required=True, help="Path to save checkpoints")
+    parser.add_argument("--ckpt_path", type=str, required=True, help="Path to save checkpoints")
+    parser.add_argument("--jobs", type=int, required=False, default=2, help="Path to save checkpoints")
+    parser.add_argument("--log_dir", type=str, required=False, default="large-v3", help="Path to save checkpoints")
+    parser.add_argument("--model_dir", type=str, required=False, default="large-v3", help="Path to save checkpoints")
+    args = parser.parse_args()
+
+    filelist_or_dir = args.filelist_or_dir
+    out_dir = args.out_dir
+    ckpt_path = args.ckpt_path
+    jobs = args.jobs
+    vad_jobs = jobs * 2
+
+    if os.path.isfile(filelist_or_dir):
+        filelist_name = filelist_or_dir.split('/')[-1].split('.')[0]
+        generator = open(filelist_or_dir).read().splitlines()
+    else:
+        filelist_name = "single"
+        generator = glob.glob(f"{filelist_or_dir}/*.wav")
+
+    os.makedirs(os.path.join(out_dir, "vocal"), exist_ok=True)
+    os.makedirs(os.path.join(out_dir, "bgm"), exist_ok=True)
+
+
+    gpu_num = torch.cuda.device_count()
+
+    processes = []
+    vad_processes = []
+    queue = mp.Queue()
+    vad_queue = mp.Queue()
+    for thread_num in range(jobs):
+        rank = thread_num % gpu_num
+        p = mp.Process(target=inference, args=(rank, ckpt_path, out_dir, queue))
+        p.start()
+        processes.append(p)
+
+    accum = []
+
+    for filename in tqdm(generator):
+        accum.append(filename)
+        if len(accum) == 1:
+            queue.put(accum.copy())
+            accum.clear()
+
+    for _ in range(jobs):
+        queue.put(None)
+
+    last_batches = queue.qsize()
+    bar = tqdm(total=last_batches, desc="seperation")
+    queue_watcher = QueueWatcher(queue, bar)
+    for p in processes:
+        p.join()
+    queue_watcher.set()
+
+    for p in vad_processes:
+        p.join()

data_pipeline/seperation/inference_mp.sh

@@ -0,0 +1,7 @@
+python3 inference_mp.py \
+    /data/v-ziqianning/workspace/SingingTTS/data/youtube_testdata/wav \
+    /data/v-ziqianning/workspace/SingingTTS/data/youtube_testdata/vocal \
+    /data/v-ziqianning/workspace/SingingTTS/data/youtube_testdata/bgm \
+    /data/v-ziqianning/workspace/SingingTTS/data_pipeline/seperation/Music-Source-Separation-Training/ckpts/model_bs_roformer_ep_317_sdr_12.9755.yaml \
+    /data/v-ziqianning/workspace/SingingTTS/data_pipeline/seperation/Music-Source-Separation-Training/ckpts/model_bs_roformer_ep_317_sdr_12.9755.ckpt \
+    4

data_pipeline/seperation/models/bandit/core/__init__.py

@@ -0,0 +1,744 @@
+import os.path
+from collections import defaultdict
+from itertools import chain, combinations
+from typing import (
+    Any,
+    Dict,
+    Iterator,
+    Mapping, Optional,
+    Tuple, Type,
+    TypedDict
+)
+
+import pytorch_lightning as pl
+import torch
+import torchaudio as ta
+import torchmetrics as tm
+from asteroid import losses as asteroid_losses
+# from deepspeed.ops.adam import DeepSpeedCPUAdam
+# from geoopt import optim as gooptim
+from pytorch_lightning.utilities.types import STEP_OUTPUT
+from torch import nn, optim
+from torch.optim import lr_scheduler
+from torch.optim.lr_scheduler import LRScheduler
+
+from models.bandit.core import loss, metrics as metrics_, model
+from models.bandit.core.data._types import BatchedDataDict
+from models.bandit.core.data.augmentation import BaseAugmentor, StemAugmentor
+from models.bandit.core.utils import audio as audio_
+from models.bandit.core.utils.audio import BaseFader
+
+# from pandas.io.json._normalize import nested_to_record
+
+ConfigDict = TypedDict('ConfigDict', {'name': str, 'kwargs': Dict[str, Any]})
+
+
+class SchedulerConfigDict(ConfigDict):
+    monitor: str
+
+
+OptimizerSchedulerConfigDict = TypedDict(
+        'OptimizerSchedulerConfigDict',
+        {"optimizer": ConfigDict, "scheduler": SchedulerConfigDict},
+        total=False
+)
+
+
+class LRSchedulerReturnDict(TypedDict, total=False):
+    scheduler: LRScheduler
+    monitor: str
+
+
+class ConfigureOptimizerReturnDict(TypedDict, total=False):
+    optimizer: torch.optim.Optimizer
+    lr_scheduler: LRSchedulerReturnDict
+
+
+OutputType = Dict[str, Any]
+MetricsType = Dict[str, torch.Tensor]
+
+
+def get_optimizer_class(name: str) -> Type[optim.Optimizer]:
+
+    if name == "DeepSpeedCPUAdam":
+        return DeepSpeedCPUAdam
+
+    for module in [optim, gooptim]:
+        if name in module.__dict__:
+            return module.__dict__[name]
+
+    raise NameError
+
+
+def parse_optimizer_config(
+        config: OptimizerSchedulerConfigDict,
+        parameters: Iterator[nn.Parameter]
+) -> ConfigureOptimizerReturnDict:
+    optim_class = get_optimizer_class(config["optimizer"]["name"])
+    optimizer = optim_class(parameters, **config["optimizer"]["kwargs"])
+
+    optim_dict: ConfigureOptimizerReturnDict = {
+            "optimizer": optimizer,
+    }
+
+    if "scheduler" in config:
+
+        lr_scheduler_class_ = config["scheduler"]["name"]
+        lr_scheduler_class = lr_scheduler.__dict__[lr_scheduler_class_]
+        lr_scheduler_dict: LRSchedulerReturnDict = {
+                "scheduler": lr_scheduler_class(
+                        optimizer,
+                        **config["scheduler"]["kwargs"]
+                )
+        }
+
+        if lr_scheduler_class_ == "ReduceLROnPlateau":
+            lr_scheduler_dict["monitor"] = config["scheduler"]["monitor"]
+
+        optim_dict["lr_scheduler"] = lr_scheduler_dict
+
+    return optim_dict
+
+
+def parse_model_config(config: ConfigDict) -> Any:
+    name = config["name"]
+
+    for module in [model]:
+        if name in module.__dict__:
+            return module.__dict__[name](**config["kwargs"])
+
+    raise NameError
+
+
+_LEGACY_LOSS_NAMES = ["HybridL1Loss"]
+
+
+def _parse_legacy_loss_config(config: ConfigDict) -> nn.Module:
+    name = config["name"]
+
+    if name == "HybridL1Loss":
+        return loss.TimeFreqL1Loss(**config["kwargs"])
+
+    raise NameError
+
+
+def parse_loss_config(config: ConfigDict) -> nn.Module:
+    name = config["name"]
+
+    if name in _LEGACY_LOSS_NAMES:
+        return _parse_legacy_loss_config(config)
+
+    for module in [loss, nn.modules.loss, asteroid_losses]:
+        if name in module.__dict__:
+            # print(config["kwargs"])
+            return module.__dict__[name](**config["kwargs"])
+
+    raise NameError
+
+
+def get_metric(config: ConfigDict) -> tm.Metric:
+    name = config["name"]
+
+    for module in [tm, metrics_]:
+        if name in module.__dict__:
+            return module.__dict__[name](**config["kwargs"])
+    raise NameError
+
+
+def parse_metric_config(config: Dict[str, ConfigDict]) -> tm.MetricCollection:
+    metrics = {}
+
+    for metric in config:
+        metrics[metric] = get_metric(config[metric])
+
+    return tm.MetricCollection(metrics)
+
+
+def parse_fader_config(config: ConfigDict) -> BaseFader:
+    name = config["name"]
+
+    for module in [audio_]:
+        if name in module.__dict__:
+            return module.__dict__[name](**config["kwargs"])
+
+    raise NameError
+
+
+class LightningSystem(pl.LightningModule):
+    _VOX_STEMS = ["speech", "vocals"]
+    _BG_STEMS = ["background", "effects", "mne"]
+
+    def __init__(
+            self,
+            config: Dict,
+            loss_adjustment: float = 1.0,
+            attach_fader: bool = False
+            ) -> None:
+        super().__init__()
+        self.optimizer_config = config["optimizer"]
+        self.model = parse_model_config(config["model"])
+        self.loss = parse_loss_config(config["loss"])
+        self.metrics = nn.ModuleDict(
+                {
+                        stem: parse_metric_config(config["metrics"]["dev"])
+                        for stem in self.model.stems
+                }
+        )
+
+        self.metrics.disallow_fsdp = True
+
+        self.test_metrics = nn.ModuleDict(
+                {
+                        stem: parse_metric_config(config["metrics"]["test"])
+                        for stem in self.model.stems
+                }
+        )
+
+        self.test_metrics.disallow_fsdp = True
+
+        self.fs = config["model"]["kwargs"]["fs"]
+
+        self.fader_config = config["inference"]["fader"]
+        if attach_fader:
+            self.fader = parse_fader_config(config["inference"]["fader"])
+        else:
+            self.fader = None
+
+        self.augmentation: Optional[BaseAugmentor]
+        if config.get("augmentation", None) is not None:
+            self.augmentation = StemAugmentor(**config["augmentation"])
+        else:
+            self.augmentation = None
+
+        self.predict_output_path: Optional[str] = None
+        self.loss_adjustment = loss_adjustment
+
+        self.val_prefix = None
+        self.test_prefix = None
+
+
+    def configure_optimizers(self) -> Any:
+        return parse_optimizer_config(
+            self.optimizer_config,
+            self.trainer.model.parameters()
+            )
+
+    def compute_loss(self, batch: BatchedDataDict, output: OutputType) -> Dict[
+        str, torch.Tensor]:
+        return {"loss": self.loss(output, batch)}
+
+    def update_metrics(
+            self,
+            batch: BatchedDataDict,
+            output: OutputType,
+            mode: str
+    ) -> None:
+
+        if mode == "test":
+            metrics = self.test_metrics
+        else:
+            metrics = self.metrics
+
+        for stem, metric in metrics.items():
+
+            if stem == "mne:+":
+                stem = "mne"
+
+            # print(f"matching for {stem}")
+            if mode == "train":
+                metric.update(
+                    output["audio"][stem],#.cpu(),
+                    batch["audio"][stem],#.cpu()
+                    )
+            else:
+                if stem not in batch["audio"]:
+                    matched = False
+                    if stem in self._VOX_STEMS:
+                        for bstem in self._VOX_STEMS:
+                            if bstem in batch["audio"]:
+                                batch["audio"][stem] = batch["audio"][bstem]
+                                matched = True
+                                break
+                    elif stem in self._BG_STEMS:
+                        for bstem in self._BG_STEMS:
+                            if bstem in batch["audio"]:
+                                batch["audio"][stem] = batch["audio"][bstem]
+                                matched = True
+                                break
+                else:
+                    matched = True
+
+                # print(batch["audio"].keys())
+
+                if matched:
+                    # print(f"matched {stem}!")
+                    if stem == "mne" and "mne" not in output["audio"]:
+                        output["audio"]["mne"] = output["audio"]["music"] + output["audio"]["effects"]
+                    
+                    metric.update(
+                        output["audio"][stem],#.cpu(),
+                        batch["audio"][stem],#.cpu(),
+                    )
+
+                    # print(metric.compute())
+    def compute_metrics(self, mode: str="dev") -> Dict[
+        str, torch.Tensor]:
+
+        if mode == "test":
+            metrics = self.test_metrics
+        else:
+            metrics = self.metrics
+
+        metric_dict = {}
+
+        for stem, metric in metrics.items():
+            md = metric.compute()
+            metric_dict.update(
+                    {f"{stem}/{k}": v for k, v in md.items()}
+                    )
+            
+        self.log_dict(metric_dict, prog_bar=True, logger=False)
+
+        return metric_dict
+
+    def reset_metrics(self, test_mode: bool = False) -> None:
+
+        if test_mode:
+            metrics = self.test_metrics
+        else:
+            metrics = self.metrics
+
+        for _, metric in metrics.items():
+            metric.reset()
+
+
+    def forward(self, batch: BatchedDataDict) -> Any:
+        batch, output = self.model(batch)
+        
+
+        return batch, output
+
+    def common_step(self, batch: BatchedDataDict, mode: str) -> Any:
+        batch, output = self.forward(batch)
+        # print(batch)
+        # print(output)
+        loss_dict = self.compute_loss(batch, output)
+
+        with torch.no_grad():
+            self.update_metrics(batch, output, mode=mode)
+
+        if mode == "train":
+            self.log("loss", loss_dict["loss"], prog_bar=True)
+
+        return output, loss_dict
+
+
+    def training_step(self, batch: BatchedDataDict) -> Dict[str, Any]:
+
+        if self.augmentation is not None:
+            with torch.no_grad():
+                batch = self.augmentation(batch)
+
+        _, loss_dict = self.common_step(batch, mode="train")
+
+        with torch.inference_mode():
+            self.log_dict_with_prefix(
+                    loss_dict,
+                    "train",
+                    batch_size=batch["audio"]["mixture"].shape[0]
+            )
+
+        loss_dict["loss"] *= self.loss_adjustment
+
+        return loss_dict
+
+    def on_train_batch_end(
+            self, outputs: STEP_OUTPUT, batch: BatchedDataDict, batch_idx: int
+    ) -> None:
+
+        metric_dict = self.compute_metrics()
+        self.log_dict_with_prefix(metric_dict, "train")
+        self.reset_metrics()
+
+    def validation_step(
+            self,
+            batch: BatchedDataDict,
+            batch_idx: int,
+            dataloader_idx: int = 0
+    ) -> Dict[str, Any]:
+
+        with torch.inference_mode():
+            curr_val_prefix = f"val{dataloader_idx}" if dataloader_idx > 0 else "val"
+
+            if curr_val_prefix != self.val_prefix:
+                # print(f"Switching to validation dataloader {dataloader_idx}")
+                if self.val_prefix is not None:
+                    self._on_validation_epoch_end()
+                self.val_prefix = curr_val_prefix
+            _, loss_dict = self.common_step(batch, mode="val")
+
+            self.log_dict_with_prefix(
+                    loss_dict,
+                    self.val_prefix,
+                    batch_size=batch["audio"]["mixture"].shape[0],
+                    prog_bar=True,
+                    add_dataloader_idx=False
+            )
+
+        return loss_dict
+
+    def on_validation_epoch_end(self) -> None:
+        self._on_validation_epoch_end()
+
+    def _on_validation_epoch_end(self) -> None:
+        metric_dict = self.compute_metrics()
+        self.log_dict_with_prefix(metric_dict, self.val_prefix, prog_bar=True,
+                    add_dataloader_idx=False)
+        # self.logger.save()
+        # print(self.val_prefix, "Validation metrics:", metric_dict)
+        self.reset_metrics()
+
+
+    def old_predtest_step(
+            self,
+            batch: BatchedDataDict,
+            batch_idx: int,
+            dataloader_idx: int = 0
+    ) -> Tuple[BatchedDataDict, OutputType]:
+
+        audio_batch = batch["audio"]["mixture"]
+        track_batch = batch.get("track", ["" for _ in range(len(audio_batch))])
+
+        output_list_of_dicts = [
+                self.fader(
+                        audio[None, ...],
+                        lambda a: self.test_forward(a, track)
+                )
+                for audio, track in zip(audio_batch, track_batch)
+        ]
+
+        output_dict_of_lists = defaultdict(list)
+
+        for output_dict in output_list_of_dicts:
+            for stem, audio in output_dict.items():
+                output_dict_of_lists[stem].append(audio)
+
+        output = {
+                "audio": {
+                        stem: torch.concat(output_list, dim=0)
+                        for stem, output_list in output_dict_of_lists.items()
+                }
+        }
+
+        return batch, output
+
+    def predtest_step(
+            self,
+            batch: BatchedDataDict,
+            batch_idx: int = -1,
+            dataloader_idx: int = 0
+    ) -> Tuple[BatchedDataDict, OutputType]:
+
+        if getattr(self.model, "bypass_fader", False):
+            batch, output = self.model(batch)
+        else:
+            audio_batch = batch["audio"]["mixture"]
+            output = self.fader(
+                audio_batch,
+                lambda a: self.test_forward(a, "", batch=batch)
+            )
+
+        return batch, output
+
+    def test_forward(
+            self,
+            audio: torch.Tensor,
+            track: str = "",
+            batch: BatchedDataDict = None
+    ) -> torch.Tensor:
+
+        if self.fader is None:
+            self.attach_fader()
+
+        cond = batch.get("condition", None)
+
+        if cond is not None and cond.shape[0] == 1:
+            cond = cond.repeat(audio.shape[0], 1)
+
+        _, output = self.forward(
+                {"audio": {"mixture": audio},
+                 "track": track,
+                 "condition": cond,
+                }
+        )  # TODO: support track properly
+
+        return output["audio"]
+
+    def on_test_epoch_start(self) -> None:
+        self.attach_fader(force_reattach=True)
+
+    def test_step(
+            self,
+            batch: BatchedDataDict,
+            batch_idx: int,
+            dataloader_idx: int = 0
+    ) -> Any:
+        curr_test_prefix = f"test{dataloader_idx}"
+
+        # print(batch["audio"].keys())
+
+        if curr_test_prefix != self.test_prefix:
+            # print(f"Switching to test dataloader {dataloader_idx}")
+            if self.test_prefix is not None:
+                self._on_test_epoch_end()
+            self.test_prefix = curr_test_prefix
+
+        with torch.inference_mode():
+            _, output = self.predtest_step(batch, batch_idx, dataloader_idx)
+            # print(output)
+            self.update_metrics(batch, output, mode="test")
+
+        return output
+
+    def on_test_epoch_end(self) -> None:
+        self._on_test_epoch_end()
+
+    def _on_test_epoch_end(self) -> None:
+        metric_dict = self.compute_metrics(mode="test")
+        self.log_dict_with_prefix(metric_dict, self.test_prefix, prog_bar=True,
+                    add_dataloader_idx=False)
+        # self.logger.save()
+        # print(self.test_prefix, "Test metrics:", metric_dict)
+        self.reset_metrics()
+
+    def predict_step(
+            self,
+            batch: BatchedDataDict,
+            batch_idx: int = 0,
+            dataloader_idx: int = 0,
+            include_track_name: Optional[bool] = None,
+            get_no_vox_combinations: bool = True,
+            get_residual: bool = False,
+            treat_batch_as_channels: bool = False,
+            fs: Optional[int] = None,
+    ) -> Any:
+        assert self.predict_output_path is not None
+
+        batch_size = batch["audio"]["mixture"].shape[0]
+
+        if include_track_name is None:
+            include_track_name = batch_size > 1
+
+        with torch.inference_mode():
+            batch, output = self.predtest_step(batch, batch_idx, dataloader_idx)
+        print('Pred test finished...')
+        torch.cuda.empty_cache()
+        metric_dict = {}
+
+        if get_residual:
+            mixture = batch["audio"]["mixture"]
+            extracted = sum([output["audio"][stem] for stem in output["audio"]])
+            residual = mixture - extracted
+            print(extracted.shape, mixture.shape, residual.shape)
+
+            output["audio"]["residual"] = residual
+
+        if get_no_vox_combinations:
+            no_vox_stems = [
+                    stem for stem in output["audio"] if
+                    stem not in self._VOX_STEMS
+            ]
+            no_vox_combinations = chain.from_iterable(
+                    combinations(no_vox_stems, r) for r in
+                    range(2, len(no_vox_stems) + 1)
+            )
+
+            for combination in no_vox_combinations:
+                combination_ = list(combination)
+                output["audio"]["+".join(combination_)] = sum(
+                        [output["audio"][stem] for stem in combination_]
+                )
+
+        if treat_batch_as_channels:
+            for stem in output["audio"]:
+                output["audio"][stem] = output["audio"][stem].reshape(
+                        1, -1, output["audio"][stem].shape[-1]
+                )
+            batch_size = 1
+
+        for b in range(batch_size):
+            print("!!", b)
+            for stem in output["audio"]:
+                print(f"Saving audio for {stem} to {self.predict_output_path}")
+                track_name = batch["track"][b].split("/")[-1]
+
+                if batch.get("audio", {}).get(stem, None) is not None:
+                    self.test_metrics[stem].reset()
+                    metrics = self.test_metrics[stem](
+                            batch["audio"][stem][[b], ...],
+                            output["audio"][stem][[b], ...]
+                    )
+                    snr = metrics["snr"]
+                    sisnr = metrics["sisnr"]
+                    sdr = metrics["sdr"]
+                    metric_dict[stem] = metrics
+                    print(
+                            track_name,
+                            f"snr={snr:2.2f} dB",
+                            f"sisnr={sisnr:2.2f}",
+                            f"sdr={sdr:2.2f} dB",
+                    )
+                    filename = f"{stem} - snr={snr:2.2f}dB - sdr={sdr:2.2f}dB.wav"
+                else:
+                    filename = f"{stem}.wav"
+
+                if include_track_name:
+                    output_dir = os.path.join(
+                            self.predict_output_path,
+                            track_name
+                    )
+                else:
+                    output_dir = self.predict_output_path
+
+                os.makedirs(output_dir, exist_ok=True)
+
+                if fs is None:
+                    fs = self.fs
+
+                ta.save(
+                        os.path.join(output_dir, filename),
+                        output["audio"][stem][b, ...].cpu(),
+                        fs,
+                )
+
+        return metric_dict
+
+    def get_stems(
+            self,
+            batch: BatchedDataDict,
+            batch_idx: int = 0,
+            dataloader_idx: int = 0,
+            include_track_name: Optional[bool] = None,
+            get_no_vox_combinations: bool = True,
+            get_residual: bool = False,
+            treat_batch_as_channels: bool = False,
+            fs: Optional[int] = None,
+    ) -> Any:
+        assert self.predict_output_path is not None
+
+        batch_size = batch["audio"]["mixture"].shape[0]
+
+        if include_track_name is None:
+            include_track_name = batch_size > 1
+
+        with torch.inference_mode():
+            batch, output = self.predtest_step(batch, batch_idx, dataloader_idx)
+        torch.cuda.empty_cache()
+        metric_dict = {}
+
+        if get_residual:
+            mixture = batch["audio"]["mixture"]
+            extracted = sum([output["audio"][stem] for stem in output["audio"]])
+            residual = mixture - extracted
+            # print(extracted.shape, mixture.shape, residual.shape)
+
+            output["audio"]["residual"] = residual
+
+        if get_no_vox_combinations:
+            no_vox_stems = [
+                    stem for stem in output["audio"] if
+                    stem not in self._VOX_STEMS
+            ]
+            no_vox_combinations = chain.from_iterable(
+                    combinations(no_vox_stems, r) for r in
+                    range(2, len(no_vox_stems) + 1)
+            )
+
+            for combination in no_vox_combinations:
+                combination_ = list(combination)
+                output["audio"]["+".join(combination_)] = sum(
+                        [output["audio"][stem] for stem in combination_]
+                )
+
+        if treat_batch_as_channels:
+            for stem in output["audio"]:
+                output["audio"][stem] = output["audio"][stem].reshape(
+                        1, -1, output["audio"][stem].shape[-1]
+                )
+            batch_size = 1
+
+        result = {}
+        for b in range(batch_size):
+            for stem in output["audio"]:
+                track_name = batch["track"][b].split("/")[-1]
+
+                if batch.get("audio", {}).get(stem, None) is not None:
+                    self.test_metrics[stem].reset()
+                    metrics = self.test_metrics[stem](
+                            batch["audio"][stem][[b], ...],
+                            output["audio"][stem][[b], ...]
+                    )
+                    snr = metrics["snr"]
+                    sisnr = metrics["sisnr"]
+                    sdr = metrics["sdr"]
+                    metric_dict[stem] = metrics
+                    print(
+                            track_name,
+                            f"snr={snr:2.2f} dB",
+                            f"sisnr={sisnr:2.2f}",
+                            f"sdr={sdr:2.2f} dB",
+                    )
+                    filename = f"{stem} - snr={snr:2.2f}dB - sdr={sdr:2.2f}dB.wav"
+                else:
+                    filename = f"{stem}.wav"
+
+                if include_track_name:
+                    output_dir = os.path.join(
+                            self.predict_output_path,
+                            track_name
+                    )
+                else:
+                    output_dir = self.predict_output_path
+
+                os.makedirs(output_dir, exist_ok=True)
+
+                if fs is None:
+                    fs = self.fs
+
+                result[stem] = output["audio"][stem][b, ...].cpu().numpy()
+
+        return result
+
+    def load_state_dict(
+            self, state_dict: Mapping[str, Any], strict: bool = False
+    ) -> Any:
+
+        return super().load_state_dict(state_dict, strict=False)
+
+
+    def set_predict_output_path(self, path: str) -> None:
+        self.predict_output_path = path
+        os.makedirs(self.predict_output_path, exist_ok=True)
+
+        self.attach_fader()
+
+    def attach_fader(self, force_reattach=False) -> None:
+        if self.fader is None or force_reattach:
+            self.fader = parse_fader_config(self.fader_config)
+            self.fader.to(self.device)
+
+
+    def log_dict_with_prefix(
+            self,
+            dict_: Dict[str, torch.Tensor],
+            prefix: str,
+            batch_size: Optional[int] = None,
+            **kwargs: Any
+    ) -> None:
+        self.log_dict(
+                {f"{prefix}/{k}": v for k, v in dict_.items()},
+                batch_size=batch_size,
+                logger=True,
+                sync_dist=True,
+                **kwargs,
+        )

data_pipeline/seperation/models/bandit/core/data/__init__.py

@@ -0,0 +1,2 @@
+from .dnr.datamodule import DivideAndRemasterDataModule
+from .musdb.datamodule import MUSDB18DataModule

data_pipeline/seperation/models/bandit/core/data/_types.py

@@ -0,0 +1,18 @@
+from typing import Dict, Sequence, TypedDict
+
+import torch
+
+AudioDict = Dict[str, torch.Tensor]
+
+DataDict = TypedDict('DataDict', {'audio': AudioDict, 'track': str})
+
+BatchedDataDict = TypedDict(
+        'BatchedDataDict',
+        {'audio': AudioDict, 'track': Sequence[str]}
+)
+
+
+class DataDictWithLanguage(TypedDict):
+    audio: AudioDict
+    track: str
+    language: str

data_pipeline/seperation/models/bandit/core/data/augmentation.py

@@ -0,0 +1,107 @@
+from abc import ABC
+from typing import Any, Dict, Union
+
+import torch
+import torch_audiomentations as tam
+from torch import nn
+
+from models.bandit.core.data._types import BatchedDataDict, DataDict
+
+
+class BaseAugmentor(nn.Module, ABC):
+    def forward(self, item: Union[DataDict, BatchedDataDict]) -> Union[
+        DataDict, BatchedDataDict]:
+        raise NotImplementedError
+
+
+class StemAugmentor(BaseAugmentor):
+    def __init__(
+            self,
+            audiomentations: Dict[str, Dict[str, Any]],
+            fix_clipping: bool = True,
+            scaler_margin: float = 0.5,
+            apply_both_default_and_common: bool = False,
+    ) -> None:
+        super().__init__()
+
+        augmentations = {}
+
+        self.has_default = "[default]" in audiomentations
+        self.has_common = "[common]" in audiomentations
+        self.apply_both_default_and_common = apply_both_default_and_common
+
+        for stem in audiomentations:
+            if audiomentations[stem]["name"] == "Compose":
+                augmentations[stem] = getattr(
+                        tam,
+                        audiomentations[stem]["name"]
+                )(
+                        [
+                                getattr(tam, aug["name"])(**aug["kwargs"])
+                                for aug in
+                                audiomentations[stem]["kwargs"]["transforms"]
+                        ],
+                        **audiomentations[stem]["kwargs"]["kwargs"],
+                )
+            else:
+                augmentations[stem] = getattr(
+                        tam,
+                        audiomentations[stem]["name"]
+                )(
+                        **audiomentations[stem]["kwargs"]
+                )
+
+        self.augmentations = nn.ModuleDict(augmentations)
+        self.fix_clipping = fix_clipping
+        self.scaler_margin = scaler_margin
+
+    def check_and_fix_clipping(
+            self, item: Union[DataDict, BatchedDataDict]
+    ) -> Union[DataDict, BatchedDataDict]:
+        max_abs = []
+
+        for stem in item["audio"]:
+            max_abs.append(item["audio"][stem].abs().max().item())
+
+        if max(max_abs) > 1.0:
+            scaler = 1.0 / (max(max_abs) + torch.rand(
+                    (1,),
+                    device=item["audio"]["mixture"].device
+            ) * self.scaler_margin)
+
+            for stem in item["audio"]:
+                item["audio"][stem] *= scaler
+
+        return item
+
+    def forward(self, item: Union[DataDict, BatchedDataDict]) -> Union[
+        DataDict, BatchedDataDict]:
+
+        for stem in item["audio"]:
+            if stem == "mixture":
+                continue
+
+            if self.has_common:
+                item["audio"][stem] = self.augmentations["[common]"](
+                        item["audio"][stem]
+                ).samples
+
+            if stem in self.augmentations:
+                item["audio"][stem] = self.augmentations[stem](
+                        item["audio"][stem]
+                ).samples
+            elif self.has_default:
+                if not self.has_common or self.apply_both_default_and_common:
+                    item["audio"][stem] = self.augmentations["[default]"](
+                            item["audio"][stem]
+                    ).samples
+
+        item["audio"]["mixture"] = sum(
+                [item["audio"][stem] for stem in item["audio"]
+                 if stem != "mixture"]
+        )  # type: ignore[call-overload, assignment]
+
+        if self.fix_clipping:
+            item = self.check_and_fix_clipping(item)
+
+        return item

data_pipeline/seperation/models/bandit/core/data/augmented.py

@@ -0,0 +1,35 @@
+import warnings
+from typing import Dict, Optional, Union
+
+import torch
+from torch import nn
+from torch.utils import data
+
+
+class AugmentedDataset(data.Dataset):
+    def __init__(
+            self,
+            dataset: data.Dataset,
+            augmentation: nn.Module = nn.Identity(),
+            target_length: Optional[int] = None,
+    ) -> None:
+        warnings.warn(
+                "This class is no longer used. Attach augmentation to "
+                "the LightningSystem instead.",
+                DeprecationWarning,
+        )
+
+        self.dataset = dataset
+        self.augmentation = augmentation
+
+        self.ds_length: int = len(dataset)  # type: ignore[arg-type]
+        self.length = target_length if target_length is not None else self.ds_length
+
+    def __getitem__(self, index: int) -> Dict[str, Union[str, Dict[str,
+    torch.Tensor]]]:
+        item = self.dataset[index % self.ds_length]
+        item = self.augmentation(item)
+        return item
+
+    def __len__(self) -> int:
+        return self.length