mirror of
https://github.com/w-okada/voice-changer.git
synced 2025-01-23 13:35:12 +03:00
129 lines
3.9 KiB
Python
129 lines
3.9 KiB
Python
|
|
|
|
from scipy.interpolate import interp1d
|
|
import torch
|
|
import numpy as np
|
|
import json
|
|
import os
|
|
hann_window = {}
|
|
|
|
|
|
def convert_continuos_f0(f0, f0_size):
|
|
# 正式版チェックOK
|
|
# get start and end of f0
|
|
if (f0 == 0).all():
|
|
return np.zeros((f0_size,))
|
|
start_f0 = f0[f0 != 0][0]
|
|
end_f0 = f0[f0 != 0][-1]
|
|
# padding start and end of f0 sequence
|
|
cf0 = f0
|
|
start_idx = np.where(cf0 == start_f0)[0][0]
|
|
end_idx = np.where(cf0 == end_f0)[0][-1]
|
|
cf0[:start_idx] = start_f0
|
|
cf0[end_idx:] = end_f0
|
|
# get non-zero frame index
|
|
nz_frames = np.where(cf0 != 0)[0]
|
|
# perform linear interpolation
|
|
f = interp1d(nz_frames, cf0[nz_frames], bounds_error=False, fill_value=0.0)
|
|
# print(cf0.shape, cf0_.shape, f0.shape, f0_size)
|
|
# print(cf0_)
|
|
return f(np.arange(0, f0_size))
|
|
|
|
|
|
def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
|
|
# 正式版チェックOK
|
|
if torch.min(y) < -1.:
|
|
print('min value is ', torch.min(y))
|
|
if torch.max(y) > 1.:
|
|
print('max value is ', torch.max(y))
|
|
|
|
dtype_device = str(y.dtype) + '_' + str(y.device)
|
|
wnsize_dtype_device = str(win_size) + '_' + dtype_device
|
|
if wnsize_dtype_device not in hann_window:
|
|
hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
|
|
|
|
y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft - hop_size) / 2), int((n_fft - hop_size) / 2)), mode='reflect')
|
|
y = y.squeeze(1)
|
|
|
|
spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
|
|
center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=True)
|
|
spec = torch.view_as_real(spec)
|
|
|
|
spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
|
|
return spec
|
|
|
|
|
|
def get_hparams_from_file(config_path):
|
|
# 正式版チェックOK
|
|
with open(config_path, "r", encoding="utf-8") as f:
|
|
data = f.read()
|
|
config = json.loads(data)
|
|
|
|
hparams = HParams(**config)
|
|
return hparams
|
|
|
|
|
|
class HParams():
|
|
# 正式版チェックOK
|
|
def __init__(self, **kwargs):
|
|
for k, v in kwargs.items():
|
|
if type(v) == dict:
|
|
v = HParams(**v)
|
|
self[k] = v
|
|
|
|
def keys(self):
|
|
return self.__dict__.keys()
|
|
|
|
def items(self):
|
|
return self.__dict__.items()
|
|
|
|
def values(self):
|
|
return self.__dict__.values()
|
|
|
|
def __len__(self):
|
|
return len(self.__dict__)
|
|
|
|
def __getitem__(self, key):
|
|
return getattr(self, key)
|
|
|
|
def __setitem__(self, key, value):
|
|
return setattr(self, key, value)
|
|
|
|
def __contains__(self, key):
|
|
return key in self.__dict__
|
|
|
|
def __repr__(self):
|
|
return self.__dict__.__repr__()
|
|
|
|
|
|
def load_checkpoint(checkpoint_path, model, optimizer=None):
|
|
# 正式版チェックOK
|
|
assert os.path.isfile(checkpoint_path), f"No such file or directory: {checkpoint_path}"
|
|
checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
|
|
iteration = checkpoint_dict['iteration']
|
|
learning_rate = checkpoint_dict['learning_rate']
|
|
if optimizer is not None:
|
|
optimizer.load_state_dict(checkpoint_dict['optimizer'])
|
|
saved_state_dict = {
|
|
**checkpoint_dict['pe'],
|
|
**checkpoint_dict['flow'],
|
|
**checkpoint_dict['text_enc'],
|
|
**checkpoint_dict['dec'],
|
|
**checkpoint_dict['emb_g']
|
|
}
|
|
if hasattr(model, 'module'):
|
|
state_dict = model.module.state_dict()
|
|
else:
|
|
state_dict = model.state_dict()
|
|
new_state_dict = {}
|
|
for k, v in state_dict.items():
|
|
try:
|
|
new_state_dict[k] = saved_state_dict[k]
|
|
except:
|
|
new_state_dict[k] = v
|
|
if hasattr(model, 'module'):
|
|
model.module.load_state_dict(new_state_dict)
|
|
else:
|
|
model.load_state_dict(new_state_dict)
|
|
return model, optimizer, learning_rate, iteration
|