Python torch.nn.functional.conv_transpose1d() Examples
The following are 16
code examples of torch.nn.functional.conv_transpose1d().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
torch.nn.functional
, or try the search function
.
![](https://www.programcreek.com/common/static/images/search.png)
Example #1
Source File: quaternion_ops.py From Pytorch-Quaternion-Neural-Networks with GNU General Public License v3.0 | 6 votes |
def quaternion_transpose_conv(input, r_weight, i_weight, j_weight, k_weight, bias, stride, padding, output_padding, groups, dilatation): """ Applies a quaternion trasposed convolution to the incoming data: """ cat_kernels_4_r = torch.cat([r_weight, -i_weight, -j_weight, -k_weight], dim=1) cat_kernels_4_i = torch.cat([i_weight, r_weight, -k_weight, j_weight], dim=1) cat_kernels_4_j = torch.cat([j_weight, k_weight, r_weight, -i_weight], dim=1) cat_kernels_4_k = torch.cat([k_weight, -j_weight, i_weight, r_weight], dim=1) cat_kernels_4_quaternion = torch.cat([cat_kernels_4_r, cat_kernels_4_i, cat_kernels_4_j, cat_kernels_4_k], dim=0) if input.dim() == 3: convfunc = F.conv_transpose1d elif input.dim() == 4: convfunc = F.conv_transpose2d elif input.dim() == 5: convfunc = F.conv_transpose3d else: raise Exception("The convolutional input is either 3, 4 or 5 dimensions." " input.dim = " + str(input.dim())) return convfunc(input, cat_kernels_4_quaternion, bias, stride, padding, output_padding, groups, dilatation)
Example #2
Source File: modules.py From source_separation with Apache License 2.0 | 6 votes |
def forward(self, x, output_size=None): """ Implemented complex transposed convolution using combining 'grouped convolution' and 'real / img weight' :param x: data (N, C, T) C is concatenated with C/2 real channels and C/2 idea channels :return: complex transposed convolution result """ # forward real if self.padding: x = F.pad(x, (self.padding, self.padding), 'reflect') real_part = F.conv_transpose1d(x, self.A, None, stride=self.stride, padding=0, dilation=self.dilation, groups=2) # forward idea spl = self.out_channels // 2 weight_B = torch.cat([self.B[:spl] * (-1), self.B[spl:]]) idea_part = F.conv_transpose1d(x, weight_B, None, stride=self.stride, padding=0, dilation=self.dilation, groups=2) if self.output_padding: real_part = F.pad(real_part, (self.output_padding, self.output_padding), 'reflect') idea_part = F.pad(idea_part, (self.output_padding, self.output_padding), 'reflect') return real_part + idea_part
Example #3
Source File: quaternion_ops.py From Quaternion-Recurrent-Neural-Networks with GNU General Public License v3.0 | 6 votes |
def quaternion_transpose_conv(input, r_weight, i_weight, j_weight, k_weight, bias, stride, padding, output_padding, groups, dilatation): """ Applies a quaternion trasposed convolution to the incoming data: """ cat_kernels_4_r = torch.cat([r_weight, -i_weight, -j_weight, -k_weight], dim=1) cat_kernels_4_i = torch.cat([i_weight, r_weight, -k_weight, j_weight], dim=1) cat_kernels_4_j = torch.cat([j_weight, k_weight, r_weight, -i_weight], dim=1) cat_kernels_4_k = torch.cat([k_weight, -j_weight, i_weight, r_weight], dim=1) cat_kernels_4_quaternion = torch.cat([cat_kernels_4_r, cat_kernels_4_i, cat_kernels_4_j, cat_kernels_4_k], dim=0) if input.dim() == 3: convfunc = F.conv_transpose1d elif input.dim() == 4: convfunc = F.conv_transpose2d elif input.dim() == 5: convfunc = F.conv_transpose3d else: raise Exception("The convolutional input is either 3, 4 or 5 dimensions." " input.dim = " + str(input.dim())) return convfunc(input, cat_kernels_4_quaternion, bias, stride, padding, output_padding, groups, dilatation)
Example #4
Source File: waveunet_utils.py From Wave-U-Net-Pytorch with MIT License | 6 votes |
def forward(self, x): # Pad here if not using transposed conv input_size = x.shape[2] if self.padding != "valid": num_pad = (self.kernel_size-1)//2 out = F.pad(x, (num_pad, num_pad), mode=self.padding) else: out = x # Lowpass filter (+ 0 insertion if transposed) if self.transpose: expected_steps = ((input_size - 1) * self.stride + 1) if self.padding == "valid": expected_steps = expected_steps - self.kernel_size + 1 out = F.conv_transpose1d(out, self.filter, stride=self.stride, padding=0, groups=self.channels) diff_steps = out.shape[2] - expected_steps if diff_steps > 0: assert(diff_steps % 2 == 0) out = out[:,:,diff_steps//2:-diff_steps//2] else: assert(input_size % self.stride == 1) out = F.conv1d(out, self.filter, stride=self.stride, padding=0, groups=self.channels) return out
Example #5
Source File: stft.py From tn2-wg with BSD 3-Clause "New" or "Revised" License | 5 votes |
def inverse(self, magnitude, phase): recombine_magnitude_phase = torch.cat( [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, Variable(self.inverse_basis, requires_grad=False), stride=self.hop_length, padding=0) if self.window is not None: window_sum = window_sumsquare( self.window, magnitude.size(-1), hop_length=self.hop_length, win_length=self.win_length, n_fft=self.filter_length, dtype=np.float32) # remove modulation effects approx_nonzero_indices = torch.from_numpy( np.where(window_sum > tiny(window_sum))[0]) window_sum = torch.autograd.Variable( torch.from_numpy(window_sum), requires_grad=False) window_sum = window_sum.cuda() if magnitude.is_cuda else window_sum inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length inverse_transform = inverse_transform[:, :, int(self.filter_length/2):] inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):] return inverse_transform
Example #6
Source File: modules.py From TTS-Cube with Apache License 2.0 | 5 votes |
def inverse(self, magnitude, phase): recombine_magnitude_phase = torch.cat([magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d(recombine_magnitude_phase, self.inverse_basis, stride=self.hop_length, padding=0) inverse_transform = inverse_transform[:, :, self.filter_length:] inverse_transform = inverse_transform[:, :, :self.num_samples] return inverse_transform
Example #7
Source File: stft.py From TTS-Cube with Apache License 2.0 | 5 votes |
def inverse(self, magnitude, phase): recombine_magnitude_phase = torch.cat( [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, Variable(self.inverse_basis, requires_grad=False), stride=self.hop_length, padding=0) if self.window is not None: window_sum = self._window_sumsquare( self.window, magnitude.size(-1), hop_length=self.hop_length, win_length=self.win_length, n_fft=self.filter_length, dtype=np.float32) # remove modulation effects approx_nonzero_indices = torch.from_numpy( np.where(window_sum > tiny(window_sum))[0]) window_sum = torch.autograd.Variable( torch.from_numpy(window_sum), requires_grad=False).cuda() inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length inverse_transform = inverse_transform[:, :, int(self.filter_length/2):] inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):] return inverse_transform
Example #8
Source File: modules.py From ddsp_pytorch with GNU General Public License v3.0 | 5 votes |
def forward(self, input): weight = self.window * self.conv_tr.weight return F.conv_transpose1d(input, weight, bias=self.conv_tr.bias, stride=self.conv_tr.stride, padding=self.conv_tr.padding, output_padding=self.conv_tr.output_padding, groups=self.conv_tr.groups, dilation=self.conv_tr.dilation)
Example #9
Source File: stft.py From LightSpeech with MIT License | 5 votes |
def inverse(self, magnitude, phase): recombine_magnitude_phase = torch.cat( [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, Variable(self.inverse_basis, requires_grad=False), stride=self.hop_length, padding=0) if self.window is not None: window_sum = window_sumsquare( self.window, magnitude.size(-1), hop_length=self.hop_length, win_length=self.win_length, n_fft=self.filter_length, dtype=np.float32) # remove modulation effects approx_nonzero_indices = torch.from_numpy( np.where(window_sum > tiny(window_sum))[0]) window_sum = torch.autograd.Variable( torch.from_numpy(window_sum), requires_grad=False) window_sum = window_sum.cuda() if magnitude.is_cuda else window_sum inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length inverse_transform = inverse_transform[:, :, int(self.filter_length/2):] inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):] return inverse_transform
Example #10
Source File: stft.py From melgan with BSD 3-Clause "New" or "Revised" License | 5 votes |
def inverse(self, magnitude, phase): recombine_magnitude_phase = torch.cat( [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, Variable(self.inverse_basis, requires_grad=False), stride=self.hop_length, padding=0) if self.window is not None: window_sum = window_sumsquare( self.window, magnitude.size(-1), hop_length=self.hop_length, win_length=self.win_length, n_fft=self.filter_length, dtype=np.float32) # remove modulation effects approx_nonzero_indices = torch.from_numpy( np.where(window_sum > tiny(window_sum))[0]) window_sum = torch.autograd.Variable( torch.from_numpy(window_sum), requires_grad=False) window_sum = window_sum.cuda() if magnitude.is_cuda else window_sum inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length inverse_transform = inverse_transform[:, :, int(self.filter_length/2):] inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):] return inverse_transform
Example #11
Source File: stft.py From FastSpeech with MIT License | 5 votes |
def inverse(self, magnitude, phase): recombine_magnitude_phase = torch.cat( [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, Variable(self.inverse_basis, requires_grad=False), stride=self.hop_length, padding=0) if self.window is not None: window_sum = window_sumsquare( self.window, magnitude.size(-1), hop_length=self.hop_length, win_length=self.win_length, n_fft=self.filter_length, dtype=np.float32) # remove modulation effects approx_nonzero_indices = torch.from_numpy( np.where(window_sum > tiny(window_sum))[0]) window_sum = torch.autograd.Variable( torch.from_numpy(window_sum), requires_grad=False) window_sum = window_sum.cuda() if magnitude.is_cuda else window_sum inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length inverse_transform = inverse_transform[:, :, int(self.filter_length/2):] inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):] return inverse_transform
Example #12
Source File: stft.py From fac-via-ppg with Apache License 2.0 | 5 votes |
def inverse(self, magnitude, phase): recombine_magnitude_phase = torch.cat( [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, Variable(self.inverse_basis, requires_grad=False), stride=self.hop_length, padding=0) if self.window is not None: window_sum = window_sumsquare( self.window, magnitude.size(-1), hop_length=self.hop_length, win_length=self.win_length, n_fft=self.filter_length, dtype=np.float32) # remove modulation effects approx_nonzero_indices = torch.from_numpy( np.where(window_sum > tiny(window_sum))[0]) window_sum = torch.autograd.Variable( torch.from_numpy(window_sum), requires_grad=False) inverse_transform[:, :, approx_nonzero_indices] /= window_sum[ approx_nonzero_indices].cuda() # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length inverse_transform = inverse_transform[:, :, int(self.filter_length/2):] inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):] return inverse_transform
Example #13
Source File: test_pyprof_nvtx.py From apex with BSD 3-Clause "New" or "Revised" License | 5 votes |
def test_conv_transpose1d(self): # Data and weight tensors conv_transpose1d_tensor = torch.randn(64, 16, 64, device='cuda', dtype=self.dtype) conv_transpose1d_filter = torch.randn(16, 32, 3, device='cuda', dtype=self.dtype) conv_transpose1d_bias = torch.randn(32, device='cuda', dtype=self.dtype) # Conv transpose runs conv_transpose1d_out = F.conv_transpose1d(conv_transpose1d_tensor, conv_transpose1d_filter) conv_transpose1d_out_biased = F.conv_transpose1d(conv_transpose1d_tensor, conv_transpose1d_filter, bias=conv_transpose1d_bias) conv_transpose1d_out_strided = F.conv_transpose1d(conv_transpose1d_tensor, conv_transpose1d_filter, stride=2) conv_transpose1d_out_padded = F.conv_transpose1d(conv_transpose1d_tensor, conv_transpose1d_filter, padding=3) conv_transpose1d_out2_padded = F.conv_transpose1d(conv_transpose1d_tensor, conv_transpose1d_filter, output_padding=2, dilation=3) conv_transpose1d_out_grouped = F.conv_transpose1d(conv_transpose1d_tensor, conv_transpose1d_filter, groups=2) conv_transpose1d_out_dilated = F.conv_transpose1d(conv_transpose1d_tensor, conv_transpose1d_filter, dilation=2)
Example #14
Source File: stft.py From Tacotron2-Mandarin with MIT License | 5 votes |
def inverse(self, magnitude, phase): recombine_magnitude_phase = torch.cat( [magnitude * torch.cos(phase), magnitude * torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, Variable(self.inverse_basis, requires_grad=False), stride=self.hop_length, padding=0) if self.window is not None: window_sum = window_sumsquare( self.window, magnitude.size(-1), hop_length=self.hop_length, win_length=self.win_length, n_fft=self.filter_length, dtype=np.float32) # remove modulation effects approx_nonzero_indices = torch.from_numpy( np.where(window_sum > tiny(window_sum))[0]) window_sum = torch.autograd.Variable( torch.from_numpy(window_sum), requires_grad=False) window_sum = window_sum.cuda() if magnitude.is_cuda else window_sum inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length inverse_transform = inverse_transform[:, :, int(self.filter_length / 2):] inverse_transform = inverse_transform[:, :, :-int(self.filter_length / 2):] return inverse_transform
Example #15
Source File: enc_dec.py From asteroid with MIT License | 5 votes |
def forward(self, spec): """ Applies transposed convolution to a TF representation. This is equivalent to overlap-add. Args: spec (:class:`torch.Tensor`): 3D or 4D Tensor. The TF representation. (Output of :func:`Encoder.forward`). Returns: :class:`torch.Tensor`: The corresponding time domain signal. """ filters = self.get_filters() if spec.ndim == 2: # Input is (freq, conv_time), output is (time) return F.conv_transpose1d( spec.unsqueeze(0), filters, stride=self.stride, padding=self.padding, output_padding=self.output_padding ).squeeze() if spec.ndim == 3: # Input is (batch, freq, conv_time), output is (batch, 1, time) return F.conv_transpose1d(spec, filters, stride=self.stride, padding=self.padding, output_padding=self.output_padding) elif spec.ndim > 3: # Multiply all the left dimensions together and group them in the # batch. Make the convolution and restore. view_as = (-1,) + spec.shape[-2:] out = F.conv_transpose1d(spec.view(view_as), filters, stride=self.stride, padding=self.padding, output_padding=self.output_padding) return out.view(spec.shape[:-2] + (-1,))
Example #16
Source File: stft.py From torch-stft with BSD 3-Clause "New" or "Revised" License | 4 votes |
def inverse(self, magnitude, phase): """Call the inverse STFT (iSTFT), given magnitude and phase tensors produced by the ```transform``` function. Arguments: magnitude {tensor} -- Magnitude of STFT with shape (num_batch, num_frequencies, num_frames) phase {tensor} -- Phase of STFT with shape (num_batch, num_frequencies, num_frames) Returns: inverse_transform {tensor} -- Reconstructed audio given magnitude and phase. Of shape (num_batch, num_samples) """ recombine_magnitude_phase = torch.cat( [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1) inverse_transform = F.conv_transpose1d( recombine_magnitude_phase, self.inverse_basis, stride=self.hop_length, padding=0) if self.window is not None: window_sum = window_sumsquare( self.window, magnitude.size(-1), hop_length=self.hop_length, win_length=self.win_length, n_fft=self.filter_length, dtype=np.float32) # remove modulation effects approx_nonzero_indices = torch.from_numpy( np.where(window_sum > tiny(window_sum))[0]) window_sum = torch.from_numpy(window_sum).to(inverse_transform.device) inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices] # scale by hop ratio inverse_transform *= float(self.filter_length) / self.hop_length inverse_transform = inverse_transform[..., self.pad_amount:] inverse_transform = inverse_transform[..., :self.num_samples] inverse_transform = inverse_transform.squeeze(1) return inverse_transform