| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| from functools import lru_cache |
| import os |
| import random |
| import traceback |
| from pathlib import Path |
| from typing import Any, Dict, List, Optional, Tuple |
|
|
| import numpy as np |
| import torch |
| from einops import rearrange |
| from scipy import ndimage |
| from torch.special import gammaln |
| from tqdm import tqdm |
|
|
|
|
| def get_abs_rel_paths(input_path: Path, base_path: Path) -> Tuple[Path, Path]: |
| """ |
| Get the absolute and relative paths of input file path. |
| |
| Args: |
| input_path: An absolute or relative path. |
| base_path: base directory the input is relative to. |
| |
| Returns: |
| The absolute and relative paths of the file. |
| """ |
| if os.path.isabs(input_path): |
| abs_path = input_path |
| rel_path = input_path.relative_to(base_path) |
| else: |
| rel_path = input_path |
| abs_path = base_path / rel_path |
|
|
| return abs_path, rel_path |
|
|
|
|
| def get_audio_filepaths(manifest_entry: Dict[str, Any], audio_dir: Path) -> Tuple[Path, Path]: |
| """ |
| Get the absolute and relative paths of audio from a manifest entry. |
| |
| Args: |
| manifest_entry: Manifest entry dictionary. |
| audio_dir: base directory where audio is stored. |
| |
| Returns: |
| The absolute and relative paths of the audio. |
| """ |
| audio_filepath = Path(manifest_entry["audio_filepath"]) |
| audio_filepath_abs, audio_filepath_rel = get_abs_rel_paths(input_path=audio_filepath, base_path=audio_dir) |
| return audio_filepath_abs, audio_filepath_rel |
|
|
|
|
| def normalize_volume(audio: np.array, volume_level: float = 0.95) -> np.array: |
| """Apply peak normalization to the input audio. |
| """ |
| if not (0.0 <= volume_level <= 1.0): |
| raise ValueError(f"Volume must be in range [0.0, 1.0], received {volume_level}") |
|
|
| if audio.size == 0: |
| return audio |
|
|
| max_sample = np.max(np.abs(audio)) |
| if max_sample == 0: |
| return audio |
|
|
| return volume_level * (audio / np.max(np.abs(audio))) |
|
|
|
|
| class BetaBinomialInterpolator: |
| """ |
| This module calculates alignment prior matrices (based on beta-binomial distribution) using cached popular sizes and image interpolation. |
| The implementation is taken from https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/SpeechSynthesis/FastPitch/fastpitch/data_function.py |
| """ |
|
|
| def __init__(self, round_mel_len_to=50, round_text_len_to=10, cache_size=500): |
| self.round_mel_len_to = round_mel_len_to |
| self.round_text_len_to = round_text_len_to |
|
|
| @staticmethod |
| def round(val, to): |
| return max(1, int(np.round((val + 1) / to))) * to |
|
|
| def __call__(self, w, h): |
| bw = BetaBinomialInterpolator.round(w, to=self.round_mel_len_to) |
| bh = BetaBinomialInterpolator.round(h, to=self.round_text_len_to) |
| ret = ndimage.zoom(beta_binomial_prior_distribution(bw, bh).T, zoom=(w / bw, h / bh), order=1) |
| assert ret.shape[0] == w, ret.shape |
| assert ret.shape[1] == h, ret.shape |
| return ret |
|
|
|
|
| def general_padding(item, item_len, max_len, pad_value=0): |
| if item_len < max_len: |
| item = torch.nn.functional.pad(item, (0, max_len - item_len), value=pad_value) |
| return item |
|
|
|
|
| def stack_tensors(tensors: List[torch.Tensor], max_lens: List[int], pad_value: float = 0.0) -> torch.Tensor: |
| """ |
| Create batch by stacking input tensor list along the time axes. |
| |
| Args: |
| tensors: List of tensors to pad and stack |
| max_lens: List of lengths to pad each axis to, starting with the last axis |
| pad_value: Value for padding |
| |
| Returns: |
| Padded and stacked tensor. |
| """ |
| padded_tensors = [] |
| for tensor in tensors: |
| padding = [] |
| for i, max_len in enumerate(max_lens, 1): |
| padding += [0, max_len - tensor.shape[-i]] |
|
|
| padded_tensor = torch.nn.functional.pad(tensor, pad=padding, value=pad_value) |
| padded_tensors.append(padded_tensor) |
|
|
| stacked_tensor = torch.stack(padded_tensors) |
| return stacked_tensor |
|
|
|
|
| def logbeta(x, y): |
| return gammaln(x) + gammaln(y) - gammaln(x + y) |
|
|
|
|
| def logcombinations(n, k): |
| return gammaln(n + 1) - gammaln(k + 1) - gammaln(n - k + 1) |
|
|
|
|
| def logbetabinom(n, a, b, x): |
| return logcombinations(n, x) + logbeta(x + a, n - x + b) - logbeta(a, b) |
|
|
| def beta_binomial_prior_distribution(phoneme_count: int, mel_count: int, scaling_factor: float = 1.0) -> np.array: |
| x = rearrange(torch.arange(0, phoneme_count), "b -> 1 b") |
| y = rearrange(torch.arange(1, mel_count + 1), "b -> b 1") |
| a = scaling_factor * y |
| b = scaling_factor * (mel_count + 1 - y) |
| n = torch.FloatTensor([phoneme_count - 1]) |
|
|
| return logbetabinom(n, a, b, x).exp().numpy() |
|
|
|
|
| def get_base_dir(paths): |
| def is_relative_to(path1, path2): |
| try: |
| path1.relative_to(path2) |
| return True |
| except ValueError: |
| return False |
|
|
| def common_path(path1, path2): |
| while path1 is not None: |
| if is_relative_to(path2, path1): |
| return path1 |
| path1 = path1.parent if path1 != path1.parent else None |
| return None |
|
|
| base_dir = None |
| for p in paths: |
| audio_dir = Path(p).parent |
| if base_dir is None: |
| base_dir = audio_dir |
| continue |
| base_dir = common_path(base_dir, audio_dir) |
|
|
| return base_dir |
|
|
|
|
| def filter_dataset_by_duration(entries: List[Dict[str, Any]], min_duration: float, max_duration: float): |
| """ |
| Filter out manifest entries based on duration. |
| |
| Args: |
| entries: List of manifest entry dictionaries. |
| min_duration: Minimum duration below which entries are removed. |
| max_duration: Maximum duration above which entries are removed. |
| |
| Returns: |
| filtered_entries: List of manifest entries after filtering. |
| total_hours: Total duration of original dataset, in hours |
| filtered_hours: Total duration of dataset after filtering, in hours |
| """ |
| filtered_entries = [] |
| total_duration = 0.0 |
| filtered_duration = 0.0 |
| for entry in entries: |
| duration = entry["duration"] |
| total_duration += duration |
| if (min_duration and duration < min_duration) or (max_duration and duration > max_duration): |
| continue |
|
|
| filtered_duration += duration |
| filtered_entries.append(entry) |
|
|
| total_hours = total_duration / 3600.0 |
| filtered_hours = filtered_duration / 3600.0 |
|
|
| return filtered_entries, total_hours, filtered_hours |
|
|
|
|
| def get_weighted_sampler( |
| sample_weights: List[float], batch_size: int, world_size: int, num_steps: int |
| ) -> torch.utils.data.WeightedRandomSampler: |
| """ |
| Create pytorch sampler for doing weighted random sampling. |
| |
| Args: |
| sample_weights: List of sampling weights for all elements in the dataset. |
| batch_size: Batch size to sample. |
| world_size: Number of devices being used. |
| num_steps: Number of steps to be considered an epoch. |
| |
| Returns: |
| Pytorch sampler |
| """ |
| weights = torch.tensor(sample_weights, dtype=torch.float64) |
| num_samples = batch_size * world_size * num_steps |
| sampler = torch.utils.data.WeightedRandomSampler(weights=weights, num_samples=num_samples) |
| return sampler |
|
|
|
|
| import torch |
| from torch import nn |
|
|
|
|
| class ConvNorm(nn.Module): |
| """ 1D Convolution """ |
|
|
| def __init__( |
| self, |
| in_channels, |
| out_channels, |
| kernel_size=1, |
| stride=1, |
| padding=None, |
| dilation=1, |
| bias=True, |
| w_init_gain="linear", |
| transpose=False, |
| ): |
| super(ConvNorm, self).__init__() |
|
|
| if padding is None: |
| assert kernel_size % 2 == 1 |
| padding = int(dilation * (kernel_size - 1) / 2) |
|
|
| self.conv = nn.Conv1d( |
| in_channels, |
| out_channels, |
| kernel_size=kernel_size, |
| stride=stride, |
| padding=padding, |
| dilation=dilation, |
| bias=bias, |
| ) |
| self.transpose = transpose |
|
|
| def forward(self, x): |
| if self.transpose: |
| x = x.contiguous().transpose(1, 2) |
| x = self.conv(x) |
| if self.transpose: |
| x = x.contiguous().transpose(1, 2) |
|
|
| return x |
|
|
|
|
| class LinearNorm(nn.Module): |
| """ LinearNorm Projection """ |
|
|
| def __init__(self, in_features, out_features, bias=False): |
| super(LinearNorm, self).__init__() |
| self.linear = nn.Linear(in_features, out_features, bias) |
|
|
| nn.init.xavier_uniform_(self.linear.weight) |
| if bias: |
| nn.init.constant_(self.linear.bias, 0.0) |
|
|
| def forward(self, x): |
| x = self.linear(x) |
| return x |
|
|
|
|
| class AlignmentEncoder(torch.nn.Module): |
| """ Alignment Encoder for Unsupervised Duration Modeling """ |
|
|
| def __init__(self, |
| n_mel_channels, |
| n_att_channels, |
| n_text_channels, |
| temperature, |
| multi_speaker, |
| spk_channel): |
| super().__init__() |
| self.temperature = temperature |
| self.softmax = torch.nn.Softmax(dim=3) |
| self.log_softmax = torch.nn.LogSoftmax(dim=3) |
|
|
| self.key_proj = nn.Sequential( |
| ConvNorm( |
| n_text_channels, |
| n_text_channels * 2, |
| kernel_size=3, |
| bias=True, |
| w_init_gain='relu' |
| ), |
| torch.nn.ReLU(), |
| ConvNorm( |
| n_text_channels * 2, |
| n_att_channels, |
| kernel_size=1, |
| bias=True, |
| ), |
| ) |
|
|
| self.query_proj = nn.Sequential( |
| ConvNorm( |
| n_mel_channels, |
| n_mel_channels * 2, |
| kernel_size=3, |
| bias=True, |
| w_init_gain='relu', |
| ), |
| torch.nn.ReLU(), |
| ConvNorm( |
| n_mel_channels * 2, |
| n_mel_channels, |
| kernel_size=1, |
| bias=True, |
| ), |
| torch.nn.ReLU(), |
| ConvNorm( |
| n_mel_channels, |
| n_att_channels, |
| kernel_size=1, |
| bias=True, |
| ), |
| ) |
|
|
| if multi_speaker: |
| self.key_spk_proj = LinearNorm(spk_channel, n_text_channels) |
| self.query_spk_proj = LinearNorm(spk_channel, n_mel_channels) |
|
|
| def forward(self, queries, keys, mask=None, attn_prior=None, speaker_embed=None): |
| """Forward pass of the aligner encoder. |
| Args: |
| queries (torch.tensor): B x C x T1 tensor (probably going to be mel data). |
| keys (torch.tensor): B x C2 x T2 tensor (text data). |
| mask (torch.tensor): uint8 binary mask for variable length entries (should be in the T2 domain). |
| attn_prior (torch.tensor): prior for attention matrix. |
| speaker_embed (torch.tensor): B x C tnesor of speaker embedding for multi-speaker scheme. |
| Output: |
| attn (torch.tensor): B x 1 x T1 x T2 attention mask. Final dim T2 should sum to 1. |
| attn_logprob (torch.tensor): B x 1 x T1 x T2 log-prob attention mask. |
| """ |
| |
| |
| if speaker_embed is not None: |
| keys = keys + self.key_spk_proj(speaker_embed.unsqueeze(1).expand( |
| -1, keys.shape[-1], -1 |
| )).transpose(1, 2) |
| queries = queries + self.query_spk_proj(speaker_embed.unsqueeze(1).expand( |
| -1, queries.shape[-1], -1 |
| )).transpose(1, 2) |
| keys_enc = self.key_proj(keys) |
| queries_enc = self.query_proj(queries) |
|
|
| |
| attn = (queries_enc[:, :, :, None] - keys_enc[:, :, None]) ** 2 |
| attn = -self.temperature * attn.sum(1, keepdim=True) |
|
|
| if attn_prior is not None: |
| |
| attn = self.log_softmax(attn) + torch.log(attn_prior[:, None] + 1e-8) |
| |
|
|
| attn_logprob = attn.clone() |
|
|
| if mask is not None: |
| attn.data.masked_fill_(mask.permute(0, 2, 1).unsqueeze(2), -float("inf")) |
|
|
| attn = self.softmax(attn) |
| return attn, attn_logprob |
|
|
| if __name__ == '__main__': |
| import matplotlib.pyplot as plt |
| beta_binomial_interpolator = BetaBinomialInterpolator() |
| attn_prior = beta_binomial_prior_distribution(500, 1000) |
| print(attn_prior.shape) |
|
|
| |
| |
| |
|
|
|
|
|
|
|
|
|
|
