def __init__(
self,
n_fft,
input_channels,
internal_channels,
n_blocks,
n_internal_layers,
mk_block_f,
mk_ds_f,
mk_us_f,
first_conv_activation,
last_activation,
t_down_layers,
f_down_layers,
# Conditional Mechanism #
control_vector_type,
control_input_dim,
embedding_dim,
condition_to,
control_type,
control_n_layer,
film_type,
gamma_activation,
beta_activation,
):
super(DenseCUNet_FiLM, self).__init__(
n_fft,
input_channels,
internal_channels,
n_blocks,
n_internal_layers,
mk_block_f,
mk_ds_f,
mk_us_f,
first_conv_activation,
last_activation,
t_down_layers,
f_down_layers,
# Conditional Mechanism #
control_vector_type,
control_input_dim,
embedding_dim,
condition_to)
assert film_type in ['simple', 'complex']
self.film = FiLM_simple if film_type == 'simple' else FiLM_complex
gamma_activation = get_activation_by_name(gamma_activation)
beta_activation = get_activation_by_name(beta_activation)
if control_type == "dense":
control_block = dense_control_block(embedding_dim, control_n_layer)
self.condition_generator = film_control_model(
control_block, n_blocks, internal_channels, film_type,
gamma_activation, beta_activation, condition_to)
else:
raise NotImplementedError
self.activation = self.last_conv[-1]
def __init__(self,
n_fft,
input_channels, internal_channels,
n_blocks, n_internal_layers,
mk_block_f, mk_ds_f, mk_us_f,
first_conv_activation, last_activation,
t_down_layers, f_down_layers,
# Conditional Mechanism #
control_vector_type, control_input_dim, embedding_dim, condition_to
):
first_conv_activation = get_activation_by_name(first_conv_activation)
last_activation = get_activation_by_name(last_activation)
super(Dense_CUNet, self).__init__()
'''num_block should be an odd integer'''
assert n_blocks % 2 == 1
dim_f, t_down_layers, f_down_layers = self.mk_overall_structure(n_fft, internal_channels, input_channels,
n_blocks,
n_internal_layers, last_activation,
first_conv_activation,
t_down_layers, f_down_layers)
self.mk_blocks(dim_f, internal_channels, mk_block_f, mk_ds_f, mk_us_f, t_down_layers)
#########################
# Conditional Mechanism #
#########################
assert control_vector_type in ['one_hot_mode', 'embedding']
if control_vector_type == 'one_hot_mode':
if control_input_dim != embedding_dim:
warn('in one_hot_mode, embedding_dim should be the same as num_targets. auto correction')
embedding_dim = control_input_dim
with torch.no_grad():
one_hot_weight = torch.zeros((control_input_dim, embedding_dim))
for i in range(control_input_dim):
one_hot_weight[i, i] = 1.
self.embedding = nn.Embedding(control_input_dim, embedding_dim, _weight=one_hot_weight)
self.embedding.weight.requires_grad = True
elif control_vector_type == 'embedding':
self.embedding = nn.Embedding(control_input_dim, embedding_dim)
# Where to condition
assert condition_to in ['encoder', 'decoder', 'full']
self.is_encoder_conditioned = self.is_middle_conditioned = self.is_decoder_conditioned = False
if condition_to == 'encoder':
self.is_encoder_conditioned = True
elif condition_to == 'decoder':
self.is_decoder_conditioned = True
elif condition_to == 'full':
self.is_encoder_conditioned = self.is_middle_conditioned = self.is_decoder_conditioned = True
else:
raise NotImplementedError
self.activation = self.last_conv[-1]
def __init__(self,
n_fft,
n_blocks, input_channels, internal_channels, n_internal_layers,
first_conv_activation, last_activation,
t_down_layers, f_down_layers,
kernel_size_t, kernel_size_f,
bn_factor, min_bn_units,
tfc_tdf_bias,
tfc_tdf_activation,
num_tdfs, dk,
control_vector_type, control_input_dim, embedding_dim, condition_to,
control_type, control_n_layer, pocm_type, pocm_norm
):
tfc_tdf_activation = functions.get_activation_by_name(tfc_tdf_activation)
def mk_tfc_lasaft(in_channels, internal_channels, f):
return TFC_LightSAFT(in_channels, n_internal_layers, internal_channels,
kernel_size_t, kernel_size_f, f,
bn_factor, min_bn_units,
tfc_tdf_bias,
tfc_tdf_activation,
embedding_dim, num_tdfs, dk)
def mk_ds(internal_channels, i, f, t_down_layers):
if t_down_layers is None:
scale = (2, 2)
else:
scale = (2, 2) if i in t_down_layers else (1, 2)
ds = nn.Sequential(
nn.Conv2d(in_channels=internal_channels, out_channels=internal_channels,
kernel_size=scale, stride=scale),
nn.BatchNorm2d(internal_channels)
)
return ds, f // scale[-1]
def mk_us(internal_channels, i, f, n, t_down_layers):
if t_down_layers is None:
scale = (2, 2)
else:
scale = (2, 2) if i in [n - 1 - s for s in t_down_layers] else (1, 2)
us = nn.Sequential(
nn.ConvTranspose2d(in_channels=internal_channels, out_channels=internal_channels,
kernel_size=scale, stride=scale),
nn.BatchNorm2d(internal_channels)
)
return us, f * scale[-1]
super(DCUN_TFC_GPoCM_LightSAFT, self).__init__(
n_fft,
input_channels, internal_channels,
n_blocks, n_internal_layers,
mk_tfc_lasaft, mk_ds, mk_us,
first_conv_activation, last_activation,
t_down_layers, f_down_layers,
# Conditional Mechanism #
control_vector_type, control_input_dim, embedding_dim, condition_to,
control_type, control_n_layer, pocm_type, pocm_norm
)
def __init__(
self,
n_fft,
input_channels,
internal_channels,
n_blocks,
n_internal_layers,
first_conv_activation,
last_activation,
t_down_layers,
f_down_layers,
kernel_size_t,
kernel_size_f,
tfc_activation,
# Conditional Mechanism #
control_vector_type,
control_input_dim,
embedding_dim,
# Conditional Model #
control_type,
control_n_layer,
condition_to,
film_type,
gamma_activation,
beta_activation):
tfc_activation = functions.get_activation_by_name(tfc_activation)
def mk_tfc_tdf(in_channels, internal_channels, f):
return TFC(in_channels, n_internal_layers, internal_channels,
kernel_size_t, kernel_size_f, tfc_activation)
def mk_tfc_tdf_ds(internal_channels, i, f, t_down_layers):
if t_down_layers is None:
scale = (2, 2)
else:
scale = (2, 2) if i in t_down_layers else (1, 2)
ds = nn.Sequential(
nn.Conv2d(in_channels=internal_channels,
out_channels=internal_channels,
kernel_size=scale,
stride=scale), nn.BatchNorm2d(internal_channels))
return ds, f // scale[-1]
def mk_tfc_tdf_us(internal_channels, i, f, n, t_down_layers):
if t_down_layers is None:
scale = (2, 2)
else:
scale = (2, 2) if i in [n - 1 - s
for s in t_down_layers] else (1, 2)
us = nn.Sequential(
nn.ConvTranspose2d(in_channels=internal_channels,
out_channels=internal_channels,
kernel_size=scale,
stride=scale),
nn.BatchNorm2d(internal_channels))
return us, f * scale[-1]
super(DCUN_TFC_FiLM, self).__init__(
n_fft,
input_channels,
internal_channels,
n_blocks,
n_internal_layers,
mk_tfc_tdf,
mk_tfc_tdf_ds,
mk_tfc_tdf_us,
first_conv_activation,
last_activation,
t_down_layers,
f_down_layers,
# Conditional Mechanism #
control_vector_type,
control_input_dim,
embedding_dim,
condition_to,
control_type,
control_n_layer,
film_type,
gamma_activation,
beta_activation)
