def __init__(
self,
in_dim,
hidden_dim,
out_dim,
num_layers=1,
dropout=0.5,
num_gaussians=8,
dim_wise=False,
init_type="none",
):
super(MDNv2, self).__init__()
model = [nn.Linear(in_dim, hidden_dim), nn.ReLU(), nn.Dropout(dropout)]
if num_layers > 1:
for _ in range(num_layers - 1):
model += [
nn.Linear(hidden_dim, hidden_dim),
nn.ReLU(),
nn.Dropout(dropout),
]
model += [
MDNLayer(
in_dim=hidden_dim,
out_dim=out_dim,
num_gaussians=num_gaussians,
dim_wise=dim_wise,
)
]
self.model = nn.Sequential(*model)
init_weights(self, init_type)
def __init__(
self,
in_dim,
hidden_dim,
out_dim,
num_layers=1,
num_gaussians=8,
dim_wise=False,
init_type="none",
**kwargs,
):
super(MDN, self).__init__()
if "dropout" in kwargs:
warn(
"dropout argument in MDN is deprecated"
" and will be removed in future versions"
)
model = [nn.Linear(in_dim, hidden_dim), nn.ReLU()]
if num_layers > 1:
for _ in range(num_layers - 1):
model += [nn.Linear(hidden_dim, hidden_dim), nn.ReLU()]
model += [
MDNLayer(
in_dim=hidden_dim,
out_dim=out_dim,
num_gaussians=num_gaussians,
dim_wise=dim_wise,
)
]
self.model = nn.Sequential(*model)
init_weights(self, init_type)
def __init__(
self,
in_dim,
hidden_dim,
out_dim,
num_layers=1,
bidirectional=True,
dropout=0.0,
num_gaussians=8,
dim_wise=False,
init_type="none",
):
super(RMDN, self).__init__()
self.linear = nn.Linear(in_dim, hidden_dim)
self.relu = nn.ReLU()
self.num_direction = 2 if bidirectional else 1
self.lstm = nn.LSTM(
hidden_dim,
hidden_dim,
num_layers,
bidirectional=bidirectional,
batch_first=True,
dropout=dropout,
)
self.mdn = MDNLayer(
in_dim=self.num_direction * hidden_dim,
out_dim=out_dim,
num_gaussians=num_gaussians,
dim_wise=dim_wise,
)
init_weights(self, init_type)
def __init__(
self,
in_dim,
hidden_dim,
out_dim,
num_layers=4,
# NOTE: you must carefully set the following parameters
in_lf0_idx=300,
in_lf0_min=5.3936276,
in_lf0_max=6.491111,
out_lf0_idx=180,
out_lf0_mean=5.953093881972361,
out_lf0_scale=0.23435173188961034,
init_type="none",
use_mdn=False,
num_gaussians=8,
dim_wise=False,
):
super().__init__()
self.in_lf0_idx = in_lf0_idx
self.in_lf0_min = in_lf0_min
self.in_lf0_max = in_lf0_max
self.out_lf0_idx = out_lf0_idx
self.out_lf0_mean = out_lf0_mean
self.out_lf0_scale = out_lf0_scale
self.use_mdn = use_mdn
model = [
nn.ReflectionPad1d(3),
WNConv1d(in_dim, hidden_dim, kernel_size=7, padding=0),
]
for n in range(num_layers):
model.append(ResnetBlock(hidden_dim, dilation=2 ** n))
last_conv_out_dim = hidden_dim if use_mdn else out_dim
model += [
nn.LeakyReLU(0.2),
nn.ReflectionPad1d(3),
WNConv1d(hidden_dim, last_conv_out_dim, kernel_size=7, padding=0),
]
self.model = nn.Sequential(*model)
if self.use_mdn:
self.mdn_layer = MDNLayer(
in_dim=hidden_dim,
out_dim=out_dim,
num_gaussians=num_gaussians,
dim_wise=dim_wise,
)
else:
self.mdn_layer = None
init_weights(self, init_type)
def __init__(self,
in_dim,
hidden_dim,
out_dim,
num_layers=1,
dropout=0.0,
num_gaussians=8):
super(MDN, self).__init__()
model = [nn.Linear(in_dim, hidden_dim), nn.ReLU()]
if num_layers > 1:
for _ in range(num_layers - 1):
model += [nn.Linear(hidden_dim, hidden_dim), nn.ReLU()]
model += [MDNLayer(hidden_dim, out_dim, num_gaussians=num_gaussians)]
self.model = nn.Sequential(*model)
def __init__(self,
in_dim,
hidden_dim,
out_dim,
num_layers=4,
dropout=0.0,
num_gaussians=8,
dim_wise=False):
super().__init__()
model = [
Conv1dResnet(in_dim, hidden_dim, hidden_dim, num_layers, dropout),
nn.ReLU(),
MDNLayer(hidden_dim, out_dim, num_gaussians, dim_wise)
]
self.model = nn.Sequential(*model)
def __init__(
self,
in_dim,
hidden_dim,
out_dim,
num_layers=4,
init_type="none",
use_mdn=False,
num_gaussians=8,
dim_wise=False,
**kwargs,
):
super().__init__()
self.use_mdn = use_mdn
if "dropout" in kwargs:
warn(
"dropout argument in Conv1dResnet is deprecated"
" and will be removed in future versions"
)
model = [
nn.ReflectionPad1d(3),
WNConv1d(in_dim, hidden_dim, kernel_size=7, padding=0),
]
for n in range(num_layers):
model.append(ResnetBlock(hidden_dim, dilation=2 ** n))
last_conv_out_dim = hidden_dim if use_mdn else out_dim
model += [
nn.LeakyReLU(0.2),
nn.ReflectionPad1d(3),
WNConv1d(hidden_dim, last_conv_out_dim, kernel_size=7, padding=0),
]
self.model = nn.Sequential(*model)
if self.use_mdn:
self.mdn_layer = MDNLayer(
in_dim=hidden_dim,
out_dim=out_dim,
num_gaussians=num_gaussians,
dim_wise=dim_wise,
)
else:
self.mdn_layer = None
init_weights(self, init_type)
def __init__(
self,
in_dim,
out_dim,
num_layers=5,
hidden_dim=256,
kernel_size=5,
dropout=0.5,
init_type="none",
use_mdn=False,
num_gaussians=1,
dim_wise=False,
):
super().__init__()
self.use_mdn = use_mdn
conv = nn.ModuleList()
for idx in range(num_layers):
in_channels = in_dim if idx == 0 else hidden_dim
conv += [
nn.Sequential(
nn.Conv1d(
in_channels,
hidden_dim,
kernel_size,
stride=1,
padding=(kernel_size - 1) // 2,
),
nn.ReLU(),
LayerNorm(hidden_dim, dim=1),
nn.Dropout(dropout),
)
]
self.conv = nn.Sequential(*conv)
if self.use_mdn:
self.mdn_layer = MDNLayer(
hidden_dim, out_dim, num_gaussians=num_gaussians, dim_wise=dim_wise
)
else:
self.fc = nn.Linear(hidden_dim, out_dim)
init_weights(self, init_type)
def __init__(self,
in_dim,
hidden_dim,
out_dim,
num_layers=1,
bidirectional=True,
dropout=0.0,
num_gaussians=8):
super(RMDN, self).__init__()
self.linear = nn.Linear(in_dim, hidden_dim)
self.relu = nn.ReLU()
self.num_direction = 2 if bidirectional else 1
self.lstm = nn.LSTM(hidden_dim,
hidden_dim,
num_layers,
bidirectional=bidirectional,
batch_first=True,
dropout=dropout)
self.mdn = MDNLayer(self.num_direction * hidden_dim,
out_dim,
num_gaussians=num_gaussians)
def __init__(
self,
in_dim,
hidden_dim,
out_dim,
num_layers=4,
num_gaussians=8,
dim_wise=False,
init_type="none",
**kwargs,
):
super().__init__()
if "dropout" in kwargs:
warn(
"dropout argument in Conv1dResnet is deprecated"
" and will be removed in future versions"
)
model = [
Conv1dResnet(
in_dim=in_dim,
hidden_dim=hidden_dim,
out_dim=hidden_dim,
num_layers=num_layers,
),
nn.ReLU(),
MDNLayer(
in_dim=hidden_dim,
out_dim=out_dim,
num_gaussians=num_gaussians,
dim_wise=dim_wise,
),
]
self.model = nn.Sequential(*model)
init_weights(self, init_type)
def __init__(
self,
in_dim,
ff_hidden_dim=2048,
conv_hidden_dim=1024,
lstm_hidden_dim=256,
out_dim=199,
dropout=0.0,
num_lstm_layers=2,
bidirectional=True,
# NOTE: you must carefully set the following parameters
in_lf0_idx=300,
in_lf0_min=5.3936276,
in_lf0_max=6.491111,
out_lf0_idx=180,
out_lf0_mean=5.953093881972361,
out_lf0_scale=0.23435173188961034,
skip_inputs=False,
init_type="none",
use_mdn=False,
num_gaussians=8,
dim_wise=False,
):
super().__init__()
self.in_lf0_idx = in_lf0_idx
self.in_lf0_min = in_lf0_min
self.in_lf0_max = in_lf0_max
self.out_lf0_idx = out_lf0_idx
self.out_lf0_mean = out_lf0_mean
self.out_lf0_scale = out_lf0_scale
self.skip_inputs = skip_inputs
self.use_mdn = use_mdn
self.ff = nn.Sequential(
nn.Linear(in_dim, ff_hidden_dim),
nn.ReLU(),
nn.Linear(ff_hidden_dim, ff_hidden_dim),
nn.ReLU(),
nn.Linear(ff_hidden_dim, ff_hidden_dim),
nn.ReLU(),
)
self.conv = nn.Sequential(
nn.ReflectionPad1d(3),
nn.Conv1d(ff_hidden_dim + 1, conv_hidden_dim, kernel_size=7, padding=0),
nn.BatchNorm1d(conv_hidden_dim),
nn.ReLU(),
nn.ReflectionPad1d(3),
nn.Conv1d(conv_hidden_dim, conv_hidden_dim, kernel_size=7, padding=0),
nn.BatchNorm1d(conv_hidden_dim),
nn.ReLU(),
nn.ReflectionPad1d(3),
nn.Conv1d(conv_hidden_dim, conv_hidden_dim, kernel_size=7, padding=0),
nn.BatchNorm1d(conv_hidden_dim),
nn.ReLU(),
)
num_direction = 2 if bidirectional else 1
self.lstm = nn.LSTM(
conv_hidden_dim,
lstm_hidden_dim,
num_lstm_layers,
bidirectional=True,
batch_first=True,
dropout=dropout,
)
if self.skip_inputs:
last_in_dim = num_direction * lstm_hidden_dim + in_dim
else:
last_in_dim = num_direction * lstm_hidden_dim
if self.use_mdn:
self.mdn_layer = MDNLayer(
last_in_dim, out_dim, num_gaussians=num_gaussians, dim_wise=dim_wise
)
else:
self.fc = nn.Linear(last_in_dim, out_dim)
init_weights(self, init_type)