DL-Art-School/codes/trainer/eval/audio_diffusion_fid.py

import os
import os.path as osp
import random

import torch
import torchaudio
import torchvision.utils
from pytorch_fid.fid_score import calculate_frechet_distance
from torch import distributed
from tqdm import tqdm
from transformers import Wav2Vec2ForCTC
import torch.nn.functional as F
import numpy as np

import trainer.eval.evaluator as evaluator
from data.audio.paired_voice_audio_dataset import load_tsv_aligned_codes
from data.audio.unsupervised_audio_dataset import load_audio
from data.audio.voice_tokenizer import VoiceBpeTokenizer
from models.clip.mel_text_clip import MelTextCLIP
from models.audio.tts.tacotron2 import text_to_sequence
from scripts.audio.gen.speech_synthesis_utils import load_discrete_vocoder_diffuser, wav_to_mel, load_speech_dvae, \
    convert_mel_to_codes, load_univnet_vocoder, wav_to_univnet_mel, load_clvp
from trainer.injectors.audio_injectors import denormalize_mel, TorchMelSpectrogramInjector, normalize_mel
from utils.util import ceil_multiple, opt_get, load_model_from_config, pad_or_truncate


class AudioDiffusionFid(evaluator.Evaluator):
    """
    Evaluator produces generate from a diffusion model, then uses a CLIP model to judge the similarity between text & speech.

    This evaluator is kind of a mess. It has been repeatedly modified to work with several different model types, which
    means it is bloated beyond belief. I would not recommend attempting to understand what is going on here.
    """
    def __init__(self, model, opt_eval, env):
        super().__init__(model, opt_eval, env, uses_all_ddp=True)
        self.real_path = opt_eval['eval_tsv']
        self.data = load_tsv_aligned_codes(self.real_path)

        # Deterministically shuffle the data.
        ostate = random.getstate()
        random.seed(5)
        random.shuffle(self.data)
        random.setstate(ostate)

        if 'clip_dataset' in opt_eval.keys():
            self.data = self.data[:opt_eval['clip_dataset']]
        if distributed.is_initialized() and distributed.get_world_size() > 1:
            self.skip = distributed.get_world_size()  # One batch element per GPU.
        else:
            self.skip = 1
        diffusion_steps = opt_get(opt_eval, ['diffusion_steps'], 50)
        diffusion_schedule = opt_get(env['opt'], ['steps', 'generator', 'injectors', 'diffusion', 'beta_schedule', 'schedule_name'], None)
        if diffusion_schedule is None:
            print("Unable to infer diffusion schedule from master options. Getting it from eval (or guessing).")
            diffusion_schedule = opt_get(opt_eval, ['diffusion_schedule'], 'cosine')
        conditioning_free_diffusion_enabled = opt_get(opt_eval, ['conditioning_free'], False)
        conditioning_free_k = opt_get(opt_eval, ['conditioning_free_k'], 1)
        self.diffuser = load_discrete_vocoder_diffuser(desired_diffusion_steps=diffusion_steps, schedule=diffusion_schedule,
                                                       enable_conditioning_free_guidance=conditioning_free_diffusion_enabled,
                                                       conditioning_free_k=conditioning_free_k)
        self.bpe_tokenizer = VoiceBpeTokenizer('../experiments/bpe_lowercase_asr_256.json')
        self.dev = self.env['device']
        mode = opt_get(opt_eval, ['diffusion_type'], 'tts')
        self.local_modules = {}
        if mode == 'tts':
            self.diffusion_fn = self.perform_diffusion_tts
        elif mode == 'original_vocoder':
            self.local_modules['dvae'] = load_speech_dvae().cpu()
            self.diffusion_fn = self.perform_original_diffusion_vocoder
        elif mode == 'vocoder':
            self.local_modules['dvae'] = load_speech_dvae().cpu()
            self.diffusion_fn = self.perform_diffusion_vocoder
        elif mode == 'ctc_to_mel':
            self.diffusion_fn = self.perform_diffusion_ctc
            self.local_modules['vocoder'] = load_univnet_vocoder().cpu()
            self.local_modules['clvp'] = load_clvp()
        elif 'tts9_mel' in mode:
            mel_means, self.mel_max, self.mel_min, mel_stds, mel_vars = torch.load('../experiments/univnet_mel_norms.pth')
            self.local_modules['dvae'] = load_speech_dvae().cpu()
            self.local_modules['vocoder'] = load_univnet_vocoder().cpu()
            self.diffusion_fn = self.perform_diffusion_tts9_mel_from_codes
            if mode == 'tts9_mel_autoin':
                self.local_modules['autoregressive'] = load_model_from_config("../experiments/train_gpt_tts_unified.yml",
                                                                              model_name='gpt',
                                                                              also_load_savepoint=False,
                                                                              load_path='../experiments/unified_large_diverse_basis.pth',
                                                                              device=torch.device('cpu')).cuda().eval()
                self.tts9_codegen = self.tts9_get_autoregressive_codes
            else:
                self.tts9_codegen = self.tts9_get_dvae_codes
        elif 'tfd' == mode:
            self.diffusion_fn = self.perform_diffusion_tfd
            self.local_modules['vocoder'] = load_univnet_vocoder().cpu()

    def perform_diffusion_tts(self, audio, codes, text, sample_rate=5500):
        real_resampled = torchaudio.functional.resample(audio, 22050, sample_rate).unsqueeze(0)
        aligned_codes_compression_factor = sample_rate * 221 // 11025
        output_size = codes.shape[-1]*aligned_codes_compression_factor
        padded_size = ceil_multiple(output_size, 2048)
        padding_added = padded_size - output_size
        padding_needed_for_codes = padding_added // aligned_codes_compression_factor
        if padding_needed_for_codes > 0:
            codes = F.pad(codes, (0, padding_needed_for_codes))
        output_shape = (1, 1, padded_size)
        gen = self.diffuser.p_sample_loop(self.model, output_shape,
                                    model_kwargs={'tokens': codes.unsqueeze(0),
                                                  'conditioning_input': real_resampled})
        return gen, real_resampled, sample_rate

    def perform_original_diffusion_vocoder(self, audio, codes, text, sample_rate=11025):
        mel = wav_to_mel(audio)
        mel_codes = convert_mel_to_codes(self.local_modules['dvae'], mel)
        back_to_mel = self.local_modules['dvae'].decode(mel_codes)[0]
        orig_audio = audio
        real_resampled = torchaudio.functional.resample(audio, 22050, sample_rate).unsqueeze(0)

        output_size = real_resampled.shape[-1]
        aligned_mel_compression_factor = output_size // back_to_mel.shape[-1]
        padded_size = ceil_multiple(output_size, 2048)
        padding_added = padded_size - output_size
        padding_needed_for_codes = padding_added // aligned_mel_compression_factor
        if padding_needed_for_codes > 0:
            back_to_mel = F.pad(back_to_mel, (0, padding_needed_for_codes))
        output_shape = (1, 1, padded_size)
        gen = self.diffuser.p_sample_loop(self.model, output_shape,
                                    model_kwargs={'spectrogram': back_to_mel,
                                                  'conditioning_input': orig_audio.unsqueeze(0)})

        # Pop it back down to 5.5kHz for an accurate comparison with the other diffusers.
        real_resampled = torchaudio.functional.resample(real_resampled.squeeze(0), sample_rate, 5500).unsqueeze(0)
        gen = torchaudio.functional.resample(gen.squeeze(0), sample_rate, 5500).unsqueeze(0)
        return gen, real_resampled, 5500


    def perform_diffusion_vocoder(self, audio, codes, text, sample_rate=5500):
        mel = wav_to_mel(audio)
        mel_codes = convert_mel_to_codes(self.local_modules['dvae'], mel)
        text_codes = text_to_sequence(text)
        real_resampled = torchaudio.functional.resample(audio, 22050, sample_rate).unsqueeze(0)

        output_size = real_resampled.shape[-1]
        aligned_codes_compression_factor = output_size // mel_codes.shape[-1]
        padded_size = ceil_multiple(output_size, 2048)
        padding_added = padded_size - output_size
        padding_needed_for_codes = padding_added // aligned_codes_compression_factor
        if padding_needed_for_codes > 0:
            mel_codes = F.pad(mel_codes, (0, padding_needed_for_codes))
        output_shape = (1, 1, padded_size)
        gen = self.diffuser.p_sample_loop(self.model, output_shape,
                                    model_kwargs={'tokens': mel_codes,
                                                  'conditioning_input': audio.unsqueeze(0),
                                                  'unaligned_input': torch.tensor(text_codes, device=audio.device).unsqueeze(0)})
        return gen, real_resampled, sample_rate

    def tts9_get_autoregressive_codes(self, mel, text):
        mel_codes = convert_mel_to_codes(self.local_modules['dvae'], mel)
        text_codes = torch.LongTensor(self.bpe_tokenizer.encode(text)).unsqueeze(0).to(mel.device)
        cond_inputs = pad_or_truncate(mel, 132300//256).unsqueeze(1)
        mlc = self.local_modules['autoregressive'].mel_length_compression
        auto_latents = self.local_modules['autoregressive'](cond_inputs, text_codes,
                                                                    torch.tensor([text_codes.shape[-1]], device=mel.device),
                                                                    mel_codes,
                                                                    torch.tensor([mel_codes.shape[-1]*mlc], device=mel.device),
                                                                    text_first=True, raw_mels=None, return_latent=True,
                                                                    clip_inputs=False)
        return auto_latents

    def tts9_get_dvae_codes(self, mel, text):
        return convert_mel_to_codes(self.local_modules['dvae'], mel)

    def perform_diffusion_tts9_mel_from_codes(self, audio, codes, text):
        SAMPLE_RATE = 24000
        mel = wav_to_mel(audio)
        mel_codes = self.tts9_codegen(mel, text)
        real_resampled = torchaudio.functional.resample(audio, 22050, SAMPLE_RATE).unsqueeze(0)
        univnet_mel = wav_to_univnet_mel(real_resampled, do_normalization=False)  # to be used for a conditioning input, but also guides output shape.
        output_shape = univnet_mel.shape
        gen_mel = self.diffuser.p_sample_loop(self.model, output_shape,
                                    model_kwargs={'aligned_conditioning': mel_codes,
                                                  'conditioning_input': univnet_mel})
        # denormalize mel
        gen_mel = denormalize_mel(gen_mel)

        gen_wav = self.local_modules['vocoder'].inference(gen_mel)
        real_dec = self.local_modules['vocoder'].inference(univnet_mel)
        return gen_wav.float(), real_dec, SAMPLE_RATE

    def perform_diffusion_ctc(self, audio, codes, text):
        SAMPLE_RATE = 24000
        text_codes = torch.LongTensor(self.bpe_tokenizer.encode(text)).unsqueeze(0).to(audio.device)
        clvp_latent = self.local_modules['clvp'].embed_text(text_codes)

        real_resampled = torchaudio.functional.resample(audio, 22050, SAMPLE_RATE).unsqueeze(0)
        univnet_mel = wav_to_univnet_mel(real_resampled, do_normalization=True)
        output_shape = univnet_mel.shape
        cond_mel = TorchMelSpectrogramInjector({'n_mel_channels': 100, 'mel_fmax': 11000, 'filter_length': 8000, 'normalize': True,
                                                'true_normalization': True, 'in': 'in', 'out': 'out'}, {})({'in': audio})['out']

        gen_mel = self.diffuser.p_sample_loop(self.model, output_shape, model_kwargs={'codes': codes.unsqueeze(0),
                                                  'conditioning_input': cond_mel, 'type': torch.tensor([0], device=codes.device),
                                                  'clvp_input': clvp_latent})
        gen_mel_denorm = denormalize_mel(gen_mel)

        gen_wav = self.local_modules['vocoder'].inference(gen_mel_denorm)
        real_dec = self.local_modules['vocoder'].inference(denormalize_mel(univnet_mel))
        return gen_wav.float(), real_dec, gen_mel, univnet_mel, SAMPLE_RATE

    def perform_diffusion_tfd(self, audio, codes, text):
        SAMPLE_RATE = 24000
        audio_resampled = torchaudio.functional.resample(audio, 22050, SAMPLE_RATE).unsqueeze(0)
        vmel = wav_to_mel(audio)
        umel = wav_to_univnet_mel(audio_resampled, do_normalization=True)
        gen_mel = self.diffuser.p_sample_loop(self.model, umel.shape,
                                              model_kwargs={'truth_mel': vmel,
                                                            'conditioning_input': None,
                                                            'disable_diversity': True})

        gen_wav = self.local_modules['vocoder'].inference(denormalize_mel(gen_mel))
        real_dec = self.local_modules['vocoder'].inference(denormalize_mel(umel))
        return gen_wav.float(), real_dec, gen_mel, umel, SAMPLE_RATE

    def load_projector(self):
        """
        Builds the CLIP model used to project speech into a latent. This model has fixed parameters and a fixed loading
        path for the time being.
        """
        model = MelTextCLIP(dim_text=512, dim_latent=512, dim_speech=512, num_text_tokens=148, text_enc_depth=8,
                            text_seq_len=400, text_heads=8, speech_enc_depth=10, speech_heads=8, speech_seq_len=1000,
                            text_mask_percentage=.15, voice_mask_percentage=.15)
        weights = torch.load('../experiments/clip_text_to_voice_for_speech_fid.pth')
        model.load_state_dict(weights)
        return model

    def project(self, projector, sample, sample_rate):
        sample = torchaudio.functional.resample(sample, sample_rate, 22050)
        mel = wav_to_mel(sample)
        return projector.get_speech_projection(mel).squeeze(0)  # Getting rid of the batch dimension means it's just [hidden_dim]

    def load_w2v(self):
        return Wav2Vec2ForCTC.from_pretrained("jbetker/wav2vec2-large-robust-ft-libritts-voxpopuli")

    def intelligibility_loss(self, w2v, sample, real_sample, sample_rate, real_text):
        """
        Measures the differences between CTC losses using wav2vec2 against the real sample and the generated sample.
        """
        text_codes = torch.tensor(text_to_sequence(real_text), device=sample.device)
        results = []
        for s in [sample, real_sample]:
            s = torchaudio.functional.resample(s, sample_rate, 16000)
            norm_s = (s - s.mean()) / torch.sqrt(s.var() + 1e-7)
            norm_s = norm_s.squeeze(1)
            loss = w2v(input_values=norm_s, labels=text_codes).loss
            results.append(loss)
        gen_loss, real_loss = results
        return gen_loss - real_loss

    def compute_frechet_distance(self, proj1, proj2):
        # I really REALLY FUCKING HATE that this is going to numpy. Why does "pytorch_fid" operate in numpy land. WHY?
        proj1 = proj1.cpu().numpy()
        proj2 = proj2.cpu().numpy()
        mu1 = np.mean(proj1, axis=0)
        mu2 = np.mean(proj2, axis=0)
        sigma1 = np.cov(proj1, rowvar=False)
        sigma2 = np.cov(proj2, rowvar=False)
        return torch.tensor(calculate_frechet_distance(mu1, sigma1, mu2, sigma2))

    def perform_eval(self):
        save_path = osp.join(self.env['base_path'], "../", "audio_eval", str(self.env["step"]))
        os.makedirs(save_path, exist_ok=True)

        projector = self.load_projector().to(self.env['device'])
        projector.eval()

        w2v = self.load_w2v().to(self.env['device'])
        w2v.eval()
        for k, mod in self.local_modules.items():
            self.local_modules[k] = mod.to(self.env['device'])

        # Attempt to fix the random state as much as possible. RNG state will be restored before returning.
        rng_state = torch.get_rng_state()
        torch.manual_seed(5)
        self.model.eval()

        with torch.no_grad():
            gen_projections = []
            real_projections = []
            intelligibility_losses = []
            for i in tqdm(list(range(0, len(self.data), self.skip))):
                path, text, codes = self.data[i + self.env['rank']]
                audio = load_audio(path, 22050).to(self.dev)
                codes = codes.to(self.dev)
                sample, ref, gen_mel, ref_mel, sample_rate = self.diffusion_fn(audio, codes, text)

                gen_projections.append(self.project(projector, sample, sample_rate).cpu())  # Store on CPU to avoid wasting GPU memory.
                real_projections.append(self.project(projector, ref, sample_rate).cpu())
                intelligibility_losses.append(self.intelligibility_loss(w2v, sample, ref, sample_rate, text))

                torchvision.utils.save_image((gen_mel.unsqueeze(1) + 1) / 2, os.path.join(save_path, f'{self.env["rank"]}_{i}_mel.png'))
                torchvision.utils.save_image((ref_mel.unsqueeze(1) + 1) / 2, os.path.join(save_path, f'{self.env["rank"]}_{i}_mel_target.png'))
                torchaudio.save(os.path.join(save_path, f"{self.env['rank']}_{i}_gen.wav"), sample.squeeze(0).cpu(), sample_rate)
                torchaudio.save(os.path.join(save_path, f"{self.env['rank']}_{i}_real.wav"), ref.squeeze(0).cpu(), sample_rate)
            gen_projections = torch.stack(gen_projections, dim=0)
            real_projections = torch.stack(real_projections, dim=0)
            intelligibility_loss = torch.stack(intelligibility_losses, dim=0).mean()
            frechet_distance = torch.tensor(self.compute_frechet_distance(gen_projections, real_projections), device=self.env['device'])

            if distributed.is_initialized() and distributed.get_world_size() > 1:
                distributed.all_reduce(frechet_distance)
                frechet_distance = frechet_distance / distributed.get_world_size()
                distributed.all_reduce(intelligibility_loss)
                intelligibility_loss = intelligibility_loss / distributed.get_world_size()

        self.model.train()
        torch.set_rng_state(rng_state)

        # Put modules used for evaluation back into CPU memory.
        for k, mod in self.local_modules.items():
            self.local_modules[k] = mod.cpu()

        return {"frechet_distance": frechet_distance, "intelligibility_loss": intelligibility_loss}

"""
if __name__ == '__main__':
    from utils.util import load_model_from_config

    diffusion = load_model_from_config('X:\\dlas\\experiments\\train_diffusion_tts7_dvae_thin_with_text.yml', 'generator',
                                       also_load_savepoint=False, load_path='X:\\dlas\\experiments\\train_diffusion_tts7_dvae_thin_with_text\\models\\56500_generator_ema.pth').cuda()
    opt_eval = {'eval_tsv': 'Y:\\libritts\\test-clean\\transcribed-brief-w2v.tsv', 'diffusion_steps': 100,
                'conditioning_free': False, 'conditioning_free_k': 1,
                'diffusion_schedule': 'linear', 'diffusion_type': 'vocoder'}
    env = {'rank': 0, 'base_path': 'D:\\tmp\\test_eval', 'step': 2, 'device': 'cuda', 'opt': {}}
    eval = AudioDiffusionFid(diffusion, opt_eval, env)
    print(eval.perform_eval())
"""


if __name__ == '__main__':
    diffusion = load_model_from_config('X:\\dlas\\experiments\\train_tts_diffusion_tfd11_quant.yml', 'generator',
                                       also_load_savepoint=False,
                                       load_path='X:\\dlas\\experiments\\train_tts_diffusion_tfd12_linear_dvae\\models\\12000_generator.pth').cuda()
    opt_eval = {'eval_tsv': 'Y:\\libritts\\test-clean\\transcribed-brief-w2v.tsv', 'diffusion_steps': 50,
                'conditioning_free': False, 'conditioning_free_k': 1,
                'diffusion_schedule': 'linear', 'diffusion_type': 'tfd'}
    env = {'rank': 0, 'base_path': 'D:\\tmp\\test_eval', 'step': 101, 'device': 'cuda', 'opt': {}}
    eval = AudioDiffusionFid(diffusion, opt_eval, env)
    print(eval.perform_eval())