def __init__(self, *args, seq_channels=512, **kwargs):
super().__init__(*args, **kwargs)
self.seq_channels = seq_channels
del self.linear
nf = 32
in_c = self.observation_space.shape[0]
self.convs = nn.ModuleList([
self._make_layer(
nn.Conv2d(in_c, nf, 8, 4, 0, bias=self.norm is None)),
self._make_layer(
nn.Conv2d(nf, nf * 2, 6, 3, 0, bias=self.norm is None)),
self._make_layer(
nn.Conv2d(nf * 2, nf * 4, 4, 2, 0, bias=self.norm is None)),
])
layer_norm = self.norm is not None and 'layer' in self.norm
self.seq_conv = nn.Sequential(
nn.ReplicationPad1d((3, 0)),
nn.Conv1d(1920, seq_channels, 4),
*([nn.GroupNorm(1, seq_channels)] if layer_norm else []),
nn.ReLU(),
nn.ReplicationPad1d((3, 0)),
nn.Conv1d(seq_channels, seq_channels, 4, bias=False),
*([nn.GroupNorm(1, seq_channels)] if layer_norm else []),
nn.ReLU(),
)
self.reset_weights()
def __init__(self, param=None):
super(TxtNet, self).__init__()
self.conv1 = nn.Conv1d(in_channels=300,
out_channels=300,
kernel_size=1,
bias=True)
self.conv2 = nn.Sequential(
nn.ReplicationPad1d((0, 1)),
nn.Conv1d(in_channels=300,
out_channels=300,
kernel_size=2,
bias=True))
self.conv3 = nn.Sequential(
nn.ReplicationPad1d((1, 1)),
nn.Conv1d(in_channels=300,
out_channels=300,
kernel_size=3,
bias=True))
self.conv5 = nn.Sequential(
nn.ReplicationPad1d((2, 2)),
nn.Conv1d(in_channels=300,
out_channels=300,
kernel_size=5,
bias=True))
self.conv7 = nn.Sequential(
nn.ReplicationPad1d((3, 3)),
nn.Conv1d(in_channels=300,
out_channels=300,
kernel_size=7,
bias=True))
self.slp = nn.Linear(300 * 5, 512)
def __init__(self, *args, h_action_size=32, seq_channels=512, **kwargs):
super().__init__(*args, **kwargs)
self.seq_channels = seq_channels
del self.linear
self.h_action_space = gym.spaces.Box(-1, 1, h_action_size)
self.h_observation_space = gym.spaces.Box(-1, 1, seq_channels)
self.h_pd = make_pd(self.h_action_space)
nf = 32
in_c = self.observation_space.shape[0]
self.convs = nn.ModuleList([
self._make_layer(
nn.Conv2d(in_c, nf, 8, 4, 0, bias=self.norm is None)),
self._make_layer(
nn.Conv2d(nf, nf * 2, 6, 3, 0, bias=self.norm is None)),
self._make_layer(
nn.Conv2d(nf * 2, nf * 4, 4, 2, 0, bias=self.norm is None)),
self._make_layer(
nn.Conv2d(nf * 4, nf * 8, 3, 1, 0, bias=self.norm is None)),
])
self.l1_seq_conv = nn.Sequential(
nn.ReplicationPad1d((3, 0)),
nn.Conv1d(768, seq_channels, 4, bias=False),
nn.GroupNorm(1, seq_channels),
nn.ReLU(),
nn.ReplicationPad1d((3, 0)),
nn.Conv1d(seq_channels, seq_channels, 4, bias=False),
nn.GroupNorm(1, seq_channels),
nn.ReLU(),
)
self.l2_seq_conv = nn.Sequential(
nn.ReplicationPad1d((3, 0)),
nn.Conv1d(seq_channels, seq_channels, 4, bias=False),
nn.GroupNorm(1, seq_channels),
nn.ReLU(),
nn.ReplicationPad1d((3, 0)),
nn.Conv1d(seq_channels, seq_channels, 4, bias=False),
nn.GroupNorm(1, seq_channels),
nn.ReLU(),
)
self.l2_action_upsample = nn.Sequential(
nn.Linear(h_action_size, seq_channels, bias=False),
nn.GroupNorm(1, seq_channels),
nn.ReLU(),
)
self.l1_merge = nn.Sequential(
nn.Linear(seq_channels * 2, seq_channels, bias=False),
nn.GroupNorm(1, seq_channels),
nn.ReLU(),
)
self.head_l2 = ActorCriticHead(seq_channels, self.h_pd)
self.reset_weights()
def _forward(self, x):
# Compute padding to compromise the downsample loss
input_len = x.shape[0]
left_over = input_len % self.dr
if left_over % 2 == 0:
left_pad = left_over // 2
right_pad = left_pad
else:
left_pad = left_over // 2
right_pad = left_over // 2 + 1
# Model forwarding
x = x.permute(1, 0, 2).contiguous() # (T, B, D) -> (B, T, D)
spec_stacked, pos_enc, attn_mask = self.process_MAM_data(x)
x = self.model(spec_stacked,
pos_enc,
attn_mask,
output_all_encoded_layers=False) # (B, T, D)
# If using a downsampling model, apply tile and padding
if x.shape[1] != input_len:
x = self.tile_representations(x)
# padding
x = x.permute(0, 2, 1).contiguous() # (B, T, D) -> (B, D, T)
padding = nn.ReplicationPad1d((left_pad, right_pad))
x = padding(x)
x = x.permute(2, 0, 1).contiguous() # (B, D, T) -> (T, B, D)
# If not using a downsampling model, permute to output
else:
x = x.permute(1, 0, 2).contiguous() # (B, T, D) -> (T, B, D)
return x
def __init__(self, width, input_len, level=None, device=None):
super().__init__()
self.filter_len = 2
if level is not None:
self.level = level
else:
self.level = self.max_dwt_level(input_len)
self.input_len = input_len
self.width = width
# This is bit manipulation to assert that xlen is a power of 2
if not ((self.input_len &
(self.input_len - 1) == 0) and self.input_len != 0):
raise ValueError("Input array length {} is not power of 2".format(
self.input_len))
if self.level > self.max_dwt_level(self.input_len):
s = "Input array length {} gives max DWT level {}".format(
self.input_len, self.max_dwt_level(self.input_len))
raise ValueError(s)
self.c_filter = torch.tensor(np.divide(np.array([1., 1.]), np.sqrt(2)),
dtype=torch.float).reshape((1, 1, 2))
self.d_filter = torch.tensor(np.divide(np.array([1., -1.]),
np.sqrt(2)),
dtype=torch.float).reshape((1, 1, 2))
if device is not None:
self.c_filter = self.c_filter.to(device)
self.d_filter = self.d_filter.to(device)
# If the input array is odd-length, pad the array by repeating the
# last element
self.padder = nn.ReplicationPad1d((0, 1))
def __init__(self, n_channels, dilations, use_skip=True):
super(DenseResBlocks1d, self).__init__()
self.use_skip = use_skip
self.n_layers = len(dilations)
self.convs = nn.ModuleList()
self.skips = nn.ModuleList()
for i, dilation in enumerate(dilations):
self.convs.append(
nn.Sequential(
nn.ReplicationPad1d(dilation),
utils.wn_xavier(
nn.Conv1d(n_channels,
2 * n_channels,
3,
dilation=dilation)),
Func(F.glu, dim=1),
))
last_c = (4 *
n_channels if use_skip and i < self.n_layers - 1 else 2 *
n_channels)
self.skips.append(
nn.Sequential(
utils.wn_xavier(nn.Conv1d(n_channels, last_c, 1)),
Func(F.glu, dim=1),
))
def __init__(self, channels, ratio, kernel_size, negative_slope=0.01, dropout=0.5):
super(BaseComponent, self).__init__()
self.layers = nn.Sequential(
nn.ReplicationPad1d(kernel_size // 2 * 2), nn.Conv1d(channels, int(channels * ratio), kernel_size),
nn.LeakyReLU(negative_slope), nn.Dropout(dropout),
nn.Conv1d(int(channels * ratio), channels, kernel_size), nn.Tanh()
)
def __init__(self, sample_rate=16000, n_fft=401, hop_length=256, n_mels=23, context_size=7, subsample=16):
super(LogMel, self).__init__()
self.stft = MelSpectrogram(sample_rate=sample_rate, n_fft=n_fft, hop_length=hop_length, n_mels=n_mels)
self.pad = nn.ReplicationPad1d(padding=context_size)
self.context_size = context_size
self.subsample = subsample
def __init__(self, pad):
super(ReplicationPad, self).__init__()
if len(pad) == 6:
self.pad = nn.ReplicationPad3d(list(reversed(pad)))
if len(pad) == 4:
self.pad = nn.ReplicationPad2d(list(reversed(pad)))
if len(pad) == 2:
self.pad = nn.ReplicationPad1d(list(reversed(pad)))
def __init__(self):
super(Resblock, self).__init__()
self.pad = nn.ReplicationPad1d((2, 0))
self.conv1 = nn.Conv1d(256, 512, kernel_size=3, stride=1)
self.ins_norm_1 = nn.InstanceNorm1d(512)
self.conv_gate_1 = nn.Conv1d(256, 512, kernel_size=3, stride=1)
self.ins_gate_1 = nn.InstanceNorm1d(512)
self.conv2 = nn.Conv1d(512, 256, kernel_size=3, stride=1)
self.ins_norm_2 = nn.InstanceNorm1d(256)
def __init__(self, dim, dilation=1):
super().__init__()
self.block = nn.Sequential(
nn.LeakyReLU(0.2),
nn.ReplicationPad1d(dilation),
WNConv1d(dim, dim, kernel_size=3, dilation=dilation),
nn.LeakyReLU(0.2),
WNConv1d(dim, dim, kernel_size=1),
)
self.shortcut = WNConv1d(dim, dim, kernel_size=1)
def _forward(self, x):
if self.permute_input:
x = x.permute(1, 0, 2).contiguous() # (T, B, D) -> (B, T, D)
input_len = x.shape[0]
else:
input_len = x.shape[1]
# Compute padding to compromise the downsample loss
left_over = input_len % self.dr
if left_over % 2 == 0:
left_pad = left_over // 2
right_pad = left_pad
else:
left_pad = left_over // 2
right_pad = left_over // 2 + 1
# Model forwarding
spec_stacked, pos_enc, attn_mask = self.process_input_data(x) # x shape: (B, T, D)
x = self.model(spec_stacked, pos_enc, attn_mask, output_all_encoded_layers=self.weighted_sum or self.select_layer != -1) # (B, T, D) or # (N, B, T, D)
# Apply weighted sum
if self.weighted_sum:
if type(x) is list: x = torch.stack(x)
softmax_weight = nn.functional.softmax(self.weight, dim=-1)
B, T, D = x.shape[1], x.shape[2], x.shape[3]
x = x.reshape(self.num_layers, -1)
x = torch.matmul(softmax_weight, x).reshape(B, T, D)
# Select a specific layer
elif self.select_layer != -1:
x = x[self.select_layer]
if self.spec_aug and not self.spec_aug_prev and self.model.training:
x = spec_augment(x, mask_T=70, mask_F=86, num_T=2, num_F=2, p=1.0) # (B, T, D)
# If using a downsampling model, apply tile and padding
if x.shape[1] != input_len:
x = self.tile_representations(x)
# padding
x = x.permute(0, 2, 1).contiguous() # (B, T, D) -> (B, D, T)
padding = nn.ReplicationPad1d((left_pad, right_pad))
x = padding(x)
if self.permute_input: x = x.permute(2, 0, 1).contiguous() # (B, D, T) -> (T, B, D)
else: x = x.permute(0, 2, 1).contiguous() # (B, D, T) -> (B, T, D)
# If not using a downsampling model, permute to output
elif self.permute_input:
x = x.permute(1, 0, 2).contiguous() # (B, T, D) -> (T, B, D)
# else: (B, T, D)
return x
def __init__(self, in_channels, out_channels):
super(G_Downsample, self).__init__()
self.pad = nn.ReplicationPad1d((4, 0))
self.conv = nn.Conv1d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=5,
stride=2)
self.conv_gate = nn.Conv1d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=5,
stride=2)
self.ins_norm = nn.InstanceNorm1d(out_channels)
self.ins_gate = nn.InstanceNorm1d(out_channels)
def build_conv_block(self, dim, padding_type, norm_layer, use_dropout,
use_bias):
conv_block = []
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReflectionPad1d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad1d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' %
padding_type)
conv_block += [
nn.Conv1d(dim, dim, kernel_size=3, padding=p, bias=use_bias),
norm_layer(dim),
nn.ReLU(True)
]
if use_dropout:
conv_block += [nn.Dropout(0.5)]
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReflectionPad1d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad1d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' %
padding_type)
conv_block += [
nn.Conv1d(dim, dim, kernel_size=3, padding=p, bias=use_bias),
norm_layer(dim)
]
return nn.Sequential(*conv_block)
def __init__(self, input_size, ngf, n_residual_layers):
super().__init__()
ratios = [8, 8, 2, 2]
self.hop_length = np.prod(ratios)
mult = int(2**len(ratios))
model = [
nn.ReplicationPad1d(3),
WNConv1d(input_size, mult * ngf, kernel_size=7, padding=0),
]
# Upsample to raw audio scale
for i, r in enumerate(ratios):
model += [
nn.LeakyReLU(0.2),
WNConvTranspose1d(
mult * ngf,
mult * ngf // 2,
kernel_size=r * 2,
stride=r,
padding=r // 2 + r % 2,
output_padding=r % 2,
),
]
for j in range(n_residual_layers):
model += [ResnetBlock(mult * ngf // 2, dilation=3**j)]
mult //= 2
model += [
nn.LeakyReLU(0.2),
nn.ReplicationPad1d(3),
WNConv1d(ngf, 1, kernel_size=7, padding=0),
nn.Tanh(),
]
self.model = nn.Sequential(*model)
self.apply(weights_init)
def block(n_in, n_out, k, stride):
# padding dims only really make sense for stride = 1
ka = k // 2
kb = ka - 1 if k % 2 == 0 else ka
pad = ZeroPad1d(ka + kb, 0) if zero_pad else nn.ReplicationPad1d((ka + kb, 0))
return nn.Sequential(
pad,
nn.Conv1d(n_in, n_out, k, stride=stride, bias=conv_bias),
nn.Dropout(p=dropout),
norm_block(False, n_out, affine=not non_affine_group_norm),
nn.ReLU(),
)
def __init__(self, in_channels=80, num_features=512, out_channels=4, time_window=2, num_blocks=2):
super().__init__()
self.in_channels = in_channels
self.num_features = num_features
self.out_channels = out_channels
self.num_blocks = num_blocks
self.time_window = time_window
self.conv1 = nn.Sequential(
nn.ReplicationPad1d(1),
nn.Conv1d(self.in_channels, self.num_features, kernel_size=3, bias=False),
nn.BatchNorm1d(self.num_features),
nn.ReLU(inplace=True),
nn.Dropout(p=0.25)
)
self._make_blocks()
self.pad = nn.ReplicationPad1d(1)
self.relu = nn.ReLU(inplace=True)
self.drop = nn.Dropout(p=0.25)
# Reduce the dimension
self.reduce = nn.Conv1d(self.num_features, self.num_features, kernel_size=2*self.time_window+1)
# Output logits for training mode
self.out = nn.Linear(self.num_features, self.out_channels)
def upsample(self, x, input_len):
# Compute padding to compromise the downsample loss
left_over = input_len % self.dr
if left_over % 2 == 0:
left_pad = left_over // 2
right_pad = left_pad
else:
left_pad = left_over // 2
right_pad = left_over // 2 + 1
x = self.tile_representations(x)
# padding
x = x.permute(0, 2, 1).contiguous() # (B, T, D) -> (B, D, T)
padding = nn.ReplicationPad1d((left_pad, right_pad))
x = padding(x)
x = x.permute(0, 2, 1).contiguous() # (B, D, T) -> (B, T, D)
return x
def __init__(self, flows, n_group, sr, window_size, n_mels, use_conv1x1,
memory_efficient, **kwargs):
super().__init__()
self.flows = flows
self.n_group = n_group
self.win_size = window_size
self.hop_size = 256
self.n_mels = n_mels
self.sr = sr
self.sub_sr = self.hop_size // n_group
self.upsampler = nn.Sequential(
nn.ReplicationPad1d((0, 1)),
nn.ConvTranspose1d(n_mels,
n_mels,
self.sub_sr * 2 + 1,
self.sub_sr,
padding=self.sub_sr), nn.LeakyReLU(0.4, True))
self.upsampler.apply(add_weight_norms)
self.WNs = nn.ModuleList()
if use_conv1x1:
self.invconv1x1 = nn.ModuleList()
# Set up layers with the right sizes based on how many dimensions
# have been output already
for k in range(flows):
self.WNs.append(WN2D(n_group, n_mels, **kwargs))
if use_conv1x1:
self.invconv1x1.append(
InvertibleConv1x1(n_group,
memory_efficient=memory_efficient))
self.mel = nn.Sequential(
nn.ReflectionPad1d((window_size // 2 - self.hop_size // 2,
window_size // 2 + self.hop_size // 2)),
MelSpectrogram(sr,
window_size,
n_mels,
self.hop_size,
center=False,
fmax=8000))
def __init__(self, input_dim, output_dim, kernel_size):
"""Construct a convolution layer with the specified sizes
Arguments:
input_dim {int} -- the dimension of the input
output_dim {int} -- the dimension of the ouput
kernel_size {[type]} -- the size of the filters. With a kernel_size of k, the filter will look at the (k - 1) / 2
previous and next rows to compute the current one
"""
super().__init__()
self.input_dim = input_dim
self.output_dim = output_dim
# the size of the kernel must be odd
assert kernel_size % 2 == 1
self.padder = nn.ReplicationPad1d(kernel_size // 2)
self.conv = nn.Conv1d(input_dim, output_dim, kernel_size)
def __init__(self, input_dim, output_dim, kernel_size):
"""Construct a convolution layer with the specified sizes
Arguments:
input_dim {int} -- the dimension of the input
output_dim {int} -- the dimension of the ouput
kernel_size {[type]} -- the size of the filters. With a kernel_size of k, the filter will generate values for the (k - 1) / 2
previous and next rows as well as the current one.
"""
super().__init__()
self.input_dim = input_dim
self.output_dim = output_dim
self.kernel_size = kernel_size
# the size of the kernel must be odd
assert kernel_size % 2 == 1
self.padder = nn.ReplicationPad1d(kernel_size // 2)
self.conv = nn.ConvTranspose1d(input_dim, output_dim, kernel_size)
def __init__(self, nf0, per_feature, grid_dim):
super().__init__()
in_channels = nf0
if per_feature:
weights_channels = nf0
else:
weights_channels = 1
self.new_integration_octree = nn.Sequential(
nn.ReplicationPad1d(1),
nn.Conv1d(in_channels, nf0, kernel_size=3, padding=0, bias=True)
)
self.old_integration_octree = nn.Sequential(
nn.ReplicationPad1d(1),
nn.Conv1d(in_channels, nf0, kernel_size=3, padding=0, bias=False)
)
self.update_old_net_octree = nn.Sequential(
nn.ReplicationPad1d(1),
nn.Conv1d(in_channels, weights_channels, kernel_size=3, padding=0, bias=True)
)
self.update_new_net_octree = nn.Sequential(
nn.ReplicationPad1d(1),
nn.Conv1d(in_channels, weights_channels, kernel_size=3, padding=0, bias=False)
)
self.reset_old_net = nn.Sequential(
nn.ReplicationPad1d(1),
nn.Conv1d(in_channels, weights_channels, kernel_size=3, padding=0, bias=True)
)
self.reset_new_net = nn.Sequential(
nn.ReplicationPad1d(1),
nn.Conv1d(in_channels, weights_channels, kernel_size=3, padding=0, bias=False),
)
self.sigmoid = nn.Sigmoid()
self.relu = nn.ReLU()
coord_conv_volume = np.mgrid[-grid_dim // 2:grid_dim // 2,
-grid_dim // 2:grid_dim // 2,
-grid_dim // 2:grid_dim // 2]
coord_conv_volume = np.stack(coord_conv_volume, axis=0).astype(np.float32)
coord_conv_volume = coord_conv_volume / grid_dim
self.coord_conv_volume = torch.Tensor(coord_conv_volume).float().cuda()[None, :, :, :, :]
self.counter = 0
def __init__(self):
super(Generator, self).__init__()
self.pad = nn.ReplicationPad1d((14, 0))
self.conv_first = nn.Conv1d(in_channels=24,
out_channels=128,
kernel_size=15,
stride=1)
self.conv_first_gate = nn.Conv1d(in_channels=24,
out_channels=128,
kernel_size=15,
stride=1)
self.down_sample1 = G_Downsample(128, 256)
self.down_sample2 = G_Downsample(256, 256)
self.res_block = Res6block()
self.up_sample1 = G_Upsample(256, 512)
self.up_sample2 = G_Upsample(256, 256)
self.conv_last = nn.Conv1d(in_channels=128,
out_channels=24,
kernel_size=15,
stride=1)
def __init__(self, ndf, n_layers, downsampling_factor):
super().__init__()
model = nn.ModuleDict()
model["layer_0"] = nn.Sequential(
nn.ReplicationPad1d(7),
WNConv1d(1, ndf, kernel_size=15),
nn.LeakyReLU(0.2, True),
)
nf = ndf
stride = downsampling_factor
for n in range(1, n_layers + 1):
nf_prev = nf
nf = min(nf * stride, 1024)
model["layer_%d" % n] = nn.Sequential(
WNConv1d(
nf_prev,
nf,
kernel_size=stride * 10 + 1,
stride=stride,
padding=stride * 5,
groups=nf_prev // 4,
),
nn.LeakyReLU(0.2, True),
)
nf = min(nf * 2, 1024)
model["layer_%d" % (n_layers + 1)] = nn.Sequential(
WNConv1d(nf_prev, nf, kernel_size=5, stride=1, padding=2),
nn.LeakyReLU(0.2, True),
)
model["layer_%d" % (n_layers + 2)] = WNConv1d(nf,
1,
kernel_size=3,
stride=1,
padding=1)
self.model = model
def Gaussin_smooth(x):
'''
x: N * timestep * 4
'''
# Create gaussian kernels
win_size = 5
std = 1
box_dim = 4
x_mask = x > 0
x_mask_neg = 1 - x_mask.float()
x = x * x_mask.float()
obj_num, ftr_dim = x.shape
time_step = int(ftr_dim / box_dim)
x_trans = x.view(obj_num, time_step, box_dim).permute(0, 2, 1)
pad_size = int((win_size - 1) / 2)
filter_param = signal.gaussian(win_size, std)
filter_param = filter_param / np.sum(filter_param)
kernel = torch.tensor(filter_param, dtype=x.dtype, device=x.device)
pad_fun = nn.ReplicationPad1d(pad_size)
x_trans_pad = pad_fun(x_trans)
# Apply smoothing
x_smooth_trans = F.conv1d(x_trans_pad.contiguous().view(
-1, 1, time_step + pad_size * 2),
kernel.unsqueeze(0).unsqueeze(0),
padding=0)
x_smooth_trans = x_smooth_trans.view(obj_num, box_dim, time_step)
x_smooth = x_smooth_trans.permute(0, 2, 1)
x_smooth = x_smooth.contiguous().view(obj_num, ftr_dim)
# remask
x_smooth = x_smooth * x_mask.float()
x_smooth += x_mask_neg.float() * (-1)
#pdb.set_trace()
return x_smooth.squeeze()
def __init__(self):
super(NNPaddingModule, self).__init__()
self.input1d = torch.randn(1, 4, 50)
self.module1d = nn.ModuleList([
nn.ReflectionPad1d(2),
nn.ReplicationPad1d(2),
nn.ConstantPad1d(2, 3.5),
])
self.input2d = torch.randn(1, 4, 30, 10)
self.module2d = nn.ModuleList([
nn.ReflectionPad2d(2),
nn.ReplicationPad2d(2),
nn.ZeroPad2d(2),
nn.ConstantPad2d(2, 3.5),
])
self.input3d = torch.randn(1, 4, 10, 4, 4)
self.module3d = nn.ModuleList([
nn.ReflectionPad3d(1),
nn.ReplicationPad3d(3),
nn.ConstantPad3d(3, 3.5),
])
def __init__(self):
super(Model, self).__init__()
self.pad_0 = nn.ReplicationPad1d(2)
self.pad_1 = nn.ReplicationPad1d(padding=(3,4))
self.pad_2 = nn.ReplicationPad1d(padding=(1,0))
def __init__(self,
input_dim,
output_dim,
kernel_size,
stride,
padding=0,
norm='none',
activation='relu',
pad_type='zero'):
super(Conv1dBlock, self).__init__()
self.use_bias = True
# initialize padding
if pad_type == 'reflect':
self.pad = nn.ReflectionPad1d(padding)
elif pad_type == 'replicate':
self.pad = nn.ReplicationPad1d(padding)
elif pad_type == 'zero':
self.pad = None # just using default function
elif pad_type == 'none':
self.pad = None
else:
assert 0, "Unsupported padding type: {}".format(pad_type)
# initialize normalization
norm_dim = output_dim
if norm == 'bn':
self.norm = nn.BatchNorm1d(norm_dim)
elif norm == 'in':
self.norm = nn.InstanceNorm1d(norm_dim)
elif norm == 'ln':
self.norm = nn.LayerNorm(norm_dim)
elif norm == 'none':
self.norm = None
else:
assert 0, "Unsupported normalization: {}".format(norm)
# initialize activation
if activation == 'relu':
self.activation = nn.ReLU(inplace=True)
elif activation == 'lrelu':
self.activation = nn.LeakyReLU(0.2, inplace=True)
elif activation == 'prelu':
self.activation = nn.PReLU()
elif activation == 'selu':
self.activation = nn.SELU(inplace=True)
elif activation == 'tanh':
self.activation = nn.Tanh()
elif activation == 'none':
self.activation = None
else:
assert 0, "Unsupported activation: {}".format(activation)
# initialize convolution
if pad_type == 'zero':
self.conv = nn.Conv1d(input_dim,
output_dim,
kernel_size,
stride,
padding,
bias=self.use_bias)
else:
self.conv = nn.Conv1d(input_dim,
output_dim,
kernel_size,
stride,
bias=self.use_bias)
def __init__(self, args, in_planes, splitting=True, dropout=0.5,
simple_lifting=False):
super(Interactor, self).__init__()
self.modified = args.INN
kernel_size = args.kernel
dilation = args.dilation
self.dropout = args.dropout
pad = dilation * (kernel_size - 1) // 2 + 1 # 2 1 0 0
# pad = k_size // 2
self.splitting = splitting
self.split = Splitting()
# Dynamic build sequential network
modules_P = []
modules_U = []
modules_psi = []
modules_phi = []
prev_size = 1
# HARD CODED Architecture
if simple_lifting:
modules_P += [
nn.ReplicationPad1d(pad),
nn.Conv2d(in_planes, in_planes,
kernel_size=kernel_size, stride=1),
nn.Dropout(self.dropout),
nn.Tanh()
]
modules_U += [
nn.ReplicationPad1d(pad),
nn.Conv2d(in_planes, in_planes,
kernel_size=kernel_size, stride=1),
nn.Dropout(self.dropout),
nn.Tanh()
]
else:
size_hidden = args.hidden_size
modules_P += [
nn.ReplicationPad1d(pad),
nn.Conv1d(in_planes * prev_size, int(in_planes * size_hidden),
kernel_size=kernel_size, dilation=dilation, stride=1, groups= args.groups),
nn.LeakyReLU(negative_slope=0.01, inplace=True),
nn.Dropout(self.dropout),
nn.Conv1d(int(in_planes * size_hidden), in_planes,
kernel_size=3, stride=1, groups= args.groups),
nn.Tanh()
]
modules_U += [
nn.ReplicationPad1d(pad),
nn.Conv1d(in_planes * prev_size, int(in_planes * size_hidden),
kernel_size=kernel_size, dilation=dilation, stride=1, groups= args.groups),
nn.LeakyReLU(negative_slope=0.01, inplace=True),
nn.Dropout(self.dropout),
nn.Conv1d(int(in_planes * size_hidden), in_planes,
kernel_size=3, stride=1, groups= args.groups),
nn.Tanh()
]
if self.modified:
modules_phi += [
nn.ReplicationPad1d(pad),
nn.Conv1d(in_planes * prev_size, int(in_planes * size_hidden),
kernel_size=kernel_size, dilation=dilation, stride=1, groups= args.groups),
nn.LeakyReLU(negative_slope=0.01, inplace=True),
nn.Dropout(self.dropout),
nn.Conv1d(int(in_planes * size_hidden), in_planes,
kernel_size=3, stride=1, groups= args.groups),
nn.Tanh()
]
modules_psi += [
nn.ReplicationPad1d(pad),
nn.Conv1d(in_planes * prev_size, int(in_planes * size_hidden),
kernel_size=kernel_size, dilation=dilation, stride=1, groups= args.groups),
nn.LeakyReLU(negative_slope=0.01, inplace=True),
nn.Dropout(self.dropout),
nn.Conv1d(int(in_planes * size_hidden), in_planes,
kernel_size=3, stride=1, groups= args.groups),
nn.Tanh()
]
self.phi = nn.Sequential(*modules_phi)
self.psi = nn.Sequential(*modules_psi)
self.P = nn.Sequential(*modules_P)
self.U = nn.Sequential(*modules_U)
def __init__(self,
in_planes,
modified=False,
size=[],
splitting=True,
k_size=4,
dropout=0.5,
simple_lifting=False):
super(LiftingScheme, self).__init__()
self.modified = modified
kernel_size = k_size
pad = k_size // 2 # 2 1 0 0
self.splitting = splitting
self.split = Splitting()
# Dynamic build sequential network
modules_P = []
modules_U = []
modules_psi = []
modules_phi = []
prev_size = 1
# HARD CODED Architecture
if simple_lifting:
modules_P += [
nn.ReflectionPad2d(pad),
nn.Conv2d(in_planes,
in_planes,
kernel_size=kernel_size,
stride=1),
nn.Tanh()
]
modules_U += [
nn.ReflectionPad2d(pad),
nn.Conv2d(in_planes,
in_planes,
kernel_size=kernel_size,
stride=1),
nn.Tanh()
]
else:
size_hidden = 4 # Todo: extend
modules_P += [
nn.ReflectionPad1d(pad),
# nn.ReplicationPad1d(pad),
nn.Conv1d(
in_planes * prev_size,
in_planes * size_hidden, #3-6
kernel_size=kernel_size,
stride=1),
# Todo: BN
nn.ReLU(),
# nn.BatchNorm1d(in_planes * size_hidden, momentum=0.1),
# nn.LeakyReLU(negative_slope=0.01, inplace=True),
nn.Dropout(dropout), # Todo: change value
]
modules_U += [
nn.ReplicationPad1d(pad),
# nn.ReplicationPad1d(pad),
nn.Conv1d(in_planes * prev_size,
in_planes * size_hidden,
kernel_size=kernel_size,
stride=1),
nn.ReLU(), # Todo: leakyrelu 0.1
# nn.BatchNorm1d(in_planes * size_hidden, momentum=0.1),
# nn.LeakyReLU(negative_slope=0.01, inplace=True),
nn.Dropout(dropout),
]
prev_size = size_hidden
# Final dense
modules_P += [
nn.Conv1d(in_planes * prev_size,
in_planes,
kernel_size=2,
stride=1),
nn.Tanh(), # Todo: leakyrelu 0.1
# nn.BatchNorm1d(in_planes , momentum=0.1),
# nn.LeakyReLU(negative_slope=0.01, inplace=True),
nn.Dropout(dropout),
]
modules_U += [
nn.Conv1d(
in_planes * prev_size,
in_planes, #6-3
kernel_size=2,
stride=1),
nn.Tanh(),
# nn.BatchNorm1d(in_planes, momentum=0.1),
# nn.LeakyReLU(negative_slope=0.01, inplace=True),
nn.Dropout(dropout),
]
modules_phi += [
nn.ReplicationPad1d(pad),
nn.Conv1d(in_planes,
in_planes,
kernel_size=kernel_size,
stride=1),
nn.Conv1d(in_planes, in_planes, kernel_size=2, stride=1),
nn.Tanh()
]
modules_psi += [
nn.ReplicationPad1d(pad),
nn.Conv1d(in_planes,
in_planes,
kernel_size=kernel_size,
stride=1),
nn.Conv1d(in_planes, in_planes, kernel_size=2, stride=1),
nn.Tanh()
]
self.P = nn.Sequential(*modules_P)
self.U = nn.Sequential(*modules_U)
self.phi = nn.Sequential(*modules_phi)
self.psi = nn.Sequential(*modules_psi)
