mirror of
https://github.com/Anjok07/ultimatevocalremovergui.git
synced 2024-12-18 10:26:03 +01:00
140 lines
4.2 KiB
Python
140 lines
4.2 KiB
Python
from abc import ABCMeta
|
|
|
|
import torch
|
|
import torch.nn as nn
|
|
from pytorch_lightning import LightningModule
|
|
from .modules import TFC_TDF
|
|
|
|
dim_s = 4
|
|
|
|
class AbstractMDXNet(LightningModule):
|
|
__metaclass__ = ABCMeta
|
|
|
|
def __init__(self, target_name, lr, optimizer, dim_c, dim_f, dim_t, n_fft, hop_length, overlap):
|
|
super().__init__()
|
|
self.target_name = target_name
|
|
self.lr = lr
|
|
self.optimizer = optimizer
|
|
self.dim_c = dim_c
|
|
self.dim_f = dim_f
|
|
self.dim_t = dim_t
|
|
self.n_fft = n_fft
|
|
self.n_bins = n_fft // 2 + 1
|
|
self.hop_length = hop_length
|
|
self.window = nn.Parameter(torch.hann_window(window_length=self.n_fft, periodic=True), requires_grad=False)
|
|
self.freq_pad = nn.Parameter(torch.zeros([1, dim_c, self.n_bins - self.dim_f, self.dim_t]), requires_grad=False)
|
|
|
|
def configure_optimizers(self):
|
|
if self.optimizer == 'rmsprop':
|
|
return torch.optim.RMSprop(self.parameters(), self.lr)
|
|
|
|
if self.optimizer == 'adamw':
|
|
return torch.optim.AdamW(self.parameters(), self.lr)
|
|
|
|
class ConvTDFNet(AbstractMDXNet):
|
|
def __init__(self, target_name, lr, optimizer, dim_c, dim_f, dim_t, n_fft, hop_length,
|
|
num_blocks, l, g, k, bn, bias, overlap):
|
|
|
|
super(ConvTDFNet, self).__init__(
|
|
target_name, lr, optimizer, dim_c, dim_f, dim_t, n_fft, hop_length, overlap)
|
|
self.save_hyperparameters()
|
|
|
|
self.num_blocks = num_blocks
|
|
self.l = l
|
|
self.g = g
|
|
self.k = k
|
|
self.bn = bn
|
|
self.bias = bias
|
|
|
|
if optimizer == 'rmsprop':
|
|
norm = nn.BatchNorm2d
|
|
|
|
if optimizer == 'adamw':
|
|
norm = lambda input:nn.GroupNorm(2, input)
|
|
|
|
self.n = num_blocks // 2
|
|
scale = (2, 2)
|
|
|
|
self.first_conv = nn.Sequential(
|
|
nn.Conv2d(in_channels=self.dim_c, out_channels=g, kernel_size=(1, 1)),
|
|
norm(g),
|
|
nn.ReLU(),
|
|
)
|
|
|
|
f = self.dim_f
|
|
c = g
|
|
self.encoding_blocks = nn.ModuleList()
|
|
self.ds = nn.ModuleList()
|
|
for i in range(self.n):
|
|
self.encoding_blocks.append(TFC_TDF(c, l, f, k, bn, bias=bias, norm=norm))
|
|
self.ds.append(
|
|
nn.Sequential(
|
|
nn.Conv2d(in_channels=c, out_channels=c + g, kernel_size=scale, stride=scale),
|
|
norm(c + g),
|
|
nn.ReLU()
|
|
)
|
|
)
|
|
f = f // 2
|
|
c += g
|
|
|
|
self.bottleneck_block = TFC_TDF(c, l, f, k, bn, bias=bias, norm=norm)
|
|
|
|
self.decoding_blocks = nn.ModuleList()
|
|
self.us = nn.ModuleList()
|
|
for i in range(self.n):
|
|
self.us.append(
|
|
nn.Sequential(
|
|
nn.ConvTranspose2d(in_channels=c, out_channels=c - g, kernel_size=scale, stride=scale),
|
|
norm(c - g),
|
|
nn.ReLU()
|
|
)
|
|
)
|
|
f = f * 2
|
|
c -= g
|
|
|
|
self.decoding_blocks.append(TFC_TDF(c, l, f, k, bn, bias=bias, norm=norm))
|
|
|
|
self.final_conv = nn.Sequential(
|
|
nn.Conv2d(in_channels=c, out_channels=self.dim_c, kernel_size=(1, 1)),
|
|
)
|
|
|
|
def forward(self, x):
|
|
|
|
x = self.first_conv(x)
|
|
|
|
x = x.transpose(-1, -2)
|
|
|
|
ds_outputs = []
|
|
for i in range(self.n):
|
|
x = self.encoding_blocks[i](x)
|
|
ds_outputs.append(x)
|
|
x = self.ds[i](x)
|
|
|
|
x = self.bottleneck_block(x)
|
|
|
|
for i in range(self.n):
|
|
x = self.us[i](x)
|
|
x *= ds_outputs[-i - 1]
|
|
x = self.decoding_blocks[i](x)
|
|
|
|
x = x.transpose(-1, -2)
|
|
|
|
x = self.final_conv(x)
|
|
|
|
return x
|
|
|
|
class Mixer(nn.Module):
|
|
def __init__(self, device, mixer_path):
|
|
|
|
super(Mixer, self).__init__()
|
|
|
|
self.linear = nn.Linear((dim_s+1)*2, dim_s*2, bias=False)
|
|
|
|
self.load_state_dict(
|
|
torch.load(mixer_path, map_location=device)
|
|
)
|
|
|
|
def forward(self, x):
|
|
x = x.reshape(1,(dim_s+1)*2,-1).transpose(-1,-2)
|
|
x = self.linear(x)
|
|
return x.transpose(-1,-2).reshape(dim_s,2,-1) |