| import matplotlib
|
| import torch
|
| from matplotlib import pyplot as plt
|
|
|
| matplotlib.use("Agg")
|
|
|
|
|
| def convert_pad_shape(pad_shape):
|
| l = pad_shape[::-1]
|
| pad_shape = [item for sublist in l for item in sublist]
|
| return pad_shape
|
|
|
|
|
| def sequence_mask(length, max_length=None):
|
| if max_length is None:
|
| max_length = length.max()
|
| x = torch.arange(max_length, dtype=length.dtype, device=length.device)
|
| return x.unsqueeze(0) < length.unsqueeze(1)
|
|
|
|
|
| def init_weights(m, mean=0.0, std=0.01):
|
| classname = m.__class__.__name__
|
| if classname.find("Conv") != -1:
|
| m.weight.data.normal_(mean, std)
|
|
|
|
|
| def get_padding(kernel_size, dilation=1):
|
| return int((kernel_size * dilation - dilation) / 2)
|
|
|
|
|
| def plot_mel(data, titles=None):
|
| fig, axes = plt.subplots(len(data), 1, squeeze=False)
|
|
|
| if titles is None:
|
| titles = [None for i in range(len(data))]
|
|
|
| plt.tight_layout()
|
|
|
| for i in range(len(data)):
|
| mel = data[i]
|
|
|
| if isinstance(mel, torch.Tensor):
|
| mel = mel.float().detach().cpu().numpy()
|
|
|
| axes[i][0].imshow(mel, origin="lower")
|
| axes[i][0].set_aspect(2.5, adjustable="box")
|
| axes[i][0].set_ylim(0, mel.shape[0])
|
| axes[i][0].set_title(titles[i], fontsize="medium")
|
| axes[i][0].tick_params(labelsize="x-small", left=False, labelleft=False)
|
| axes[i][0].set_anchor("W")
|
|
|
| return fig
|
|
|
|
|
| def slice_segments(x, ids_str, segment_size=4):
|
| ret = torch.zeros_like(x[:, :, :segment_size])
|
| for i in range(x.size(0)):
|
| idx_str = ids_str[i]
|
| idx_end = idx_str + segment_size
|
| ret[i] = x[i, :, idx_str:idx_end]
|
|
|
| return ret
|
|
|
|
|
| def rand_slice_segments(x, x_lengths=None, segment_size=4):
|
| b, d, t = x.size()
|
| if x_lengths is None:
|
| x_lengths = t
|
| ids_str_max = torch.clamp(x_lengths - segment_size + 1, min=0)
|
| ids_str = (torch.rand([b], device=x.device) * ids_str_max).to(dtype=torch.long)
|
| ret = slice_segments(x, ids_str, segment_size)
|
| return ret, ids_str
|
|
|
|
|
| @torch.jit.script
|
| def fused_add_tanh_sigmoid_multiply(in_act, n_channels):
|
| n_channels_int = n_channels[0]
|
| t_act = torch.tanh(in_act[:, :n_channels_int, :])
|
| s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
|
| acts = t_act * s_act
|
|
|
| return acts
|
|
|
|
|
| def avg_with_mask(x, mask):
|
| assert mask.dtype == torch.float, "Mask should be float"
|
|
|
| if mask.ndim == 2:
|
| mask = mask.unsqueeze(1)
|
|
|
| if mask.shape[1] == 1:
|
| mask = mask.expand_as(x)
|
|
|
| return (x * mask).sum() / mask.sum()
|
|
|
