Aloento/9Nine-PITS

1# from https://github.com/jaywalnut310/vits2import numpy as np3import torch4from torch.nn import functional as F5 6DEFAULT_MIN_BIN_WIDTH = 1e-37DEFAULT_MIN_BIN_HEIGHT = 1e-38DEFAULT_MIN_DERIVATIVE = 1e-39 10 11def piecewise_rational_quadratic_transform(12    inputs,13    unnormalized_widths,14    unnormalized_heights,15    unnormalized_derivatives,16    inverse=False,17    tails=None,18    tail_bound=1.,19    min_bin_width=DEFAULT_MIN_BIN_WIDTH,20    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,21    min_derivative=DEFAULT_MIN_DERIVATIVE22):23  if tails is None:24    spline_fn = rational_quadratic_spline25    spline_kwargs = {}26  else:27    spline_fn = unconstrained_rational_quadratic_spline28    spline_kwargs = {29      'tails': tails,30      'tail_bound': tail_bound31    }32 33  outputs, logabsdet = spline_fn(34    inputs=inputs,35    unnormalized_widths=unnormalized_widths,36    unnormalized_heights=unnormalized_heights,37    unnormalized_derivatives=unnormalized_derivatives,38    inverse=inverse,39    min_bin_width=min_bin_width,40    min_bin_height=min_bin_height,41    min_derivative=min_derivative,42    **spline_kwargs43  )44  return outputs, logabsdet45 46 47def searchsorted(bin_locations, inputs, eps=1e-6):48  bin_locations[..., -1] += eps49  return torch.sum(50    inputs[..., None] >= bin_locations,51    dim=-152  ) - 153 54 55def unconstrained_rational_quadratic_spline(56    inputs,57    unnormalized_widths,58    unnormalized_heights,59    unnormalized_derivatives,60    inverse=False,61    tails='linear',62    tail_bound=1.,63    min_bin_width=DEFAULT_MIN_BIN_WIDTH,64    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,65    min_derivative=DEFAULT_MIN_DERIVATIVE66):67  inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)68  outside_interval_mask = ~inside_interval_mask69 70  outputs = torch.zeros_like(inputs)71  logabsdet = torch.zeros_like(inputs)72 73  if tails == 'linear':74    unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))75    constant = np.log(np.exp(1 - min_derivative) - 1)76    unnormalized_derivatives[..., 0] = constant77    unnormalized_derivatives[..., -1] = constant78 79    outputs[outside_interval_mask] = inputs[outside_interval_mask]80    logabsdet[outside_interval_mask] = 081  else:82    raise RuntimeError('{} tails are not implemented.'.format(tails))83 84  outputs[inside_interval_mask], logabsdet[inside_interval_mask] = rational_quadratic_spline(85    inputs=inputs[inside_interval_mask],86    unnormalized_widths=unnormalized_widths[inside_interval_mask, :],87    unnormalized_heights=unnormalized_heights[inside_interval_mask, :],88    unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],89    inverse=inverse,90    left=-tail_bound, right=tail_bound, bottom=-tail_bound, top=tail_bound,91    min_bin_width=min_bin_width,92    min_bin_height=min_bin_height,93    min_derivative=min_derivative94  )95 96  return outputs, logabsdet97 98 99def rational_quadratic_spline(100    inputs,101    unnormalized_widths,102    unnormalized_heights,103    unnormalized_derivatives,104    inverse=False,105    left=0., right=1., bottom=0., top=1.,106    min_bin_width=DEFAULT_MIN_BIN_WIDTH,107    min_bin_height=DEFAULT_MIN_BIN_HEIGHT,108    min_derivative=DEFAULT_MIN_DERIVATIVE109):110  if torch.min(inputs) < left or torch.max(inputs) > right:111    raise ValueError('Input to a transform is not within its domain')112 113  num_bins = unnormalized_widths.shape[-1]114 115  if min_bin_width * num_bins > 1.0:116    raise ValueError('Minimal bin width too large for the number of bins')117  if min_bin_height * num_bins > 1.0:118    raise ValueError('Minimal bin height too large for the number of bins')119 120  widths = F.softmax(unnormalized_widths, dim=-1)121  widths = min_bin_width + (1 - min_bin_width * num_bins) * widths122  cumwidths = torch.cumsum(widths, dim=-1)123  cumwidths = F.pad(cumwidths, pad=(1, 0), mode='constant', value=0.0)124  cumwidths = (right - left) * cumwidths + left125  cumwidths[..., 0] = left126  cumwidths[..., -1] = right127  widths = cumwidths[..., 1:] - cumwidths[..., :-1]128 129  derivatives = min_derivative + F.softplus(unnormalized_derivatives)130 131  heights = F.softmax(unnormalized_heights, dim=-1)132  heights = min_bin_height + (1 - min_bin_height * num_bins) * heights133  cumheights = torch.cumsum(heights, dim=-1)134  cumheights = F.pad(cumheights, pad=(1, 0), mode='constant', value=0.0)135  cumheights = (top - bottom) * cumheights + bottom136  cumheights[..., 0] = bottom137  cumheights[..., -1] = top138  heights = cumheights[..., 1:] - cumheights[..., :-1]139 140  if inverse:141    bin_idx = searchsorted(cumheights, inputs)[..., None]142  else:143    bin_idx = searchsorted(cumwidths, inputs)[..., None]144 145  input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]146  input_bin_widths = widths.gather(-1, bin_idx)[..., 0]147 148  input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]149  delta = heights / widths150  input_delta = delta.gather(-1, bin_idx)[..., 0]151 152  input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]153  input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]154 155  input_heights = heights.gather(-1, bin_idx)[..., 0]156 157  if inverse:158    a = (((inputs - input_cumheights) * (input_derivatives159                                         + input_derivatives_plus_one160                                         - 2 * input_delta)161          + input_heights * (input_delta - input_derivatives)))162    b = (input_heights * input_derivatives163         - (inputs - input_cumheights) * (input_derivatives164                                          + input_derivatives_plus_one165                                          - 2 * input_delta))166    c = - input_delta * (inputs - input_cumheights)167 168    discriminant = b.pow(2) - 4 * a * c169    assert (discriminant >= 0).all()170 171    root = (2 * c) / (-b - torch.sqrt(discriminant))172    outputs = root * input_bin_widths + input_cumwidths173 174    theta_one_minus_theta = root * (1 - root)175    denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)176                                 * theta_one_minus_theta)177    derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * root.pow(2)178                                                 + 2 * input_delta * theta_one_minus_theta179                                                 + input_derivatives * (1 - root).pow(2))180    logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)181 182    return outputs, -logabsdet183  else:184    theta = (inputs - input_cumwidths) / input_bin_widths185    theta_one_minus_theta = theta * (1 - theta)186 187    numerator = input_heights * (input_delta * theta.pow(2)188                                 + input_derivatives * theta_one_minus_theta)189    denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)190                                 * theta_one_minus_theta)191    outputs = input_cumheights + numerator / denominator192 193    derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * theta.pow(2)194                                                 + 2 * input_delta * theta_one_minus_theta195                                                 + input_derivatives * (1 - theta).pow(2))196    logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)197 198    return outputs, logabsdet199