Spaces:
Runtime error
Runtime error
File size: 10,539 Bytes
8d4c60f |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 |
import os
import librosa
from scipy.io.wavfile import write
from mel_processing import spectrogram_torch
from text import text_to_sequence, _clean_text
from models import SynthesizerTrn
import utils
import commons
import sys
import re
import numpy as np
# import torch
# torch.set_num_threads(1) #设置torch线程为1,防止多任务推理时服务崩溃,但flask仍然会使用多线程
from torch import no_grad, LongTensor, inference_mode, FloatTensor
import audonnx
import uuid
from io import BytesIO
class Voice:
def __init__(self, model, config, out_path=None):
self.out_path = out_path
if not os.path.exists(self.out_path):
try:
os.mkdir(self.out_path)
except:
pass
self.hps_ms = utils.get_hparams_from_file(config)
self.n_speakers = self.hps_ms.data.n_speakers if 'n_speakers' in self.hps_ms.data.keys() else 0
self.n_symbols = len(self.hps_ms.symbols) if 'symbols' in self.hps_ms.keys() else 0
self.speakers = self.hps_ms.speakers if 'speakers' in self.hps_ms.keys() else ['0']
self.use_f0 = self.hps_ms.data.use_f0 if 'use_f0' in self.hps_ms.data.keys() else False
self.emotion_embedding = self.hps_ms.data.emotion_embedding if 'emotion_embedding' in self.hps_ms.data.keys() else False
self.net_g_ms = SynthesizerTrn(
self.n_symbols,
self.hps_ms.data.filter_length // 2 + 1,
self.hps_ms.train.segment_size // self.hps_ms.data.hop_length,
n_speakers=self.n_speakers,
emotion_embedding=self.emotion_embedding,
**self.hps_ms.model)
_ = self.net_g_ms.eval()
utils.load_checkpoint(model, self.net_g_ms)
def get_text(self, text, hps, cleaned=False):
if cleaned:
text_norm = text_to_sequence(text, hps.symbols, [])
else:
text_norm = text_to_sequence(text, hps.symbols, hps.data.text_cleaners)
if hps.data.add_blank:
text_norm = commons.intersperse(text_norm, 0)
text_norm = LongTensor(text_norm)
return text_norm
def get_label_value(self, text, label, default, warning_name='value'):
value = re.search(rf'\[{label}=(.+?)\]', text)
if value:
try:
text = re.sub(rf'\[{label}=(.+?)\]', '', text, 1)
value = float(value.group(1))
except:
print(f'Invalid {warning_name}!')
sys.exit(1)
else:
value = default
return value, text
def ex_return(self, text, escape=False):
if escape:
return text.encode('unicode_escape').decode()
else:
return text
def return_speakers(self, escape=False):
return self.speakers
def get_label(self, text, label):
if f'[{label}]' in text:
return True, text.replace(f'[{label}]', '')
else:
return False, text
def generate(self, text=None, speaker_id=None, format=None, speed=1, audio_path=None, target_id=None, escape=False,
option=None, w2v2_folder=None):
if self.n_symbols != 0:
if not self.emotion_embedding:
length_scale, text = self.get_label_value(text, 'LENGTH', speed, 'length scale')
noise_scale, text = self.get_label_value(text, 'NOISE', 0.667, 'noise scale')
noise_scale_w, text = self.get_label_value(text, 'NOISEW', 0.8, 'deviation of noise')
cleaned, text = self.get_label(text, 'CLEANED')
stn_tst = self.get_text(text, self.hps_ms, cleaned=cleaned)
with no_grad():
x_tst = stn_tst.unsqueeze(0)
x_tst_lengths = LongTensor([stn_tst.size(0)])
sid = LongTensor([speaker_id])
audio = self.net_g_ms.infer(x_tst, x_tst_lengths, sid=sid,
noise_scale=noise_scale,
noise_scale_w=noise_scale_w,
length_scale=length_scale)[0][0, 0].data.cpu().float().numpy()
# else:
# w2v2_model = audonnx.load(os.path.dirname(w2v2_folder))
#
# if option == 'clean':
# self.ex_print(_clean_text(
# text, self.hps_ms.data.text_cleaners), escape)
#
# length_scale, text = self.get_label_value(
# text, 'LENGTH', 1, 'length scale')
# noise_scale, text = self.get_label_value(
# text, 'NOISE', 0.667, 'noise scale')
# noise_scale_w, text = self.get_label_value(
# text, 'NOISEW', 0.8, 'deviation of noise')
# cleaned, text = self.get_label(text, 'CLEANED')
#
# stn_tst = self.get_text(text, self.hps_ms, cleaned=cleaned)
#
# emotion_reference = input('Path of an emotion reference: ')
# if emotion_reference.endswith('.npy'):
# emotion = np.load(emotion_reference)
# emotion = FloatTensor(emotion).unsqueeze(0)
# else:
# audio16000, sampling_rate = librosa.load(
# emotion_reference, sr=16000, mono=True)
# emotion = w2v2_model(audio16000, sampling_rate)[
# 'hidden_states']
# emotion_reference = re.sub(
# r'\..*$', '', emotion_reference)
# np.save(emotion_reference, emotion.squeeze(0))
# emotion = FloatTensor(emotion)
#
#
# with no_grad():
# x_tst = stn_tst.unsqueeze(0)
# x_tst_lengths = LongTensor([stn_tst.size(0)])
# sid = LongTensor([speaker_id])
# audio = self.net_g_ms.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=noise_scale,
# noise_scale_w=noise_scale_w,
# length_scale=length_scale, emotion_embedding=emotion)[0][
# 0, 0].data.cpu().float().numpy()
# else:
# model = input('Path of a hubert-soft Model: ')
# from hubert_model import hubert_soft
# hubert = hubert_soft(model)
# if audio_path != '[VC]':
# if self.use_f0:
# audio, sampling_rate = librosa.load(
# audio_path, sr=self.hps_ms.data.sampling_rate, mono=True)
# audio16000 = librosa.resample(
# audio, orig_sr=sampling_rate, target_sr=16000)
# else:
# audio16000, sampling_rate = librosa.load(
# audio_path, sr=16000, mono=True)
#
# out_path = "H:/git/MoeGoe-Simple-API/upload/hubert.wav"
# length_scale, out_path = self.get_label_value(
# out_path, 'LENGTH', 1, 'length scale')
# noise_scale, out_path = self.get_label_value(
# out_path, 'NOISE', 0.1, 'noise scale')
# noise_scale_w, out_path = self.get_label_value(
# out_path, 'NOISEW', 0.1, 'deviation of noise')
#
# with inference_mode():
# units = hubert.units(FloatTensor(audio16000).unsqueeze(
# 0).unsqueeze(0)).squeeze(0).numpy()
# if self.use_f0:
# f0_scale, out_path = self.get_label_value(
# out_path, 'F0', 1, 'f0 scale')
# f0 = librosa.pyin(audio, sr=sampling_rate,
# fmin=librosa.note_to_hz('C0'),
# fmax=librosa.note_to_hz('C7'),
# frame_length=1780)[0]
# target_length = len(units[:, 0])
# f0 = np.nan_to_num(np.interp(np.arange(0, len(f0) * target_length, len(f0)) / target_length,
# np.arange(0, len(f0)), f0)) * f0_scale
# units[:, 0] = f0 / 10
#
# stn_tst = FloatTensor(units)
# with no_grad():
# x_tst = stn_tst.unsqueeze(0)
# x_tst_lengths = LongTensor([stn_tst.size(0)])
# sid = LongTensor([target_id])
# audio = self.net_g_ms.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=noise_scale,
# noise_scale_w=noise_scale_w, length_scale=length_scale)[0][
# 0, 0].data.float().numpy()
with BytesIO() as f:
fname = str(uuid.uuid1())
if format == 'ogg':
write(f, self.hps_ms.data.sampling_rate, audio)
with BytesIO() as o:
utils.wav2ogg(f, o)
return BytesIO(o.getvalue()), "audio/ogg", fname + ".ogg"
elif format == 'silk':
file_path = self.out_path + "/" + fname + ".wav"
write(file_path, 24000, audio)
silk_path = utils.convert_to_silk(file_path)
os.remove(file_path)
return silk_path, "audio/silk", fname + ".silk"
else:
write(f, self.hps_ms.data.sampling_rate, audio)
return BytesIO(f.getvalue()), "audio/wav", fname + ".wav"
def voice_conversion(self, audio_path, original_id, target_id):
audio = utils.load_audio_to_torch(
audio_path, self.hps_ms.data.sampling_rate)
y = audio.unsqueeze(0)
spec = spectrogram_torch(y, self.hps_ms.data.filter_length,
self.hps_ms.data.sampling_rate, self.hps_ms.data.hop_length,
self.hps_ms.data.win_length,
center=False)
spec_lengths = LongTensor([spec.size(-1)])
sid_src = LongTensor([original_id])
with no_grad():
sid_tgt = LongTensor([target_id])
audio = self.net_g_ms.voice_conversion(spec, spec_lengths, sid_src=sid_src, sid_tgt=sid_tgt)[
0][0, 0].data.cpu().float().numpy()
with BytesIO() as f:
write(f, self.hps_ms.data.sampling_rate, audio)
return BytesIO(f.getvalue())
|