eval.py

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)

    vocoder_type = model_params.vocoder.type

    if vocoder_type == 'bigvgan':
        from modules.bigvgan import bigvgan
        bigvgan_name = model_params.vocoder.name
        bigvgan_model = bigvgan.BigVGAN.from_pretrained(bigvgan_name, 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)
        vocoder_fn = bigvgan_model
    elif vocoder_type == 'hifigan':
        from modules.hifigan.generator import HiFTGenerator
        from modules.hifigan.f0_predictor import ConvRNNF0Predictor
        hift_config = yaml.safe_load(open('configs/hifigan.yml', 'r'))
        hift_gen = HiFTGenerator(**hift_config['hift'], f0_predictor=ConvRNNF0Predictor(**hift_config['f0_predictor']))
        hift_gen.load_state_dict(torch.load(hift_config['pretrained_model_path'], map_location='cpu'))
        hift_gen.eval()
        hift_gen.to(device)
        vocoder_fn = hift_gen
    elif vocoder_type == "vocos":
        vocos_config = yaml.safe_load(open(model_params.vocoder.vocos.config, 'r'))
        vocos_path = model_params.vocoder.vocos.path
        vocos_model_params = recursive_munch(vocos_config['model_params'])
        vocos = build_model(vocos_model_params, stage='mel_vocos')
        vocos_checkpoint_path = vocos_path
        vocos, _, _, _ = load_checkpoint(vocos, None, vocos_checkpoint_path,
                                         load_only_params=True, ignore_modules=[], is_distributed=False)
        _ = [vocos[key].eval().to(device) for key in vocos]
        _ = [vocos[key].to(device) for key in vocos]
        total_params = sum(sum(p.numel() for p in vocos[key].parameters() if p.requires_grad) for key in vocos.keys())
        print(f"Vocoder model total parameters: {total_params / 1_000_000:.2f}M")
        vocoder_fn = vocos.decoder
    else:
        raise ValueError(f"Unsupported vocoder type: {vocoder_type}")

    speech_tokenizer_type = model_params.speech_tokenizer.type
    if speech_tokenizer_type == 'whisper':
        # whisper
        from transformers import AutoFeatureExtractor, WhisperModel
        whisper_name = model_params.speech_tokenizer.name
        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)

        def semantic_fn(waves_16k):
            ori_inputs = whisper_feature_extractor([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[:, :waves_16k.size(-1) // 320 + 1]
            return S_ori
    elif speech_tokenizer_type == 'cnhubert':
        from transformers import (
            Wav2Vec2FeatureExtractor,
            HubertModel,
        )
        hubert_model_name = config['model_params']['speech_tokenizer']['name']
        hubert_feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(hubert_model_name)
        hubert_model = HubertModel.from_pretrained(hubert_model_name)
        hubert_model = hubert_model.to(device)
        hubert_model = hubert_model.eval()
        hubert_model = hubert_model.half()

        def semantic_fn(waves_16k):
            ori_waves_16k_input_list = [
                waves_16k[bib].cpu().numpy()
                for bib in range(len(waves_16k))
            ]
            ori_inputs = hubert_feature_extractor(ori_waves_16k_input_list,
                                                  return_tensors="pt",
                                                  return_attention_mask=True,
                                                  padding=True,
                                                  sampling_rate=16000).to(device)
            with torch.no_grad():
                ori_outputs = hubert_model(
                    ori_inputs.input_values.half(),
                )
            S_ori = ori_outputs.last_hidden_state.float()
            return S_ori
    elif speech_tokenizer_type == 'xlsr':
        from transformers import (
            Wav2Vec2FeatureExtractor,
            Wav2Vec2Model,
        )
        model_name = config['model_params']['speech_tokenizer']['name']
        output_layer = config['model_params']['speech_tokenizer']['output_layer']
        wav2vec_feature_extractor = Wav2Vec2FeatureExtractor.from_pretrained(model_name)
        wav2vec_model = Wav2Vec2Model.from_pretrained(model_name)
        wav2vec_model.encoder.layers = wav2vec_model.encoder.layers[:output_layer]
        wav2vec_model = wav2vec_model.to(device)
        wav2vec_model = wav2vec_model.eval()
        wav2vec_model = wav2vec_model.half()

        def semantic_fn(waves_16k):
            ori_waves_16k_input_list = [
                waves_16k[bib].cpu().numpy()
                for bib in range(len(waves_16k))
            ]
            ori_inputs = wav2vec_feature_extractor(ori_waves_16k_input_list,
                                                   return_tensors="pt",
                                                   return_attention_mask=True,
                                                   padding=True,
                                                   sampling_rate=16000).to(device)
            with torch.no_grad():
                ori_outputs = wav2vec_model(
                    ori_inputs.input_values.half(),
                )
            S_ori = ori_outputs.last_hidden_state.float()
            return S_ori
    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']['spect_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,
        semantic_fn,
        vocoder_fn,
        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()
    elif args.xvector_extractor == 'wavlm-large':
        import sys
        sys.path.append("../UniSpeech/downstreams/speaker_verification")
        from verification import init_model
        wavlm_model = init_model("wavlm_large", "D:/wavlm_large_finetune.pth")
        wavlm_model.cuda()
        wavlm_model.eval()
    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,
        semantic_fn,
        vocoder_fn,
        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,
                        semantic_fn,
                        vocoder_fn,
                        campplus_model,
                        to_mel,
                        mel_fn_args,
                        sr,
                        length_adjust,
                        diffusion_steps,
                        inference_cfg_rate,
                        remove_prompt=args.remove_prompt,
                    )
                    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)
            elif args.xvector_extractor == 'wavlm-large':
                ref_embed = wavlm_model(ref_waves_16k.to(device)).cpu()
                vc_embed = wavlm_model(vc_wave_16k.to(device)).cpu()
                similarity = torch.nn.functional.cosine_similarity(ref_embed, vc_embed, dim=-1)
            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,

    semantic_fn,

    vocoder_fn,

    campplus_model,

    to_mel,

    mel_fn_args,

    sr,

    length_adjust,

    diffusion_steps,

    inference_cfg_rate,

    remove_prompt=False,

):
    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)

    S_alt = semantic_fn(source_waves_16k)
    S_ori = semantic_fn(ref_waves_16k)

    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]
    if remove_prompt:
        cat_condition = cond
        mel2 = torch.zeros([mel2.size(0), mel2.size(1), 0]).to(mel2.device)
    else:
        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 = vocoder_fn(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="wavlm-large"
    )  # wavlm or resemblyzer
    parser.add_argument("--baseline", type=str, default="") # use "" for Seed-VC
    parser.add_argument("--max-samples", type=int, default=20)
    parser.add_argument("--remove-prompt", type=bool, default=False)
    args = parser.parse_args()
    main(args)