|
from monotonic_align import maximum_path
|
|
from monotonic_align import mask_from_lens
|
|
from monotonic_align.core import maximum_path_c
|
|
import numpy as np
|
|
import torch
|
|
import copy
|
|
from torch import nn
|
|
import torch.nn.functional as F
|
|
import torchaudio
|
|
import librosa
|
|
import matplotlib.pyplot as plt
|
|
from munch import Munch
|
|
|
|
|
|
def maximum_path(neg_cent, mask):
|
|
"""Cython optimized version.
|
|
neg_cent: [b, t_t, t_s]
|
|
mask: [b, t_t, t_s]
|
|
"""
|
|
device = neg_cent.device
|
|
dtype = neg_cent.dtype
|
|
neg_cent = np.ascontiguousarray(neg_cent.data.cpu().numpy().astype(np.float32))
|
|
path = np.ascontiguousarray(np.zeros(neg_cent.shape, dtype=np.int32))
|
|
|
|
t_t_max = np.ascontiguousarray(
|
|
mask.sum(1)[:, 0].data.cpu().numpy().astype(np.int32)
|
|
)
|
|
t_s_max = np.ascontiguousarray(
|
|
mask.sum(2)[:, 0].data.cpu().numpy().astype(np.int32)
|
|
)
|
|
maximum_path_c(path, neg_cent, t_t_max, t_s_max)
|
|
return torch.from_numpy(path).to(device=device, dtype=dtype)
|
|
|
|
|
|
def get_data_path_list(train_path=None, val_path=None):
|
|
if train_path is None:
|
|
train_path = "Data/train_list.txt"
|
|
if val_path is None:
|
|
val_path = "Data/val_list.txt"
|
|
|
|
with open(train_path, "r", encoding="utf-8", errors="ignore") as f:
|
|
train_list = f.readlines()
|
|
with open(val_path, "r", encoding="utf-8", errors="ignore") as f:
|
|
val_list = f.readlines()
|
|
|
|
return train_list, val_list
|
|
|
|
|
|
def length_to_mask(lengths):
|
|
mask = (
|
|
torch.arange(lengths.max())
|
|
.unsqueeze(0)
|
|
.expand(lengths.shape[0], -1)
|
|
.type_as(lengths)
|
|
)
|
|
mask = torch.gt(mask + 1, lengths.unsqueeze(1))
|
|
return mask
|
|
|
|
|
|
|
|
def log_norm(x, mean=-4, std=4, dim=2):
|
|
"""
|
|
normalized log mel -> mel -> norm -> log(norm)
|
|
"""
|
|
x = torch.log(torch.exp(x * std + mean).norm(dim=dim))
|
|
return x
|
|
|
|
|
|
def get_image(arrs):
|
|
plt.switch_backend("agg")
|
|
fig = plt.figure()
|
|
ax = plt.gca()
|
|
ax.imshow(arrs)
|
|
|
|
return fig
|
|
|
|
|
|
def recursive_munch(d):
|
|
if isinstance(d, dict):
|
|
return Munch((k, recursive_munch(v)) for k, v in d.items())
|
|
elif isinstance(d, list):
|
|
return [recursive_munch(v) for v in d]
|
|
else:
|
|
return d
|
|
|
|
|
|
def log_print(message, logger):
|
|
logger.info(message)
|
|
print(message)
|
|
|
