mirror of
https://github.com/storytold/storyteller-ml.git
synced 2026-10-28 09:08:54 +00:00
add seed-vc model (#60)
* init seed-vc * seed-vc workflow * put seed-vc in the right dir
This commit is contained in:
Madhukar Mishra
@@ -0,0 +1,499 @@
|
||||
import shutil
|
||||
import warnings
|
||||
import argparse
|
||||
import torch
|
||||
import os
|
||||
import os.path as osp
|
||||
import yaml
|
||||
|
||||
warnings.simplefilter("ignore")
|
||||
|
||||
# load packages
|
||||
import random
|
||||
|
||||
from tqdm import tqdm
|
||||
from modules.commons import *
|
||||
import time
|
||||
|
||||
import torchaudio
|
||||
import librosa
|
||||
import torchaudio.compliance.kaldi as kaldi
|
||||
|
||||
from hf_utils import load_custom_model_from_hf
|
||||
from resemblyzer import preprocess_wav, VoiceEncoder
|
||||
|
||||
# Load model and configuration
|
||||
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
|
||||
|
||||
from transformers import Wav2Vec2FeatureExtractor, WavLMForXVector
|
||||
from transformers import Wav2Vec2Processor, HubertForCTC
|
||||
|
||||
import jiwer
|
||||
import string
|
||||
|
||||
from baselines.dnsmos.dnsmos_computor import DNSMOSComputer
|
||||
|
||||
def calc_mos(computor, audio, orin_sr):
|
||||
# only 16k audio is supported
|
||||
target_sr = 16000
|
||||
if orin_sr != 16000:
|
||||
audio = librosa.resample(
|
||||
audio, orig_sr=orin_sr, target_sr=target_sr, res_type="kaiser_fast"
|
||||
)
|
||||
result = computor.compute(audio, target_sr, False)
|
||||
sig, bak, ovr = result["SIG"], result["BAK"], result["OVRL"]
|
||||
|
||||
if ovr == 0:
|
||||
print("calculate dns mos failed")
|
||||
return sig, bak, ovr
|
||||
|
||||
mos_computer = DNSMOSComputer(
|
||||
"baselines/dnsmos/sig_bak_ovr.onnx",
|
||||
"baselines/dnsmos/model_v8.onnx",
|
||||
device="cuda",
|
||||
device_id=0,
|
||||
)
|
||||
|
||||
def load_models(args):
|
||||
dit_checkpoint_path, dit_config_path = load_custom_model_from_hf("Plachta/Seed-VC",
|
||||
"DiT_seed_v2_uvit_whisper_small_wavenet_bigvgan_pruned.pth",
|
||||
"config_dit_mel_seed_uvit_whisper_small_wavenet.yml")
|
||||
|
||||
config = yaml.safe_load(open(dit_config_path, "r"))
|
||||
model_params = recursive_munch(config["model_params"])
|
||||
model = build_model(model_params, stage="DiT")
|
||||
hop_length = config["preprocess_params"]["spect_params"]["hop_length"]
|
||||
sr = config["preprocess_params"]["sr"]
|
||||
|
||||
# Load checkpoints
|
||||
model, _, _, _ = load_checkpoint(
|
||||
model,
|
||||
None,
|
||||
dit_checkpoint_path,
|
||||
load_only_params=True,
|
||||
ignore_modules=[],
|
||||
is_distributed=False,
|
||||
)
|
||||
for key in model:
|
||||
model[key].eval()
|
||||
model[key].to(device)
|
||||
model.cfm.estimator.setup_caches(max_batch_size=1, max_seq_length=8192)
|
||||
|
||||
# Load additional modules
|
||||
from modules.campplus.DTDNN import CAMPPlus
|
||||
|
||||
campplus_ckpt_path = load_custom_model_from_hf(
|
||||
"funasr/campplus", "campplus_cn_common.bin", config_filename=None
|
||||
)
|
||||
campplus_model = CAMPPlus(feat_dim=80, embedding_size=192)
|
||||
campplus_model.load_state_dict(torch.load(campplus_ckpt_path, map_location="cpu"))
|
||||
campplus_model.eval()
|
||||
campplus_model.to(device)
|
||||
|
||||
from modules.bigvgan import bigvgan
|
||||
|
||||
bigvgan_model = bigvgan.BigVGAN.from_pretrained(
|
||||
"nvidia/bigvgan_v2_22khz_80band_256x", use_cuda_kernel=False
|
||||
)
|
||||
|
||||
# remove weight norm in the model and set to eval mode
|
||||
bigvgan_model.remove_weight_norm()
|
||||
bigvgan_model = bigvgan_model.eval().to(device)
|
||||
|
||||
if model_params.speech_tokenizer.type == "facodec":
|
||||
ckpt_path, config_path = load_custom_model_from_hf("Plachta/FAcodec", 'pytorch_model.bin', 'config.yml')
|
||||
|
||||
codec_config = yaml.safe_load(open(config_path))
|
||||
codec_model_params = recursive_munch(codec_config['model_params'])
|
||||
codec_encoder = build_model(codec_model_params, stage="codec")
|
||||
|
||||
ckpt_params = torch.load(ckpt_path, map_location="cpu")
|
||||
|
||||
for key in codec_encoder:
|
||||
codec_encoder[key].load_state_dict(ckpt_params[key], strict=False)
|
||||
_ = [codec_encoder[key].eval() for key in codec_encoder]
|
||||
_ = [codec_encoder[key].to(device) for key in codec_encoder]
|
||||
speechtokenizer_set = ('facodec', codec_encoder, None)
|
||||
elif model_params.speech_tokenizer.type == "whisper":
|
||||
from transformers import AutoFeatureExtractor, WhisperModel
|
||||
whisper_name = model_params.speech_tokenizer.whisper_name if hasattr(model_params.speech_tokenizer,
|
||||
'whisper_name') else "whisper-large-v3"
|
||||
whisper_model = WhisperModel.from_pretrained(whisper_name, torch_dtype=torch.float16).to(device)
|
||||
del whisper_model.decoder
|
||||
whisper_feature_extractor = AutoFeatureExtractor.from_pretrained(whisper_name)
|
||||
speechtokenizer_set = ('whisper', whisper_model, whisper_feature_extractor)
|
||||
else:
|
||||
raise ValueError(f"Unsupported speech tokenizer type: {model_params.speech_tokenizer.type}")
|
||||
# Generate mel spectrograms
|
||||
mel_fn_args = {
|
||||
"n_fft": config['preprocess_params']['spect_params']['n_fft'],
|
||||
"win_size": config['preprocess_params']['spect_params']['win_length'],
|
||||
"hop_size": config['preprocess_params']['spect_params']['hop_length'],
|
||||
"num_mels": config['preprocess_params']['spect_params']['n_mels'],
|
||||
"sampling_rate": sr,
|
||||
"fmin": config['preprocess_params'].get('fmin', 0),
|
||||
"fmax": None if config['preprocess_params'].get('fmax', "None") == "None" else 8000,
|
||||
"center": False
|
||||
}
|
||||
from modules.audio import mel_spectrogram
|
||||
|
||||
to_mel = lambda x: mel_spectrogram(x, **mel_fn_args)
|
||||
|
||||
return (
|
||||
model,
|
||||
speechtokenizer_set,
|
||||
bigvgan_model,
|
||||
campplus_model,
|
||||
to_mel,
|
||||
mel_fn_args,
|
||||
)
|
||||
|
||||
|
||||
@torch.no_grad()
|
||||
def main(args):
|
||||
# init xvector models
|
||||
if args.xvector_extractor == "wavlm":
|
||||
wavlm_feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(
|
||||
"microsoft/wavlm-base-plus-sv"
|
||||
)
|
||||
wavlm_model = WavLMForXVector.from_pretrained(
|
||||
"microsoft/wavlm-base-plus-sv"
|
||||
).to(device)
|
||||
elif args.xvector_extractor == "resemblyzer":
|
||||
resemblyzer_encoder = VoiceEncoder()
|
||||
else:
|
||||
raise ValueError(f"Unknown xvector extractor: {args.xvector_extractor}")
|
||||
|
||||
# init asr model
|
||||
asr_processor = Wav2Vec2Processor.from_pretrained("facebook/hubert-large-ls960-ft")
|
||||
asr_model = HubertForCTC.from_pretrained("facebook/hubert-large-ls960-ft").to(device)
|
||||
|
||||
(
|
||||
model,
|
||||
speechtokenizer_set,
|
||||
bigvgan_model,
|
||||
campplus_model,
|
||||
to_mel,
|
||||
mel_fn_args,
|
||||
) = load_models(args)
|
||||
sr = mel_fn_args["sampling_rate"]
|
||||
|
||||
source_dir = args.source
|
||||
target_dir = args.target
|
||||
diffusion_steps = args.diffusion_steps
|
||||
length_adjust = args.length_adjust
|
||||
inference_cfg_rate = args.inference_cfg_rate
|
||||
baseline = args.baseline
|
||||
max_samples = args.max_samples
|
||||
try:
|
||||
source_audio_list = open(osp.join(source_dir, "index.tsv"), "r").readlines()
|
||||
except FileNotFoundError:
|
||||
source_audio_list = os.listdir(source_dir)
|
||||
source_audio_list = [f for f in source_audio_list if f.endswith(".wav")]
|
||||
target_audio_list = os.listdir(target_dir)
|
||||
|
||||
conversion_result_dir = args.output
|
||||
if baseline:
|
||||
conversion_result_dir = os.path.join(conversion_result_dir, baseline)
|
||||
os.makedirs(conversion_result_dir, exist_ok=True)
|
||||
|
||||
similarity_list = []
|
||||
gt_wer_list = []
|
||||
gt_cer_list = []
|
||||
vc_wer_list = []
|
||||
vc_cer_list = []
|
||||
dnsmos_list = []
|
||||
for source_i, source_line in enumerate(tqdm(source_audio_list)):
|
||||
if source_i >= max_samples:
|
||||
break
|
||||
source_index, source_transcript = source_line.strip().split("\t")
|
||||
source_path = osp.join(source_dir, f"{source_index}.wav")
|
||||
for target_i, target_name in enumerate(target_audio_list):
|
||||
target_path = osp.join(target_dir, target_name)
|
||||
print(f"Processing {source_path} -> {target_path}")
|
||||
|
||||
if os.path.exists(osp.join(conversion_result_dir, source_index, f"{target_name}")):
|
||||
# already converted, load the converted file
|
||||
vc_wave_16k, _ = librosa.load(
|
||||
osp.join(conversion_result_dir, source_index, f"{target_name}"), sr=16000
|
||||
)
|
||||
vc_wave_16k = torch.tensor(vc_wave_16k).unsqueeze(0)
|
||||
ref_waves_16k, _ = librosa.load(target_path, sr=16000)
|
||||
ref_waves_16k = torch.tensor(ref_waves_16k).unsqueeze(0)
|
||||
else:
|
||||
if baseline == "openvoice":
|
||||
from baselines.openvoice import convert as openvoice_convert
|
||||
ref_waves_16k, vc_wave_16k = openvoice_convert(source_path, target_path, "temp.wav")
|
||||
elif baseline == "cosyvoice":
|
||||
from baselines.cosyvoice import convert as cosyvoice_convert
|
||||
ref_waves_16k, vc_wave_16k = cosyvoice_convert(source_path, target_path, "temp.wav")
|
||||
else:
|
||||
ref_waves_16k, vc_wave = convert(
|
||||
source_path,
|
||||
target_path,
|
||||
model,
|
||||
speechtokenizer_set,
|
||||
bigvgan_model,
|
||||
campplus_model,
|
||||
to_mel,
|
||||
mel_fn_args,
|
||||
sr,
|
||||
length_adjust,
|
||||
diffusion_steps,
|
||||
inference_cfg_rate,
|
||||
)
|
||||
vc_wave_16k = torchaudio.functional.resample(vc_wave, sr, 16000)
|
||||
os.makedirs(osp.join(conversion_result_dir, source_index), exist_ok=True)
|
||||
torchaudio.save(
|
||||
osp.join(conversion_result_dir, source_index, f"{target_name}"),
|
||||
vc_wave_16k.cpu(),
|
||||
16000,
|
||||
)
|
||||
if args.xvector_extractor == "wavlm":
|
||||
ref_inputs = wavlm_feature_extractor(
|
||||
ref_waves_16k.squeeze(0).cpu(), padding=True, return_tensors="pt"
|
||||
).to(device)
|
||||
ref_embeddings = wavlm_model(**ref_inputs).embeddings
|
||||
ref_embeddings = torch.nn.functional.normalize(ref_embeddings, dim=-1).cpu()
|
||||
|
||||
vc_inputs = wavlm_feature_extractor(
|
||||
vc_wave_16k.squeeze(0).cpu(), padding=True, return_tensors="pt"
|
||||
).to(device)
|
||||
vc_embeddings = wavlm_model(**vc_inputs).embeddings
|
||||
vc_embeddings = torch.nn.functional.normalize(vc_embeddings, dim=-1).cpu()
|
||||
|
||||
similarity = torch.nn.functional.cosine_similarity(
|
||||
ref_embeddings, vc_embeddings, dim=-1
|
||||
)
|
||||
elif args.xvector_extractor == "resemblyzer":
|
||||
ref_wav_resemblyzer = preprocess_wav(target_path)
|
||||
vc_wav_resemblyzer = preprocess_wav(
|
||||
osp.join(conversion_result_dir, source_index, f"{target_name}")
|
||||
)
|
||||
ref_embed = resemblyzer_encoder.embed_utterance(ref_wav_resemblyzer)
|
||||
vc_embed = resemblyzer_encoder.embed_utterance(vc_wav_resemblyzer)
|
||||
similarity = np.inner(ref_embed, vc_embed)
|
||||
else:
|
||||
raise ValueError(f"Unknown xvector extractor: {args.xvector_extractor}")
|
||||
print(f"Similarity: {similarity}")
|
||||
similarity_list.append(similarity)
|
||||
|
||||
# perform asr
|
||||
vc_asr_inputs = asr_processor(
|
||||
vc_wave_16k.squeeze(0).cpu(), return_tensors="pt", padding=True
|
||||
).to(device)
|
||||
vc_asr_logits = asr_model(**vc_asr_inputs).logits
|
||||
predicted_ids = torch.argmax(vc_asr_logits, dim=-1)
|
||||
vc_transcription = asr_processor.decode(predicted_ids[0])
|
||||
|
||||
# perform asr on source 16k
|
||||
source_wav_16k = librosa.load(source_path, sr=16000)[0]
|
||||
source_asr_inputs = asr_processor(
|
||||
source_wav_16k, return_tensors="pt", padding=True
|
||||
).to(device)
|
||||
source_asr_logits = asr_model(**source_asr_inputs).logits
|
||||
source_predicted_ids = torch.argmax(source_asr_logits, dim=-1)
|
||||
source_transcription = asr_processor.decode(source_predicted_ids[0])
|
||||
|
||||
# convert transcriptions to all lower to calculate WER and CER
|
||||
source_transcript = source_transcript.lower()
|
||||
# remove punctuations in source_transcript
|
||||
source_transcript = source_transcript.translate(str.maketrans("", "", string.punctuation))
|
||||
source_transcription = source_transcription.lower()
|
||||
vc_transcription = vc_transcription.lower()
|
||||
|
||||
# calculate WER and CER
|
||||
gt_wer = jiwer.wer(source_transcript, source_transcription)
|
||||
gt_cer = jiwer.cer(source_transcript, source_transcription)
|
||||
vc_wer = jiwer.wer(source_transcript, vc_transcription)
|
||||
vc_cer = jiwer.cer(source_transcript, vc_transcription)
|
||||
|
||||
print(f"GT WER: {gt_wer}, CER: {gt_cer}")
|
||||
print(f"VC WER: {vc_wer}, CER: {vc_cer}")
|
||||
gt_wer_list.append(gt_wer)
|
||||
gt_cer_list.append(gt_cer)
|
||||
vc_wer_list.append(vc_wer)
|
||||
vc_cer_list.append(vc_cer)
|
||||
|
||||
# calculate dnsmos
|
||||
sig, bak, ovr = calc_mos(mos_computer, vc_wave_16k.squeeze(0).cpu().numpy(), 16000)
|
||||
dnsmos_list.append((sig, bak, ovr))
|
||||
|
||||
print(f"Average GT WER: {sum(gt_wer_list) / len(gt_wer_list)}")
|
||||
print(f"Average GT CER: {sum(gt_cer_list) / len(gt_cer_list)}")
|
||||
print(f"Average VC WER: {sum(vc_wer_list) / len(vc_wer_list)}")
|
||||
print(f"Average VC CER: {sum(vc_cer_list) / len(vc_cer_list)}")
|
||||
print(f"Average similarity: {sum(similarity_list) / len(similarity_list)}")
|
||||
|
||||
print(f"Average DNS MOS SIG: {sum([x[0] for x in dnsmos_list]) / len(dnsmos_list)}")
|
||||
print(f"Average DNS MOS BAK: {sum([x[1] for x in dnsmos_list]) / len(dnsmos_list)}")
|
||||
print(f"Average DNS MOS OVR: {sum([x[2] for x in dnsmos_list]) / len(dnsmos_list)}")
|
||||
|
||||
# save wer and cer result into this directory as a txt
|
||||
with open(osp.join(conversion_result_dir, source_index, "result.txt"), 'w') as f:
|
||||
f.write(f"GT WER: {sum(gt_wer_list[-len(target_audio_list):]) / len(target_audio_list)}\n")
|
||||
f.write(f"GT CER: {sum(gt_cer_list[-len(target_audio_list):]) / len(target_audio_list)}\n")
|
||||
f.write(f"VC WER: {sum(vc_wer_list[-len(target_audio_list):]) / len(target_audio_list)}\n")
|
||||
f.write(f"VC CER: {sum(vc_cer_list[-len(target_audio_list):]) / len(target_audio_list)}\n")
|
||||
f.write(f"Average similarity: {sum(similarity_list[-len(target_audio_list):]) / len(target_audio_list)}\n")
|
||||
|
||||
print(f"Average WER: {sum(gt_wer_list) / len(gt_wer_list)}")
|
||||
print(f"Average CER: {sum(gt_cer_list) / len(gt_cer_list)}")
|
||||
print(f"Average WER: {sum(vc_wer_list) / len(vc_wer_list)}")
|
||||
print(f"Average CER: {sum(vc_cer_list) / len(vc_cer_list)}")
|
||||
print(f"Average similarity: {sum(similarity_list) / len(similarity_list)}")
|
||||
# save similarity list
|
||||
with open(osp.join(conversion_result_dir, f"{args.xvector_extractor}_similarity.tsv"), "w") as f:
|
||||
f.write("\n".join([str(s) for s in similarity_list]))
|
||||
# save wer and cer result into this directory as a txt
|
||||
with open(osp.join(conversion_result_dir, "result.txt"), 'w') as f:
|
||||
f.write(f"GT WER: {sum(gt_wer_list) / len(gt_wer_list)}\n")
|
||||
f.write(f"GT CER: {sum(gt_cer_list) / len(gt_cer_list)}\n")
|
||||
f.write(f"VC WER: {sum(vc_wer_list) / len(vc_wer_list)}\n")
|
||||
f.write(f"VC CER: {sum(vc_cer_list) / len(vc_cer_list)}\n")
|
||||
|
||||
print(f"Average DNS MOS SIG: {sum([x[0] for x in dnsmos_list]) / len(dnsmos_list)}")
|
||||
print(f"Average DNS MOS BAK: {sum([x[1] for x in dnsmos_list]) / len(dnsmos_list)}")
|
||||
print(f"Average DNS MOS OVR: {sum([x[2] for x in dnsmos_list]) / len(dnsmos_list)}")
|
||||
|
||||
|
||||
def convert(
|
||||
source_path,
|
||||
target_path,
|
||||
model,
|
||||
speechtokenizer_set,
|
||||
bigvgan_model,
|
||||
campplus_model,
|
||||
to_mel,
|
||||
mel_fn_args,
|
||||
sr,
|
||||
length_adjust,
|
||||
diffusion_steps,
|
||||
inference_cfg_rate,
|
||||
):
|
||||
source_audio = librosa.load(source_path, sr=sr)[0]
|
||||
ref_audio = librosa.load(target_path, sr=sr)[0]
|
||||
# decoded_wav = encodec_model.decoder(encodec_latent)
|
||||
# torchaudio.save("test.wav", decoded_wav.cpu().squeeze(0), 24000)
|
||||
# crop only the first 30 seconds
|
||||
source_audio = torch.tensor(source_audio).unsqueeze(0).float().to(device)
|
||||
ref_audio = torch.tensor(ref_audio).unsqueeze(0).float().to(device)
|
||||
|
||||
if source_audio.size(1) + ref_audio.size(1) > 30 * sr:
|
||||
print(f"reference audio clipped from {ref_audio.size(1)/sr} seconds to {30 * sr - source_audio.size(1)} seconds")
|
||||
ref_audio = ref_audio[:, :30 * sr - source_audio.size(1)]
|
||||
|
||||
|
||||
source_waves_16k = torchaudio.functional.resample(source_audio, sr, 16000)
|
||||
ref_waves_16k = torchaudio.functional.resample(ref_audio, sr, 16000)
|
||||
|
||||
converted_waves_24k = torchaudio.functional.resample(source_audio, sr, 24000)
|
||||
wave_lengths_24k = torch.LongTensor([converted_waves_24k.size(1)]).to(
|
||||
converted_waves_24k.device
|
||||
)
|
||||
waves_input = converted_waves_24k.unsqueeze(1)
|
||||
if speechtokenizer_set[0] == 'facodec':
|
||||
codec_encoder = speechtokenizer_set[1]
|
||||
z = codec_encoder.encoder(waves_input)
|
||||
(quantized, codes) = codec_encoder.quantizer(z, waves_input)
|
||||
S_alt = torch.cat([codes[1], codes[0]], dim=1)
|
||||
|
||||
# S_ori should be extracted in the same way
|
||||
waves_24k = torchaudio.functional.resample(ref_audio, sr, 24000)
|
||||
waves_input = waves_24k.unsqueeze(1)
|
||||
z = codec_encoder.encoder(waves_input)
|
||||
(quantized, codes) = codec_encoder.quantizer(z, waves_input)
|
||||
S_ori = torch.cat([codes[1], codes[0]], dim=1)
|
||||
elif speechtokenizer_set[0] == 'whisper':
|
||||
whisper_model = speechtokenizer_set[1]
|
||||
whisper_feature_extractor = speechtokenizer_set[2]
|
||||
converted_waves_16k = torchaudio.functional.resample(source_audio, sr, 16000)
|
||||
alt_inputs = whisper_feature_extractor([converted_waves_16k.squeeze(0).cpu().numpy()],
|
||||
return_tensors="pt",
|
||||
return_attention_mask=True, )
|
||||
alt_input_features = whisper_model._mask_input_features(
|
||||
alt_inputs.input_features, attention_mask=alt_inputs.attention_mask).to(device)
|
||||
with torch.no_grad():
|
||||
alt_outputs = whisper_model.encoder(
|
||||
alt_input_features.to(whisper_model.encoder.dtype),
|
||||
head_mask=None,
|
||||
output_attentions=False,
|
||||
output_hidden_states=False,
|
||||
return_dict=True,
|
||||
)
|
||||
S_alt = alt_outputs.last_hidden_state.to(torch.float32)
|
||||
S_alt = S_alt[:, :converted_waves_16k.size(-1) // 320 + 1]
|
||||
|
||||
ori_waves_16k = torchaudio.functional.resample(ref_audio, sr, 16000)
|
||||
ori_inputs = whisper_feature_extractor([ori_waves_16k.squeeze(0).cpu().numpy()],
|
||||
return_tensors="pt",
|
||||
return_attention_mask=True)
|
||||
ori_input_features = whisper_model._mask_input_features(
|
||||
ori_inputs.input_features, attention_mask=ori_inputs.attention_mask).to(device)
|
||||
with torch.no_grad():
|
||||
ori_outputs = whisper_model.encoder(
|
||||
ori_input_features.to(whisper_model.encoder.dtype),
|
||||
head_mask=None,
|
||||
output_attentions=False,
|
||||
output_hidden_states=False,
|
||||
return_dict=True,
|
||||
)
|
||||
S_ori = ori_outputs.last_hidden_state.to(torch.float32)
|
||||
S_ori = S_ori[:, :ori_waves_16k.size(-1) // 320 + 1]
|
||||
else:
|
||||
raise ValueError(f"Unsupported speech tokenizer type: {speechtokenizer_set[0]}")
|
||||
|
||||
mel = to_mel(source_audio.to(device).float())
|
||||
mel2 = to_mel(ref_audio.to(device).float())
|
||||
|
||||
target_lengths = torch.LongTensor([int(mel.size(2) * length_adjust)]).to(mel.device)
|
||||
target2_lengths = torch.LongTensor([mel2.size(2)]).to(mel2.device)
|
||||
|
||||
feat2 = torchaudio.compliance.kaldi.fbank(
|
||||
ref_waves_16k, num_mel_bins=80, dither=0, sample_frequency=16000
|
||||
)
|
||||
feat2 = feat2 - feat2.mean(dim=0, keepdim=True)
|
||||
style2 = campplus_model(feat2.unsqueeze(0))
|
||||
# Length regulation
|
||||
cond = model.length_regulator(
|
||||
S_alt, ylens=target_lengths, n_quantizers=3, f0=None
|
||||
)[0]
|
||||
prompt_condition = model.length_regulator(
|
||||
S_ori, ylens=target2_lengths, n_quantizers=3, f0=None
|
||||
)[0]
|
||||
cat_condition = torch.cat([prompt_condition, cond], dim=1)
|
||||
|
||||
vc_target = model.cfm.inference(
|
||||
cat_condition,
|
||||
torch.LongTensor([cat_condition.size(1)]).to(mel2.device),
|
||||
mel2,
|
||||
style2,
|
||||
None,
|
||||
diffusion_steps,
|
||||
inference_cfg_rate=inference_cfg_rate,
|
||||
)
|
||||
vc_target = vc_target[:, :, mel2.size(-1) :]
|
||||
|
||||
# Convert to waveform
|
||||
vc_wave = bigvgan_model(vc_target).squeeze(1)
|
||||
|
||||
return ref_waves_16k, vc_wave
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument(
|
||||
"--source", type=str, default="./examples/libritts-test-clean/"
|
||||
)
|
||||
parser.add_argument("--target", type=str, default="./examples/reference/")
|
||||
parser.add_argument("--output", type=str, default="./examples/eval/converted/")
|
||||
parser.add_argument("--diffusion-steps", type=int, default=30)
|
||||
parser.add_argument("--length-adjust", type=float, default=1.0)
|
||||
parser.add_argument("--inference-cfg-rate", type=float, default=0.7)
|
||||
parser.add_argument(
|
||||
"--xvector-extractor", type=str, default="resemblyzer"
|
||||
) # wavlm or resemblyzer
|
||||
parser.add_argument("--baseline", type=str, default="") # use "" for Seed-VC
|
||||
parser.add_argument("--max-samples", type=int, default=20)
|
||||
args = parser.parse_args()
|
||||
main(args)
|
||||
Reference in New Issue
Block a user