batch_eval_dpo.py

import logging
import os
from pathlib import Path

import hydra
import torch
import torch.distributed as distributed
import torchaudio
from hydra.core.hydra_config import HydraConfig
from omegaconf import DictConfig
from tqdm import tqdm

from mmaudio.data.data_setup import setup_eval_dataset
from mmaudio.eval_utils import ModelConfig, all_model_cfg, generate, make_video_new, load_full_video_frames, make_video, generate_dpo
from mmaudio.model.flow_matching import FlowMatching
from mmaudio.model.networks_new import MMAudio, get_my_mmaudio
from mmaudio.model.utils.features_utils import FeaturesUtils

torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True

local_rank = int(os.environ['LOCAL_RANK'])
world_size = int(os.environ['WORLD_SIZE'])
log = logging.getLogger()


@torch.inference_mode()
@hydra.main(version_base='1.3.2', config_path='config', config_name='eval_for_dpo_config.yaml')
def main(cfg: DictConfig):
    device = 'cuda'
    torch.cuda.set_device(local_rank)

    if cfg.model not in all_model_cfg:
        raise ValueError(f'Unknown model variant: {cfg.model}')
    model: ModelConfig = all_model_cfg[cfg.model]
    # model.download_if_needed()
    seq_cfg = model.seq_cfg

    run_dir = Path(HydraConfig.get().run.dir)
    if cfg.output_name is None:
        output_dir = run_dir / cfg.dataset
    else:
        output_dir = run_dir / f'{cfg.dataset}-{cfg.output_name}'
    output_dir.mkdir(parents=True, exist_ok=True)

    # load a pretrained model
    seq_cfg.duration = cfg.duration_s
    net: MMAudio = get_my_mmaudio(cfg.model).to(device).eval()
    
    # todo May 10
    if model.model_path is None:
        if model.model_name == 'small_44k': 
            model.model_path = Path(cfg.small_44k_pretrained_ckpt_path)
        else:
            raise ValueError('Given Model Is Not Supported !')
    
    net.load_weights(torch.load(model.model_path, map_location=device, weights_only=True))
    log.info(f'Loaded weights from {model.model_path}')
    net.update_seq_lengths(seq_cfg.latent_seq_len, seq_cfg.clip_seq_len, seq_cfg.sync_seq_len)
    log.info(f'Latent seq len: {seq_cfg.latent_seq_len}')
    log.info(f'Clip seq len: {seq_cfg.clip_seq_len}')
    log.info(f'Sync seq len: {seq_cfg.sync_seq_len}')

    # misc setup
    rng = torch.Generator(device=device)
    rng.manual_seed(cfg.seed)
    fm = FlowMatching(cfg.sampling.min_sigma,
                      inference_mode=cfg.sampling.method,
                      num_steps=cfg.sampling.num_steps)

    feature_utils = FeaturesUtils(tod_vae_ckpt=model.vae_path,
                                  synchformer_ckpt=model.synchformer_ckpt,
                                  enable_conditions=True,
                                  mode=model.mode,
                                  bigvgan_vocoder_ckpt=model.bigvgan_16k_path,
                                  need_vae_encoder=False)
    feature_utils = feature_utils.to(device).eval()

    if cfg.compile:
        net.preprocess_conditions = torch.compile(net.preprocess_conditions)
        net.predict_flow = torch.compile(net.predict_flow)
        feature_utils.compile()

    dataset, loader = setup_eval_dataset(cfg.dataset, cfg)

    with torch.amp.autocast(enabled=cfg.amp, dtype=torch.bfloat16, device_type=device):
        for batch in tqdm(loader):
            audios_bank = generate_dpo(batch.get('clip_video', None),
                              batch.get('sync_video', None),
                              batch.get('caption', None),
                              feature_utils=feature_utils,
                              net=net,
                              fm=fm,
                              rng=rng,
                              cfg_strength=cfg.cfg_strength,
                              clip_batch_size_multiplier=64,
                              sync_batch_size_multiplier=64,
                              num_samples_per_video=cfg.num_samples_per_video)

            # load video frames
            video_paths = batch['video_path']
            video_info_dict = {}
            for video_path in video_paths:
                video_info = load_full_video_frames(video_path, cfg.duration_s)
                video_info_dict[video_path] = video_info

            # same audio and video for each sample id
            for sample_id, audios in enumerate(audios_bank):

                audios = audios.float().cpu()
                names = batch['name']

                # # todo
                # output_dir_audio = output_dir / f'{sample_id + 1}' / 'audios'
                # output_dir_video = output_dir / f'{sample_id + 1}' / 'videos'
                # output_dir_audio.mkdir(parents=True, exist_ok=True)
                # output_dir_video.mkdir(parents=True, exist_ok=True)

                for audio, name, video_path in zip(audios, names, video_paths):
                    # todo
                    output_dir_save = output_dir / 'generated_videos' / f'{name}' / f'{sample_id + 1}'
                    output_dir_save.mkdir(parents=True, exist_ok=True)
        
                    torchaudio.save(output_dir_save / f'{name}.flac', audio, seq_cfg.sampling_rate)
                    #video_info = load_full_video_frames(video_path, cfg.duration_s) # todo should be optimized due to repeated calculation
                    video_save_path = output_dir_save / f'{name}.mp4'
                    make_video(video_info_dict[video_path], video_save_path, audio, sampling_rate=seq_cfg.sampling_rate)


def distributed_setup():
    distributed.init_process_group(backend="nccl")
    local_rank = distributed.get_rank()
    world_size = distributed.get_world_size()
    log.info(f'Initialized: local_rank={local_rank}, world_size={world_size}')
    return local_rank, world_size


if __name__ == '__main__':
    distributed_setup()

    main()

    # clean-up
    distributed.destroy_process_group()