manually copy part of the diffvox source code

modules/functional.py

@@ -0,0 +1,229 @@
+import torch
+import torch.nn.functional as F
+from torchcomp import compexp_gain, db2amp
+from torchlpc import sample_wise_lpc
+from typing import List, Tuple, Union, Any, Optional
+import math
+
+
+def inv_22(a, b, c, d):
+    return torch.stack([d, -b, -c, a]).view(2, 2) / (a * d - b * c)
+
+
+def eig_22(a, b, c, d):
+    # https://croninprojects.org/Vince/Geodesy/FindingEigenvectors.pdf
+    T = a + d
+    D = a * d - b * c
+    half_T = T * 0.5
+    root = torch.sqrt(half_T * half_T - D)  # + 0j)
+    L = torch.stack([half_T + root, half_T - root])
+
+    y = (L - a) / b
+    # y = c / L
+    V = torch.stack([torch.ones_like(y), y])
+    return L, V / V.abs().square().sum(0).sqrt()
+
+
+def fir(x, b):
+    padded = F.pad(x.reshape(-1, 1, x.size(-1)), (b.size(0) - 1, 0))
+    return F.conv1d(padded, b.flip(0).view(1, 1, -1)).view(*x.shape)
+
+
+def allpole(x: torch.Tensor, a: torch.Tensor):
+    h = x.reshape(-1, x.shape[-1])
+    return sample_wise_lpc(
+        h,
+        a.broadcast_to(h.shape + a.shape),
+    ).reshape(*x.shape)
+
+
+def biquad(x: torch.Tensor, b0, b1, b2, a0, a1, a2):
+    b0 = b0 / a0
+    b1 = b1 / a0
+    b2 = b2 / a0
+    a1 = a1 / a0
+    a2 = a2 / a0
+
+    beta1 = b1 - b0 * a1
+    beta2 = b2 - b0 * a2
+
+    tmp = a1.square() - 4 * a2
+    if tmp < 0:
+        pole = 0.5 * (-a1 + 1j * torch.sqrt(-tmp))
+        u = -1j * x[..., :-1]
+        h = sample_wise_lpc(
+            u.reshape(-1, u.shape[-1]),
+            -pole.broadcast_to(u.shape).reshape(-1, u.shape[-1], 1),
+        ).reshape(*u.shape)
+        h = (
+            h.real * (beta1 * pole.real / pole.imag + beta2 / pole.imag)
+            - beta1 * h.imag
+        )
+    else:
+        L, V = eig_22(-a1, -a2, torch.ones_like(a1), torch.zeros_like(a1))
+        inv_V = inv_22(*V.view(-1))
+
+        C = torch.stack([beta1, beta2]) @ V
+
+        # project input to eigen space
+        h = x[..., :-1].unsqueeze(-2) * inv_V[:, :1]
+        L = L.unsqueeze(-1).broadcast_to(h.shape)
+
+        h = (
+            sample_wise_lpc(h.reshape(-1, h.shape[-1]), -L.reshape(-1, L.shape[-1], 1))
+            .reshape(*h.shape)
+            .transpose(-2, -1)
+        ) @ C
+    tmp = b0 * x
+    y = torch.cat([tmp[..., :1], h + tmp[..., 1:]], -1)
+    return y
+
+
+def highpass_biquad_coef(
+    sample_rate: int,
+    cutoff_freq: torch.Tensor,
+    Q: torch.Tensor,
+):
+    w0 = 2 * torch.pi * cutoff_freq / sample_rate
+    alpha = torch.sin(w0) / 2.0 / Q
+
+    b0 = (1 + torch.cos(w0)) / 2
+    b1 = -1 - torch.cos(w0)
+    b2 = b0
+    a0 = 1 + alpha
+    a1 = -2 * torch.cos(w0)
+    a2 = 1 - alpha
+    return b0, b1, b2, a0, a1, a2
+
+
+def apply_biquad(bq):
+    return lambda waveform, *args, **kwargs: biquad(waveform, *bq(*args, **kwargs))
+
+
+highpass_biquad = apply_biquad(highpass_biquad_coef)
+
+
+def lowpass_biquad_coef(
+    sample_rate: int,
+    cutoff_freq: torch.Tensor,
+    Q: torch.Tensor,
+):
+    w0 = 2 * torch.pi * cutoff_freq / sample_rate
+    alpha = torch.sin(w0) / 2 / Q
+
+    b0 = (1 - torch.cos(w0)) / 2
+    b1 = 1 - torch.cos(w0)
+    b2 = b0
+    a0 = 1 + alpha
+    a1 = -2 * torch.cos(w0)
+    a2 = 1 - alpha
+    return b0, b1, b2, a0, a1, a2
+
+
+def equalizer_biquad_coef(
+    sample_rate: int,
+    center_freq: torch.Tensor,
+    gain: torch.Tensor,
+    Q: torch.Tensor,
+):
+
+    w0 = 2 * torch.pi * center_freq / sample_rate
+    A = torch.exp(gain / 40.0 * math.log(10))
+    alpha = torch.sin(w0) / 2 / Q
+
+    b0 = 1 + alpha * A
+    b1 = -2 * torch.cos(w0)
+    b2 = 1 - alpha * A
+
+    a0 = 1 + alpha / A
+    a1 = -2 * torch.cos(w0)
+    a2 = 1 - alpha / A
+    return b0, b1, b2, a0, a1, a2
+
+
+def lowshelf_biquad_coef(
+    sample_rate: int,
+    cutoff_freq: torch.Tensor,
+    gain: torch.Tensor,
+    Q: torch.Tensor,
+):
+
+    w0 = 2 * torch.pi * cutoff_freq / sample_rate
+    A = torch.exp(gain / 40.0 * math.log(10))
+    alpha = torch.sin(w0) / 2 / Q
+    cosw0 = torch.cos(w0)
+    sqrtA = torch.sqrt(A)
+
+    b0 = A * (A + 1 - (A - 1) * cosw0 + 2 * alpha * sqrtA)
+    b1 = 2 * A * (A - 1 - (A + 1) * cosw0)
+    b2 = A * (A + 1 - (A - 1) * cosw0 - 2 * alpha * sqrtA)
+
+    a0 = A + 1 + (A - 1) * cosw0 + 2 * alpha * sqrtA
+    a1 = -2 * (A - 1 + (A + 1) * cosw0)
+    a2 = A + 1 + (A - 1) * cosw0 - 2 * alpha * sqrtA
+
+    return b0, b1, b2, a0, a1, a2
+
+
+def highshelf_biquad_coef(
+    sample_rate: int,
+    cutoff_freq: torch.Tensor,
+    gain: torch.Tensor,
+    Q: torch.Tensor,
+):
+
+    w0 = 2 * torch.pi * cutoff_freq / sample_rate
+    A = torch.exp(gain / 40.0 * math.log(10))
+    alpha = torch.sin(w0) / 2 / Q
+    cosw0 = torch.cos(w0)
+    sqrtA = torch.sqrt(A)
+
+    b0 = A * (A + 1 + (A - 1) * cosw0 + 2 * alpha * sqrtA)
+    b1 = -2 * A * (A - 1 + (A + 1) * cosw0)
+    b2 = A * (A + 1 + (A - 1) * cosw0 - 2 * alpha * sqrtA)
+
+    a0 = A + 1 - (A - 1) * cosw0 + 2 * alpha * sqrtA
+    a1 = 2 * (A - 1 - (A + 1) * cosw0)
+    a2 = A + 1 - (A - 1) * cosw0 - 2 * alpha * sqrtA
+
+    return b0, b1, b2, a0, a1, a2
+
+
+highpass_biquad = apply_biquad(highpass_biquad_coef)
+lowpass_biquad = apply_biquad(lowpass_biquad_coef)
+highshelf_biquad = apply_biquad(highshelf_biquad_coef)
+lowshelf_biquad = apply_biquad(lowshelf_biquad_coef)
+equalizer_biquad = apply_biquad(equalizer_biquad_coef)
+
+
+def avg(rms: torch.Tensor, avg_coef: torch.Tensor):
+    assert torch.all(avg_coef > 0) and torch.all(avg_coef <= 1)
+
+    h = rms * avg_coef
+
+    return sample_wise_lpc(
+        h,
+        (avg_coef - 1).broadcast_to(h.shape).unsqueeze(-1),
+    )
+
+
+def avg_rms(audio: torch.Tensor, avg_coef) -> torch.Tensor:
+    return avg(audio.square().clamp_min(1e-8), avg_coef).sqrt()
+
+
+def compressor_expander(
+    x: torch.Tensor,
+    avg_coef: Union[torch.Tensor, float],
+    cmp_th: Union[torch.Tensor, float],
+    cmp_ratio: Union[torch.Tensor, float],
+    exp_th: Union[torch.Tensor, float],
+    exp_ratio: Union[torch.Tensor, float],
+    at: Union[torch.Tensor, float],
+    rt: Union[torch.Tensor, float],
+    make_up: torch.Tensor,
+    lookahead_func=lambda x: x,
+):
+    rms = avg_rms(x, avg_coef=avg_coef)
+    gain = compexp_gain(rms, cmp_th, cmp_ratio, exp_th, exp_ratio, at, rt)
+    gain = lookahead_func(gain)
+    return x * gain * db2amp(make_up).broadcast_to(x.shape[0], 1)

modules/fx.py

@@ -0,0 +1,994 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch.nn.utils.parametrize import register_parametrization
+from torchcomp import ms2coef, coef2ms, db2amp
+from torchaudio.transforms import Spectrogram, InverseSpectrogram
+
+from typing import List, Tuple, Union, Any, Optional, Callable
+import math
+from torch_fftconv import fft_conv1d
+from functools import reduce
+
+from .functional import (
+    compressor_expander,
+    lowpass_biquad,
+    highpass_biquad,
+    equalizer_biquad,
+    lowshelf_biquad,
+    highshelf_biquad,
+    lowpass_biquad_coef,
+    highpass_biquad_coef,
+    highshelf_biquad_coef,
+    lowshelf_biquad_coef,
+    equalizer_biquad_coef,
+)
+from .utils import chain_functions
+
+
+class Clip(nn.Module):
+    def __init__(self, max: Optional[float] = None, min: Optional[float] = None):
+        super().__init__()
+        self.min = min
+        self.max = max
+
+    def forward(self, x):
+        if self.min is not None:
+            x = torch.clip(x, min=self.min)
+        if self.max is not None:
+            x = torch.clip(x, max=self.max)
+        return x
+
+
+def clip_delay_eq_Q(m: nn.Module, Q: float):
+    if isinstance(m, Delay) and isinstance(m.eq, LowPass):
+        register_parametrization(m.eq.params, "Q", Clip(max=Q))
+    return m
+
+
+float2param = lambda x: nn.Parameter(
+    torch.tensor(x, dtype=torch.float32) if not isinstance(x, torch.Tensor) else x
+)
+
+STEREO_NORM = math.sqrt(2)
+
+
+def broadcast2stereo(m, args):
+    x, *_ = args
+    return x.expand(-1, 2, -1) if x.shape[1] == 1 else x
+
+
+hadamard = lambda x: torch.stack([x.sum(1), x[:, 0] - x[:, 1]], 1) / STEREO_NORM
+
+
+class Hadamard(nn.Module):
+    def forward(self, x):
+        return hadamard(x)
+
+
+class FX(nn.Module):
+    def __init__(self, **kwargs) -> None:
+        super().__init__()
+
+        self.params = nn.ParameterDict({k: float2param(v) for k, v in kwargs.items()})
+
+
+class SmoothingCoef(nn.Module):
+    def forward(self, x):
+        return x.sigmoid()
+
+    def right_inverse(self, y):
+        return (y / (1 - y)).log()
+
+
+class CompRatio(nn.Module):
+    def forward(self, x):
+        return x.exp() + 1
+
+    def right_inverse(self, y):
+        return torch.log(y - 1)
+
+
+class MinMax(nn.Module):
+    def __init__(self, min=0.0, max: Union[float, torch.Tensor] = 1.0):
+        super().__init__()
+        if isinstance(min, torch.Tensor):
+            self.register_buffer("min", min, persistent=False)
+        else:
+            self.min = min
+
+        if isinstance(max, torch.Tensor):
+            self.register_buffer("max", max, persistent=False)
+        else:
+            self.max = max
+
+        self._m = SmoothingCoef()
+
+    def forward(self, x):
+        return self._m(x) * (self.max - self.min) + self.min
+
+    def right_inverse(self, y):
+        return self._m.right_inverse((y - self.min) / (self.max - self.min))
+
+
+class WrappedPositive(nn.Module):
+    def __init__(self, period):
+        super().__init__()
+        self.period = period
+
+    def forward(self, x):
+        return x.abs() % self.period
+
+    def right_inverse(self, y):
+        return y
+
+
+class CompressorExpander(FX):
+    cmp_ratio_min: float = 1
+    cmp_ratio_max: float = 20
+
+    def __init__(
+        self,
+        sr: int,
+        cmp_ratio: float = 2.0,
+        exp_ratio: float = 0.5,
+        at_ms: float = 50.0,
+        rt_ms: float = 50.0,
+        avg_coef: float = 0.3,
+        cmp_th: float = -18.0,
+        exp_th: float = -54.0,
+        make_up: float = 0.0,
+        delay: int = 0,
+        lookahead: bool = False,
+        max_lookahead: float = 15.0,
+    ):
+        super().__init__(
+            cmp_th=cmp_th,
+            exp_th=exp_th,
+            make_up=make_up,
+            avg_coef=avg_coef,
+            cmp_ratio=cmp_ratio,
+            exp_ratio=exp_ratio,
+        )
+        # deprecated, please use lookahead instead
+        self.delay = delay
+        self.sr = sr
+
+        self.params["at"] = nn.Parameter(ms2coef(torch.tensor(at_ms), sr))
+        self.params["rt"] = nn.Parameter(ms2coef(torch.tensor(rt_ms), sr))
+
+        if lookahead:
+            self.params["lookahead"] = nn.Parameter(torch.ones(1) / sr * 1000)
+            register_parametrization(
+                self.params, "lookahead", WrappedPositive(max_lookahead)
+            )
+            sinc_length = int(sr * (max_lookahead + 1) * 0.001) + 1
+            left_pad_size = int(sr * 0.001)
+            self._pad_size = (left_pad_size, sinc_length - left_pad_size - 1)
+            self.register_buffer(
+                "_arange",
+                torch.arange(sinc_length) - left_pad_size,
+                persistent=False,
+            )
+        self.lookahead = lookahead
+
+        register_parametrization(self.params, "at", SmoothingCoef())
+        register_parametrization(self.params, "rt", SmoothingCoef())
+        register_parametrization(self.params, "avg_coef", SmoothingCoef())
+        register_parametrization(
+            self.params, "cmp_ratio", MinMax(self.cmp_ratio_min, self.cmp_ratio_max)
+        )
+        register_parametrization(self.params, "exp_ratio", SmoothingCoef())
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            s = (
+                f"attack: {coef2ms(self.params.at, self.sr).item()} (ms)\n"
+                f"release: {coef2ms(self.params.rt, self.sr).item()} (ms)\n"
+                f"avg_coef: {self.params.avg_coef.item()}\n"
+                f"compressor_ratio: {self.params.cmp_ratio.item()}\n"
+                f"expander_ratio: {self.params.exp_ratio.item()}\n"
+                f"compressor_threshold: {self.params.cmp_th.item()} (dB)\n"
+                f"expander_threshold: {self.params.exp_th.item()} (dB)\n"
+                f"make_up: {self.params.make_up.item()} (dB)"
+            )
+            if self.lookahead:
+                s += f"\nlookahead: {self.params.lookahead.item()} (ms)"
+        return s
+
+    def forward(self, x):
+        if self.lookahead:
+            lookahead_in_samples = self.params.lookahead * 0.001 * self.sr
+            sinc_filter = torch.sinc(self._arange - lookahead_in_samples)
+            lookahead_func = lambda gain: F.conv1d(
+                F.pad(
+                    gain.view(-1, 1, gain.size(-1)), self._pad_size, mode="replicate"
+                ),
+                sinc_filter[None, None, :],
+            ).view(*gain.shape)
+        else:
+            lookahead_func = lambda x: x
+
+        return compressor_expander(
+            x.reshape(-1, x.shape[-1]),
+            lookahead_func=lookahead_func,
+            **{k: v for k, v in self.params.items() if k != "lookahead"},
+        ).view(*x.shape)
+
+
+class Panning(FX):
+    def __init__(self, pan: float = 0.0):
+        assert pan <= 100 and pan >= -100
+        super().__init__(pan=(pan + 100) / 200)
+
+        register_parametrization(self.params, "pan", SmoothingCoef())
+
+        self.register_forward_pre_hook(broadcast2stereo)
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            s = f"pan: {self.params.pan.item() * 200 - 100}"
+        return s
+
+    def forward(self, x: torch.Tensor):
+        angle = self.params.pan.view(1) * torch.pi * 0.5
+        amp = torch.concat([angle.cos(), angle.sin()]).view(2, 1) * STEREO_NORM
+        return x * amp
+
+
+class StereoWidth(Panning):
+    def forward(self, x: torch.Tensor):
+        return chain_functions(hadamard, super().forward, hadamard)(x)
+
+
+class ImpulseResponse(nn.Module):
+    def forward(self, h):
+        return torch.cat([torch.ones_like(h[..., :1]), h], dim=-1)
+
+
+class FIR(FX):
+    def __init__(
+        self,
+        length: int,
+        channels: int = 2,
+        conv_method: str = "direct",
+    ):
+        super().__init__(kernel=torch.zeros(channels, length - 1))
+        self._padding = length - 1
+        self.channels = channels
+
+        match conv_method:
+            case "direct":
+                self.conv_func = F.conv1d
+            case "fft":
+                self.conv_func = fft_conv1d
+            case _:
+                raise ValueError(f"Unknown conv_method: {conv_method}")
+
+        if channels == 2:
+            self.register_forward_pre_hook(broadcast2stereo)
+
+    def forward(self, x: torch.Tensor):
+        zero_padded = F.pad(x[..., :-1], (self._padding, 0), "constant", 0)
+        return x + self.conv_func(
+            zero_padded, self.params.kernel.flip(1).unsqueeze(1), groups=self.channels
+        )
+
+
+class QFactor(nn.Module):
+    def forward(self, x):
+        return x.exp()
+
+    def right_inverse(self, y):
+        return y.log()
+
+
+class LowPass(FX):
+    def __init__(
+        self,
+        sr: int,
+        freq: float = 17500.0,
+        Q: float = 0.707,
+        min_freq: float = 200.0,
+        max_freq: float = 18000,
+        min_Q: float = 0.5,
+        max_Q: float = 10.0,
+    ):
+        super().__init__(freq=freq, Q=Q)
+
+        self.sr = sr
+        register_parametrization(self.params, "freq", MinMax(min_freq, max_freq))
+        register_parametrization(self.params, "Q", MinMax(min_Q, max_Q))
+
+    def forward(self, x):
+        return lowpass_biquad(
+            x, sample_rate=self.sr, cutoff_freq=self.params.freq, Q=self.params.Q
+        )
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            s = f"freq: {self.params.freq.item():.4f}, Q: {self.params.Q.item():.4f}"
+        return s
+
+
+class HighPass(LowPass):
+    def __init__(
+        self,
+        *args,
+        freq: float = 200.0,
+        min_freq: float = 16.0,
+        max_freq: float = 5300.0,
+        **kwargs,
+    ):
+        super().__init__(
+            *args, freq=freq, min_freq=min_freq, max_freq=max_freq, **kwargs
+        )
+
+    def forward(self, x):
+        return highpass_biquad(
+            x, sample_rate=self.sr, cutoff_freq=self.params.freq, Q=self.params.Q
+        )
+
+
+class Peak(FX):
+    def __init__(
+        self,
+        sr: int,
+        gain: float = 0.0,
+        freq: float = 2000.0,
+        Q: float = 0.707,
+        min_freq: float = 33.0,
+        max_freq: float = 17500.0,
+        min_Q: float = 0.2,
+        max_Q: float = 20,
+    ):
+        super().__init__(freq=freq, Q=Q, gain=gain)
+
+        self.sr = sr
+
+        register_parametrization(self.params, "freq", MinMax(min_freq, max_freq))
+        register_parametrization(self.params, "Q", MinMax(min_Q, max_Q))
+
+    def forward(self, x):
+        return equalizer_biquad(
+            x,
+            sample_rate=self.sr,
+            center_freq=self.params.freq,
+            Q=self.params.Q,
+            gain=self.params.gain,
+        )
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            s = f"freq: {self.params.freq.item():.4f}, gain: {self.params.gain.item():.4f}, Q: {self.params.Q.item():.4f}"
+        return s
+
+
+class LowShelf(FX):
+    def __init__(
+        self,
+        sr: int,
+        gain: float = 0.0,
+        freq: float = 115.0,
+        min_freq: float = 30,
+        max_freq: float = 200,
+    ):
+        super().__init__(freq=freq, gain=gain)
+
+        self.sr = sr
+        register_parametrization(self.params, "freq", MinMax(min_freq, max_freq))
+
+        self.register_buffer("Q", torch.tensor(0.707), persistent=False)
+
+    def forward(self, x):
+        return lowshelf_biquad(
+            x,
+            sample_rate=self.sr,
+            cutoff_freq=self.params.freq,
+            gain=self.params.gain,
+            Q=self.Q,
+        )
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            s = f"freq: {self.params.freq.item():.4f}, gain: {self.params.gain.item():.4f}"
+        return s
+
+
+class HighShelf(LowShelf):
+    def __init__(
+        self,
+        *args,
+        freq: float = 4525,
+        min_freq: float = 750,
+        max_freq: float = 8300,
+        **kwargs,
+    ):
+        super().__init__(
+            *args, freq=freq, min_freq=min_freq, max_freq=max_freq, **kwargs
+        )
+
+    def forward(self, x):
+        return highshelf_biquad(
+            x,
+            sample_rate=self.sr,
+            cutoff_freq=self.params.freq,
+            gain=self.params.gain,
+            Q=self.Q,
+        )
+
+
+def module2coeffs(
+    m: Union[LowPass, HighPass, Peak, LowShelf, HighShelf],
+) -> Tuple[
+    torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor
+]:
+    match m:
+        case LowPass():
+            return lowpass_biquad_coef(m.sr, m.params.freq, m.params.Q)
+        case HighPass():
+            return highpass_biquad_coef(m.sr, m.params.freq, m.params.Q)
+        case Peak():
+            return equalizer_biquad_coef(m.sr, m.params.freq, m.params.Q, m.params.gain)
+        case LowShelf():
+            return lowshelf_biquad_coef(m.sr, m.params.freq, m.params.gain, m.Q)
+        case HighShelf():
+            return highshelf_biquad_coef(m.sr, m.params.freq, m.params.gain, m.Q)
+        case _:
+            raise ValueError(f"Unknown module: {m}")
+
+
+class AlwaysNegative(nn.Module):
+    def forward(self, x):
+        return -F.softplus(x)
+
+    def right_inverse(self, y):
+        return torch.log(y.neg().exp() - 1)
+
+
+class Reverb(FX):
+    def __init__(self, ir_len=60000, n_fft=384, hop_length=192, downsample_factor=1):
+        super().__init__(
+            log_mag=torch.full((2, n_fft // downsample_factor // 2 + 1), -1.0),
+            log_mag_delta=torch.full((2, n_fft // downsample_factor // 2 + 1), -5.0),
+        )
+
+        self.steps = (ir_len - n_fft + hop_length - 1) // hop_length
+        self.n_fft = n_fft
+        self.hop_length = hop_length
+        self.downsample_factor = downsample_factor
+
+        self._noise_angle = nn.Parameter(
+            torch.rand(2, n_fft // 2 + 1, self.steps) * 2 * torch.pi
+        )
+
+        self.register_buffer(
+            "_arange", torch.arange(self.steps, dtype=torch.float32), persistent=False
+        )
+        self.spec_forward = Spectrogram(n_fft, hop_length=hop_length, power=None)
+        self.spec_inverse = InverseSpectrogram(
+            n_fft,
+            hop_length=hop_length,
+        )
+
+        register_parametrization(self.params, "log_mag", AlwaysNegative())
+        register_parametrization(self.params, "log_mag_delta", AlwaysNegative())
+
+        self.register_forward_pre_hook(broadcast2stereo)
+
+    def forward(self, x):
+        h = x
+        H = self.spec_forward(h)
+
+        log_mag = self.params.log_mag
+        log_mag_delta = self.params.log_mag_delta
+
+        if self.downsample_factor > 1:
+            log_mag = F.interpolate(
+                log_mag.unsqueeze(0),
+                size=self._noise_angle.size(1),
+                align_corners=True,
+                mode="linear",
+            ).squeeze(0)
+            log_mag_delta = F.interpolate(
+                log_mag_delta.unsqueeze(0),
+                size=self._noise_angle.size(1),
+                align_corners=True,
+                mode="linear",
+            ).squeeze(0)
+
+        ir_2d = torch.exp(
+            log_mag.unsqueeze(-1)
+            + log_mag_delta.unsqueeze(-1) * self._arange
+            + self._noise_angle * 1j
+        )
+
+        padded_H = F.pad(H.flatten(1, 2), (ir_2d.shape[-1] - 1, 0))
+
+        H = F.conv1d(
+            padded_H,
+            hadamard(ir_2d.unsqueeze(0)).flatten(1, 2).flip(-1).transpose(0, 1),
+            groups=H.shape[2] * 2,
+        ).view(*H.shape)
+
+        h = self.spec_inverse(H)
+        return h
+
+
+class Delay(FX):
+    min_delay: float = 100
+    max_delay: float = 1000
+
+    def __init__(
+        self,
+        sr: int,
+        delay=200.0,
+        feedback=0.1,
+        gain=0.1,
+        ir_duration: float = 2,
+        eq: Optional[nn.Module] = None,
+        recursive_eq=False,
+    ):
+        super().__init__(
+            delay=delay,
+            feedback=feedback,
+            gain=gain,
+        )
+        self.sr = sr
+        self.ir_length = int(sr * max(ir_duration, self.max_delay * 0.002))
+
+        register_parametrization(
+            self.params, "delay", MinMax(self.min_delay, self.max_delay)
+        )
+        register_parametrization(self.params, "feedback", SmoothingCoef())
+        register_parametrization(self.params, "gain", SmoothingCoef())
+
+        self.eq = eq
+        self.recursive_eq = recursive_eq
+
+        self.register_buffer(
+            "_arange", torch.arange(self.ir_length, dtype=torch.float32)
+        )
+
+        self.odd_pan = Panning(0)
+        self.even_pan = Panning(0)
+
+    def forward(self, x):
+        assert x.size(1) == 1, x.size()
+        delay_in_samples = self.sr * self.params.delay * 0.001
+        num_delays = self.ir_length // int(delay_in_samples.item() + 1)
+        series = torch.arange(1, num_delays + 1, device=x.device)
+        decays = self.params.feedback ** (series - 1)
+
+        if self.recursive_eq and self.eq is not None:
+            sinc_index = self._arange - delay_in_samples
+            single_sinc_filter = torch.sinc(sinc_index)
+            eq_sinc_filter = self.eq(single_sinc_filter)
+            H = torch.fft.rfft(eq_sinc_filter)
+            H_powered = torch.polar(
+                H.abs() ** series.unsqueeze(-1), H.angle() * series.unsqueeze(-1)
+            )
+            sinc_filters = torch.fft.irfft(H_powered, n=self.ir_length)
+        else:
+            delays_in_samples = delay_in_samples * series
+            sinc_indexes = self._arange - delays_in_samples.unsqueeze(-1)
+            sinc_filters = torch.sinc(sinc_indexes)
+
+        decayed_sinc_filters = sinc_filters * decays.unsqueeze(-1)
+        return self._filter(x, decayed_sinc_filters)
+
+    def _filter(self, x: torch.Tensor, decayed_sinc_filters: torch.Tensor):
+        odd_delay_filters = torch.sum(decayed_sinc_filters[::2], 0)
+        even_delay_filters = torch.sum(decayed_sinc_filters[1::2], 0)
+        stacked_filters = torch.stack([odd_delay_filters, even_delay_filters])
+
+        if self.eq is not None and not self.recursive_eq:
+            stacked_filters = self.eq(stacked_filters)
+
+        gained_odd_even_filters = stacked_filters * self.params.gain
+        padded_x = F.pad(x, (gained_odd_even_filters.size(-1) - 1, 0))
+        conv1d = F.conv1d if x.size(-1) > 44100 * 20 else fft_conv1d
+        return sum(
+            [
+                panner(s)
+                for panner, s in zip(
+                    [self.odd_pan, self.even_pan],
+                    # fft_conv1d(
+                    conv1d(
+                        padded_x,
+                        gained_odd_even_filters.flip(-1).unsqueeze(1),
+                    ).chunk(2, 1),
+                )
+            ]
+        )
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            s = (
+                f"delay: {self.sr * self.params.delay.item() * 0.001} (samples)\n"
+                f"feedback: {self.params.feedback.item()}\n"
+                f"gain: {self.params.gain.item()}"
+            )
+        return s
+
+
+class SurrogateDelay(Delay):
+    def __init__(self, *args, dropout=0.5, straight_through=False, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.dropout = dropout
+        self.straight_through = straight_through
+        self.log_damp = nn.Parameter(torch.ones(1) * -0.01)
+        register_parametrization(self, "log_damp", AlwaysNegative())
+
+    def forward(self, x):
+        assert x.size(1) == 1, x.size()
+        if not self.training:
+            return super().forward(x)
+
+        log_damp = self.log_damp
+        delay_in_samples = self.sr * self.params.delay * 0.001
+        num_delays = self.ir_length // int(delay_in_samples.item() + 1)
+        series = torch.arange(1, num_delays + 1, device=x.device)
+        decays = self.params.feedback ** (series - 1)
+
+        if self.recursive_eq and self.eq is not None:
+            exp_factor = self._arange[: self.ir_length // 2 + 1]
+            damped_exp = torch.exp(
+                log_damp * exp_factor
+                - 1j * delay_in_samples / self.ir_length * 2 * torch.pi * exp_factor
+            )
+            sinc_filter = torch.fft.irfft(damped_exp, n=self.ir_length)
+            if self.straight_through:
+                sinc_index = self._arange - delay_in_samples
+                hard_sinc_filter = torch.sinc(sinc_index)
+                sinc_filter = sinc_filter + (hard_sinc_filter - sinc_filter).detach()
+
+            eq_sinc_filter = self.eq(sinc_filter)
+            H = torch.fft.rfft(eq_sinc_filter)
+
+            # use polar form to avoid NaN
+            H_powered = torch.polar(
+                H.abs() ** series.unsqueeze(-1), H.angle() * series.unsqueeze(-1)
+            )
+            sinc_filters = torch.fft.irfft(H_powered, n=self.ir_length)
+        else:
+            exp_factors = series.unsqueeze(-1) * self._arange[: self.ir_length // 2 + 1]
+            damped_exps = torch.exp(
+                log_damp * exp_factors
+                - 1j * delay_in_samples / self.ir_length * 2 * torch.pi * exp_factors
+            )
+            sinc_filters = torch.fft.irfft(damped_exps, n=self.ir_length)
+            if self.straight_through:
+                delays_in_samples = delay_in_samples * series
+                sinc_indexes = self._arange - delays_in_samples.unsqueeze(-1)
+                hard_sinc_filters = torch.sinc(sinc_indexes)
+                sinc_filters = (
+                    sinc_filters + (hard_sinc_filters - sinc_filters).detach()
+                )
+
+        decayed_sinc_filters = sinc_filters * decays.unsqueeze(-1)
+
+        dropout_mask = torch.rand(x.size(0), device=x.device) < self.dropout
+        if not torch.any(dropout_mask):
+            return self._filter(x, decayed_sinc_filters)
+        elif torch.all(dropout_mask):
+            return super().forward(x)
+
+        out = torch.zeros((x.size(0), 2, x.size(2)), device=x.device)
+        out[~dropout_mask] = self._filter(x[~dropout_mask], decayed_sinc_filters)
+        out[dropout_mask] = super().forward(x[dropout_mask])
+        return out
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            return super().extra_repr() + f"\ndamp: {self.log_damp.exp().item()}"
+
+
+class FSDelay(FX):
+    def __init__(
+        self,
+        sr: int,
+        delay=200.0,
+        feedback=0.1,
+        gain=0.1,
+        ir_duration: float = 6,
+        eq: Optional[LowPass] = None,
+        recursive_eq=False,
+    ):
+        super().__init__(
+            delay=delay,
+            feedback=feedback,
+            gain=gain,
+        )
+        self.sr = sr
+        self.ir_length = int(sr * max(ir_duration, Delay.max_delay * 0.002))
+
+        register_parametrization(
+            self.params, "delay", MinMax(Delay.min_delay, Delay.max_delay)
+        )
+        register_parametrization(self.params, "gain", SmoothingCoef())
+
+        T_60 = ir_duration * 0.75
+        max_delay_in_samples = sr * Delay.max_delay * 0.001
+        maximum_decay = db2amp(torch.tensor(-60 / sr / T_60 * max_delay_in_samples))
+        register_parametrization(self.params, "feedback", MinMax(0, maximum_decay))
+
+        self.eq = eq
+        self.recursive_eq = recursive_eq
+
+        self.odd_pan = Panning(0)
+        self.even_pan = Panning(0)
+
+        self.register_buffer(
+            "_arange", torch.arange(self.ir_length, dtype=torch.float32)
+        )
+
+    def _get_h(self):
+        freqs = self._arange[: self.ir_length // 2 + 1] / self.ir_length * 2 * torch.pi
+        delay_in_samples = self.sr * self.params.delay * 0.001
+
+        # construct it like a fdn
+        Dinv = torch.exp(1j * freqs * delay_in_samples)
+        Dinv2 = torch.exp(2j * freqs * delay_in_samples)
+        if self.recursive_eq and self.eq is not None:
+            b0, b1, b2, a0, a1, a2 = module2coeffs(self.eq)
+            z_inv = torch.exp(-1j * freqs)
+            z_inv2 = torch.exp(-2j * freqs)
+            eq_H = (b0 + b1 * z_inv + b2 * z_inv2) / (a0 + a1 * z_inv + a2 * z_inv2)
+            damp = eq_H * self.params.feedback
+            det = Dinv2 - damp * damp
+        else:
+            damp = torch.full_like(Dinv, self.params.feedback) + 0j
+            det = Dinv2 - self.params.feedback.square()
+        inv_Dinv_m_A = torch.stack([Dinv, damp], 0) / det
+        h = torch.fft.irfft(inv_Dinv_m_A, n=self.ir_length) * self.params.gain
+
+        if self.eq is not None and not self.recursive_eq:
+            h = self.eq(h)
+        return h
+
+    def forward(self, x):
+        assert x.size(1) == 1, x.size()
+        h = self._get_h()
+
+        padded_x = F.pad(x, (h.size(-1) - 1, 0))
+        conv1d = F.conv1d if x.size(-1) > 44100 * 20 else fft_conv1d
+        return sum(
+            [
+                panner(s)
+                for panner, s in zip(
+                    [self.odd_pan, self.even_pan],
+                    conv1d(
+                        padded_x,
+                        h.flip(-1).unsqueeze(1),
+                    ).chunk(2, 1),
+                )
+            ]
+        )
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            s = (
+                f"delay: {self.sr * self.params.delay.item() * 0.001} (samples)\n"
+                f"feedback: {self.params.feedback.item()}\n"
+                f"gain: {self.params.gain.item()}"
+            )
+        return s
+
+
+class FSSurrogateDelay(FSDelay):
+    def __init__(self, *args, straight_through=False, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.straight_through = straight_through
+        self.log_damp = nn.Parameter(torch.ones(1) * -0.0001)
+        register_parametrization(self, "log_damp", AlwaysNegative())
+
+    def _get_h(self):
+        if not self.training:
+            return super()._get_h()
+
+        log_damp = self.log_damp
+        delay_in_samples = self.sr * self.params.delay * 0.001
+
+        exp_factor = self._arange[: self.ir_length // 2 + 1]
+        freqs = exp_factor / self.ir_length * 2 * torch.pi
+        D = torch.exp(log_damp * exp_factor - 1j * delay_in_samples * freqs)
+        D2 = torch.exp(log_damp * exp_factor * 2 - 2j * delay_in_samples * freqs)
+
+        if self.straight_through:
+            D_orig = torch.exp(-1j * delay_in_samples * freqs)
+            D2_orig = torch.exp(-2j * delay_in_samples * freqs)
+            D = torch.stack([D, D_orig], 0)
+            D2 = torch.stack([D2, D2_orig], 0)
+
+        if self.recursive_eq and self.eq is not None:
+            b0, b1, b2, a0, a1, a2 = module2coeffs(self.eq)
+            z_inv = torch.exp(-1j * freqs)
+            z_inv2 = torch.exp(-2j * freqs)
+            eq_H = (b0 + b1 * z_inv + b2 * z_inv2) / (a0 + a1 * z_inv + a2 * z_inv2)
+            damp = eq_H * self.params.feedback
+            odd_H = D / (1 - damp * damp * D2)
+            even_H = odd_H * D * damp
+        else:
+            damp = torch.full_like(D, self.params.feedback) + 0j
+            odd_H = D / (1 - self.params.feedback.square() * D2)
+            even_H = odd_H * D * self.params.feedback
+
+        inv_Dinv_m_A = torch.stack([odd_H, even_H], 0)
+        h = torch.fft.irfft(inv_Dinv_m_A, n=self.ir_length)
+
+        if self.straight_through:
+            damped_h, orig_h = h.unbind(1)
+            h = damped_h + (orig_h - damped_h).detach()
+
+        if self.eq is not None and not self.recursive_eq:
+            h = self.eq(h)
+        return h * self.params.gain
+
+    def extra_repr(self) -> str:
+        with torch.no_grad():
+            return super().extra_repr() + f"\ndamp: {self.log_damp.exp().item()}"
+
+
+class SendFXsAndSum(FX):
+    def __init__(self, *args, cross_send=True, pan_direct=False):
+        super().__init__(
+            **(
+                {
+                    f"sends_{i}": torch.full([len(args) - i - 1], 0.01)
+                    for i in range(len(args) - 1)
+                }
+                if cross_send
+                else {}
+            )
+        )
+        self.effects = nn.ModuleList(args)
+        if pan_direct:
+            self.pan = Panning()
+
+        if cross_send:
+            for i in range(len(args) - 1):
+                register_parametrization(self.params, f"sends_{i}", SmoothingCoef())
+
+    def forward(self, x):
+        if hasattr(self, "pan"):
+            di = self.pan(x)
+        else:
+            di = x
+
+        if len(self.params) == 0:
+            return reduce(
+                lambda x, y: x[..., : y.shape[-1]] + y[..., : x.shape[-1]],
+                map(lambda f: f(x), self.effects),
+                di,
+            )
+
+        def f(states, ps):
+            x, cum_sends = states
+            m, send_gains = ps
+            h = m(cum_sends[0])
+            return (
+                x[..., : h.shape[-1]] + h[..., : x.shape[-1]],
+                (
+                    None
+                    if cum_sends.size(0) == 1
+                    else cum_sends[1:, ..., : h.shape[-1]]
+                    + send_gains[:, None, None, None] * h[..., : cum_sends.shape[-1]]
+                ),
+            )
+
+        return reduce(
+            f,
+            zip(
+                self.effects,
+                [self.params[f"sends_{i}"] for i in range(len(self.effects) - 1)]
+                + [None],
+            ),
+            (di, x.unsqueeze(0).expand(len(self.effects), -1, -1, -1)),
+        )[0]
+
+
+class UniLossLess(nn.Module):
+    def forward(self, x):
+        tri = x.triu(1)
+        return torch.linalg.matrix_exp(tri - tri.T)
+
+
+class FDN(FX):
+    max_delay = 100
+
+    def __init__(
+        self,
+        sr: int,
+        ir_duration: float = 1.0,
+        delays=(997, 1153, 1327, 1559, 1801, 2099),
+        trainable_delay=False,
+        num_decay_freq=1,
+        delay_independent_decay=False,
+        eq: Optional[nn.Module] = None,
+    ):
+        # beta = torch.distributions.Beta(1.1, 6)
+        num_delays = len(delays)
+        super().__init__(
+            b=torch.ones(num_delays, 2) / num_delays,
+            c=torch.zeros(2, num_delays),
+            U=torch.randn(num_delays, num_delays) / num_delays**0.5,
+            gamma=torch.rand(
+                num_decay_freq, num_delays if not delay_independent_decay else 1
+            )
+            * 0.2
+            + 0.4,
+            # delays=beta.sample((num_delays,)) * 64,
+        )
+
+        self.sr = sr
+        self.ir_length = int(sr * ir_duration)
+
+        # ir_duration = T_60
+        T_60 = ir_duration * 0.75
+        delays = torch.tensor(delays)
+        if delay_independent_decay:
+            gamma_max = db2amp(-60 / sr / T_60 * delays.min())
+        else:
+            gamma_max = db2amp(-60 / sr / T_60 * delays)
+
+        register_parametrization(self.params, "gamma", MinMax(0, gamma_max))
+        register_parametrization(self.params, "U", UniLossLess())
+
+        if not trainable_delay:
+            self.register_buffer(
+                "delays",
+                delays,
+            )
+        else:
+            self.params["delays"] = nn.Parameter(delays / sr * 1000)
+            register_parametrization(self.params, "delays", MinMax(0, self.max_delay))
+
+        self.register_forward_pre_hook(broadcast2stereo)
+
+        self.eq = eq
+
+    def forward(self, x):
+        conv1d = F.conv1d if x.size(-1) > 44100 * 20 else fft_conv1d
+
+        c = self.params.c + 0j
+        b = self.params.b + 0j
+
+        gamma = self.params.gamma
+        delays = self.delays if hasattr(self, "delays") else self.params.delays
+
+        if gamma.size(0) > 1:
+            gamma = F.interpolate(
+                gamma.T.unsqueeze(1),
+                size=self.ir_length // 2 + 1,
+                align_corners=True,
+                mode="linear",
+            ).transpose(0, 2)
+
+        if gamma.size(2) == 1:
+            gamma = gamma ** (delays / delays.min())
+
+        A = self.params.U * gamma
+
+        freqs = (
+            torch.arange(self.ir_length // 2 + 1, device=x.device)
+            / self.ir_length
+            * 2
+            * torch.pi
+        )
+        invD = torch.exp(1j * freqs[:, None] * delays)
+        # H = c @ torch.linalg.inv(torch.diag_embed(invD) - A) @ b
+        H = c @ torch.linalg.solve(torch.diag_embed(invD) - A, b)
+
+        h = torch.fft.irfft(H.permute(1, 2, 0), n=self.ir_length)
+
+        if self.eq is not None:
+            h = self.eq(h)
+
+        # return fft_conv1d(
+        return conv1d(
+            F.pad(x, (self.ir_length - 1, 0)),
+            h.flip(-1),
+        )

modules/rt.py

@@ -0,0 +1,150 @@
+import numpy as np
+from numba import njit, prange
+from scipy.signal import firwin2
+import torch
+
+from .fx import Delay, FDN, module2coeffs
+
+
+@njit
+def rt_fdn(
+    x: np.ndarray,
+    delay_steps: np.ndarray,
+    firs: np.ndarray,
+    U: np.ndarray,
+):
+    _, T = x.shape
+    M = delay_steps.shape[0]
+    order = firs.shape[1]
+    y = np.zeros_like(x)
+    buf_size = delay_steps.max() + order
+    delay_buf = np.zeros((M, buf_size), dtype=x.dtype)
+    read_pointer = 0
+
+    for t in range(T):
+        # out = delay_buf[(range(M), read_pointers)]
+        # for i in prange(M):
+        #     out[i] = delay_buf[i, read_pointers[i]]
+        out = delay_buf[:, read_pointer]
+        y[:, t] = out
+
+        s = out * firs[:, 0]
+        # indexes = (read_pointers[:, None] - np.arange(1, order)) % buf_sizes[:, None]
+        # reg = np.take_along_axis(delay_buf, indexes, axis=1)
+        # s += firs[:, 1:] @ reg.T
+        # for j in prange(M):
+        #     s[j] += firs[j, 1:] @ delay_buf[j, indexes[j]]
+        for i in prange(M):
+            for j in prange(1, order):
+                s[i] += firs[i, j] * delay_buf[i, (read_pointer - j) % buf_size]
+        # for i in prange(1, order):
+        #     s += firs[:, i] * delay_buf[:, (read_pointer - i) % buf_size]
+
+        feedback = U @ s + x[:, t]
+        w_pointers = (read_pointer + delay_steps) % buf_size
+        # delay_buf[(range(M), w_pointers)] = s + B @ x[:, t]
+        for i in prange(M):
+            delay_buf[i, w_pointers[i]] = feedback[i]
+        read_pointer = (read_pointer + 1) % buf_size
+
+    return y
+
+
+@njit
+def rt_delay(
+    x: np.ndarray,
+    delay_step: int,
+    b0: float,
+    b1: float,
+    b2: float,
+    a1: float,
+    a2: float,
+):
+    T = x.shape[0]
+    y = np.zeros((2, T), dtype=x.dtype)
+    buf_size = delay_step + 1
+    read_pointer = 0
+    delay_buf = np.zeros((2, buf_size), dtype=x.dtype)
+    bq_buf = np.zeros((2, 2), dtype=x.dtype)
+
+    for t in range(T):
+        out = delay_buf[:, read_pointer]
+        y[:, t] = out
+
+        s = bq_buf[:, 0] + b0 * out
+        bq_buf[:, 0] = bq_buf[:, 1] + b1 * out - a1 * s
+        bq_buf[:, 1] = b2 * out - a2 * s
+
+        w_pointer = (read_pointer + delay_step) % buf_size
+        # cross feeding because of ping-pong delay
+        delay_buf[0, w_pointer] = s[1] + x[t]
+        delay_buf[1, w_pointer] = s[0]
+
+        read_pointer = (read_pointer + 1) % buf_size
+
+    return y
+
+
+class RealTimeDelay(Delay):
+    def forward(self, x):
+        assert x.size(1) == 1, x.size()
+        assert x.size(0) == 1, x.size()
+        with torch.no_grad():
+            delay_in_samples = round(self.sr * self.params.delay.item() * 0.001)
+            feedback = self.params.feedback.item()
+
+            if self.recursive_eq and self.eq is not None:
+                b0, b1, b2, a0, a1, a2 = [p.item() for p in module2coeffs(self.eq)]
+                b0, b1, b2, a1, a2 = b0 / a0, b1 / a0, b2 / a0, a1 / a0, a2 / a0
+            else:
+                b0, b1, b2, a1, a2 = 1.0, 0.0, 0.0, 0.0, 0.0
+
+            b0 = b0 * feedback
+            b1 = b1 * feedback
+            b2 = b2 * feedback
+            x_numpy = x.squeeze().cpu().numpy()
+            y_numpy = rt_delay(x_numpy, delay_in_samples, b0, b1, b2, a1, a2)
+        y = torch.from_numpy(y_numpy).unsqueeze(0).to(x.device) * self.params.gain
+        return self.odd_pan(y[:, :1]) + self.even_pan(y[:, 1:])
+
+
+class RealTimeFDN(FDN):
+    def forward(self, x):
+        assert x.size(1) == 2, x.size()
+        assert x.size(0) == 1, x.size()
+        with torch.no_grad():
+            delays = self.delays if hasattr(self, "delays") else self.params.delays
+
+            c = self.params.c
+            b = self.params.b
+            gamma = self.params.gamma.clone()
+
+            if gamma.size(1) == 1:
+                gamma = gamma ** (delays / delays.min())
+
+            freqs = np.linspace(0, 1, gamma.size(0))
+            firs = np.apply_along_axis(
+                lambda x: firwin2(gamma.size(0) * 2 - 1, freqs, x, fs=2),
+                1,
+                gamma.cpu().numpy().T,
+            ).astype(np.float32)
+            shifted_delays = delays - firs.shape[1] // 2
+
+            U = self.params.U
+
+            x = b @ x.squeeze()
+
+            y_numpy = rt_fdn(
+                x.cpu().numpy(),
+                # delays.cpu().numpy(),
+                shifted_delays.cpu().numpy(),
+                # firs.cpu().numpy(),
+                firs,
+                U.cpu().numpy(),
+            )
+            y = c @ torch.from_numpy(y_numpy).to(x.device)
+            y = y.unsqueeze(0)
+
+        if self.eq is not None:
+            y = self.eq(y)
+        return y

modules/utils.py

@@ -0,0 +1,64 @@
+import torch
+import numpy as np
+from functools import reduce, partial
+from operator import mul
+from torch.nn.utils.parametrize import is_parametrized, remove_parametrizations
+
+
+def chain_functions(*functions):
+    return lambda initial: reduce(lambda x, f: f(x), functions, initial)
+
+
+def remove_fx_parametrisation(fx):
+    def remover(m):
+        if not is_parametrized(m):
+            return
+        for k in list(m.parametrizations.keys()):
+            remove_parametrizations(m, k)
+
+    fx.apply(remover)
+    return fx
+
+
+def get_chunks(keys, original_shapes):
+    (position, _), *_ = filter(lambda i_k: "U.original" in i_k[1], enumerate(keys))
+    original_chunks = list(map(partial(reduce, mul), original_shapes))
+    U_matrix_shape = original_shapes[position]
+
+    dimensions_not_need = np.ravel_multi_index(
+        np.tril_indices(**dict(zip(("n", "m"), U_matrix_shape))), U_matrix_shape
+    ) + sum(original_chunks[:position])
+
+    selected_chunks = (
+        original_chunks[:position]
+        + [original_chunks[position] - dimensions_not_need.size]
+        + original_chunks[position + 1 :]
+    )
+    return selected_chunks, position, U_matrix_shape, dimensions_not_need
+
+
+def vec2statedict(
+    x: torch.Tensor,
+    keys,
+    original_shapes,
+    selected_chunks,
+    position,
+    U_matrix_shape,
+):
+    chunks = list(torch.split(x, selected_chunks))
+    U = x.new_zeros(reduce(mul, U_matrix_shape))
+    U[
+        np.ravel_multi_index(
+            np.triu_indices(n=U_matrix_shape[0], k=1, m=U_matrix_shape[1]),
+            U_matrix_shape,
+        )
+    ] = chunks[position]
+    chunks[position] = U
+
+    state_dict = dict(
+        zip(
+            keys,
+            map(lambda x, shape: x.reshape(*shape), chunks, original_shapes),
+        )
+    )
+    return state_dict

presets/fx_config.yaml

@@ -0,0 +1,188 @@
+epochs: 2000
+data_dir: null
+log_dir: null
+lufs: -18
+sr: 44100
+chunk_duration: 12
+chunk_overlap: 5
+device: cuda
+batch_size: 35
+dataset: medley_vocal
+regularise_delay: true
+model:
+  _target_: torch.nn.Sequential
+  _args_:
+  - _target_: modules.fx.Peak
+    sr: 44100
+    freq: 800
+    min_freq: 33
+    max_freq: 5400
+  - _target_: modules.fx.Peak
+    sr: 44100
+    freq: 4000
+    min_freq: 200
+    max_freq: 17500
+  - _target_: modules.fx.LowShelf
+    sr: 44100
+    freq: 115
+    min_freq: 30
+    max_freq: 200
+  - _target_: modules.fx.HighShelf
+    sr: 44100
+    freq: 6000
+    min_freq: 750
+    max_freq: 8300
+  - _target_: modules.fx.LowPass
+    sr: 44100
+    freq: 17500
+    min_freq: 200
+    max_freq: 18000
+  - _target_: modules.fx.HighPass
+    sr: 44100
+    freq: 200
+    min_freq: 16
+    max_freq: 5300
+  - _target_: modules.fx.CompressorExpander
+    sr: 44100
+    cmp_ratio: 2.0
+    exp_ratio: 0.5
+    at_ms: 50.0
+    rt_ms: 50.0
+    avg_coef: 0.3
+    cmp_th: -18.0
+    exp_th: -48.0
+    make_up: 0.0
+    lookahead: true
+    max_lookahead: 15
+  - _target_: modules.fx.SendFXsAndSum
+    _args_:
+    - _target_: modules.fx.SurrogateDelay
+      sr: 44100
+      delay: 400
+      dropout: 0
+      straight_through: true
+      recursive_eq: true
+      ir_duration: 4
+      eq:
+        _target_: modules.fx.LowPass
+        sr: 44100
+        freq: 8000
+        min_freq: 200
+        max_freq: 16000
+        min_Q: 0.5
+        max_Q: 2
+    - _target_: modules.fx.FDN
+      sr: 44100
+      delays:
+      - 997
+      - 1153
+      - 1327
+      - 1559
+      - 1801
+      - 2099
+      num_decay_freq: 49
+      delay_independent_decay: true
+      ir_duration: 12
+      eq:
+        _target_: torch.nn.Sequential
+        _args_:
+        - _target_: modules.fx.Peak
+          sr: 44100
+          freq: 800
+          min_freq: 200
+          max_freq: 2500
+          min_Q: 0.1
+          max_Q: 3
+        - _target_: modules.fx.Peak
+          sr: 44100
+          freq: 4000
+          min_freq: 600
+          max_freq: 7000
+          min_Q: 0.1
+          max_Q: 3
+        - _target_: modules.fx.LowShelf
+          sr: 44100
+          freq: 115
+          min_freq: 30
+          max_freq: 450
+        - _target_: modules.fx.HighShelf
+          sr: 44100
+          freq: 8000
+          min_freq: 1500
+          max_freq: 16000
+    cross_send: true
+    pan_direct: true
+optimiser:
+  _target_: torch.optim.Adam
+  lr: 0.01
+mss:
+  fft_sizes:
+  - 128
+  - 512
+  - 2048
+  hop_sizes:
+  - 32
+  - 128
+  - 512
+mldr:
+  s_taus:
+  - 50
+  - 100
+  l_taus:
+  - 1000
+  - 2000
+loss_fn:
+  _target_: loss.SumLosses
+  weights:
+  - 1.0
+  - 0.5
+  - 0.5
+  - 0.25
+  loss_fns:
+  - _target_: auraloss.freq.MultiResolutionSTFTLoss
+    fft_sizes:
+    - 128
+    - 512
+    - 2048
+    hop_sizes:
+    - 32
+    - 128
+    - 512
+    win_lengths:
+    - 128
+    - 512
+    - 2048
+    sample_rate: 44100
+    perceptual_weighting: true
+  - _target_: auraloss.freq.SumAndDifferenceSTFTLoss
+    fft_sizes:
+    - 128
+    - 512
+    - 2048
+    hop_sizes:
+    - 32
+    - 128
+    - 512
+    win_lengths:
+    - 128
+    - 512
+    - 2048
+    sample_rate: 44100
+    perceptual_weighting: true
+  - _target_: loss.ldr.MLDRLoss
+    sr: 44100
+    s_taus:
+    - 50
+    - 100
+    l_taus:
+    - 1000
+    - 2000
+  - _target_: loss.ldr.MLDRLoss
+    sr: 44100
+    mid_side: true
+    s_taus:
+    - 50
+    - 100
+    l_taus:
+    - 1000
+    - 2000

presets/internal/info.json

@@ -0,0 +1,1695 @@
+{
+    "runs": [
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1",
+        "~/processed/anon_tokyo/run_1"
+    ],
+    "dry_files": [
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav"
+    ],
+    "wet_files": [
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav",
+        "/data/internal/anon_tokyo/togawa_group.wav"
+    ],
+    "alignment_shifts": [
+        -4,
+        68,
+        -44040,
+        0,
+        5730,
+        -287164,
+        24,
+        78,
+        15432,
+        402,
+        -2,
+        0,
+        63,
+        9542,
+        -3,
+        -2,
+        76,
+        3072,
+        -59,
+        0,
+        64,
+        -3,
+        -17,
+        37,
+        79,
+        121,
+        124,
+        28,
+        -14,
+        2,
+        9668,
+        8820,
+        30,
+        -104,
+        67,
+        -18,
+        15066,
+        -3,
+        138,
+        -21,
+        -2,
+        36,
+        439,
+        -3,
+        141,
+        77,
+        -32,
+        3608,
+        321,
+        1,
+        -4,
+        0,
+        -28,
+        -133515,
+        -6,
+        -11,
+        -260006,
+        60,
+        -33,
+        -44,
+        -45,
+        7,
+        -7,
+        219,
+        -316,
+        0,
+        -35,
+        -98742,
+        -6,
+        -5,
+        78,
+        0,
+        -6,
+        0,
+        0,
+        67,
+        -12,
+        15495,
+        69,
+        15429,
+        -28645,
+        -108,
+        -4,
+        95,
+        2991,
+        19,
+        -4,
+        -2,
+        113,
+        -3,
+        1,
+        61,
+        5292,
+        34,
+        71,
+        67,
+        530,
+        165,
+        2,
+        46,
+        -3,
+        -6,
+        69,
+        75,
+        66,
+        0,
+        0,
+        2872,
+        35,
+        35,
+        -3,
+        35,
+        37,
+        0,
+        -2,
+        43,
+        -4,
+        -2,
+        67,
+        -6,
+        728,
+        22091,
+        0,
+        1,
+        -7,
+        15432,
+        0,
+        59,
+        0,
+        -4,
+        52,
+        30,
+        -7,
+        0,
+        -24,
+        -167543,
+        67,
+        73,
+        -2,
+        -220,
+        60,
+        -70562,
+        36,
+        2,
+        123,
+        145,
+        -1450,
+        -16962,
+        609,
+        36,
+        69,
+        -801,
+        -2,
+        4,
+        6,
+        -2,
+        75,
+        70,
+        -4,
+        -2,
+        82,
+        53,
+        32,
+        128,
+        -222,
+        -28226,
+        3557,
+        15432,
+        -6,
+        -52666,
+        70,
+        -7,
+        40,
+        65,
+        -3,
+        8,
+        74,
+        11,
+        5,
+        -1093343,
+        -129130,
+        -30,
+        34,
+        -36,
+        15563,
+        53,
+        -3,
+        67,
+        36,
+        116,
+        32,
+        21,
+        -3,
+        5,
+        389,
+        4410,
+        82,
+        15525,
+        -6,
+        100,
+        37,
+        15512,
+        -2,
+        -6,
+        34,
+        34,
+        99,
+        -80,
+        4,
+        -2,
+        -2,
+        -22,
+        269,
+        4471,
+        15543,
+        3,
+        1,
+        593,
+        35,
+        37,
+        87,
+        120,
+        -7,
+        -8,
+        8897,
+        -6,
+        -361965,
+        394,
+        430,
+        -154363,
+        -13172,
+        40,
+        135,
+        -2,
+        -9,
+        69,
+        -2,
+        3593,
+        473,
+        -2181,
+        -11364,
+        -70,
+        -4,
+        -76,
+        -2,
+        -16,
+        62,
+        -6,
+        -12239,
+        34,
+        8818,
+        -77,
+        -2,
+        15,
+        -2,
+        -2,
+        29,
+        2883,
+        -2,
+        6613,
+        -269138,
+        6614,
+        -7067,
+        340,
+        -160580,
+        137,
+        37,
+        -99,
+        35,
+        -114544,
+        -113888,
+        -33,
+        -176504,
+        15500,
+        15437,
+        49,
+        -42,
+        -176364,
+        28,
+        -4,
+        0,
+        63,
+        -6,
+        -3,
+        -7,
+        68,
+        52,
+        59,
+        47,
+        70,
+        395,
+        -2,
+        164,
+        38,
+        -17,
+        137,
+        40,
+        6,
+        2,
+        140,
+        40,
+        -40,
+        376,
+        -3,
+        61,
+        458,
+        -182879,
+        -110896,
+        3,
+        34,
+        -16,
+        80,
+        68,
+        -2,
+        0,
+        28,
+        129,
+        166,
+        1449,
+        1,
+        -161984,
+        363,
+        34,
+        135,
+        34,
+        -124,
+        36,
+        38,
+        72,
+        -123590,
+        -45411,
+        67,
+        -96332,
+        -96333,
+        63,
+        -2,
+        39,
+        -20,
+        399,
+        34,
+        37,
+        -7,
+        69,
+        -6,
+        0,
+        3,
+        2933,
+        -153040,
+        -153041,
+        -3,
+        -2,
+        66,
+        -72452,
+        -3,
+        -2,
+        -6,
+        -7,
+        1,
+        -147889,
+        37,
+        0,
+        0,
+        -2,
+        40,
+        -3,
+        44,
+        76,
+        -14,
+        49,
+        81,
+        34,
+        70,
+        63,
+        68,
+        0,
+        61,
+        0,
+        0,
+        62,
+        48,
+        58,
+        63,
+        -23,
+        -23,
+        -2
+    ],
+    "params_original_shapes": [
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [
+            1
+        ],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [
+            1
+        ],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [
+            6,
+            2
+        ],
+        [
+            2,
+            6
+        ],
+        [
+            49,
+            1
+        ],
+        [
+            6,
+            6
+        ],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        []
+    ],
+    "params_keys": [
+        "0.params.gain",
+        "0.params.parametrizations.freq.original",
+        "0.params.parametrizations.Q.original",
+        "1.params.gain",
+        "1.params.parametrizations.freq.original",
+        "1.params.parametrizations.Q.original",
+        "2.params.gain",
+        "2.params.parametrizations.freq.original",
+        "3.params.gain",
+        "3.params.parametrizations.freq.original",
+        "4.params.parametrizations.freq.original",
+        "4.params.parametrizations.Q.original",
+        "5.params.parametrizations.freq.original",
+        "5.params.parametrizations.Q.original",
+        "6.params.cmp_th",
+        "6.params.exp_th",
+        "6.params.make_up",
+        "6.params.parametrizations.lookahead.original",
+        "6.params.parametrizations.at.original",
+        "6.params.parametrizations.rt.original",
+        "6.params.parametrizations.avg_coef.original",
+        "6.params.parametrizations.cmp_ratio.original",
+        "6.params.parametrizations.exp_ratio.original",
+        "7.params.parametrizations.sends_0.original",
+        "7.effects.0.params.parametrizations.delay.original",
+        "7.effects.0.params.parametrizations.feedback.original",
+        "7.effects.0.params.parametrizations.gain.original",
+        "7.effects.0.eq.params.parametrizations.freq.original",
+        "7.effects.0.eq.params.parametrizations.Q.original",
+        "7.effects.0.odd_pan.params.parametrizations.pan.original",
+        "7.effects.0.even_pan.params.parametrizations.pan.original",
+        "7.effects.1.params.b",
+        "7.effects.1.params.c",
+        "7.effects.1.params.parametrizations.gamma.original",
+        "7.effects.1.params.parametrizations.U.original",
+        "7.effects.1.eq.0.params.gain",
+        "7.effects.1.eq.0.params.parametrizations.freq.original",
+        "7.effects.1.eq.0.params.parametrizations.Q.original",
+        "7.effects.1.eq.1.params.gain",
+        "7.effects.1.eq.1.params.parametrizations.freq.original",
+        "7.effects.1.eq.1.params.parametrizations.Q.original",
+        "7.effects.1.eq.2.params.gain",
+        "7.effects.1.eq.2.params.parametrizations.freq.original",
+        "7.effects.1.eq.3.params.gain",
+        "7.effects.1.eq.3.params.parametrizations.freq.original",
+        "7.pan.params.parametrizations.pan.original"
+    ],
+    "problematic_runs": {
+        "terminated": [],
+        "loss_above_4.0": [
+            [
+                "anon_tokyo/run_1",
+                6.585290908813477
+            ],
+            [
+                "anon_tokyo/run_1",
+                4.723783016204834
+            ]
+        ],
+        "not_converged": [],
+        "fluctuated_above_0.2": [
+            [
+                "anon_tokyo/run_1",
+                0.49335169792175293
+            ],
+            [
+                "anon_tokyo/run_1",
+                0.41164231300354004
+            ],
+            [
+                "anon_tokyo/run_1",
+                0.5299015045166016
+            ]
+        ]
+    }
+}

presets/medleydb/info.json

@@ -0,0 +1,441 @@
+{
+    "runs": [
+        "~/processed/AClassicEducation_NightOwl/AClassicEducation_NightOwl_STEM_08/run_0",
+        "~/processed/AlexanderRoss_GoodbyeBolero/AlexanderRoss_GoodbyeBolero_STEM_06/run_0",
+        "~/processed/AlexanderRoss_VelvetCurtain/AlexanderRoss_VelvetCurtain_STEM_06/run_0",
+        "~/processed/Auctioneer_OurFutureFaces/Auctioneer_OurFutureFaces_STEM_08/run_0",
+        "~/processed/AvaLuna_Waterduct/AvaLuna_Waterduct_STEM_08/run_0",
+        "~/processed/BigTroubles_Phantom/BigTroubles_Phantom_STEM_04/run_0",
+        "~/processed/BrandonWebster_DontHearAThing/BrandonWebster_DontHearAThing_STEM_02/run_0",
+        "~/processed/BrandonWebster_DontHearAThing/BrandonWebster_DontHearAThing_STEM_01/run_0",
+        "~/processed/BrandonWebster_YesSirICanFly/BrandonWebster_YesSirICanFly_STEM_02/run_0",
+        "~/processed/CatMartino_IPromise/CatMartino_IPromise_STEM_06/run_0",
+        "~/processed/ClaraBerryAndWooldog_AirTraffic/ClaraBerryAndWooldog_AirTraffic_STEM_07/run_0",
+        "~/processed/ClaraBerryAndWooldog_AirTraffic/ClaraBerryAndWooldog_AirTraffic_STEM_08/run_0",
+        "~/processed/ClaraBerryAndWooldog_Boys/ClaraBerryAndWooldog_Boys_STEM_06/run_0",
+        "~/processed/ClaraBerryAndWooldog_Stella/ClaraBerryAndWooldog_Stella_STEM_07/run_0",
+        "~/processed/ClaraBerryAndWooldog_WaltzForMyVictims/ClaraBerryAndWooldog_WaltzForMyVictims_STEM_05/run_0",
+        "~/processed/DeadMilkmen_PrisonersCinema/DeadMilkmen_PrisonersCinema_STEM_12/run_0",
+        "~/processed/Debussy_LenfantProdigue/Debussy_LenfantProdigue_STEM_01/run_0",
+        "~/processed/DreamersOfTheGhetto_HeavyLove/DreamersOfTheGhetto_HeavyLove_STEM_08/run_0",
+        "~/processed/FacesOnFilm_WaitingForGa/FacesOnFilm_WaitingForGa_STEM_03/run_0",
+        "~/processed/FamilyBand_Again/FamilyBand_Again_STEM_09/run_0",
+        "~/processed/Handel_TornamiAVagheggiar/Handel_TornamiAVagheggiar_STEM_01/run_0",
+        "~/processed/HeladoNegro_MitadDelMundo/HeladoNegro_MitadDelMundo_STEM_08/run_0",
+        "~/processed/HeladoNegro_MitadDelMundo/HeladoNegro_MitadDelMundo_STEM_03/run_0",
+        "~/processed/HopAlong_SisterCities/HopAlong_SisterCities_STEM_07/run_0",
+        "~/processed/LizNelson_Coldwar/LizNelson_Coldwar_STEM_02/run_0",
+        "~/processed/LizNelson_ImComingHome/LizNelson_ImComingHome_STEM_02/run_0",
+        "~/processed/LizNelson_ImComingHome/LizNelson_ImComingHome_STEM_03/run_0",
+        "~/processed/LizNelson_ImComingHome/LizNelson_ImComingHome_STEM_04/run_0",
+        "~/processed/LizNelson_ImComingHome/LizNelson_ImComingHome_STEM_01/run_0",
+        "~/processed/LizNelson_Rainfall/LizNelson_Rainfall_STEM_01/run_0",
+        "~/processed/LizNelson_Rainfall/LizNelson_Rainfall_STEM_03/run_0",
+        "~/processed/LizNelson_Rainfall/LizNelson_Rainfall_STEM_02/run_0",
+        "~/processed/MatthewEntwistle_DontYouEver/MatthewEntwistle_DontYouEver_STEM_07/run_0",
+        "~/processed/MatthewEntwistle_Lontano/MatthewEntwistle_Lontano_STEM_02/run_0",
+        "~/processed/Meaxic_TakeAStep/Meaxic_TakeAStep_STEM_08/run_0",
+        "~/processed/Meaxic_TakeAStep/Meaxic_TakeAStep_STEM_04/run_0",
+        "~/processed/MidnightBlue_HuntingSeason/MidnightBlue_HuntingSeason_STEM_01/run_0",
+        "~/processed/MidnightBlue_HuntingSeason/MidnightBlue_HuntingSeason_STEM_02/run_0",
+        "~/processed/MidnightBlue_StarsAreScreaming/MidnightBlue_StarsAreScreaming_STEM_06/run_0",
+        "~/processed/MidnightBlue_StarsAreScreaming/MidnightBlue_StarsAreScreaming_STEM_07/run_0",
+        "~/processed/Mozart_BesterJungling/Mozart_BesterJungling_STEM_01/run_0",
+        "~/processed/Mozart_DiesBildnis/Mozart_DiesBildnis_STEM_01/run_0",
+        "~/processed/MusicDelta_80sRock/MusicDelta_80sRock_STEM_04/run_0",
+        "~/processed/MusicDelta_Beatles/MusicDelta_Beatles_STEM_08/run_0",
+        "~/processed/MusicDelta_Beatles/MusicDelta_Beatles_STEM_07/run_0",
+        "~/processed/MusicDelta_Britpop/MusicDelta_Britpop_STEM_07/run_0",
+        "~/processed/MusicDelta_Britpop/MusicDelta_Britpop_STEM_08/run_0",
+        "~/processed/MusicDelta_Country1/MusicDelta_Country1_STEM_05/run_1",
+        "~/processed/MusicDelta_Country2/MusicDelta_Country2_STEM_05/run_0",
+        "~/processed/MusicDelta_Disco/MusicDelta_Disco_STEM_04/run_0",
+        "~/processed/MusicDelta_Gospel/MusicDelta_Gospel_STEM_06/run_0",
+        "~/processed/MusicDelta_Grunge/MusicDelta_Grunge_STEM_05/run_0",
+        "~/processed/MusicDelta_Hendrix/MusicDelta_Hendrix_STEM_04/run_0",
+        "~/processed/MusicDelta_Punk/MusicDelta_Punk_STEM_04/run_0",
+        "~/processed/MusicDelta_Reggae/MusicDelta_Reggae_STEM_04/run_0",
+        "~/processed/MusicDelta_Rock/MusicDelta_Rock_STEM_05/run_0",
+        "~/processed/MusicDelta_Rockabilly/MusicDelta_Rockabilly_STEM_05/run_0",
+        "~/processed/MutualBenefit_NotForNothing/MutualBenefit_NotForNothing_STEM_06/run_0",
+        "~/processed/PortStWillow_StayEven/PortStWillow_StayEven_STEM_08/run_0",
+        "~/processed/Schubert_Erstarrung/Schubert_Erstarrung_STEM_01/run_0",
+        "~/processed/Schumann_Mignon/Schumann_Mignon_STEM_02/run_0",
+        "~/processed/Snowmine_Curfews/Snowmine_Curfews_STEM_03/run_0",
+        "~/processed/SongYiJeon_TwoMoons/SongYiJeon_TwoMoons_STEM_01/run_0",
+        "~/processed/StevenClark_Bounty/StevenClark_Bounty_STEM_08/run_0",
+        "~/processed/StrandOfOaks_Spacestation/StrandOfOaks_Spacestation_STEM_04/run_0",
+        "~/processed/TheKitchenettes_Alive/TheKitchenettes_Alive_STEM_01/run_0",
+        "~/processed/TheScarletBrand_LesFleursDuMal/TheScarletBrand_LesFleursDuMal_STEM_08/run_0",
+        "~/processed/TleilaxEnsemble_Late/TleilaxEnsemble_Late_STEM_04/run_0",
+        "~/processed/TleilaxEnsemble_Late/TleilaxEnsemble_Late_STEM_05/run_0",
+        "~/processed/TleilaxEnsemble_MelancholyFlowers/TleilaxEnsemble_MelancholyFlowers_STEM_04/run_0",
+        "~/processed/TleilaxEnsemble_MelancholyFlowers/TleilaxEnsemble_MelancholyFlowers_STEM_05/run_0",
+        "~/processed/Torres_NewSkin/Torres_NewSkin_STEM_02/run_0",
+        "~/processed/Torres_NewSkin/Torres_NewSkin_STEM_05/run_0",
+        "~/processed/Torres_NewSkin/Torres_NewSkin_STEM_10/run_0",
+        "~/processed/Torres_NewSkin/Torres_NewSkin_STEM_03/run_0",
+        "~/processed/Wolf_DieBekherte/Wolf_DieBekherte_STEM_01/run_0"
+    ],
+    "dry_files": [
+        "/data/medley1/v1/Audio/AClassicEducation_NightOwl/AClassicEducation_NightOwl_RAW/AClassicEducation_NightOwl_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/Auctioneer_OurFutureFaces/Auctioneer_OurFutureFaces_RAW/Auctioneer_OurFutureFaces_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/AvaLuna_Waterduct/AvaLuna_Waterduct_RAW/AvaLuna_Waterduct_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/BigTroubles_Phantom/BigTroubles_Phantom_RAW/BigTroubles_Phantom_RAW_04_01.wav",
+        "/data/medley1/v1/Audio/BrandonWebster_DontHearAThing/BrandonWebster_DontHearAThing_RAW/BrandonWebster_DontHearAThing_RAW_02_01.wav",
+        "/data/medley1/v1/Audio/BrandonWebster_DontHearAThing/BrandonWebster_DontHearAThing_RAW/BrandonWebster_DontHearAThing_RAW_01_01.wav",
+        "/data/medley1/v1/Audio/BrandonWebster_YesSirICanFly/BrandonWebster_YesSirICanFly_RAW/BrandonWebster_YesSirICanFly_RAW_02_01.wav",
+        "/data/medley1/v2/Audio/CatMartino_IPromise/CatMartino_IPromise_RAW/CatMartino_IPromise_RAW_06_01.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_AirTraffic/ClaraBerryAndWooldog_AirTraffic_RAW/ClaraBerryAndWooldog_AirTraffic_RAW_07_01.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_AirTraffic/ClaraBerryAndWooldog_AirTraffic_RAW/ClaraBerryAndWooldog_AirTraffic_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_Boys/ClaraBerryAndWooldog_Boys_RAW/ClaraBerryAndWooldog_Boys_RAW_06_01.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_Stella/ClaraBerryAndWooldog_Stella_RAW/ClaraBerryAndWooldog_Stella_RAW_07_01.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_WaltzForMyVictims/ClaraBerryAndWooldog_WaltzForMyVictims_RAW/ClaraBerryAndWooldog_WaltzForMyVictims_RAW_05_01.wav",
+        "/data/medley1/v2/Audio/DeadMilkmen_PrisonersCinema/DeadMilkmen_PrisonersCinema_RAW/DeadMilkmen_PrisonersCinema_RAW_12_01.wav",
+        "/data/medley1/v1/Audio/DreamersOfTheGhetto_HeavyLove/DreamersOfTheGhetto_HeavyLove_RAW/DreamersOfTheGhetto_HeavyLove_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/FacesOnFilm_WaitingForGa/FacesOnFilm_WaitingForGa_RAW/FacesOnFilm_WaitingForGa_RAW_03_01.wav",
+        "/data/medley1/v1/Audio/FamilyBand_Again/FamilyBand_Again_RAW/FamilyBand_Again_RAW_09_01.wav",
+        "/data/medley1/v1/Audio/Handel_TornamiAVagheggiar/Handel_TornamiAVagheggiar_RAW/Handel_TornamiAVagheggiar_RAW_01_01.wav",
+        "/data/medley1/v1/Audio/HeladoNegro_MitadDelMundo/HeladoNegro_MitadDelMundo_RAW/HeladoNegro_MitadDelMundo_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/HeladoNegro_MitadDelMundo/HeladoNegro_MitadDelMundo_RAW/HeladoNegro_MitadDelMundo_RAW_03_01.wav",
+        "/data/medley1/v1/Audio/HopAlong_SisterCities/HopAlong_SisterCities_RAW/HopAlong_SisterCities_RAW_07_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_Coldwar/LizNelson_Coldwar_RAW/LizNelson_Coldwar_RAW_02_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_ImComingHome/LizNelson_ImComingHome_RAW/LizNelson_ImComingHome_RAW_02_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_ImComingHome/LizNelson_ImComingHome_RAW/LizNelson_ImComingHome_RAW_03_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_ImComingHome/LizNelson_ImComingHome_RAW/LizNelson_ImComingHome_RAW_04_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_ImComingHome/LizNelson_ImComingHome_RAW/LizNelson_ImComingHome_RAW_01_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_Rainfall/LizNelson_Rainfall_RAW/LizNelson_Rainfall_RAW_01_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_Rainfall/LizNelson_Rainfall_RAW/LizNelson_Rainfall_RAW_03_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_Rainfall/LizNelson_Rainfall_RAW/LizNelson_Rainfall_RAW_02_01.wav",
+        "/data/medley1/v1/Audio/MatthewEntwistle_DontYouEver/MatthewEntwistle_DontYouEver_RAW/MatthewEntwistle_DontYouEver_RAW_07_01.wav",
+        "/data/medley1/v1/Audio/MatthewEntwistle_Lontano/MatthewEntwistle_Lontano_RAW/MatthewEntwistle_Lontano_RAW_02_01.wav",
+        "/data/medley1/v1/Audio/Meaxic_TakeAStep/Meaxic_TakeAStep_RAW/Meaxic_TakeAStep_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/Meaxic_TakeAStep/Meaxic_TakeAStep_RAW/Meaxic_TakeAStep_RAW_04_01.wav",
+        "/data/medley1/v2/Audio/MidnightBlue_HuntingSeason/MidnightBlue_HuntingSeason_RAW/MidnightBlue_HuntingSeason_RAW_01_01.wav",
+        "/data/medley1/v2/Audio/MidnightBlue_HuntingSeason/MidnightBlue_HuntingSeason_RAW/MidnightBlue_HuntingSeason_RAW_02_01.wav",
+        "/data/medley1/v2/Audio/MidnightBlue_StarsAreScreaming/MidnightBlue_StarsAreScreaming_RAW/MidnightBlue_StarsAreScreaming_RAW_06_01.wav",
+        "/data/medley1/v2/Audio/MidnightBlue_StarsAreScreaming/MidnightBlue_StarsAreScreaming_RAW/MidnightBlue_StarsAreScreaming_RAW_07_01.wav",
+        "/data/medley1/v1/Audio/Mozart_BesterJungling/Mozart_BesterJungling_RAW/Mozart_BesterJungling_RAW_01_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_80sRock/MusicDelta_80sRock_RAW/MusicDelta_80sRock_RAW_04_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Beatles/MusicDelta_Beatles_RAW/MusicDelta_Beatles_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Beatles/MusicDelta_Beatles_RAW/MusicDelta_Beatles_RAW_07_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Britpop/MusicDelta_Britpop_RAW/MusicDelta_Britpop_RAW_07_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Britpop/MusicDelta_Britpop_RAW/MusicDelta_Britpop_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Country1/MusicDelta_Country1_RAW/MusicDelta_Country1_RAW_05_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Country2/MusicDelta_Country2_RAW/MusicDelta_Country2_RAW_05_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Disco/MusicDelta_Disco_RAW/MusicDelta_Disco_RAW_04_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Gospel/MusicDelta_Gospel_RAW/MusicDelta_Gospel_RAW_06_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Grunge/MusicDelta_Grunge_RAW/MusicDelta_Grunge_RAW_05_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Hendrix/MusicDelta_Hendrix_RAW/MusicDelta_Hendrix_RAW_04_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Punk/MusicDelta_Punk_RAW/MusicDelta_Punk_RAW_04_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Reggae/MusicDelta_Reggae_RAW/MusicDelta_Reggae_RAW_04_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Rock/MusicDelta_Rock_RAW/MusicDelta_Rock_RAW_05_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Rockabilly/MusicDelta_Rockabilly_RAW/MusicDelta_Rockabilly_RAW_05_01.wav",
+        "/data/medley1/v2/Audio/MutualBenefit_NotForNothing/MutualBenefit_NotForNothing_RAW/MutualBenefit_NotForNothing_RAW_06_01.wav",
+        "/data/medley1/v1/Audio/PortStWillow_StayEven/PortStWillow_StayEven_RAW/PortStWillow_StayEven_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/Snowmine_Curfews/Snowmine_Curfews_RAW/Snowmine_Curfews_RAW_03_01.wav",
+        "/data/medley1/v2/Audio/SongYiJeon_TwoMoons/SongYiJeon_TwoMoons_RAW/SongYiJeon_TwoMoons_RAW_01_01.wav",
+        "/data/medley1/v1/Audio/StevenClark_Bounty/StevenClark_Bounty_RAW/StevenClark_Bounty_RAW_08_01.wav",
+        "/data/medley1/v1/Audio/StrandOfOaks_Spacestation/StrandOfOaks_Spacestation_RAW/StrandOfOaks_Spacestation_RAW_04_01.wav",
+        "/data/medley1/v2/Audio/TheKitchenettes_Alive/TheKitchenettes_Alive_RAW/TheKitchenettes_Alive_RAW_01_01.wav",
+        "/data/medley1/v1/Audio/TheScarletBrand_LesFleursDuMal/TheScarletBrand_LesFleursDuMal_RAW/TheScarletBrand_LesFleursDuMal_RAW_08_01.wav",
+        "/data/medley1/v2/Audio/TleilaxEnsemble_Late/TleilaxEnsemble_Late_RAW/TleilaxEnsemble_Late_RAW_04_01.wav",
+        "/data/medley1/v2/Audio/TleilaxEnsemble_Late/TleilaxEnsemble_Late_RAW/TleilaxEnsemble_Late_RAW_05_01.wav",
+        "/data/medley1/v2/Audio/TleilaxEnsemble_MelancholyFlowers/TleilaxEnsemble_MelancholyFlowers_RAW/TleilaxEnsemble_MelancholyFlowers_RAW_04_01.wav",
+        "/data/medley1/v2/Audio/TleilaxEnsemble_MelancholyFlowers/TleilaxEnsemble_MelancholyFlowers_RAW/TleilaxEnsemble_MelancholyFlowers_RAW_05_01.wav",
+        "/data/medley1/v2/Audio/Torres_NewSkin/Torres_NewSkin_RAW/Torres_NewSkin_RAW_02_01.wav",
+        "/data/medley1/v2/Audio/Torres_NewSkin/Torres_NewSkin_RAW/Torres_NewSkin_RAW_05_01.wav",
+        "/data/medley1/v2/Audio/Torres_NewSkin/Torres_NewSkin_RAW/Torres_NewSkin_RAW_10_01.wav",
+        "/data/medley1/v2/Audio/Torres_NewSkin/Torres_NewSkin_RAW/Torres_NewSkin_RAW_03_01.wav",
+        "/data/medley1/v1/Audio/Wolf_DieBekherte/Wolf_DieBekherte_RAW/Wolf_DieBekherte_RAW_01_01.wav"
+    ],
+    "wet_files": [
+        "/data/medley1/v1/Audio/AClassicEducation_NightOwl/AClassicEducation_NightOwl_STEMS/AClassicEducation_NightOwl_STEM_08.wav",
+        "/data/medley1/v1/Audio/Auctioneer_OurFutureFaces/Auctioneer_OurFutureFaces_STEMS/Auctioneer_OurFutureFaces_STEM_08.wav",
+        "/data/medley1/v1/Audio/AvaLuna_Waterduct/AvaLuna_Waterduct_STEMS/AvaLuna_Waterduct_STEM_08.wav",
+        "/data/medley1/v1/Audio/BigTroubles_Phantom/BigTroubles_Phantom_STEMS/BigTroubles_Phantom_STEM_04.wav",
+        "/data/medley1/v1/Audio/BrandonWebster_DontHearAThing/BrandonWebster_DontHearAThing_STEMS/BrandonWebster_DontHearAThing_STEM_02.wav",
+        "/data/medley1/v1/Audio/BrandonWebster_DontHearAThing/BrandonWebster_DontHearAThing_STEMS/BrandonWebster_DontHearAThing_STEM_01.wav",
+        "/data/medley1/v1/Audio/BrandonWebster_YesSirICanFly/BrandonWebster_YesSirICanFly_STEMS/BrandonWebster_YesSirICanFly_STEM_02.wav",
+        "/data/medley1/v2/Audio/CatMartino_IPromise/CatMartino_IPromise_STEMS/CatMartino_IPromise_STEM_06.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_AirTraffic/ClaraBerryAndWooldog_AirTraffic_STEMS/ClaraBerryAndWooldog_AirTraffic_STEM_07.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_AirTraffic/ClaraBerryAndWooldog_AirTraffic_STEMS/ClaraBerryAndWooldog_AirTraffic_STEM_08.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_Boys/ClaraBerryAndWooldog_Boys_STEMS/ClaraBerryAndWooldog_Boys_STEM_06.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_Stella/ClaraBerryAndWooldog_Stella_STEMS/ClaraBerryAndWooldog_Stella_STEM_07.wav",
+        "/data/medley1/v1/Audio/ClaraBerryAndWooldog_WaltzForMyVictims/ClaraBerryAndWooldog_WaltzForMyVictims_STEMS/ClaraBerryAndWooldog_WaltzForMyVictims_STEM_05.wav",
+        "/data/medley1/v2/Audio/DeadMilkmen_PrisonersCinema/DeadMilkmen_PrisonersCinema_STEMS/DeadMilkmen_PrisonersCinema_STEM_12.wav",
+        "/data/medley1/v1/Audio/DreamersOfTheGhetto_HeavyLove/DreamersOfTheGhetto_HeavyLove_STEMS/DreamersOfTheGhetto_HeavyLove_STEM_08.wav",
+        "/data/medley1/v1/Audio/FacesOnFilm_WaitingForGa/FacesOnFilm_WaitingForGa_STEMS/FacesOnFilm_WaitingForGa_STEM_03.wav",
+        "/data/medley1/v1/Audio/FamilyBand_Again/FamilyBand_Again_STEMS/FamilyBand_Again_STEM_09.wav",
+        "/data/medley1/v1/Audio/Handel_TornamiAVagheggiar/Handel_TornamiAVagheggiar_STEMS/Handel_TornamiAVagheggiar_STEM_01.wav",
+        "/data/medley1/v1/Audio/HeladoNegro_MitadDelMundo/HeladoNegro_MitadDelMundo_STEMS/HeladoNegro_MitadDelMundo_STEM_08.wav",
+        "/data/medley1/v1/Audio/HeladoNegro_MitadDelMundo/HeladoNegro_MitadDelMundo_STEMS/HeladoNegro_MitadDelMundo_STEM_03.wav",
+        "/data/medley1/v1/Audio/HopAlong_SisterCities/HopAlong_SisterCities_STEMS/HopAlong_SisterCities_STEM_07.wav",
+        "/data/medley1/v1/Audio/LizNelson_Coldwar/LizNelson_Coldwar_STEMS/LizNelson_Coldwar_STEM_02.wav",
+        "/data/medley1/v1/Audio/LizNelson_ImComingHome/LizNelson_ImComingHome_STEMS/LizNelson_ImComingHome_STEM_02.wav",
+        "/data/medley1/v1/Audio/LizNelson_ImComingHome/LizNelson_ImComingHome_STEMS/LizNelson_ImComingHome_STEM_03.wav",
+        "/data/medley1/v1/Audio/LizNelson_ImComingHome/LizNelson_ImComingHome_STEMS/LizNelson_ImComingHome_STEM_04.wav",
+        "/data/medley1/v1/Audio/LizNelson_ImComingHome/LizNelson_ImComingHome_STEMS/LizNelson_ImComingHome_STEM_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_Rainfall/LizNelson_Rainfall_STEMS/LizNelson_Rainfall_STEM_01.wav",
+        "/data/medley1/v1/Audio/LizNelson_Rainfall/LizNelson_Rainfall_STEMS/LizNelson_Rainfall_STEM_03.wav",
+        "/data/medley1/v1/Audio/LizNelson_Rainfall/LizNelson_Rainfall_STEMS/LizNelson_Rainfall_STEM_02.wav",
+        "/data/medley1/v1/Audio/MatthewEntwistle_DontYouEver/MatthewEntwistle_DontYouEver_STEMS/MatthewEntwistle_DontYouEver_STEM_07.wav",
+        "/data/medley1/v1/Audio/MatthewEntwistle_Lontano/MatthewEntwistle_Lontano_STEMS/MatthewEntwistle_Lontano_STEM_02.wav",
+        "/data/medley1/v1/Audio/Meaxic_TakeAStep/Meaxic_TakeAStep_STEMS/Meaxic_TakeAStep_STEM_08.wav",
+        "/data/medley1/v1/Audio/Meaxic_TakeAStep/Meaxic_TakeAStep_STEMS/Meaxic_TakeAStep_STEM_04.wav",
+        "/data/medley1/v2/Audio/MidnightBlue_HuntingSeason/MidnightBlue_HuntingSeason_STEMS/MidnightBlue_HuntingSeason_STEM_01.wav",
+        "/data/medley1/v2/Audio/MidnightBlue_HuntingSeason/MidnightBlue_HuntingSeason_STEMS/MidnightBlue_HuntingSeason_STEM_02.wav",
+        "/data/medley1/v2/Audio/MidnightBlue_StarsAreScreaming/MidnightBlue_StarsAreScreaming_STEMS/MidnightBlue_StarsAreScreaming_STEM_06.wav",
+        "/data/medley1/v2/Audio/MidnightBlue_StarsAreScreaming/MidnightBlue_StarsAreScreaming_STEMS/MidnightBlue_StarsAreScreaming_STEM_07.wav",
+        "/data/medley1/v1/Audio/Mozart_BesterJungling/Mozart_BesterJungling_STEMS/Mozart_BesterJungling_STEM_01.wav",
+        "/data/medley1/v1/Audio/MusicDelta_80sRock/MusicDelta_80sRock_STEMS/MusicDelta_80sRock_STEM_04.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Beatles/MusicDelta_Beatles_STEMS/MusicDelta_Beatles_STEM_08.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Beatles/MusicDelta_Beatles_STEMS/MusicDelta_Beatles_STEM_07.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Britpop/MusicDelta_Britpop_STEMS/MusicDelta_Britpop_STEM_07.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Britpop/MusicDelta_Britpop_STEMS/MusicDelta_Britpop_STEM_08.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Country1/MusicDelta_Country1_STEMS/MusicDelta_Country1_STEM_05.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Country2/MusicDelta_Country2_STEMS/MusicDelta_Country2_STEM_05.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Disco/MusicDelta_Disco_STEMS/MusicDelta_Disco_STEM_04.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Gospel/MusicDelta_Gospel_STEMS/MusicDelta_Gospel_STEM_06.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Grunge/MusicDelta_Grunge_STEMS/MusicDelta_Grunge_STEM_05.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Hendrix/MusicDelta_Hendrix_STEMS/MusicDelta_Hendrix_STEM_04.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Punk/MusicDelta_Punk_STEMS/MusicDelta_Punk_STEM_04.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Reggae/MusicDelta_Reggae_STEMS/MusicDelta_Reggae_STEM_04.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Rock/MusicDelta_Rock_STEMS/MusicDelta_Rock_STEM_05.wav",
+        "/data/medley1/v1/Audio/MusicDelta_Rockabilly/MusicDelta_Rockabilly_STEMS/MusicDelta_Rockabilly_STEM_05.wav",
+        "/data/medley1/v2/Audio/MutualBenefit_NotForNothing/MutualBenefit_NotForNothing_STEMS/MutualBenefit_NotForNothing_STEM_06.wav",
+        "/data/medley1/v1/Audio/PortStWillow_StayEven/PortStWillow_StayEven_STEMS/PortStWillow_StayEven_STEM_08.wav",
+        "/data/medley1/v1/Audio/Snowmine_Curfews/Snowmine_Curfews_STEMS/Snowmine_Curfews_STEM_03.wav",
+        "/data/medley1/v2/Audio/SongYiJeon_TwoMoons/SongYiJeon_TwoMoons_STEMS/SongYiJeon_TwoMoons_STEM_01.wav",
+        "/data/medley1/v1/Audio/StevenClark_Bounty/StevenClark_Bounty_STEMS/StevenClark_Bounty_STEM_08.wav",
+        "/data/medley1/v1/Audio/StrandOfOaks_Spacestation/StrandOfOaks_Spacestation_STEMS/StrandOfOaks_Spacestation_STEM_04.wav",
+        "/data/medley1/v2/Audio/TheKitchenettes_Alive/TheKitchenettes_Alive_STEMS/TheKitchenettes_Alive_STEM_01.wav",
+        "/data/medley1/v1/Audio/TheScarletBrand_LesFleursDuMal/TheScarletBrand_LesFleursDuMal_STEMS/TheScarletBrand_LesFleursDuMal_STEM_08.wav",
+        "/data/medley1/v2/Audio/TleilaxEnsemble_Late/TleilaxEnsemble_Late_STEMS/TleilaxEnsemble_Late_STEM_04.wav",
+        "/data/medley1/v2/Audio/TleilaxEnsemble_Late/TleilaxEnsemble_Late_STEMS/TleilaxEnsemble_Late_STEM_05.wav",
+        "/data/medley1/v2/Audio/TleilaxEnsemble_MelancholyFlowers/TleilaxEnsemble_MelancholyFlowers_STEMS/TleilaxEnsemble_MelancholyFlowers_STEM_04.wav",
+        "/data/medley1/v2/Audio/TleilaxEnsemble_MelancholyFlowers/TleilaxEnsemble_MelancholyFlowers_STEMS/TleilaxEnsemble_MelancholyFlowers_STEM_05.wav",
+        "/data/medley1/v2/Audio/Torres_NewSkin/Torres_NewSkin_STEMS/Torres_NewSkin_STEM_02.wav",
+        "/data/medley1/v2/Audio/Torres_NewSkin/Torres_NewSkin_STEMS/Torres_NewSkin_STEM_05.wav",
+        "/data/medley1/v2/Audio/Torres_NewSkin/Torres_NewSkin_STEMS/Torres_NewSkin_STEM_10.wav",
+        "/data/medley1/v2/Audio/Torres_NewSkin/Torres_NewSkin_STEMS/Torres_NewSkin_STEM_03.wav",
+        "/data/medley1/v1/Audio/Wolf_DieBekherte/Wolf_DieBekherte_STEMS/Wolf_DieBekherte_STEM_01.wav"
+    ],
+    "alignment_shifts": [
+        20,
+        -675,
+        -2130,
+        -1644,
+        3,
+        3,
+        -98,
+        -3,
+        0,
+        0,
+        63,
+        63,
+        0,
+        -2,
+        4,
+        -657,
+        -25414,
+        -2,
+        -1967,
+        -1996,
+        -761,
+        6475,
+        5091,
+        1238,
+        5689,
+        7158,
+        2265,
+        1260,
+        1144,
+        0,
+        -5,
+        0,
+        841,
+        0,
+        0,
+        -2,
+        0,
+        -2,
+        -490,
+        -47,
+        -3,
+        -185,
+        -20,
+        -46,
+        -43,
+        -47,
+        -175,
+        -46,
+        366,
+        -46,
+        -48,
+        -50,
+        -47,
+        -5,
+        289,
+        4298,
+        0,
+        -235,
+        -351,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        -2,
+        -5,
+        -4,
+        -2,
+        2
+    ],
+    "params_original_shapes": [
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [
+            1
+        ],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [
+            1
+        ],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [
+            6,
+            2
+        ],
+        [
+            2,
+            6
+        ],
+        [
+            49,
+            1
+        ],
+        [
+            6,
+            6
+        ],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        [],
+        []
+    ],
+    "params_keys": [
+        "0.params.gain",
+        "0.params.parametrizations.freq.original",
+        "0.params.parametrizations.Q.original",
+        "1.params.gain",
+        "1.params.parametrizations.freq.original",
+        "1.params.parametrizations.Q.original",
+        "2.params.gain",
+        "2.params.parametrizations.freq.original",
+        "3.params.gain",
+        "3.params.parametrizations.freq.original",
+        "4.params.parametrizations.freq.original",
+        "4.params.parametrizations.Q.original",
+        "5.params.parametrizations.freq.original",
+        "5.params.parametrizations.Q.original",
+        "6.params.cmp_th",
+        "6.params.exp_th",
+        "6.params.make_up",
+        "6.params.parametrizations.lookahead.original",
+        "6.params.parametrizations.at.original",
+        "6.params.parametrizations.rt.original",
+        "6.params.parametrizations.avg_coef.original",
+        "6.params.parametrizations.cmp_ratio.original",
+        "6.params.parametrizations.exp_ratio.original",
+        "7.params.parametrizations.sends_0.original",
+        "7.effects.0.params.parametrizations.delay.original",
+        "7.effects.0.params.parametrizations.feedback.original",
+        "7.effects.0.params.parametrizations.gain.original",
+        "7.effects.0.eq.params.parametrizations.freq.original",
+        "7.effects.0.eq.params.parametrizations.Q.original",
+        "7.effects.0.odd_pan.params.parametrizations.pan.original",
+        "7.effects.0.even_pan.params.parametrizations.pan.original",
+        "7.effects.1.params.b",
+        "7.effects.1.params.c",
+        "7.effects.1.params.parametrizations.gamma.original",
+        "7.effects.1.params.parametrizations.U.original",
+        "7.effects.1.eq.0.params.gain",
+        "7.effects.1.eq.0.params.parametrizations.freq.original",
+        "7.effects.1.eq.0.params.parametrizations.Q.original",
+        "7.effects.1.eq.1.params.gain",
+        "7.effects.1.eq.1.params.parametrizations.freq.original",
+        "7.effects.1.eq.1.params.parametrizations.Q.original",
+        "7.effects.1.eq.2.params.gain",
+        "7.effects.1.eq.2.params.parametrizations.freq.original",
+        "7.effects.1.eq.3.params.gain",
+        "7.effects.1.eq.3.params.parametrizations.freq.original",
+        "7.pan.params.parametrizations.pan.original"
+    ],
+    "problematic_runs": {
+        "terminated": [],
+        "loss_above_4.0": [],
+        "not_converged": [
+            [
+                "Debussy_LenfantProdigue/Debussy_LenfantProdigue_STEM_01/run_0",
+                1.0083130598068237,
+                1.673229455947876
+            ]
+        ],
+        "fluctuated_above_0.2": [
+            [
+                "AlexanderRoss_GoodbyeBolero/AlexanderRoss_GoodbyeBolero_STEM_06/run_0",
+                0.5641272068023682
+            ],
+            [
+                "AlexanderRoss_VelvetCurtain/AlexanderRoss_VelvetCurtain_STEM_06/run_0",
+                0.6348648071289062
+            ],
+            [
+                "Mozart_DiesBildnis/Mozart_DiesBildnis_STEM_01/run_0",
+                0.2333838939666748
+            ],
+            [
+                "Schubert_Erstarrung/Schubert_Erstarrung_STEM_01/run_0",
+                0.24937140941619873
+            ],
+            [
+                "Schumann_Mignon/Schumann_Mignon_STEM_02/run_0",
+                0.6572010517120361
+            ]
+        ]
+    }
+}

presets/rt_config.yaml

@@ -0,0 +1,190 @@
+epochs: 2000
+data_dir: null
+log_dir: null
+lufs: -18
+sr: 44100
+chunk_duration: 12
+chunk_overlap: 5
+device: cuda
+batch_size: 35
+dataset: medley_vocal
+regularise_delay: true
+model:
+  _target_: torch.nn.Sequential
+  _args_:
+  - _target_: modules.fx.Peak
+    sr: 44100
+    freq: 800
+    min_freq: 33
+    max_freq: 5400
+  - _target_: modules.fx.Peak
+    sr: 44100
+    freq: 4000
+    min_freq: 200
+    max_freq: 17500
+  - _target_: modules.fx.LowShelf
+    sr: 44100
+    freq: 115
+    min_freq: 30
+    max_freq: 200
+  - _target_: modules.fx.HighShelf
+    sr: 44100
+    freq: 6000
+    min_freq: 750
+    max_freq: 8300
+  - _target_: modules.fx.LowPass
+    sr: 44100
+    freq: 17500
+    min_freq: 200
+    max_freq: 18000
+  - _target_: modules.fx.HighPass
+    sr: 44100
+    freq: 200
+    min_freq: 16
+    max_freq: 5300
+  - _target_: modules.fx.CompressorExpander
+    sr: 44100
+    cmp_ratio: 2.0
+    exp_ratio: 0.5
+    at_ms: 50.0
+    rt_ms: 50.0
+    avg_coef: 0.3
+    cmp_th: -18.0
+    exp_th: -48.0
+    make_up: 0.0
+    lookahead: true
+    max_lookahead: 15
+  - _target_: modules.fx.SendFXsAndSum
+    _args_:
+    # - _target_: modules.fx.SurrogateDelay
+    - _target_: modules.rt.RealTimeDelay
+      sr: 44100
+      delay: 400
+      # dropout: 0
+      # straight_through: true
+      recursive_eq: true
+      ir_duration: 4
+      eq:
+        _target_: modules.fx.LowPass
+        sr: 44100
+        freq: 8000
+        min_freq: 200
+        max_freq: 16000
+        min_Q: 0.5
+        max_Q: 2
+    # - _target_: modules.fx.FDN
+    - _target_: modules.rt.RealTimeFDN
+      sr: 44100
+      delays:
+      - 997
+      - 1153
+      - 1327
+      - 1559
+      - 1801
+      - 2099
+      num_decay_freq: 49
+      delay_independent_decay: true
+      ir_duration: 12
+      eq:
+        _target_: torch.nn.Sequential
+        _args_:
+        - _target_: modules.fx.Peak
+          sr: 44100
+          freq: 800
+          min_freq: 200
+          max_freq: 2500
+          min_Q: 0.1
+          max_Q: 3
+        - _target_: modules.fx.Peak
+          sr: 44100
+          freq: 4000
+          min_freq: 600
+          max_freq: 7000
+          min_Q: 0.1
+          max_Q: 3
+        - _target_: modules.fx.LowShelf
+          sr: 44100
+          freq: 115
+          min_freq: 30
+          max_freq: 450
+        - _target_: modules.fx.HighShelf
+          sr: 44100
+          freq: 8000
+          min_freq: 1500
+          max_freq: 16000
+    cross_send: true
+    pan_direct: true
+optimiser:
+  _target_: torch.optim.Adam
+  lr: 0.01
+mss:
+  fft_sizes:
+  - 128
+  - 512
+  - 2048
+  hop_sizes:
+  - 32
+  - 128
+  - 512
+mldr:
+  s_taus:
+  - 50
+  - 100
+  l_taus:
+  - 1000
+  - 2000
+loss_fn:
+  _target_: loss.SumLosses
+  weights:
+  - 1.0
+  - 0.5
+  - 0.5
+  - 0.25
+  loss_fns:
+  - _target_: auraloss.freq.MultiResolutionSTFTLoss
+    fft_sizes:
+    - 128
+    - 512
+    - 2048
+    hop_sizes:
+    - 32
+    - 128
+    - 512
+    win_lengths:
+    - 128
+    - 512
+    - 2048
+    sample_rate: 44100
+    perceptual_weighting: true
+  - _target_: auraloss.freq.SumAndDifferenceSTFTLoss
+    fft_sizes:
+    - 128
+    - 512
+    - 2048
+    hop_sizes:
+    - 32
+    - 128
+    - 512
+    win_lengths:
+    - 128
+    - 512
+    - 2048
+    sample_rate: 44100
+    perceptual_weighting: true
+  - _target_: loss.ldr.MLDRLoss
+    sr: 44100
+    s_taus:
+    - 50
+    - 100
+    l_taus:
+    - 1000
+    - 2000
+  - _target_: loss.ldr.MLDRLoss
+    sr: 44100
+    mid_side: true
+    s_taus:
+    - 50
+    - 100
+    l_taus:
+    - 1000
+    - 2000