Add files using upload-large-folder tool

batch_eval-Copy1.py

@@ -0,0 +1,135 @@
+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, make_video_new, load_video # todo Feb 24
+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_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)
+    
+    # todo
+    output_dir_audio = output_dir / 'audios'
+    output_dir_video = output_dir / 'videos'
+    output_dir_audio.mkdir(parents=True, exist_ok=True)
+    output_dir_video.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()
+    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 = generate(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)
+            audios = audios.float().cpu()
+            names = batch['name']    
+            '''
+             for audio, name in zip(audios, names):
+                 torchaudio.save(output_dir / f'{name}.flac', audio, seq_cfg.sampling_rate) 
+            '''
+            
+            '''
+            video_infos = batch.get('video_info', None)
+            assert video_infos is not None
+            for audio, name, video_info in zip(audios, names, video_infos):
+                torchaudio.save(output_dir_audio / f'{name}.flac', audio, seq_cfg.sampling_rate)
+                video_save_path = output_dir_video / f'{name}.mp4'
+                make_video(video_info, video_save_path, audio, sampling_rate=seq_cfg.sampling_rate)       
+            '''
+
+            video_paths = batch['video_path']
+
+            for audio, name, video_path in zip(audios, names, video_paths):
+                torchaudio.save(output_dir_audio / f'{name}.flac', audio, seq_cfg.sampling_rate)
+                video_info = load_video(video_path, cfg.duration_s)
+                video_save_path = output_dir_video / f'{name}.mp4'
+                make_video(video_info, 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()

batch_eval.py

@@ -0,0 +1,145 @@
+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, make_video_new, load_video # todo Feb 24
+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_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)
+    
+    # todo
+    # output_dir_audio = output_dir / 'audios'
+    # output_dir_video = output_dir / 'videos'
+    # output_dir_audio.mkdir(parents=True, exist_ok=True)
+    # output_dir_video.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)) # todo Mar 6
+    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 = generate(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)
+            audios = audios.float().cpu()
+            names = batch['name']    
+            
+            for audio, name in zip(audios, names):
+                torchaudio.save(output_dir / f'{name}.flac', audio, seq_cfg.sampling_rate) 
+            
+            
+            '''
+            video_infos = batch.get('video_info', None)
+            assert video_infos is not None
+            for audio, name, video_info in zip(audios, names, video_infos):
+                torchaudio.save(output_dir_audio / f'{name}.flac', audio, seq_cfg.sampling_rate)
+                video_save_path = output_dir_video / f'{name}.mp4'
+                make_video(video_info, video_save_path, audio, sampling_rate=seq_cfg.sampling_rate)       
+            '''
+            '''
+            video_paths = batch['video_path']
+
+            for audio, name, video_path in zip(audios, names, video_paths):
+                torchaudio.save(output_dir_audio / f'{name}.flac', audio, seq_cfg.sampling_rate)
+                video_info = load_video(video_path, cfg.duration_s)
+                video_save_path = output_dir_video / f'{name}.mp4'
+                make_video(video_info, 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()

config/base_config.yaml

@@ -0,0 +1,66 @@
+defaults:
+  - data: base
+  - eval_data: base
+  - override hydra/job_logging: custom-simplest
+  - _self_
+
+hydra:
+  run:
+    dir: ./output/${exp_id}
+  output_subdir: ${now:%Y-%m-%d_%H-%M-%S}-hydra
+
+enable_email: False
+
+model: small_44k
+
+exp_id: default
+debug: False
+cudnn_benchmark: True
+compile: True # todo True or False
+amp: True
+weights: null
+checkpoint: null
+seed: 14159265
+num_workers: 10 # per-GPU
+pin_memory: True # set to True if your system can handle it, i.e., have enough memory
+
+# NOTE: This DOSE NOT affect the model during inference in any way
+# they are just for the dataloader to fill in the missing data in multi-modal loading
+# to change the sequence length for the model, see networks.py
+data_dim:
+  text_seq_len: 77
+  clip_dim: 1024
+  sync_dim: 768
+  text_dim: 1024
+
+# ema configuration
+ema:
+  enable: True 
+  sigma_rels: [0.05, 0.1]
+  update_every: 1
+  checkpoint_every: 5_000
+  checkpoint_folder: ./output/${exp_id}/ema_ckpts
+  default_output_sigma: 0.05
+
+
+# sampling
+sampling:
+  mean: 0.0
+  scale: 1.0
+  min_sigma: 0.0
+  method: euler
+  num_steps: 25
+
+# classifier-free guidance
+null_condition_probability: 0.1 #0.1 todo Feb 10
+cfg_strength: 4.5 #4.5
+
+text_condition_drop_enable: False # todo Jan 16 False or True
+text_drop_step: 100_000 # todo Jan 16
+text_condition_drop_probability: [0.1, 0.3, 0.5] #[0.1, 0.3, 0.5] # todo Jan 16
+
+# checkpoint paths to external modules
+vae_16k_ckpt: ./ext_weights/v1-16.pth
+vae_44k_ckpt: ./ext_weights/v1-44.pth
+bigvgan_vocoder_ckpt: ./ext_weights/best_netG.pt
+synchformer_ckpt: ./ext_weights/synchformer_state_dict.pth

config/dpo_base_config.yaml

@@ -0,0 +1,88 @@
+defaults:
+  - dpo_data: base
+  - eval_data: base
+  - override hydra/job_logging: custom-simplest
+  - _self_
+
+hydra:
+  run:
+    dir: ./output/${exp_id}
+  output_subdir: ${now:%Y-%m-%d_%H-%M-%S}-hydra
+
+enable_email: False
+
+model: small_44k
+
+exp_id: default
+debug: False
+cudnn_benchmark: True
+compile: True # todo True or False
+amp: True
+weights: null
+checkpoint: null
+pretrained_ckpt_for_dpo: ./output/vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k/vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_ema_final.pth
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May12_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k/vgg_only_small_44k_lumina_v2a_two_stream_May12_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_ema_final.pth
+
+#'./output/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16_ema_final.pth' 
+
+# todo for iter1 checkpoint: beta20000_full_reward_ib_desync
+#'./output/vgg_only_small_44k_lumina_v2a_two_stream_May7_depth16_caption_beta20000_full_reward_ib_desync/vgg_only_small_44k_lumina_v2a_two_stream_May7_depth16_caption_beta20000_full_reward_ib_desync_ema_final.pth'
+
+#'./output/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16_ema_final.pth' 
+
+#'./output/vgg_only_small_44k_lumina_v2a_two_stream_May6_depth16_caption_beta2000_iter1_desync/vgg_only_small_44k_lumina_v2a_two_stream_May6_depth16_caption_beta2000_iter1_desync_ema_final.pth'
+
+#'./output/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16_ema_final.pth'
+
+#'./output/vgg_only_small_44k_lumina_v2a_two_stream_May6_depth16_caption_beta2000_iter1_desync/vgg_only_small_44k_lumina_v2a_two_stream_May6_depth16_caption_beta2000_iter1_desync_ema_final.pth'
+
+#---> always used ckpt of baseline model: 
+#'./output/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16_ema_final.pth' 
+
+#'./output/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16_last.pth' 
+#'./output/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16_ema_final.pth' # todo add Mar 2
+seed: 14159265
+num_workers: 10 # per-GPU
+pin_memory: True # set to True if your system can handle it, i.e., have enough memory
+
+# NOTE: This DOSE NOT affect the model during inference in any way
+# they are just for the dataloader to fill in the missing data in multi-modal loading
+# to change the sequence length for the model, see networks.py
+data_dim:
+  text_seq_len: 77
+  clip_dim: 1024
+  sync_dim: 768
+  text_dim: 1024
+
+# ema configuration
+ema:
+  enable: True 
+  sigma_rels: [0.05, 0.1]
+  update_every: 1
+  checkpoint_every: 500      # todo 
+  checkpoint_folder: ./output/${exp_id}/ema_ckpts
+  default_output_sigma: 0.05
+
+
+# sampling
+sampling:
+  mean: 0.0
+  scale: 1.0
+  min_sigma: 0.0
+  method: euler
+  num_steps: 25
+
+# classifier-free guidance
+null_condition_probability: 0.1 #0.1 todo Feb 10
+cfg_strength: 4.5 # May base: 4.5 # todo 
+
+text_condition_drop_enable: False # todo Jan 16 False or True
+text_drop_step: 100_000 # todo Jan 16
+text_condition_drop_probability: [0.1, 0.3, 0.5] #[0.1, 0.3, 0.5] # todo Jan 16
+
+# checkpoint paths to external modules
+vae_16k_ckpt: ./ext_weights/v1-16.pth
+vae_44k_ckpt: ./ext_weights/v1-44.pth
+bigvgan_vocoder_ckpt: ./ext_weights/best_netG.pt
+synchformer_ckpt: ./ext_weights/synchformer_state_dict.pth

config/eval_config.yaml

@@ -0,0 +1,68 @@
+defaults:
+  - base_config
+  - override hydra/job_logging: custom-simplest
+  - _self_
+
+hydra:
+  run:
+    dir: ./output/${exp_id}
+  output_subdir: eval-${now:%Y-%m-%d_%H-%M-%S}-hydra
+
+exp_id: ${model}
+dataset: moviegen #vggsound # todo Jan 13
+duration_s: 8.0 # todo can be changed?
+small_44k_pretrained_ckpt_path: ./output/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16_ema_final.pth 
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k/vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_ema_final.pth
+
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter3_steps5k/vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter3_steps5k_ema_final.pth
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k/vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_ema_final.pth
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May12_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k/vgg_only_small_44k_lumina_v2a_two_stream_May12_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_ema_final.pth
+
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May12_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k/vgg_only_small_44k_lumina_v2a_two_stream_May12_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_ema_final.pth
+
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta30000_full_reward_ib_desync/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta30000_full_reward_ib_desync_ema_final.pth
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta10000_iter1_desync_to_ib_av/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta10000_iter1_desync_to_ib_av_ema_final.pth
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta20000_iter1_ib_av_at_2desync/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta20000_iter1_ib_av_at_2desync_ema_final.pth
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta20000_iter1_ib_2av_at_2desync/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta20000_iter1_ib_2av_at_2desync_ema_final.pth
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta10000_desync_to_ib_av/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta10000_desync_to_ib_av_ema_final.pth
+
+#./output/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta10000_iter1_full_reward_ib_2av_at_2desync_10audio_per_video/vgg_only_small_44k_lumina_v2a_two_stream_May10_depth16_caption_beta10000_iter1_full_reward_ib_2av_at_2desync_10audio_per_video_ema_final.pth 
+
+#./output/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16/vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb18_caption_depth16_ema_final.pth
+
+# for inference, this is the per-GPU batch size
+batch_size: 8 #16
+output_name: lumina_v2a_moviegen_Sep25_base_model_inference_ema
+
+#dpo_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter3_steps5k_inference_ema
+
+#dpo_May12_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_inference_ema
+
+#dpo_iter1_May12_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_inference_ema
+
+#dpo_iter1_May11_lumina_v2a_two_stream_depth16_caption_beta30000_full_reward_ib_desync_inference_ema
+
+#dpo_iter1_May11_lumina_v2a_two_stream_depth16_caption_beta10000_desync_to_ib_av_inference_ema
+
+#dpo_iter1_May10_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_av_at_2desync_inference_ema
+
+#dpo_iter1_May10_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_2av_at_2desync_10audio_per_video_inference_ema
+
+#dpo_iter1_May10_lumina_v2a_two_stream_depth16_caption_beta10000_desync_to_ib_av_inference_ema
+
+#dpo_iter1_May10_lumina_v2a_two_stream_depth16_caption_beta10000_full_reward_ib_2av_at_2desync_10audio_per_video_inference_ema
+
+# todo for pretrained baseline model
+#lumina_v2a_two_stream_depth16_caption_May10_check_inference_ema
+
+# todo for DPO FT model
+#dpo_iter1_May10_lumina_v2a_two_stream_depth16_caption_beta10000_full_reward_ib_av_at_2desync_10audio_per_video_inference_ema # todo Jan 14

config/eval_for_dpo_base_config.yaml

@@ -0,0 +1,66 @@
+defaults:
+  - data: base
+  - eval_data_for_gen_dpo: base
+  - override hydra/job_logging: custom-simplest
+  - _self_
+
+hydra:
+  run:
+    dir: ./output/${exp_id}
+  output_subdir: ${now:%Y-%m-%d_%H-%M-%S}-hydra
+
+enable_email: False
+
+model: small_44k
+
+exp_id: default
+debug: False
+cudnn_benchmark: True
+compile: True # todo True or False
+amp: True
+weights: null
+checkpoint: null
+seed: 14159265
+num_workers: 10 # per-GPU
+pin_memory: True # set to True if your system can handle it, i.e., have enough memory
+
+# NOTE: This DOSE NOT affect the model during inference in any way
+# they are just for the dataloader to fill in the missing data in multi-modal loading
+# to change the sequence length for the model, see networks.py
+data_dim:
+  text_seq_len: 77
+  clip_dim: 1024
+  sync_dim: 768
+  text_dim: 1024
+
+# ema configuration
+ema:
+  enable: True 
+  sigma_rels: [0.05, 0.1]
+  update_every: 1
+  checkpoint_every: 5_000
+  checkpoint_folder: ./output/${exp_id}/ema_ckpts
+  default_output_sigma: 0.05
+
+
+# sampling
+sampling:
+  mean: 0.0
+  scale: 1.0
+  min_sigma: 0.0
+  method: euler
+  num_steps: 25
+
+# classifier-free guidance
+null_condition_probability: 0.1 #0.1 todo Feb 10
+cfg_strength: 4.5
+
+text_condition_drop_enable: False # todo Jan 16 False or True
+text_drop_step: 100_000 # todo Jan 16
+text_condition_drop_probability: [0.1, 0.3, 0.5] #[0.1, 0.3, 0.5] # todo Jan 16
+
+# checkpoint paths to external modules
+vae_16k_ckpt: ./ext_weights/v1-16.pth
+vae_44k_ckpt: ./ext_weights/v1-44.pth
+bigvgan_vocoder_ckpt: ./ext_weights/best_netG.pt
+synchformer_ckpt: ./ext_weights/synchformer_state_dict.pth

config/train_config.yaml

@@ -0,0 +1,40 @@
+defaults:
+  - base_config
+  - override data: base
+  - override hydra/job_logging: custom
+  - _self_
+
+hydra:
+  run:
+    dir: ./output/${exp_id}
+  output_subdir: train-${now:%Y-%m-%d_%H-%M-%S}-hydra
+
+ema: 
+  start: 0
+
+mini_train: False
+example_train: False
+vgg_only_train: True  # todo add in Jan 11
+
+log_text_interval: 200
+log_extra_interval: 20_000
+val_interval: 5_000
+eval_interval: 1_000 # todo without using Jan 12
+save_eval_interval: 2_000 # todo without using Jan 12
+save_weights_interval: 10_000
+save_checkpoint_interval: 10_000
+save_copy_iterations: []
+
+batch_size: 512 # todo 
+eval_batch_size: 256 # per-GPU todo 
+
+num_iterations: 300_000 # todo original: 500_000
+learning_rate: 1.0e-4
+linear_warmup_steps: 1_000
+
+lr_schedule: step
+lr_schedule_steps: [240_000, 270_000] # todo original: [440_000, 470_000]
+lr_schedule_gamma: 0.1
+
+clip_grad_norm: 1.0
+weight_decay: 1.0e-6

config/train_dpo_config.yaml

@@ -0,0 +1,43 @@
+defaults:
+  - dpo_base_config
+  - override dpo_data: base
+  - override hydra/job_logging: custom
+  - _self_
+
+hydra:
+  run:
+    dir: ./output/${exp_id}
+  output_subdir: train-${now:%Y-%m-%d_%H-%M-%S}-hydra
+
+ema: 
+  start: 0
+
+mini_train: False
+example_train: False
+vgg_only_train: False  # todo add in Jan 11
+dpo_train: True # todo add in Mar 2
+beta_dpo: 20000 # todo add in Mar 12: 1000, 2000, 5000, 10000
+
+
+log_text_interval: 20         # todo 
+log_extra_interval: 500 # May base: 2_000     # todo 
+val_interval: 500            # todo 
+eval_interval: 100 # todo without using Jan 12
+save_eval_interval: 200 # todo without using Jan 12
+save_weights_interval: 1_000      # todo 
+save_checkpoint_interval: 1_000    # todo 
+save_copy_iterations: []
+
+batch_size: 256 # todo : 512
+eval_batch_size: 128 # per-GPU todo: 256
+
+num_iterations: 5_000 # May base: 10_000  # todo Mar 12: 30_000 # todo Mar 6: 10_000 
+learning_rate: 2.0e-6
+linear_warmup_steps: 100 #50 # May base: 100 # todo 
+
+lr_schedule: step
+lr_schedule_steps: [240_000, 270_000] # todo Mar 12
+lr_schedule_gamma: 0.1
+
+clip_grad_norm: 1.0
+weight_decay: 1.0e-6

docs/EVAL.md

@@ -0,0 +1,22 @@
+# Evaluation
+
+## Batch Evaluation
+
+To evaluate the model on a dataset, use the `batch_eval.py` script. It is significantly more efficient in large-scale evaluation compared to `demo.py`, supporting batched inference, multi-GPU inference, torch compilation, and skipping video compositions.
+
+An example of running this script with four GPUs is as follows:
+
+```bash
+OMP_NUM_THREADS=4 torchrun --standalone --nproc_per_node=4  batch_eval.py duration_s=8 dataset=vggsound model=small_16k num_workers=8
+```
+
+You may need to update the data paths in `config/eval_data/base.yaml`. 
+More configuration options can be found in `config/base_config.yaml` and `config/eval_config.yaml`.
+
+## Precomputed Results
+
+Precomputed results for VGGSound, AudioCaps, and MovieGen are available here: https://huggingface.co/datasets/hkchengrex/MMAudio-precomputed-results
+
+## Obtaining Quantitative Metrics
+
+Our evaluation code is available here: https://github.com/hkchengrex/av-benchmark

docs/MODELS.md

@@ -0,0 +1,50 @@
+# Pretrained models
+
+The models will be downloaded automatically when you run the demo script. MD5 checksums are provided in `mmaudio/utils/download_utils.py`.
+The models are also available at https://huggingface.co/hkchengrex/MMAudio/tree/main
+
+| Model    | Download link | File size |
+| -------- | ------- | ------- |
+| Flow prediction network, small 16kHz | <a href="https://huggingface.co/hkchengrex/MMAudio/resolve/main/weights/mmaudio_small_16k.pth" download="mmaudio_small_16k.pth">mmaudio_small_16k.pth</a> | 601M |
+| Flow prediction network, small 44.1kHz | <a href="https://huggingface.co/hkchengrex/MMAudio/resolve/main/weights/mmaudio_small_44k.pth" download="mmaudio_small_44k.pth">mmaudio_small_44k.pth</a> | 601M |
+| Flow prediction network, medium 44.1kHz | <a href="https://huggingface.co/hkchengrex/MMAudio/resolve/main/weights/mmaudio_medium_44k.pth" download="mmaudio_medium_44k.pth">mmaudio_medium_44k.pth</a> | 2.4G |
+| Flow prediction network, large 44.1kHz | <a href="https://huggingface.co/hkchengrex/MMAudio/resolve/main/weights/mmaudio_large_44k.pth" download="mmaudio_large_44k.pth">mmaudio_large_44k.pth</a> | 3.9G |
+| Flow prediction network, large 44.1kHz, v2 **(recommended)** | <a href="https://huggingface.co/hkchengrex/MMAudio/resolve/main/weights/mmaudio_large_44k_v2.pth" download="mmaudio_large_44k_v2.pth">mmaudio_large_44k_v2.pth</a> | 3.9G |
+| 16kHz VAE | <a href="https://github.com/hkchengrex/MMAudio/releases/download/v0.1/v1-16.pth">v1-16.pth</a> | 655M |
+| 16kHz BigVGAN vocoder (from Make-An-Audio 2) |<a href="https://github.com/hkchengrex/MMAudio/releases/download/v0.1/best_netG.pt">best_netG.pt</a> | 429M |
+| 44.1kHz VAE |<a href="https://github.com/hkchengrex/MMAudio/releases/download/v0.1/v1-44.pth">v1-44.pth</a> | 1.2G | 
+| Synchformer visual encoder |<a href="https://github.com/hkchengrex/MMAudio/releases/download/v0.1/synchformer_state_dict.pth">synchformer_state_dict.pth</a> | 907M |
+
+To run the model, you need four components: a flow prediction network, visual feature extractors (Synchformer and CLIP, CLIP will be downloaded automatically), a VAE, and a vocoder. VAEs and vocoders are specific to the sampling rate (16kHz or 44.1kHz) and not model sizes.
+The 44.1kHz vocoder will be downloaded automatically.
+The `_v2` model performs worse in benchmarking (e.g., in  Fréchet distance), but, in my experience, generalizes better to new data.
+
+The expected directory structure (full):
+
+```bash
+MMAudio
+├── ext_weights
+│   ├── best_netG.pt
+│   ├── synchformer_state_dict.pth
+│   ├── v1-16.pth
+│   └── v1-44.pth
+├── weights
+│   ├── mmaudio_small_16k.pth
+│   ├── mmaudio_small_44k.pth
+│   ├── mmaudio_medium_44k.pth
+│   ├── mmaudio_large_44k.pth
+│   └── mmaudio_large_44k_v2.pth
+└── ...
+```
+
+The expected directory structure (minimal, for the recommended model only):
+
+```bash
+MMAudio
+├── ext_weights
+│   ├── synchformer_state_dict.pth
+│   └── v1-44.pth
+├── weights
+│   └── mmaudio_large_44k_v2.pth
+└── ...
+```

docs/TRAINING.md

@@ -0,0 +1,114 @@
+# Training
+
+## Overview
+
+We have put a large emphasis on making training as fast as possible.
+Consequently, some pre-processing steps are required.
+
+Namely, before starting any training, we
+
+1. Encode training audios into spectrograms and then with VAE into mean/std
+2. Extract CLIP and synchronization features from videos
+3. Extract CLIP features from text (captions)
+4. Encode all extracted features into [MemoryMappedTensors](https://pytorch.org/tensordict/main/reference/generated/tensordict.MemoryMappedTensor.html) with [TensorDict](https://pytorch.org/tensordict/main/reference/tensordict.html)
+
+**NOTE:** for maximum training speed (e.g., when training the base model with 2*H100s), you would need around 3~5 GB/s of random read speed. Spinning disks would not be able to catch up and most consumer-grade SSDs would struggle. In my experience, the best bet is to have a large enough system memory such that the OS can cache the data. This way, the data is read from RAM instead of disk.
+
+The current training script does not support `_v2` training.
+
+## Prerequisites
+
+Install [av-benchmark](https://github.com/hkchengrex/av-benchmark). We use this library to automatically evaluate on the validation set during training, and on test set after training.
+You will also need ffmpeg for video frames extraction. Note that `torchaudio` imposes a maximum version limit (`ffmpeg<7`). You can install it as follows:
+
+```bash
+conda install -c conda-forge 'ffmpeg<7'
+```
+
+Download the corresponding VAE (`v1-16.pth` for 16kHz training, and `v1-44.pth` for 44.1kHz training), vocoder models (`best_netG.pt` for 16kHz training; the vocoder for 44.1kHz training will be downloaded automatically), the [empty string encoding](https://github.com/hkchengrex/MMAudio/releases/download/v0.1/empty_string.pth), and Synchformer weights from [MODELS.md](https://github.com/hkchengrex/MMAudio/blob/main/docs/MODELS.md) place them in `ext_weights/`.
+
+## Preparing Audio-Video-Text Features
+
+We have prepared some example data in `training/example_videos`. 
+Running the `training/extract_video_training_latents.py` script will extract the audio, video, and text features and save them as a `TensorDict` with a `.tsv` file containing metadata on disk.
+
+To run this script, use the `torchrun` utility:
+
+```bash
+torchrun --standalone training/extract_video_training_latents.py
+```
+
+You can run this with multiple GPUs (with `--nproc_per_node=<n>`) to speed up extraction.
+Check the top of the script to switch between 16kHz/44.1kHz extraction and data path definitions.
+
+Arguments:
+
+- `latent_dir` -- where intermediate latent outputs are saved. It is safe to delete this directory afterwards.
+- `output_dir` -- where TensorDict and the metadata file are saved.
+
+## Preparing Audio-Text Features
+
+We have prepared some example data in `training/example_audios`. 
+We first need to run `training/partition_clips` to partition each audio file into clips. 
+Then, we run the `training/extract_audio_training_latents.py` script, which will extract the audio and text features and save them as a `TensorDict` with a `.tsv` file containing metadata on the disk.
+
+To run this script:
+
+```bash
+python training/partition_clips.py
+```
+
+Arguments:
+
+- `data_path` -- path to the audio files (`.flac` or `.wav`)
+- `output_dir` -- path to the output `.csv` file
+- `start` -- optional; useful when you need to run multiple processes to speed up processing -- this defines the beginning of the chunk to be processed
+- `end` -- optional; useful when you need to run multiple processes to speed up processing -- this defines the end of the chunk to be processed
+
+Then, run the `extract_audio_training_latents.py` with `torchrun`:
+
+```bash
+torchrun --standalone training/extract_audio_training_latents.py
+```
+
+You can run this with multiple GPUs (with `--nproc_per_node=<n>`) to speed up extraction.
+Check the top of the script to switch between 16kHz/44.1kHz extraction.
+
+Arguments:
+
+- `data_dir` -- path to the audio files (`.flac` or `.wav`), same as the previous step
+- `captions_tsv` -- path to the captions file, a csv file at least with columns `id` and `caption`
+- `clips_tsv` -- path to the clips file, generated in the last step
+- `latent_dir` -- where intermediate latent outputs are saved. It is safe to delete this directory afterwards.
+- `output_dir` -- where TensorDict and the metadata file are saved.
+
+## Training
+
+We use Distributed Data Parallel (DDP) for training.
+First, specify the data path in `config/data/base.yaml`. If you used the default parameters in the scripts above to extract features for the example data, the `Example_video` and `Example_audio` items should already be correct.
+
+To run training on the example data, use the following command:
+
+```bash
+OMP_NUM_THREADS=4 torchrun --standalone --nproc_per_node=1 train.py exp_id=debug compile=False  debug=True example_train=True  batch_size=1
+```
+
+This will not train a useful model, but it will check if everything is set up correctly.
+
+For full training on the base model with two GPUs, use the following command:
+
+```bash
+OMP_NUM_THREADS=4 torchrun --standalone --nproc_per_node=2 train.py exp_id=exp_1 model=small_16k
+```
+
+Any outputs from training will be stored in `output/<exp_id>`. 
+
+More configuration options can be found in `config/base_config.yaml` and `config/train_config.yaml`.
+
+## Checkpoints
+
+Model checkpoints, including optimizer states and the latest EMA weights, are available here: https://huggingface.co/hkchengrex/MMAudio
+
+---
+
+Godspeed!

docs/index.html

@@ -0,0 +1,149 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <!-- Google tag (gtag.js) -->
+    <script async src="https://www.googletagmanager.com/gtag/js?id=G-0JKBJ3WRJZ"></script>
+    <script>
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    gtag('js', new Date());
+    gtag('config', 'G-0JKBJ3WRJZ');
+    </script>
+
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Source+Sans+3&display=swap" rel="stylesheet">
+    <meta charset="UTF-8">
+    <title>MMAudio</title>
+
+    <link rel="icon" type="image/png" href="images/icon.png">
+
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <!-- CSS only -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.1/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-+0n0xVW2eSR5OomGNYDnhzAbDsOXxcvSN1TPprVMTNDbiYZCxYbOOl7+AMvyTG2x" crossorigin="anonymous">
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
+
+    <link rel="stylesheet" href="style.css">
+</head>
+<body>
+
+    <body>
+        <br><br><br><br>
+        <div class="container">
+            <div class="row text-center" style="font-size:38px">
+                <div class="col strong">
+                    Taming Multimodal Joint Training for High-Quality <br>Video-to-Audio Synthesis
+                </div>
+            </div>
+    
+            <br>
+            <div class="row text-center" style="font-size:28px">
+                <div class="col">
+                    arXiv 2024
+                </div>
+            </div>
+            <br>
+    
+            <div class="h-100 row text-center heavy justify-content-md-center" style="font-size:22px;">
+                <div class="col-sm-auto px-lg-2">
+                    <a href="https://hkchengrex.github.io/">Ho Kei Cheng<sup>1</sup></a>
+                </div>
+                <div class="col-sm-auto px-lg-2">
+                    <nobr><a href="https://scholar.google.co.jp/citations?user=RRIO1CcAAAAJ">Masato Ishii<sup>2</sup></a></nobr>
+                </div>
+                <div class="col-sm-auto px-lg-2">
+                    <nobr><a href="https://scholar.google.com/citations?user=sXAjHFIAAAAJ">Akio Hayakawa<sup>2</sup></a></nobr>
+                </div>
+                <div class="col-sm-auto px-lg-2">
+                    <nobr><a href="https://scholar.google.com/citations?user=XCRO260AAAAJ">Takashi Shibuya<sup>2</sup></a></nobr>
+                </div>
+                <div class="col-sm-auto px-lg-2">
+                    <nobr><a href="https://www.alexander-schwing.de/">Alexander Schwing<sup>1</sup></a></nobr>
+                </div>
+                <div class="col-sm-auto px-lg-2" >
+                    <nobr><a href="https://www.yukimitsufuji.com/">Yuki Mitsufuji<sup>2,3</sup></a></nobr>
+                </div>
+            </div>
+
+            <div class="h-100 row text-center heavy justify-content-md-center" style="font-size:22px;">
+                <div class="col-sm-auto px-lg-2">
+                    <sup>1</sup>University of Illinois Urbana-Champaign
+                </div>
+                <div class="col-sm-auto px-lg-2">
+                    <sup>2</sup>Sony AI
+                </div>
+                <div class="col-sm-auto px-lg-2">
+                    <sup>3</sup>Sony Group Corporation
+                </div>
+            </div>
+    
+            <br>
+    
+            <br>
+    
+            <div class="h-100 row text-center justify-content-md-center" style="font-size:20px;">
+                <div class="col-sm-2">
+                    <a href="https://arxiv.org/abs/2412.15322">[Paper]</a>
+                </div>
+                <div class="col-sm-2">
+                    <a href="https://github.com/hkchengrex/MMAudio">[Code]</a>
+                </div>
+                <div class="col-sm-3">
+                    <a href="https://huggingface.co/spaces/hkchengrex/MMAudio">[Huggingface Demo]</a>
+                </div>
+                <div class="col-sm-2">
+                    <a href="https://colab.research.google.com/drive/1TAaXCY2-kPk4xE4PwKB3EqFbSnkUuzZ8?usp=sharing">[Colab Demo]</a>
+                </div>
+                <div class="col-sm-3">
+                    <a href="https://replicate.com/zsxkib/mmaudio">[Replicate Demo]</a>
+                </div>
+            </div>
+    
+            <br>
+    
+            <hr>
+    
+            <div class="row" style="font-size:32px">
+                <div class="col strong">
+                    TL;DR
+                </div>
+            </div>
+            <br>
+            <div class="row">
+                <div class="col">
+                    <p class="light" style="text-align: left;">
+                        MMAudio generates synchronized audio given video and/or text inputs.
+                    </p>
+                </div>
+            </div>
+    
+            <br>
+            <hr>
+            <br>
+    
+            <div class="row" style="font-size:32px">
+                <div class="col strong">
+                    Demo
+                </div>
+            </div>
+            <br>
+            <div class="row" style="font-size:48px">
+                <div class="col strong text-center">
+                    <a href="video_main.html" style="text-decoration: underline;">&lt;More results&gt;</a>
+                </div>
+            </div>
+            <br>
+            <div class="video-container" style="text-align: center;">
+                <iframe src="https://youtube.com/embed/YElewUT2M4M"></iframe>
+                </div>
+
+            <br>
+    
+            <br><br>
+            <br><br>
+    
+        </div>
+
+</body>
+</html>

docs/style.css

@@ -0,0 +1,78 @@
+body {
+    font-family: 'Source Sans 3', sans-serif;
+    font-size: 18px;
+    margin-left: auto;
+    margin-right: auto;
+    font-weight: 400;
+    height: 100%;
+    max-width: 1000px;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+}
+th, td {
+    border: 1px solid #ddd;
+    padding: 8px;
+    text-align: center;
+}
+th {
+    background-color: #f2f2f2;
+}
+video {
+    width: 100%;
+    height: auto;
+}
+p {
+    font-size: 28px;
+}
+h2 {
+    font-size: 36px;
+}
+
+.strong {
+    font-weight: 700;
+}
+
+.light {
+    font-weight: 100;
+}
+
+.heavy {
+    font-weight: 900;
+}
+
+.column {
+    float: left;
+}
+
+a:link,
+a:visited {
+    color: #05538f;
+    text-decoration: none;
+}
+
+a:hover {
+    color: #63cbdd;
+}
+
+hr {
+    border: 0;
+    height: 1px;
+    background-image: linear-gradient(to right, rgba(0, 0, 0, 0), rgba(0, 0, 0, 0.75), rgba(0, 0, 0, 0));
+}
+
+.video-container {
+    position: relative;
+    padding-bottom: 56.25%; /* 16:9 */
+    height: 0;
+  }
+  
+.video-container iframe {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+}

docs/style_videos.css

@@ -0,0 +1,52 @@
+body {
+    font-family: 'Source Sans 3', sans-serif;
+    font-size: 1.5vh;
+    font-weight: 400;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+}
+th, td {
+    border: 1px solid #ddd;
+    padding: 8px;
+    text-align: center;
+}
+th {
+    background-color: #f2f2f2;
+}
+video {
+    width: 100%;
+    height: auto;
+}
+p {
+    font-size: 1.5vh;
+    font-weight: bold;
+}
+h2 {
+    font-size: 2vh;
+    font-weight: bold;
+}
+
+.video-container {
+    position: relative;
+    padding-bottom: 56.25%; /* 16:9 */
+    height: 0;
+  }
+  
+.video-container iframe {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+}
+
+.video-header {
+    background-color: #f2f2f2;
+    text-align: center;
+    font-size: 1.5vh;
+    font-weight: bold;
+    padding: 8px;
+}

docs/video_gen.html

@@ -0,0 +1,254 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <!-- Google tag (gtag.js) -->
+    <script async src="https://www.googletagmanager.com/gtag/js?id=G-0JKBJ3WRJZ"></script>
+    <script>
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    gtag('js', new Date());
+    gtag('config', 'G-0JKBJ3WRJZ');
+    </script>
+
+    <link href='https://fonts.googleapis.com/css?family=Source+Sans+Pro' rel='stylesheet' type='text/css'>
+    <meta charset="UTF-8">
+    <title>MMAudio</title>
+
+    <link rel="icon" type="image/png" href="images/icon.png">
+
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <!-- CSS only -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.1/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-+0n0xVW2eSR5OomGNYDnhzAbDsOXxcvSN1TPprVMTNDbiYZCxYbOOl7+AMvyTG2x" crossorigin="anonymous">
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
+
+    <link rel="stylesheet" href="style_videos.css">
+</head>
+<body>
+
+    <div id="moviegen_all">
+    <h2 id="moviegen" style="text-align: center;">Comparisons with Movie Gen Audio on Videos Generated by MovieGen</h2>
+    <p id="moviegen1" style="overflow: hidden;">
+        Example 1: Ice cracking with sharp snapping sound, and metal tool scraping against the ice surface. 
+        <span style="float: right;"><a href="#index">Back to index</a></span>
+    </p> 
+
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Movie Gen Audio</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/d7Lb0ihtGcE"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Ours</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/F4JoJ2r2m8U"></iframe>
+                </div> 
+        </div>
+    </div>
+    <br>
+
+    <!-- <p id="moviegen2">Example 2: Rhythmic splashing and lapping of water. <span style="float:right;"><a href="#index">Back to index</a></span> </p> 
+
+    <table>
+        <thead>
+            <tr>
+                <th>Movie Gen Audio</th>
+                <th>Ours</th>
+            </tr>
+        </thead>
+        <tbody>
+            <tr>
+                <td width="50%">
+                    <div class="video-container">
+                    <iframe src="https://youtube.com/embed/5gQNPK99CIk"></iframe>
+                    </div>
+                </td>
+                <td width="50%">
+                    <div class="video-container">
+                    <iframe src="https://youtube.com/embed/AbwnTzG-BpA"></iframe>
+                    </div>
+                </td>
+            </tr>
+        </tbody>
+    </table> -->
+
+    <p id="moviegen2" style="overflow: hidden;">
+        Example 2: Rhythmic splashing and lapping of water. 
+        <span style="float:right;"><a href="#index">Back to index</a></span> 
+    </p> 
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Movie Gen Audio</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/5gQNPK99CIk"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Ours</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/AbwnTzG-BpA"></iframe>
+                </div> 
+        </div>
+    </div>
+    <br>
+
+    <p id="moviegen3" style="overflow: hidden;">
+        Example 3: Shovel scrapes against dry earth. 
+        <span style="float:right;"><a href="#index">Back to index</a></span> 
+    </p> 
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Movie Gen Audio</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/PUKGyEve7XQ"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Ours</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/CNn7i8VNkdc"></iframe>
+            </div> 
+        </div>
+    </div>
+    <br>
+    
+
+    <p id="moviegen4" style="overflow: hidden;">
+        (Failure case) Example 4: Creamy sound of mashed potatoes being scooped. 
+        <span style="float:right;"><a href="#index">Back to index</a></span> 
+    </p> 
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Movie Gen Audio</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/PJv1zxR9JjQ"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Ours</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/c3-LJ1lNsPQ"></iframe>
+            </div> 
+        </div>
+    </div>
+    <br>
+
+    </div>
+
+    <div id="hunyuan_sora_all">
+
+    <h2 id="hunyuan" style="text-align: center;">Results on Videos Generated by Hunyuan</h2>
+    <p style="overflow: hidden;">
+        <span style="float:right;"><a href="#index">Back to index</a></span> 
+    </p> 
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Typing</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/8ln_9hhH_nk"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Water is rushing down a stream and pouring</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/5df1FZFQj30"></iframe>
+            </div> 
+        </div>
+    </div>
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Waves on beach</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/7wQ9D5WgpFc"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Water droplet</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/q7M2nsalGjM"></iframe>
+            </div> 
+        </div>
+    </div>
+    <br>
+
+    <h2 id="sora" style="text-align: center;">Results on Videos Generated by Sora</h2>
+    <p style="overflow: hidden;">
+        <span style="float:right;"><a href="#index">Back to index</a></span> 
+    </p> 
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Ships riding waves</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/JbgQzHHytk8"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Train (no text prompt given)</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/xOW7zrjpWC8"></iframe>
+            </div> 
+        </div>
+    </div>
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Seashore (no text prompt given)</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/fIuw5Y8ZZ9E"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Surfing (failure: unprompted music)</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/UcSTk-v0M_s"></iframe>
+            </div> 
+        </div>
+    </div>
+    <br>
+
+    <div id="mochi_ltx_all">
+    <h2 id="mochi" style="text-align: center;">Results on Videos Generated by Mochi 1</h2>
+    <p style="overflow: hidden;">
+        <span style="float:right;"><a href="#index">Back to index</a></span> 
+    </p> 
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Magical fire and lightning (no text prompt given)</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/tTlRZaSMNwY"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Storm (no text prompt given)</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/4hrZTMJUy3w"></iframe>
+            </div> 
+        </div>
+    </div>
+    <br>
+
+    <h2 id="ltx" style="text-align: center;">Results on Videos Generated by LTX-Video</h2>
+    <p style="overflow: hidden;">
+        <span style="float:right;"><a href="#index">Back to index</a></span> 
+    </p> 
+    <div class="row g-1">
+        <div class="col-sm-6">
+            <div class="video-header">Firewood burning and cracking</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/P7_DDpgev0g"></iframe>
+            </div> 
+        </div>
+        <div class="col-sm-6">
+            <div class="video-header">Waterfall, water splashing</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/4MvjceYnIO0"></iframe>
+            </div> 
+        </div>
+    </div>
+    <br>
+
+    </div>
+
+</body>
+</html>

docs/video_main.html

@@ -0,0 +1,98 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <!-- Google tag (gtag.js) -->
+    <script async src="https://www.googletagmanager.com/gtag/js?id=G-0JKBJ3WRJZ"></script>
+    <script>
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    gtag('js', new Date());
+    gtag('config', 'G-0JKBJ3WRJZ');
+    </script>
+
+    <link href='https://fonts.googleapis.com/css?family=Source+Sans+Pro' rel='stylesheet' type='text/css'>
+    <meta charset="UTF-8">
+    <title>MMAudio</title>
+
+    <link rel="icon" type="image/png" href="images/icon.png">
+
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
+    <!-- CSS only -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.1/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-+0n0xVW2eSR5OomGNYDnhzAbDsOXxcvSN1TPprVMTNDbiYZCxYbOOl7+AMvyTG2x" crossorigin="anonymous">
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.7.1/jquery.min.js"></script>
+
+    <link rel="stylesheet" href="style_videos.css">
+
+    <script type="text/javascript">
+        $(document).ready(function(){
+            $("#content").load("video_gen.html #moviegen_all");
+            $("#load_moveigen").click(function(){
+                $("#content").load("video_gen.html #moviegen_all");
+            });
+            $("#load_hunyuan_sora").click(function(){
+                $("#content").load("video_gen.html #hunyuan_sora_all");
+            });
+            $("#load_mochi_ltx").click(function(){
+                $("#content").load("video_gen.html #mochi_ltx_all");
+            });
+            $("#load_vgg1").click(function(){
+                $("#content").load("video_vgg.html #vgg1");
+            });
+            $("#load_vgg2").click(function(){
+                $("#content").load("video_vgg.html #vgg2");
+            });
+            $("#load_vgg3").click(function(){
+                $("#content").load("video_vgg.html #vgg3");
+            });
+            $("#load_vgg4").click(function(){
+                $("#content").load("video_vgg.html #vgg4");
+            });
+            $("#load_vgg5").click(function(){
+                $("#content").load("video_vgg.html #vgg5");
+            });
+            $("#load_vgg6").click(function(){
+                $("#content").load("video_vgg.html #vgg6");
+            });
+            $("#load_vgg_extra").click(function(){
+                $("#content").load("video_vgg.html #vgg_extra");
+            });
+        });
+    </script>
+</head>
+<body>
+    <h1 id="index" style="text-align: center;">Index</h1>
+    <p><b>(Click on the links to load the corresponding videos)</b> <span style="float:right;"><a href="index.html">Back to project page</a></span></p>
+
+    <ol>
+        <li>
+            <a href="#" id="load_moveigen">Comparisons with Movie Gen Audio on Videos Generated by MovieGen</a>
+        </li>
+        <li>
+            <a href="#" id="load_hunyuan_sora">Results on Videos Generated by Hunyuan and Sora</a>
+        </li>
+        <li>
+            <a href="#" id="load_mochi_ltx">Results on Videos Generated by Mochi 1 and LTX-Video</a>
+        </li>
+        <li>
+            On VGGSound
+            <ol>
+                <li><a id='load_vgg1' href="#">Example 1: Wolf howling</a></li>
+                <li><a id='load_vgg2' href="#">Example 2: Striking a golf ball</a></li>
+                <li><a id='load_vgg3' href="#">Example 3: Hitting a drum</a></li>
+                <li><a id='load_vgg4' href="#">Example 4: Dog barking</a></li>
+                <li><a id='load_vgg5' href="#">Example 5: Playing a string instrument</a></li>
+                <li><a id='load_vgg6' href="#">Example 6: A group of people playing tambourines</a></li>
+                <li><a id='load_vgg_extra' href="#">Extra results & failure cases</a></li>
+            </ol>
+        </li>
+    </ol>
+
+    <div id="content" class="container-fluid">
+
+    </div>
+    <br>
+    <br>
+
+</body>
+</html>

docs/video_vgg.html

@@ -0,0 +1,452 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <!-- Google tag (gtag.js) -->
+    <script async src="https://www.googletagmanager.com/gtag/js?id=G-0JKBJ3WRJZ"></script>
+    <script>
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    gtag('js', new Date());
+    gtag('config', 'G-0JKBJ3WRJZ');
+    </script>
+
+    <link href='https://fonts.googleapis.com/css?family=Source+Sans+Pro' rel='stylesheet' type='text/css'>
+    <meta charset="UTF-8">
+    <title>MMAudio</title>
+
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <!-- CSS only -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.1/dist/css/bootstrap.min.css" rel="stylesheet"
+        integrity="sha384-+0n0xVW2eSR5OomGNYDnhzAbDsOXxcvSN1TPprVMTNDbiYZCxYbOOl7+AMvyTG2x" crossorigin="anonymous">
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js"></script>
+
+    <link rel="stylesheet" href="style_videos.css">
+</head>
+<body>
+
+    <div id="vgg1">
+    <h2 style="text-align: center;">Comparisons with state-of-the-art methods in VGGSound</h2>
+    <p style="overflow: hidden;">
+        Example 1: Wolf howling. 
+        <span style="float:right;"><a href="#index">Back to index</a></span> 
+    </p> 
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Ground-truth</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/9J_V74gqMUA"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Ours</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/P6O8IpjErPc"></iframe>
+                    </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V2A-Mapper</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/w-5eyqepvTk"></iframe>
+                    </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">FoleyCrafter</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/VOLfoZlRkzo"></iframe>
+                    </div> 
+            </div>
+        </div>
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Frieren</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/49owKyA5Pa8"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">VATT</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/QVtrFgbeGDM"></iframe>
+                    </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V-AURA</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/8r0uEfSNjvI"></iframe>
+                    </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Seeing and Hearing</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/bn-sLg2qulk"></iframe>
+                    </div> 
+            </div>
+        </div>
+    </div>
+
+    <div id="vgg2">
+        <h2 style="text-align: center;">Comparisons with state-of-the-art methods in VGGSound</h2>
+        <p style="overflow: hidden;">
+            Example 2: Striking a golf ball.
+            <span style="float:right;"><a href="#index">Back to index</a></span>
+        </p>
+
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Ground-truth</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/1hwSu42kkho"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Ours</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/kZibDoDCNxI"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V2A-Mapper</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/jgKfLBLhh7Y"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">FoleyCrafter</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/Lfsx8mOPcJo"></iframe>
+                </div>
+            </div>
+        </div>
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Frieren</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/tz-LpbB0MBc"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">VATT</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/RTDUHMi08n4"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V-AURA</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/N-3TDOsPnZQ"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Seeing and Hearing</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/QnsHnLn4gB0"></iframe>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div id="vgg3">
+        <h2 style="text-align: center;">Comparisons with state-of-the-art methods in VGGSound</h2>
+        <p style="overflow: hidden;">
+            Example 3: Hitting a drum. 
+            <span style="float:right;"><a href="#index">Back to index</a></span> 
+        </p> 
+
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Ground-truth</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/0oeIwq77w0Q"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Ours</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/-UtPV9ohuIM"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V2A-Mapper</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/9yivkgN-zwc"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">FoleyCrafter</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/kkCsXPOlBvY"></iframe>
+                </div> 
+            </div>
+        </div>
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Frieren</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/MbNKsVsuvig"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">VATT</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/2yYviBjrpBw"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V-AURA</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/9yivkgN-zwc"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Seeing and Hearing</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/6dnyQt4Fuhs"></iframe>
+                </div> 
+            </div>
+        </div>
+    </div>
+    </div>
+
+    <div id="vgg4">
+        <h2 style="text-align: center;">Comparisons with state-of-the-art methods in VGGSound</h2>
+        <p style="overflow: hidden;">
+            Example 4: Dog barking. 
+            <span style="float:right;"><a href="#index">Back to index</a></span> 
+        </p> 
+
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Ground-truth</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/ckaqvTyMYAw"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Ours</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/_aRndFZzZ-I"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V2A-Mapper</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/mNCISP3LBl0"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">FoleyCrafter</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/phZBQ3L7foE"></iframe>
+                </div> 
+            </div>
+        </div>
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Frieren</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/Sb5Mg1-ORao"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">VATT</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/eHmAGOmtDDg"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V-AURA</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/NEGa3krBrm0"></iframe>
+                </div> 
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Seeing and Hearing</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/aO0EAXlwE7A"></iframe>
+                </div> 
+            </div>
+        </div>
+    </div>
+    
+    <div id="vgg5">
+        <h2 style="text-align: center;">Comparisons with state-of-the-art methods in VGGSound</h2>
+        <p style="overflow: hidden;">
+            Example 5: Playing a string instrument.
+            <span style="float:right;"><a href="#index">Back to index</a></span>
+        </p>
+
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Ground-truth</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/KP1QhWauIOc"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Ours</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/ovaJhWSquYE"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V2A-Mapper</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/N723FS9lcy8"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">FoleyCrafter</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/t0N4ZAAXo58"></iframe>
+                </div>
+            </div>
+        </div>
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Frieren</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/8YSRs03QNNA"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">VATT</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/vOpMz55J1kY"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V-AURA</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/9JHC75vr9h0"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Seeing and Hearing</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/9w0JckNzXmY"></iframe>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <div id="vgg6">
+        <h2 style="text-align: center;">Comparisons with state-of-the-art methods in VGGSound</h2>
+        <p style="overflow: hidden;">
+            Example 6: A group of people playing tambourines.
+            <span style="float:right;"><a href="#index">Back to index</a></span>
+        </p>
+
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Ground-truth</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/mx6JLxzUkRc"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Ours</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/oLirHhP9Su8"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V2A-Mapper</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/HkLkHMqptv0"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">FoleyCrafter</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/rpHiiODjmNU"></iframe>
+                </div>
+            </div>
+        </div>
+        <div class="row g-1">
+            <div class="col-sm-3">
+                <div class="video-header">Frieren</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/1mVD3fJ0LpM"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">VATT</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/yjVFnJiEJlw"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">V-AURA</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/neVeMSWtRkU"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-3">
+                <div class="video-header">Seeing and Hearing</div>
+                <div class="video-container">
+                    <iframe src="https://youtube.com/embed/EUE7YwyVWz8"></iframe>
+                </div>
+            </div>
+        </div>
+    </div>
+    
+    <div id="vgg_extra">
+        <h2 style="text-align: center;">Comparisons with state-of-the-art methods in VGGSound</h2>
+        <p style="overflow: hidden;">
+            <span style="float:right;"><a href="#index">Back to index</a></span>
+        </p>
+
+        <div class="row g-1">
+            <div class="col-sm-3">
+            <div class="video-header">Moving train</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/Ta6H45rBzJc"></iframe>
+            </div>
+            </div>
+            <div class="col-sm-3">
+            <div class="video-header">Water splashing</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/hl6AtgHXpb4"></iframe>
+            </div>
+            </div>
+            <div class="col-sm-3">
+            <div class="video-header">Skateboarding</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/n4sCNi_9buI"></iframe>
+            </div>
+            </div>
+            <div class="col-sm-3">
+            <div class="video-header">Synchronized clapping</div>
+            <div class="video-container">
+                <iframe src="https://youtube.com/embed/oxexfpLn7FE"></iframe>
+            </div>
+            </div>
+        </div>
+
+        <br><br>
+    
+        <div id="extra-failure">
+            <h2 style="text-align: center;">Failure cases</h2>
+            <p style="overflow: hidden;">
+            <span style="float:right;"><a href="#index">Back to index</a></span>
+            </p>
+
+            <div class="row g-1">
+            <div class="col-sm-6">
+                <div class="video-header">Human speech</div>
+                <div class="video-container">
+                <iframe src="https://youtube.com/embed/nx0CyrDu70Y"></iframe>
+                </div>
+            </div>
+            <div class="col-sm-6">
+                <div class="video-header">Unfamiliar vision input</div>
+                <div class="video-container">
+                <iframe src="https://youtube.com/embed/hfnAqmK3X7w"></iframe>
+                </div>
+            </div>
+            </div>
+        </div>
+        </div>
+
+</body>
+</html>

filter_dataset/av_align.py

@@ -0,0 +1,213 @@
+"""
+AV-Align Metric: Audio-Video Alignment Evaluation
+
+AV-Align is a metric for evaluating the alignment between audio and video modalities in multimedia data.
+It assesses synchronization by detecting audio and video peaks and calculating their Intersection over Union (IoU).
+A higher IoU score indicates better alignment.
+
+Usage:
+- Provide a folder of video files as input.
+- The script calculates the AV-Align score for the set of videos.
+"""
+
+
+import argparse
+import glob
+import os
+
+import cv2
+import librosa
+import librosa.display
+
+import multiprocessing
+from tqdm import tqdm
+import pandas as pd
+
+# Function to extract frames from a video file
+def extract_frames(video_path):
+    """
+    Extract frames from a video file.
+
+    Args:
+        video_path (str): Path to the input video file.
+
+    Returns:
+        frames (list): List of frames extracted from the video.
+        frame_rate (float): Frame rate of the video.
+    """
+    frames = []
+    cap = cv2.VideoCapture(video_path)
+    frame_rate = cap.get(cv2.CAP_PROP_FPS)
+
+    if not cap.isOpened():
+        raise ValueError(f"Error: Unable to open the video file. Wrong video is {video_path}")
+
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frames.append(frame)
+    cap.release()
+    return frames, frame_rate
+
+
+# Function to detect audio peaks using the Onset Detection algorithm
+def detect_audio_peaks(audio_file):
+    """
+    Detect audio peaks using the Onset Detection algorithm.
+
+    Args:
+        audio_file (str): Path to the audio file.
+
+    Returns:
+        onset_times (list): List of times (in seconds) where audio peaks occur.
+    """
+    y, sr = librosa.load(audio_file)
+    # Calculate the onset envelope
+    onset_env = librosa.onset.onset_strength(y=y, sr=sr)
+    # Get the onset events
+    onset_frames = librosa.onset.onset_detect(onset_envelope=onset_env, sr=sr)
+    onset_times = librosa.frames_to_time(onset_frames, sr=sr)
+    return onset_times
+
+
+# Function to find local maxima in a list
+def find_local_max_indexes(arr, fps):
+    """
+    Find local maxima in a list.
+
+    Args:
+        arr (list): List of values to find local maxima in.
+        fps (float): Frames per second, used to convert indexes to time.
+
+    Returns:
+        local_extrema_indexes (list): List of times (in seconds) where local maxima occur.
+    """
+
+    local_extrema_indexes = []
+    n = len(arr)
+    for i in range(1, n - 1):
+        if arr[i - 1] < arr[i] > arr[i + 1]:  # Local maximum
+            local_extrema_indexes.append(i / fps)
+
+    return local_extrema_indexes
+
+
+# Function to detect video peaks using Optical Flow
+def detect_video_peaks(frames, fps):
+    """
+    Detect video peaks using Optical Flow.
+
+    Args:
+        frames (list): List of video frames.
+        fps (float): Frame rate of the video.
+
+    Returns:
+        flow_trajectory (list): List of optical flow magnitudes for each frame.
+        video_peaks (list): List of times (in seconds) where video peaks occur.
+    """
+    flow_trajectory = [compute_of(frames[0], frames[1])] + [compute_of(frames[i - 1], frames[i]) for i in range(1, len(frames))]
+    video_peaks = find_local_max_indexes(flow_trajectory, fps)
+    return flow_trajectory, video_peaks
+
+
+# Function to compute the optical flow magnitude between two frames
+def compute_of(img1, img2):
+    """
+    Compute the optical flow magnitude between two video frames.
+
+    Args:
+        img1 (numpy.ndarray): First video frame.
+        img2 (numpy.ndarray): Second video frame.
+
+    Returns:
+        avg_magnitude (float): Average optical flow magnitude for the frame pair.
+    """
+    # Calculate the optical flow
+    prev_gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
+    curr_gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
+    flow = cv2.calcOpticalFlowFarneback(prev_gray, curr_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+
+    # Calculate the magnitude of the optical flow vectors
+    magnitude = cv2.magnitude(flow[..., 0], flow[..., 1])
+    avg_magnitude = cv2.mean(magnitude)[0]
+    return avg_magnitude
+
+
+# Function to calculate Intersection over Union (IoU) for audio and video peaks
+def calc_intersection_over_union(audio_peaks, video_peaks, fps):
+    """
+    Calculate Intersection over Union (IoU) between audio and video peaks.
+
+    Args:
+        audio_peaks (list): List of audio peak times (in seconds).
+        video_peaks (list): List of video peak times (in seconds).
+        fps (float): Frame rate of the video.
+
+    Returns:
+        iou (float): Intersection over Union score.
+    """
+    intersection_length = 0
+    for audio_peak in audio_peaks:
+        for video_peak in video_peaks:
+            if video_peak - 1 / fps < audio_peak < video_peak + 1 / fps:
+                intersection_length += 1
+                break
+    return intersection_length / (len(audio_peaks) + len(video_peaks) - intersection_length)
+
+
+def multi_wrapper(args):
+   return wrapper_cal_av_score(*args)
+
+
+def wrapper_cal_av_score(video_path, audio_path):
+    video_id = os.path.basename(video_path)[:-4]
+    try:
+        frames, fps = extract_frames(video_path)
+        audio_peaks = detect_audio_peaks(audio_path)
+        flow_trajectory, video_peaks = detect_video_peaks(frames, fps)
+        score = calc_intersection_over_union(audio_peaks, video_peaks, fps)
+        print(f'Calculated AV Align score for {os.path.basename(video_path)}')
+    except:
+        score = -1
+        print(f'Cannot Calculate AV Align score for {os.path.basename(video_path)}')
+
+    data = {
+        'video_id': video_id,
+        'score': score,
+    }
+    return data
+
+if __name__ == "__main__":
+
+    threshold = 0.2
+    video_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/videos'
+    audio_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/audios_vggsound'
+    output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/filter_dataset'
+
+    audio_file_list = os.listdir(audio_dir)
+
+    video_audio_list = []
+
+    for audio_file in tqdm(audio_file_list):
+        video_id = audio_file[:-4]
+        video_file = video_id + '.mp4'
+        video_path = os.path.join(video_dir, video_file)
+        audio_path = os.path.join(audio_dir, audio_file)
+        video_audio_list.append((video_path, audio_path))
+
+    cores = multiprocessing.cpu_count()
+    pool = multiprocessing.Pool(processes=cores)
+    
+    results = list(tqdm(pool.imap(multi_wrapper, video_audio_list), total=len(video_audio_list)))
+        
+        
+    #with multiprocessing.Pool(processes=cores) as pool:
+    #    results = pool.imap(multi_wrapper, video_audio_list)
+
+
+    output_df = pd.DataFrame(results)
+    output_df.to_csv(os.path.join(output_dir, 'vggsound_av_align_score.tsv') , sep='\t', index=False)
+
+    print("Finished !!!")

filter_dataset/av_align_hpc.py

@@ -0,0 +1,213 @@
+"""
+AV-Align Metric: Audio-Video Alignment Evaluation
+
+AV-Align is a metric for evaluating the alignment between audio and video modalities in multimedia data.
+It assesses synchronization by detecting audio and video peaks and calculating their Intersection over Union (IoU).
+A higher IoU score indicates better alignment.
+
+Usage:
+- Provide a folder of video files as input.
+- The script calculates the AV-Align score for the set of videos.
+"""
+
+
+import argparse
+import glob
+import os
+
+import cv2
+import librosa
+import librosa.display
+
+import multiprocessing
+from tqdm import tqdm
+import pandas as pd
+
+# Function to extract frames from a video file
+def extract_frames(video_path):
+    """
+    Extract frames from a video file.
+
+    Args:
+        video_path (str): Path to the input video file.
+
+    Returns:
+        frames (list): List of frames extracted from the video.
+        frame_rate (float): Frame rate of the video.
+    """
+    frames = []
+    cap = cv2.VideoCapture(video_path)
+    frame_rate = cap.get(cv2.CAP_PROP_FPS)
+
+    if not cap.isOpened():
+        raise ValueError(f"Error: Unable to open the video file. Wrong video is {video_path}")
+
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frames.append(frame)
+    cap.release()
+    return frames, frame_rate
+
+
+# Function to detect audio peaks using the Onset Detection algorithm
+def detect_audio_peaks(audio_file):
+    """
+    Detect audio peaks using the Onset Detection algorithm.
+
+    Args:
+        audio_file (str): Path to the audio file.
+
+    Returns:
+        onset_times (list): List of times (in seconds) where audio peaks occur.
+    """
+    y, sr = librosa.load(audio_file)
+    # Calculate the onset envelope
+    onset_env = librosa.onset.onset_strength(y=y, sr=sr)
+    # Get the onset events
+    onset_frames = librosa.onset.onset_detect(onset_envelope=onset_env, sr=sr)
+    onset_times = librosa.frames_to_time(onset_frames, sr=sr)
+    return onset_times
+
+
+# Function to find local maxima in a list
+def find_local_max_indexes(arr, fps):
+    """
+    Find local maxima in a list.
+
+    Args:
+        arr (list): List of values to find local maxima in.
+        fps (float): Frames per second, used to convert indexes to time.
+
+    Returns:
+        local_extrema_indexes (list): List of times (in seconds) where local maxima occur.
+    """
+
+    local_extrema_indexes = []
+    n = len(arr)
+    for i in range(1, n - 1):
+        if arr[i - 1] < arr[i] > arr[i + 1]:  # Local maximum
+            local_extrema_indexes.append(i / fps)
+
+    return local_extrema_indexes
+
+
+# Function to detect video peaks using Optical Flow
+def detect_video_peaks(frames, fps):
+    """
+    Detect video peaks using Optical Flow.
+
+    Args:
+        frames (list): List of video frames.
+        fps (float): Frame rate of the video.
+
+    Returns:
+        flow_trajectory (list): List of optical flow magnitudes for each frame.
+        video_peaks (list): List of times (in seconds) where video peaks occur.
+    """
+    flow_trajectory = [compute_of(frames[0], frames[1])] + [compute_of(frames[i - 1], frames[i]) for i in range(1, len(frames))]
+    video_peaks = find_local_max_indexes(flow_trajectory, fps)
+    return flow_trajectory, video_peaks
+
+
+# Function to compute the optical flow magnitude between two frames
+def compute_of(img1, img2):
+    """
+    Compute the optical flow magnitude between two video frames.
+
+    Args:
+        img1 (numpy.ndarray): First video frame.
+        img2 (numpy.ndarray): Second video frame.
+
+    Returns:
+        avg_magnitude (float): Average optical flow magnitude for the frame pair.
+    """
+    # Calculate the optical flow
+    prev_gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
+    curr_gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
+    flow = cv2.calcOpticalFlowFarneback(prev_gray, curr_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+
+    # Calculate the magnitude of the optical flow vectors
+    magnitude = cv2.magnitude(flow[..., 0], flow[..., 1])
+    avg_magnitude = cv2.mean(magnitude)[0]
+    return avg_magnitude
+
+
+# Function to calculate Intersection over Union (IoU) for audio and video peaks
+def calc_intersection_over_union(audio_peaks, video_peaks, fps):
+    """
+    Calculate Intersection over Union (IoU) between audio and video peaks.
+
+    Args:
+        audio_peaks (list): List of audio peak times (in seconds).
+        video_peaks (list): List of video peak times (in seconds).
+        fps (float): Frame rate of the video.
+
+    Returns:
+        iou (float): Intersection over Union score.
+    """
+    intersection_length = 0
+    for audio_peak in audio_peaks:
+        for video_peak in video_peaks:
+            if video_peak - 1 / fps < audio_peak < video_peak + 1 / fps:
+                intersection_length += 1
+                break
+    return intersection_length / (len(audio_peaks) + len(video_peaks) - intersection_length)
+
+
+def multi_wrapper(args):
+   return wrapper_cal_av_score(*args)
+
+
+def wrapper_cal_av_score(video_path, audio_path):
+    video_id = os.path.basename(video_path)[:-4]
+    try:
+        frames, fps = extract_frames(video_path)
+        audio_peaks = detect_audio_peaks(audio_path)
+        flow_trajectory, video_peaks = detect_video_peaks(frames, fps)
+        score = calc_intersection_over_union(audio_peaks, video_peaks, fps)
+        print(f'Calculated AV Align score for {os.path.basename(video_path)}')
+    except:
+        score = -1
+        print(f'Cannot Calculate AV Align score for {os.path.basename(video_path)}')
+
+    data = {
+        'video_id': video_id,
+        'score': score,
+    }
+    return data
+
+if __name__ == "__main__":
+
+    threshold = 0.2
+    video_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/videos'
+    audio_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/audios_vggsound'
+    output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/filter_dataset'
+
+    audio_file_list = os.listdir(audio_dir)
+
+    video_audio_list = []
+
+    for audio_file in tqdm(audio_file_list):
+        video_id = audio_file[:-4]
+        video_file = video_id + '.mp4'
+        video_path = os.path.join(video_dir, video_file)
+        audio_path = os.path.join(audio_dir, audio_file)
+        video_audio_list.append((video_path, audio_path))
+
+    cores = multiprocessing.cpu_count()
+    pool = multiprocessing.Pool(processes=cores)
+    
+    results = list(tqdm(pool.imap(multi_wrapper, video_audio_list), total=len(video_audio_list)))
+        
+        
+    #with multiprocessing.Pool(processes=cores) as pool:
+    #    results = pool.imap(multi_wrapper, video_audio_list)
+
+
+    output_df = pd.DataFrame(results)
+    output_df.to_csv(os.path.join(output_dir, 'vggsound_av_align_score_latest.tsv') , sep='\t', index=False)
+
+    print("Finished !!!")

filter_dataset/extract_audio.py

@@ -0,0 +1,28 @@
+import os
+import moviepy
+from moviepy.audio.AudioClip import AudioArrayClip
+from moviepy.editor import VideoFileClip
+import numpy as np
+import argparse
+
+
+video_root = '/inspire/hdd/global_user/zhoutao-240108120126/Movie-Gen-Audio/MovieGenAudioBenchSfx/video_with_audio'
+audio_root = '/inspire/hdd/global_user/zhoutao-240108120126/Movie-Gen-Audio/MovieGenAudioBenchSfx/audio-only'
+
+if not os.path.exists(audio_root):
+    os.makedirs(audio_root)
+
+v_name_list = os.listdir(video_root)
+for v_name in v_name_list:
+    v_id = v_name[:-4]
+    v_path = os.path.join(video_root, v_name)
+    audio_name = v_id + '.wav'
+    dst_path = os.path.join(audio_root, audio_name)
+    try:
+        video = VideoFileClip(v_path)
+        audio_fps = video.audio.fps
+        audio = video.audio
+        audio.write_audiofile(dst_path, fps=audio_fps)
+        print("finish video id: " + audio_name)
+    except:
+        print('Failed video id: {}' + audio_name)

filter_dataset/filter_vggsound.py

@@ -0,0 +1,43 @@
+import os
+import pandas as pd
+from tqdm import tqdm
+av_align_tsv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/filter_dataset/vggsound_av_align_score.tsv'
+train_tsv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/sets/vgg-train-filtered.tsv'
+val_tsv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/sets/vgg-val-filtered.tsv'
+test_tsv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/sets/vgg-test-filtered.tsv'
+filtered_tsv_saved_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/filter_dataset/filtered_vggsound'
+
+THRESHOLD = 0.2 # can be cnaged accordingly
+
+def filter_vggsound(tsv_path, saved_video_ids, filtered_tsv_saved_dir, saved_tsv_name=''):
+    df_list = pd.read_csv(tsv_path, sep='\t', dtype={'id': str}).to_dict('records')
+    saved_id_label_list = []
+    for record in tqdm(df_list):
+        id = record['id']
+        label = record['label']
+        if id in saved_video_ids:
+            data = {
+                'id': id,
+                'label': label
+            }
+            saved_id_label_list.append(data)
+
+    output_df = pd.DataFrame(saved_id_label_list)
+    output_df.to_csv(os.path.join(filtered_tsv_saved_dir, saved_tsv_name), sep='\t', index=False)
+    print(f'Saved to: {saved_tsv_name}')
+    
+# read the tsv for subset information
+df_list = pd.read_csv(av_align_tsv_path, sep='\t', dtype={'video_id': str}).to_dict('records')
+saved_video_ids = []
+for record in tqdm(df_list):
+    id = record['video_id']
+    score = record['score']
+    if score > THRESHOLD:
+        saved_video_ids.append(id)
+        
+        
+filter_vggsound(train_tsv_path, saved_video_ids, filtered_tsv_saved_dir, saved_tsv_name='train_filter_av_align.tsv')
+filter_vggsound(val_tsv_path, saved_video_ids, filtered_tsv_saved_dir, saved_tsv_name='val_filter_av_align.tsv')
+filter_vggsound(test_tsv_path, saved_video_ids, filtered_tsv_saved_dir, saved_tsv_name='test_filter_av_align.tsv')
+
+

filter_dataset/get_testing_audio_gt.py

@@ -0,0 +1,26 @@
+import os
+import pandas as pd
+from tqdm import tqdm
+import shutil
+
+full_audio_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/videos' # audios_vggsound
+vgg_test_tsv = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/sets/vgg-test-filtered.tsv'
+test_audio_gt_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/test_videos_new' # gt_audio_test
+
+audio_files_list = os.listdir(full_audio_dir)
+
+df_list = pd.read_csv(vgg_test_tsv, sep='\t', dtype={'id': str}).to_dict('records')
+count = 0
+for record in tqdm(df_list):
+    id = record['id']
+    label = record['label']
+    if f'{id}.mp4' in audio_files_list:
+        current_audio_path = os.path.join(full_audio_dir, f'{id}.mp4')
+        target_audio_path = os.path.join(test_audio_gt_dir, f'{id}.mp4')
+        shutil.copyfile(current_audio_path, target_audio_path)
+        count += 1
+
+print(f'Moved {count} files !')
+
+
+

filter_dataset/get_train_audio_gt.py

@@ -0,0 +1,26 @@
+import os
+import pandas as pd
+from tqdm import tqdm
+import shutil
+
+full_audio_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/videos' # audios_vggsound
+vgg_test_tsv = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/sets/vgg-train-filtered.tsv'
+test_audio_gt_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/train_videos_new' # copy val subset
+
+audio_files_list = os.listdir(full_audio_dir)
+
+df_list = pd.read_csv(vgg_test_tsv, sep='\t', dtype={'id': str}).to_dict('records')
+count = 0
+for record in tqdm(df_list):
+    id = record['id']
+    label = record['label']
+    if f'{id}.mp4' in audio_files_list:
+        current_audio_path = os.path.join(full_audio_dir, f'{id}.mp4')
+        target_audio_path = os.path.join(test_audio_gt_dir, f'{id}.mp4')
+        shutil.copyfile(current_audio_path, target_audio_path)
+        count += 1
+
+print(f'Moved {count} files !')
+
+
+

filter_dataset/get_val_audio_gt.py

@@ -0,0 +1,26 @@
+import os
+import pandas as pd
+from tqdm import tqdm
+import shutil
+
+full_audio_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/videos' # audios_vggsound
+vgg_test_tsv = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/sets/vgg-val-filtered.tsv'
+test_audio_gt_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/val_videos_new' # copy val subset
+
+audio_files_list = os.listdir(full_audio_dir)
+
+df_list = pd.read_csv(vgg_test_tsv, sep='\t', dtype={'id': str}).to_dict('records')
+count = 0
+for record in tqdm(df_list):
+    id = record['id']
+    label = record['label']
+    if f'{id}.mp4' in audio_files_list:
+        current_audio_path = os.path.join(full_audio_dir, f'{id}.mp4')
+        target_audio_path = os.path.join(test_audio_gt_dir, f'{id}.mp4')
+        shutil.copyfile(current_audio_path, target_audio_path)
+        count += 1
+
+print(f'Moved {count} files !')
+
+
+

gradio_demo.py

@@ -0,0 +1,339 @@
+import logging
+from argparse import ArgumentParser
+from datetime import datetime
+from fractions import Fraction
+from pathlib import Path
+
+import gradio as gr
+import torch
+import torchaudio
+
+from mmaudio.eval_utils import (ModelConfig, VideoInfo, all_model_cfg, generate, load_image,
+                                load_video, make_video, setup_eval_logging)
+from mmaudio.model.flow_matching import FlowMatching
+from mmaudio.model.networks import MMAudio, get_my_mmaudio
+from mmaudio.model.sequence_config import SequenceConfig
+from mmaudio.model.utils.features_utils import FeaturesUtils
+
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+
+log = logging.getLogger()
+
+device = 'cpu'
+if torch.cuda.is_available():
+    device = 'cuda'
+elif torch.backends.mps.is_available():
+    device = 'mps'
+else:
+    log.warning('CUDA/MPS are not available, running on CPU')
+dtype = torch.bfloat16
+
+model: ModelConfig = all_model_cfg['large_44k_v2']
+model.download_if_needed()
+output_dir = Path('./output/gradio')
+
+setup_eval_logging()
+
+
+def get_model() -> tuple[MMAudio, FeaturesUtils, SequenceConfig]:
+    seq_cfg = model.seq_cfg
+
+    net: MMAudio = get_my_mmaudio(model.model_name).to(device, dtype).eval()
+    net.load_weights(torch.load(model.model_path, map_location=device, weights_only=True))
+    log.info(f'Loaded weights from {model.model_path}')
+
+    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, dtype).eval()
+
+    return net, feature_utils, seq_cfg
+
+
+net, feature_utils, seq_cfg = get_model()
+
+
+@torch.inference_mode()
+def video_to_audio(video: gr.Video, prompt: str, negative_prompt: str, seed: int, num_steps: int,
+                   cfg_strength: float, duration: float):
+
+    rng = torch.Generator(device=device)
+    if seed >= 0:
+        rng.manual_seed(seed)
+    else:
+        rng.seed()
+    fm = FlowMatching(min_sigma=0, inference_mode='euler', num_steps=num_steps)
+
+    video_info = load_video(video, duration)
+    clip_frames = video_info.clip_frames
+    sync_frames = video_info.sync_frames
+    duration = video_info.duration_sec
+    clip_frames = clip_frames.unsqueeze(0)
+    sync_frames = sync_frames.unsqueeze(0)
+    seq_cfg.duration = duration
+    net.update_seq_lengths(seq_cfg.latent_seq_len, seq_cfg.clip_seq_len, seq_cfg.sync_seq_len)
+
+    audios = generate(clip_frames,
+                      sync_frames, [prompt],
+                      negative_text=[negative_prompt],
+                      feature_utils=feature_utils,
+                      net=net,
+                      fm=fm,
+                      rng=rng,
+                      cfg_strength=cfg_strength)
+    audio = audios.float().cpu()[0]
+
+    current_time_string = datetime.now().strftime('%Y%m%d_%H%M%S')
+    output_dir.mkdir(exist_ok=True, parents=True)
+    video_save_path = output_dir / f'{current_time_string}.mp4'
+    make_video(video_info, video_save_path, audio, sampling_rate=seq_cfg.sampling_rate)
+    return video_save_path
+
+
+@torch.inference_mode()
+def image_to_audio(image: gr.Image, prompt: str, negative_prompt: str, seed: int, num_steps: int,
+                   cfg_strength: float, duration: float):
+
+    rng = torch.Generator(device=device)
+    if seed >= 0:
+        rng.manual_seed(seed)
+    else:
+        rng.seed()
+    fm = FlowMatching(min_sigma=0, inference_mode='euler', num_steps=num_steps)
+
+    image_info = load_image(image)
+    clip_frames = image_info.clip_frames
+    sync_frames = image_info.sync_frames
+    clip_frames = clip_frames.unsqueeze(0)
+    sync_frames = sync_frames.unsqueeze(0)
+    seq_cfg.duration = duration
+    net.update_seq_lengths(seq_cfg.latent_seq_len, seq_cfg.clip_seq_len, seq_cfg.sync_seq_len)
+
+    audios = generate(clip_frames,
+                      sync_frames, [prompt],
+                      negative_text=[negative_prompt],
+                      feature_utils=feature_utils,
+                      net=net,
+                      fm=fm,
+                      rng=rng,
+                      cfg_strength=cfg_strength,
+                      image_input=True)
+    audio = audios.float().cpu()[0]
+
+    current_time_string = datetime.now().strftime('%Y%m%d_%H%M%S')
+    output_dir.mkdir(exist_ok=True, parents=True)
+    video_save_path = output_dir / f'{current_time_string}.mp4'
+    video_info = VideoInfo.from_image_info(image_info, duration, fps=Fraction(1))
+    make_video(video_info, video_save_path, audio, sampling_rate=seq_cfg.sampling_rate)
+    return video_save_path
+
+
+@torch.inference_mode()
+def text_to_audio(prompt: str, negative_prompt: str, seed: int, num_steps: int, cfg_strength: float,
+                  duration: float):
+
+    rng = torch.Generator(device=device)
+    if seed >= 0:
+        rng.manual_seed(seed)
+    else:
+        rng.seed()
+    fm = FlowMatching(min_sigma=0, inference_mode='euler', num_steps=num_steps)
+
+    clip_frames = sync_frames = None
+    seq_cfg.duration = duration
+    net.update_seq_lengths(seq_cfg.latent_seq_len, seq_cfg.clip_seq_len, seq_cfg.sync_seq_len)
+
+    audios = generate(clip_frames,
+                      sync_frames, [prompt],
+                      negative_text=[negative_prompt],
+                      feature_utils=feature_utils,
+                      net=net,
+                      fm=fm,
+                      rng=rng,
+                      cfg_strength=cfg_strength)
+    audio = audios.float().cpu()[0]
+
+    current_time_string = datetime.now().strftime('%Y%m%d_%H%M%S')
+    output_dir.mkdir(exist_ok=True, parents=True)
+    audio_save_path = output_dir / f'{current_time_string}.flac'
+    torchaudio.save(audio_save_path, audio, seq_cfg.sampling_rate)
+    return audio_save_path
+
+
+video_to_audio_tab = gr.Interface(
+    fn=video_to_audio,
+    description="""
+    Project page: <a href="https://hkchengrex.com/MMAudio/">https://hkchengrex.com/MMAudio/</a><br>
+    Code: <a href="https://github.com/hkchengrex/MMAudio">https://github.com/hkchengrex/MMAudio</a><br>
+
+    NOTE: It takes longer to process high-resolution videos (>384 px on the shorter side). 
+    Doing so does not improve results.
+    """,
+    inputs=[
+        gr.Video(),
+        gr.Text(label='Prompt'),
+        gr.Text(label='Negative prompt', value='music'),
+        gr.Number(label='Seed (-1: random)', value=-1, precision=0, minimum=-1),
+        gr.Number(label='Num steps', value=25, precision=0, minimum=1),
+        gr.Number(label='Guidance Strength', value=4.5, minimum=1),
+        gr.Number(label='Duration (sec)', value=8, minimum=1),
+    ],
+    outputs='playable_video',
+    cache_examples=False,
+    title='MMAudio — Video-to-Audio Synthesis',
+    examples=[
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_beach.mp4',
+            'waves, seagulls',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_serpent.mp4',
+            '',
+            'music',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_seahorse.mp4',
+            'bubbles',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_india.mp4',
+            'Indian holy music',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_galloping.mp4',
+            'galloping',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_kraken.mp4',
+            'waves, storm',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/mochi_storm.mp4',
+            'storm',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/hunyuan_spring.mp4',
+            '',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/hunyuan_typing.mp4',
+            'typing',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/hunyuan_wake_up.mp4',
+            '',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+        [
+            'https://huggingface.co/hkchengrex/MMAudio/resolve/main/examples/sora_nyc.mp4',
+            '',
+            '',
+            0,
+            25,
+            4.5,
+            10,
+        ],
+    ])
+
+text_to_audio_tab = gr.Interface(
+    fn=text_to_audio,
+    description="""
+    Project page: <a href="https://hkchengrex.com/MMAudio/">https://hkchengrex.com/MMAudio/</a><br>
+    Code: <a href="https://github.com/hkchengrex/MMAudio">https://github.com/hkchengrex/MMAudio</a><br>
+    """,
+    inputs=[
+        gr.Text(label='Prompt'),
+        gr.Text(label='Negative prompt'),
+        gr.Number(label='Seed (-1: random)', value=-1, precision=0, minimum=-1),
+        gr.Number(label='Num steps', value=25, precision=0, minimum=1),
+        gr.Number(label='Guidance Strength', value=4.5, minimum=1),
+        gr.Number(label='Duration (sec)', value=8, minimum=1),
+    ],
+    outputs='audio',
+    cache_examples=False,
+    title='MMAudio — Text-to-Audio Synthesis',
+)
+
+image_to_audio_tab = gr.Interface(
+    fn=image_to_audio,
+    description="""
+    Project page: <a href="https://hkchengrex.com/MMAudio/">https://hkchengrex.com/MMAudio/</a><br>
+    Code: <a href="https://github.com/hkchengrex/MMAudio">https://github.com/hkchengrex/MMAudio</a><br>
+
+    NOTE: It takes longer to process high-resolution images (>384 px on the shorter side). 
+    Doing so does not improve results.
+    """,
+    inputs=[
+        gr.Image(type='filepath'),
+        gr.Text(label='Prompt'),
+        gr.Text(label='Negative prompt'),
+        gr.Number(label='Seed (-1: random)', value=-1, precision=0, minimum=-1),
+        gr.Number(label='Num steps', value=25, precision=0, minimum=1),
+        gr.Number(label='Guidance Strength', value=4.5, minimum=1),
+        gr.Number(label='Duration (sec)', value=8, minimum=1),
+    ],
+    outputs='playable_video',
+    cache_examples=False,
+    title='MMAudio — Image-to-Audio Synthesis (experimental)',
+)
+
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument('--port', type=int, default=7860)
+    args = parser.parse_args()
+
+    gr.TabbedInterface([video_to_audio_tab, text_to_audio_tab, image_to_audio_tab],
+                       ['Video-to-Audio', 'Text-to-Audio', 'Image-to-Audio (experimental)']).launch(
+                           server_port=args.port, allowed_paths=[output_dir])

mmaudio/runner.py

@@ -0,0 +1,938 @@
+"""
+trainer.py - wrapper and utility functions for network training
+Compute loss, back-prop, update parameters, logging, etc.
+"""
+import os
+from pathlib import Path
+from typing import Optional, Union
+
+import torch
+import torch.distributed
+import torch.optim as optim
+#from av_bench.evaluate import evaluate # todo Jan 12
+#from av_bench.extract import extract
+from nitrous_ema import PostHocEMA
+from omegaconf import DictConfig
+from torch.nn.parallel import DistributedDataParallel as DDP
+
+from mmaudio.model.flow_matching import FlowMatching
+#from mmaudio.model.networks import get_my_mmaudio
+from mmaudio.model.networks_new import get_my_mmaudio
+from mmaudio.model.sequence_config import CONFIG_16K, CONFIG_44K
+from mmaudio.model.utils.features_utils import FeaturesUtils
+from mmaudio.model.utils.parameter_groups import get_parameter_groups
+from mmaudio.model.utils.sample_utils import log_normal_sample
+from mmaudio.utils.dist_utils import (info_if_rank_zero, local_rank, string_if_rank_zero)
+from mmaudio.utils.log_integrator import Integrator
+from mmaudio.utils.logger import TensorboardLogger
+from mmaudio.utils.time_estimator import PartialTimeEstimator, TimeEstimator
+from mmaudio.utils.video_joiner import VideoJoiner
+
+import torch.nn.functional as F
+import copy # todo Mar 2
+
+class Runner:
+
+    def __init__(self,
+                 cfg: DictConfig,
+                 log: TensorboardLogger,
+                 run_path: Union[str, Path],
+                 for_training: bool = True,
+                 latent_mean: Optional[torch.Tensor] = None,
+                 latent_std: Optional[torch.Tensor] = None,
+                 dpo_train: bool = False):
+        self.exp_id = cfg.exp_id
+        self.use_amp = cfg.amp
+        self.for_training = for_training
+        self.cfg = cfg
+        self.dpo_train = dpo_train # todo Mar 2
+
+        if cfg.model.endswith('16k'):
+            self.seq_cfg = CONFIG_16K
+            mode = '16k'
+        elif cfg.model.endswith('44k'):
+            self.seq_cfg = CONFIG_44K
+            mode = '44k'
+        else:
+            raise ValueError(f'Unknown model: {cfg.model}')
+
+        self.sample_rate = self.seq_cfg.sampling_rate
+        self.duration_sec = self.seq_cfg.duration
+
+        # setting up the model
+        empty_string_feat = torch.load('./ext_weights/empty_string.pth', weights_only=True)[0]
+        
+        self.network = DDP(get_my_mmaudio(cfg.model,
+                                            latent_mean=latent_mean,
+                                            latent_std=latent_std,
+                                            empty_string_feat=empty_string_feat).cuda(),
+                            device_ids=[local_rank],
+                            broadcast_buffers=False,
+                            find_unused_parameters=True)
+
+        if dpo_train: # 
+            self.beta_dpo = cfg.beta_dpo #10000 # todo 1000, 2000, 5000
+            map_location = 'cuda:%d' % local_rank
+            pretrained_ckpt = torch.load(cfg['pretrained_ckpt_for_dpo'], map_location={'cuda:0': map_location}, weights_only=True)
+            self.network.module.load_state_dict(pretrained_ckpt, strict=True)
+            info_if_rank_zero(log, 'Loading pretrained weights from the disk')
+
+            self.ref_network = copy.deepcopy(self.network)
+            self.ref_network.requires_grad_ = False
+            self.ref_network.eval()
+            for param in self.ref_network.parameters():
+                param.requires_grad = False            
+        
+        if cfg.compile:
+            # NOTE: though train_fn and val_fn are very similar
+            # (early on they are implemented as a single function)
+            # keeping them separate and compiling them separately are CRUCIAL for high performance
+            self.train_fn = torch.compile(self.train_fn)
+            self.val_fn = torch.compile(self.val_fn)
+        
+        if cfg.compile and dpo_train: # todo Mar 2
+            self.train_fn_dpo = torch.compile(self.train_fn_dpo)
+
+        self.fm = FlowMatching(cfg.sampling.min_sigma,
+                               inference_mode=cfg.sampling.method,
+                               num_steps=cfg.sampling.num_steps)
+
+        # ema profile
+        if for_training and cfg.ema.enable and local_rank == 0:
+            self.ema = PostHocEMA(self.network.module,
+                                  sigma_rels=cfg.ema.sigma_rels,
+                                  update_every=cfg.ema.update_every,
+                                  checkpoint_every_num_steps=cfg.ema.checkpoint_every,
+                                  checkpoint_folder=cfg.ema.checkpoint_folder,
+                                  step_size_correction=True).cuda()
+            self.ema_start = cfg.ema.start
+        else:
+            self.ema = None
+
+        self.rng = torch.Generator(device='cuda')
+        self.rng.manual_seed(cfg['seed'] + local_rank)
+
+        # setting up feature extractors and VAEs
+        if mode == '16k':
+            self.features = FeaturesUtils(
+                tod_vae_ckpt=cfg['vae_16k_ckpt'],
+                bigvgan_vocoder_ckpt=cfg['bigvgan_vocoder_ckpt'],
+                synchformer_ckpt=cfg['synchformer_ckpt'],
+                enable_conditions=True,
+                mode=mode,
+                need_vae_encoder=False,
+            )
+        elif mode == '44k':
+            self.features = FeaturesUtils(
+                tod_vae_ckpt=cfg['vae_44k_ckpt'],
+                synchformer_ckpt=cfg['synchformer_ckpt'],
+                enable_conditions=True,
+                mode=mode,
+                need_vae_encoder=False,
+            )
+        self.features = self.features.cuda().eval()
+
+        if cfg.compile:
+            self.features.compile()
+
+        # hyperparameters
+        self.log_normal_sampling_mean = cfg.sampling.mean
+        self.log_normal_sampling_scale = cfg.sampling.scale
+        self.null_condition_probability = cfg.null_condition_probability
+        self.cfg_strength = cfg.cfg_strength
+
+        # todo add extra hyperparameters 
+        self.text_condition_drop_probability = cfg.text_condition_drop_probability # todo Jan 16 [0.3, 0.5]
+        self.text_condition_drop_enable = cfg.text_condition_drop_enable # todo Jan 16 True or False
+        self.text_drop_step = cfg.text_drop_step # todo Jan 16
+        
+        # setting up logging
+        self.log = log
+        self.run_path = Path(run_path)
+        vgg_cfg = cfg.dpo_data.VGGSound
+        if for_training:
+            self.val_video_joiner = VideoJoiner(vgg_cfg.root, self.run_path / 'val-sampled-videos',
+                                                self.sample_rate, self.duration_sec)
+        else:
+            self.test_video_joiner = VideoJoiner(vgg_cfg.root,
+                                                 self.run_path / 'test-sampled-videos',
+                                                 self.sample_rate, self.duration_sec)
+        string_if_rank_zero(self.log, 'model_size',
+                            f'{sum([param.nelement() for param in self.network.parameters()])}')
+        string_if_rank_zero(
+            self.log, 'number_of_parameters_that_require_gradient: ',
+            str(
+                sum([
+                    param.nelement()
+                    for param in filter(lambda p: p.requires_grad, self.network.parameters())
+                ])))
+        info_if_rank_zero(self.log, 'torch version: ' + torch.__version__)
+        self.train_integrator = Integrator(self.log, distributed=True)
+        self.val_integrator = Integrator(self.log, distributed=True)
+
+        # setting up optimizer and loss
+        if for_training:
+            self.enter_train()
+            parameter_groups = get_parameter_groups(self.network, cfg, print_log=(local_rank == 0))
+            self.optimizer = optim.AdamW(parameter_groups,
+                                         lr=cfg['learning_rate'],
+                                         weight_decay=cfg['weight_decay'],
+                                         betas=[0.9, 0.95],
+                                         eps=1e-6 if self.use_amp else 1e-8,
+                                         fused=True)
+            if self.use_amp:
+                self.scaler = torch.amp.GradScaler(init_scale=2048)
+            self.clip_grad_norm = cfg['clip_grad_norm']
+
+            # linearly warmup learning rate
+            linear_warmup_steps = cfg['linear_warmup_steps']
+
+            def warmup(currrent_step: int):
+                return (currrent_step + 1) / (linear_warmup_steps + 1)
+
+            warmup_scheduler = optim.lr_scheduler.LambdaLR(self.optimizer, lr_lambda=warmup)
+
+            # setting up learning rate scheduler
+            if cfg['lr_schedule'] == 'constant':
+                next_scheduler = optim.lr_scheduler.LambdaLR(self.optimizer, lr_lambda=lambda _: 1)
+            elif cfg['lr_schedule'] == 'poly':
+                total_num_iter = cfg['iterations']
+                next_scheduler = optim.lr_scheduler.LambdaLR(self.optimizer,
+                                                             lr_lambda=lambda x:
+                                                             (1 - (x / total_num_iter))**0.9)
+            elif cfg['lr_schedule'] == 'step':
+                next_scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer,
+                                                                cfg['lr_schedule_steps'],
+                                                                cfg['lr_schedule_gamma'])
+            else:
+                raise NotImplementedError
+
+            self.scheduler = optim.lr_scheduler.SequentialLR(self.optimizer,
+                                                             [warmup_scheduler, next_scheduler],
+                                                             [linear_warmup_steps])
+
+            # Logging info
+            self.log_text_interval = cfg['log_text_interval']
+            self.log_extra_interval = cfg['log_extra_interval']
+            self.save_weights_interval = cfg['save_weights_interval']
+            self.save_checkpoint_interval = cfg['save_checkpoint_interval']
+            self.save_copy_iterations = cfg['save_copy_iterations']
+            self.num_iterations = cfg['num_iterations']
+            if cfg['debug']:
+                self.log_text_interval = self.log_extra_interval = 1
+
+            # update() is called when we log metrics, within the logger
+            self.log.batch_timer = TimeEstimator(self.num_iterations, self.log_text_interval)
+            # update() is called every iteration, in this script
+            self.log.data_timer = PartialTimeEstimator(self.num_iterations, 1, ema_alpha=0.9)
+        else:
+            self.enter_val()
+
+    def train_fn(
+        self,
+        clip_f: torch.Tensor,
+        sync_f: torch.Tensor,
+        text_f: torch.Tensor,
+        a_mean: torch.Tensor,
+        a_std: torch.Tensor,
+        it: int = 0,  # todo Jan 16
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        # sample
+        a_randn = torch.empty_like(a_mean).normal_(generator=self.rng)
+        x1 = a_mean + a_std * a_randn
+        bs = x1.shape[0]  # batch_size * seq_len * num_channels
+
+        # normalize the latents
+        x1 = self.network.module.normalize(x1)
+
+        t = log_normal_sample(x1,
+                              generator=self.rng,
+                              m=self.log_normal_sampling_mean,
+                              s=self.log_normal_sampling_scale)
+        x0, x1, xt, (clip_f, sync_f, text_f) = self.fm.get_x0_xt_c(x1,
+                                                                   t,
+                                                                   Cs=[clip_f, sync_f, text_f],
+                                                                   generator=self.rng)
+
+        # classifier-free training
+        samples = torch.rand(bs, device=x1.device, generator=self.rng)
+
+        # null mask is for when a video is provided but we decided to ignore it
+        null_video = (samples < self.null_condition_probability)
+        # complete mask is for when a video is not provided or we decided to ignore it
+        clip_f[null_video] = self.network.module.empty_clip_feat
+        sync_f[null_video] = self.network.module.empty_sync_feat
+
+        samples = torch.rand(bs, device=x1.device, generator=self.rng)
+        # todo Jan 16: add text drop prob schedule
+        if self.text_condition_drop_enable: # todo Jan 16
+            drop_index = int(it // self.text_drop_step) # todo Jan 16
+            if drop_index >= len(self.text_condition_drop_probability): # todo Jan 16
+                text_condition_drop_prob = self.text_condition_drop_probability[-1] # todo Jan 16
+
+            else:
+                text_condition_drop_prob = self.text_condition_drop_probability[drop_index] # todo Jan 16
+
+            if it % self.text_drop_step == 0:
+                info_if_rank_zero(self.log, f'Text Condition Drop Prob is: {text_condition_drop_prob}') # todo Jan 16
+
+            null_text = (samples < text_condition_drop_prob) # todo Jan 16
+        else:
+            null_text = (samples < self.null_condition_probability)  # todo Jan 16 [0.1, 0.2, 0.3, 0.4, 0.5]
+        
+        #null_text = (samples < self.null_condition_probability) todo Jan 16 comment it when to use dynamic text condition drop
+        text_f[null_text] = self.network.module.empty_string_feat
+
+        pred_v = self.network(xt, clip_f, sync_f, text_f, t)
+        loss = self.fm.loss(pred_v, x0, x1)
+        mean_loss = loss.mean()
+        return x1, loss, mean_loss, t
+    
+    def train_fn_dpo(
+            self,
+            clip_f: torch.Tensor,
+            sync_f: torch.Tensor,
+            text_f: torch.Tensor,
+            chosen_a_mean: torch.Tensor,
+            chosen_a_std: torch.Tensor,
+            reject_a_mean: torch.Tensor,
+            reject_a_std: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        # sample
+
+        a_randn_chosen = torch.empty_like(chosen_a_mean).normal_(generator=self.rng)
+        x1_chosen = chosen_a_mean + chosen_a_std * a_randn_chosen
+
+        a_randn_reject = torch.empty_like(reject_a_mean).normal_(generator=self.rng)
+        x1_reject = reject_a_mean + reject_a_std * a_randn_reject
+
+        # normalize the latents
+        x1_chosen = self.network.module.normalize(x1_chosen)
+        x1_reject = self.network.module.normalize(x1_reject) # todo Mar 2 (needs to change)
+
+        x1 = torch.cat((x1_chosen, x1_reject), dim=0)
+        bs = x1.shape[0]  # batch_size * seq_len * num_channels * 2 # todo Mar 2 needs to change
+
+
+        t = log_normal_sample(x1.chunk(2)[0], # todo keep the t same for both chosen and reject
+                              generator=self.rng,
+                              m=self.log_normal_sampling_mean,
+                              s=self.log_normal_sampling_scale)
+
+        t = t.repeat(2) # todo
+
+        x0, x1, xt, (clip_f, sync_f, text_f) = self.fm.get_x0_xt_c_dpo(x1,
+                                                                   t,
+                                                                   Cs=[clip_f, sync_f, text_f],
+                                                                   generator=self.rng)
+
+        # classifier-free training
+        samples = torch.rand(bs//2, device=x1.device, generator=self.rng)
+
+        # null mask is for when a video is provided but we decided to ignore it
+        null_video = (samples < self.null_condition_probability)
+        # complete mask is for when a video is not provided or we decided to ignore it
+        clip_f[null_video] = self.network.module.empty_clip_feat
+        sync_f[null_video] = self.network.module.empty_sync_feat
+
+        samples = torch.rand(bs//2, device=x1.device, generator=self.rng)
+        
+         # todo Jan 16: add text drop prob schedule
+        if self.text_condition_drop_enable: # todo Jan 16
+            drop_index = int(it // self.text_drop_step) # todo Jan 16
+            if drop_index >= len(self.text_condition_drop_probability): # todo Jan 16
+                text_condition_drop_prob = self.text_condition_drop_probability[-1] # todo Jan 16
+
+            else:
+                text_condition_drop_prob = self.text_condition_drop_probability[drop_index] # todo Jan 16
+
+            if it % self.text_drop_step == 0:
+                info_if_rank_zero(self.log, f'Text Condition Drop Prob is: {text_condition_drop_prob}') # todo Jan 16
+
+            null_text = (samples < text_condition_drop_prob) # todo Jan 16
+        else:
+            null_text = (samples < self.null_condition_probability)  # todo Jan 16 [0.1, 0.2, 0.3, 0.4, 0.5]
+        
+        #null_text = (samples < self.null_condition_probability) todo Jan 16 comment it when to use dynamic text condition drop
+        text_f[null_text] = self.network.module.empty_string_feat
+
+        clip_f = clip_f.repeat(2, 1, 1)
+        sync_f = sync_f.repeat(2, 1, 1)
+        text_f = text_f.repeat(2, 1, 1)
+
+        pred_v = self.network(xt, clip_f, sync_f, text_f, t)
+
+        model_loss = self.fm.loss(pred_v, x0, x1)
+
+        model_losses_w, model_losses_l = model_loss.chunk(2)
+
+        model_diff = model_losses_w - model_losses_l
+        raw_model_loss = 0.5 * (model_losses_w.mean() + model_losses_l.mean())
+
+        with torch.no_grad():
+            ref_pred_v = self.ref_network(xt, clip_f, sync_f, text_f, t)
+            ref_loss = self.fm.loss(ref_pred_v, x0, x1)
+            ref_losses_w, ref_losses_l = ref_loss.chunk(2)
+            ref_diff = ref_losses_w - ref_losses_l
+            raw_ref_loss = ref_loss.mean()
+
+        scale_term = -0.5 * self.beta_dpo
+        inside_term = scale_term * (model_diff - ref_diff)
+        implicit_acc = (
+                               scale_term * (model_diff - ref_diff) > 0
+                       ).sum().float() / inside_term.size(0)
+
+        loss = -1 * F.logsigmoid(inside_term) + model_losses_w
+        mean_loss = -1 * F.logsigmoid(inside_term).mean() + model_losses_w.mean()
+
+        return x1, loss, mean_loss, t.chunk(2)[0], raw_model_loss, raw_ref_loss, implicit_acc
+
+
+    def val_fn(
+        self,
+        clip_f: torch.Tensor,
+        sync_f: torch.Tensor,
+        text_f: torch.Tensor,
+        x1: torch.Tensor,
+    ) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:
+        bs = x1.shape[0]  # batch_size * seq_len * num_channels
+        # normalize the latents
+        x1 = self.network.module.normalize(x1)
+        t = log_normal_sample(x1,
+                              generator=self.rng,
+                              m=self.log_normal_sampling_mean,
+                              s=self.log_normal_sampling_scale)
+        x0, x1, xt, (clip_f, sync_f, text_f) = self.fm.get_x0_xt_c(x1,
+                                                                   t,
+                                                                   Cs=[clip_f, sync_f, text_f],
+                                                                   generator=self.rng)
+
+        # classifier-free training
+        samples = torch.rand(bs, device=x1.device, generator=self.rng)
+        # null mask is for when a video is provided but we decided to ignore it
+        null_video = (samples < self.null_condition_probability)
+        # complete mask is for when a video is not provided or we decided to ignore it
+        clip_f[null_video] = self.network.module.empty_clip_feat
+        sync_f[null_video] = self.network.module.empty_sync_feat
+
+        samples = torch.rand(bs, device=x1.device, generator=self.rng)
+        null_text = (samples < self.null_condition_probability)
+        text_f[null_text] = self.network.module.empty_string_feat
+
+        pred_v = self.network(xt, clip_f, sync_f, text_f, t)
+
+        loss = self.fm.loss(pred_v, x0, x1)
+        mean_loss = loss.mean()
+        return loss, mean_loss, t
+
+    def train_pass(self, data, it: int = 0):
+
+        if not self.for_training:
+            raise ValueError('train_pass() should not be called when not training.')
+
+        self.enter_train()
+        with torch.amp.autocast('cuda', enabled=self.use_amp, dtype=torch.bfloat16):
+            clip_f = data['clip_features'].cuda(non_blocking=True)
+            sync_f = data['sync_features'].cuda(non_blocking=True)
+            text_f = data['text_features'].cuda(non_blocking=True)
+            video_exist = data['video_exist'].cuda(non_blocking=True)
+            text_exist = data['text_exist'].cuda(non_blocking=True)
+            a_mean = data['a_mean'].cuda(non_blocking=True)
+            a_std = data['a_std'].cuda(non_blocking=True)
+
+            # these masks are for non-existent data; masking for CFG training is in train_fn
+            clip_f[~video_exist] = self.network.module.empty_clip_feat
+            sync_f[~video_exist] = self.network.module.empty_sync_feat
+            text_f[~text_exist] = self.network.module.empty_string_feat
+
+            self.log.data_timer.end()
+            if it % self.log_extra_interval == 0:
+                unmasked_clip_f = clip_f.clone()
+                unmasked_sync_f = sync_f.clone()
+                unmasked_text_f = text_f.clone()
+            x1, loss, mean_loss, t = self.train_fn(clip_f, sync_f, text_f, a_mean, a_std, it) # todo Jan 16
+ 
+            self.train_integrator.add_dict({'loss': mean_loss})
+
+        if it % self.log_text_interval == 0 and it != 0:
+            self.train_integrator.add_scalar('lr', self.scheduler.get_last_lr()[0])
+            self.train_integrator.add_binned_tensor('binned_loss', loss, t)
+            self.train_integrator.finalize('train', it)
+            self.train_integrator.reset_except_hooks()
+
+        # Backward pass
+        self.optimizer.zero_grad(set_to_none=True)
+        if self.use_amp:
+            self.scaler.scale(mean_loss).backward()
+            self.scaler.unscale_(self.optimizer)
+            grad_norm = torch.nn.utils.clip_grad_norm_(self.network.parameters(),
+                                                       self.clip_grad_norm)
+            self.scaler.step(self.optimizer)
+            self.scaler.update()
+        else:
+            mean_loss.backward()
+            grad_norm = torch.nn.utils.clip_grad_norm_(self.network.parameters(),
+                                                       self.clip_grad_norm)
+            self.optimizer.step()
+
+        if self.ema is not None and it >= self.ema_start:
+            self.ema.update()
+        self.scheduler.step()
+        self.integrator.add_scalar('grad_norm', grad_norm)
+
+        self.enter_val()
+        with torch.amp.autocast('cuda', enabled=self.use_amp,
+                                dtype=torch.bfloat16), torch.inference_mode():
+            try:
+                if it % self.log_extra_interval == 0:
+                    # save GT audio
+                    # unnormalize the latents
+                    x1 = self.network.module.unnormalize(x1[0:1])
+                    mel = self.features.decode(x1)
+                    audio = self.features.vocode(mel).cpu()[0]  # 1 * num_samples
+                    self.log.log_spectrogram('train', f'spec-gt-r{local_rank}', mel.cpu()[0], it)
+                    self.log.log_audio('train',
+                                       f'audio-gt-r{local_rank}',
+                                       audio,
+                                       it,
+                                       sample_rate=self.sample_rate)
+
+                    # save audio from sampling
+                    x0 = torch.empty_like(x1[0:1]).normal_(generator=self.rng)
+                    clip_f = unmasked_clip_f[0:1]
+                    sync_f = unmasked_sync_f[0:1]
+                    text_f = unmasked_text_f[0:1]
+                    conditions = self.network.module.preprocess_conditions(clip_f, sync_f, text_f)
+                    empty_conditions = self.network.module.get_empty_conditions(x0.shape[0])
+                    cfg_ode_wrapper = lambda t, x: self.network.module.ode_wrapper(
+                        t, x, conditions, empty_conditions, self.cfg_strength)
+                    x1_hat = self.fm.to_data(cfg_ode_wrapper, x0)
+                    x1_hat = self.network.module.unnormalize(x1_hat)
+                    mel = self.features.decode(x1_hat)
+                    audio = self.features.vocode(mel).cpu()[0]
+                    self.log.log_spectrogram('train', f'spec-r{local_rank}', mel.cpu()[0], it)
+                    self.log.log_audio('train',
+                                       f'audio-r{local_rank}',
+                                       audio,
+                                       it,
+                                       sample_rate=self.sample_rate)
+            except Exception as e:
+                self.log.warning(f'Error in extra logging: {e}')
+                if self.cfg.debug:
+                    raise
+
+        # Save network weights and checkpoint if needed
+        save_copy = it in self.save_copy_iterations
+
+        if (it % self.save_weights_interval == 0 and it != 0) or save_copy:
+            self.save_weights(it)
+
+        if it % self.save_checkpoint_interval == 0 and it != 0:
+            self.save_checkpoint(it, save_copy=save_copy)
+
+        self.log.data_timer.start()
+
+
+    def train_dpo_pass(self, data, it: int = 0):
+
+        if not self.for_training:
+            raise ValueError('train_pass() should not be called when not training.')
+
+        self.enter_train()
+        with torch.amp.autocast('cuda', enabled=self.use_amp, dtype=torch.bfloat16):
+            clip_f = data['clip_features'].cuda(non_blocking=True)
+            sync_f = data['sync_features'].cuda(non_blocking=True)
+            text_f = data['text_features'].cuda(non_blocking=True)
+            video_exist = data['video_exist'].cuda(non_blocking=True)
+            text_exist = data['text_exist'].cuda(non_blocking=True)
+            chosen_a_mean = data['chosen_a_mean'].cuda(non_blocking=True)
+            chosen_a_std = data['chosen_a_std'].cuda(non_blocking=True)
+
+            reject_a_mean = data['reject_a_mean'].cuda(non_blocking=True)
+            reject_a_std = data['reject_a_std'].cuda(non_blocking=True)
+
+            # these masks are for non-existent data; masking for CFG training is in train_fn
+            clip_f[~video_exist] = self.network.module.empty_clip_feat
+            sync_f[~video_exist] = self.network.module.empty_sync_feat
+            text_f[~text_exist] = self.network.module.empty_string_feat
+
+            self.log.data_timer.end()
+            if it % self.log_extra_interval == 0:
+                unmasked_clip_f = clip_f.clone()
+                unmasked_sync_f = sync_f.clone()
+                unmasked_text_f = text_f.clone()
+            x1, loss, mean_loss, t, raw_model_loss, raw_ref_loss, implicit_acc = self.train_fn_dpo(clip_f, sync_f, text_f, chosen_a_mean, chosen_a_std, reject_a_mean, reject_a_std)
+
+            self.train_integrator.add_dict({'loss': mean_loss})
+            self.train_integrator.add_dict({'raw_model_loss': raw_model_loss})
+            self.train_integrator.add_dict({'raw_ref_loss': raw_ref_loss})
+            self.train_integrator.add_dict({'implicit_acc': implicit_acc})
+
+
+        if it % self.log_text_interval == 0 and it != 0:
+            self.train_integrator.add_scalar('lr', self.scheduler.get_last_lr()[0])
+            self.train_integrator.add_binned_tensor('binned_loss', loss, t)
+            self.train_integrator.finalize('train', it)
+            self.train_integrator.reset_except_hooks()
+
+        # Backward pass
+        self.optimizer.zero_grad(set_to_none=True)
+        if self.use_amp:
+            self.scaler.scale(mean_loss).backward()
+            self.scaler.unscale_(self.optimizer)
+            grad_norm = torch.nn.utils.clip_grad_norm_(self.network.parameters(),
+                                                       self.clip_grad_norm)
+            self.scaler.step(self.optimizer)
+            self.scaler.update()
+        else:
+            mean_loss.backward()
+            grad_norm = torch.nn.utils.clip_grad_norm_(self.network.parameters(),
+                                                       self.clip_grad_norm)
+            self.optimizer.step()
+
+        if self.ema is not None and it >= self.ema_start:
+            self.ema.update()
+        self.scheduler.step()
+        self.integrator.add_scalar('grad_norm', grad_norm)
+
+        self.enter_val()
+        with torch.amp.autocast('cuda', enabled=self.use_amp,
+                                dtype=torch.bfloat16), torch.inference_mode():
+            try: # todo needs to be changed Mar 2
+                if it % self.log_extra_interval == 0:
+                    # save GT audio
+                    # unnormalize the latents
+                    x1_chosen = x1.chunk(2)[0]
+                    x1_reject = x1.chunk(2)[1]
+                    # todo need to be changed accordingly
+                    
+                    
+                    x1_chosen, x1_rekject = self.network.module.unnormalize(x1_chosen[0:1]), self.network.module.unnormalize(x1_reject[0:1])
+                    mel_chosen = self.features.decode(x1_chosen)
+                    audio_chosen = self.features.vocode(mel_chosen).cpu()[0]  # 1 * num_samples
+                    mel_reject = self.features.decode(x1_reject)
+                    audio_reject = self.features.vocode(mel_reject).cpu()[0]  # 1 * num_samples
+
+                    self.log.log_spectrogram('train-chosen', f'spec-gt-chosen-r{local_rank}', mel_chosen.cpu()[0], it)
+                    self.log.log_audio('train-chosen',
+                                       f'audio-gt-chosen-r{local_rank}',
+                                       audio_chosen,
+                                       it,
+                                       sample_rate=self.sample_rate)
+
+                    self.log.log_spectrogram('train-reject', f'spec-gt-reject-r{local_rank}', mel_reject.cpu()[0], it)
+                    self.log.log_audio('train-reject',
+                                       f'audio-gt-reject-r{local_rank}',
+                                       audio_reject,
+                                       it,
+                                       sample_rate=self.sample_rate)
+
+                    # save audio from sampling
+                    x0_chosen = torch.empty_like(x1_chosen[0:1]).normal_(generator=self.rng)
+                    x0_reject = torch.empty_like(x1_reject[0:1]).normal_(generator=self.rng)
+                    clip_f = unmasked_clip_f[0:1]
+                    sync_f = unmasked_sync_f[0:1]
+                    text_f = unmasked_text_f[0:1]
+                    conditions = self.network.module.preprocess_conditions(clip_f, sync_f, text_f)
+                    empty_conditions = self.network.module.get_empty_conditions(x0_chosen.shape[0])
+                    cfg_ode_wrapper = lambda t, x: self.network.module.ode_wrapper(
+                        t, x, conditions, empty_conditions, self.cfg_strength)
+                    x1_hat_chosen = self.fm.to_data(cfg_ode_wrapper, x0_chosen)
+                    x1_hat_reject = self.fm.to_data(cfg_ode_wrapper, x0_reject)
+
+                    x1_hat_chosen, x1_hat_reject = self.network.module.unnormalize(x1_hat_chosen), self.network.module.unnormalize(x1_hat_reject)
+                    mel_chosen = self.features.decode(x1_hat_chosen)
+                    audio_chosen = self.features.vocode(mel_chosen).cpu()[0]
+
+                    mel_reject = self.features.decode(x1_hat_reject)
+                    audio_reject = self.features.vocode(mel_reject).cpu()[0]
+
+                    self.log.log_spectrogram('train-chosen', f'spec-chosen-r{local_rank}', mel_chosen.cpu()[0], it)
+                    self.log.log_audio('train-chosen',
+                                       f'audio-chosen-r{local_rank}',
+                                       audio_chosen,
+                                       it,
+                                       sample_rate=self.sample_rate)
+
+                    self.log.log_spectrogram('train-reject', f'spec-reject-r{local_rank}', mel_reject.cpu()[0], it)
+                    self.log.log_audio('train-reject',
+                                       f'audio-reject-r{local_rank}',
+                                       audio_reject,
+                                       it,
+                                       sample_rate=self.sample_rate)
+
+
+                    '''
+                    x1 = self.network.module.unnormalize(x1[0:1])
+                    mel = self.features.decode(x1)
+                    audio = self.features.vocode(mel).cpu()[0]  # 1 * num_samples
+                    self.log.log_spectrogram('train', f'spec-gt-r{local_rank}', mel.cpu()[0], it)
+                    self.log.log_audio('train',
+                                       f'audio-gt-r{local_rank}',
+                                       audio,
+                                       it,
+                                       sample_rate=self.sample_rate)
+
+                    # save audio from sampling
+                    x0 = torch.empty_like(x1[0:1]).normal_(generator=self.rng)
+                    clip_f = unmasked_clip_f[0:1]
+                    sync_f = unmasked_sync_f[0:1]
+                    text_f = unmasked_text_f[0:1]
+                    conditions = self.network.module.preprocess_conditions(clip_f, sync_f, text_f)
+                    empty_conditions = self.network.module.get_empty_conditions(x0.shape[0])
+                    cfg_ode_wrapper = lambda t, x: self.network.module.ode_wrapper(
+                        t, x, conditions, empty_conditions, self.cfg_strength)
+                    x1_hat = self.fm.to_data(cfg_ode_wrapper, x0)
+                    x1_hat = self.network.module.unnormalize(x1_hat)
+                    mel = self.features.decode(x1_hat)
+                    audio = self.features.vocode(mel).cpu()[0]
+                    self.log.log_spectrogram('train', f'spec-r{local_rank}', mel.cpu()[0], it)
+                    self.log.log_audio('train',
+                                       f'audio-r{local_rank}',
+                                       audio,
+                                       it,
+                                       sample_rate=self.sample_rate)'''
+            except Exception as e:
+                self.log.warning(f'Error in extra logging: {e}')
+                if self.cfg.debug:
+                    raise
+
+        # Save network weights and checkpoint if needed
+        save_copy = it in self.save_copy_iterations
+
+        if (it % self.save_weights_interval == 0 and it != 0) or save_copy:
+            self.save_weights(it)
+
+        if it % self.save_checkpoint_interval == 0 and it != 0:
+            self.save_checkpoint(it, save_copy=save_copy)
+
+        self.log.data_timer.start()
+
+
+
+    @torch.inference_mode()
+    def validation_pass(self, data, it: int = 0):
+        self.enter_val()
+        with torch.amp.autocast('cuda', enabled=self.use_amp, dtype=torch.bfloat16):
+            clip_f = data['clip_features'].cuda(non_blocking=True)
+            sync_f = data['sync_features'].cuda(non_blocking=True)
+            text_f = data['text_features'].cuda(non_blocking=True)
+            video_exist = data['video_exist'].cuda(non_blocking=True)
+            text_exist = data['text_exist'].cuda(non_blocking=True)
+            a_mean = data['a_mean'].cuda(non_blocking=True)
+            a_std = data['a_std'].cuda(non_blocking=True)
+
+            clip_f[~video_exist] = self.network.module.empty_clip_feat
+            sync_f[~video_exist] = self.network.module.empty_sync_feat
+            text_f[~text_exist] = self.network.module.empty_string_feat
+            a_randn = torch.empty_like(a_mean).normal_(generator=self.rng)
+            x1 = a_mean + a_std * a_randn
+
+            self.log.data_timer.end()
+            loss, mean_loss, t = self.val_fn(clip_f.clone(), sync_f.clone(), text_f.clone(), x1)
+
+            self.val_integrator.add_binned_tensor('binned_loss', loss, t)
+            self.val_integrator.add_dict({'loss': mean_loss})
+
+        self.log.data_timer.start()
+
+    @torch.inference_mode()
+    def inference_pass(self,
+                       data,
+                       it: int,
+                       data_cfg: DictConfig,
+                       *,
+                       save_eval: bool = True) -> Path:
+        self.enter_val()
+        with torch.amp.autocast('cuda', enabled=self.use_amp, dtype=torch.bfloat16):
+            clip_f = data['clip_features'].cuda(non_blocking=True)
+            sync_f = data['sync_features'].cuda(non_blocking=True)
+            text_f = data['text_features'].cuda(non_blocking=True)
+            video_exist = data['video_exist'].cuda(non_blocking=True)
+            text_exist = data['text_exist'].cuda(non_blocking=True)
+            a_mean = data['a_mean'].cuda(non_blocking=True)  # for the shape only
+
+            clip_f[~video_exist] = self.network.module.empty_clip_feat
+            sync_f[~video_exist] = self.network.module.empty_sync_feat
+            text_f[~text_exist] = self.network.module.empty_string_feat
+
+            # sample
+            x0 = torch.empty_like(a_mean).normal_(generator=self.rng)
+            conditions = self.network.module.preprocess_conditions(clip_f, sync_f, text_f)
+            empty_conditions = self.network.module.get_empty_conditions(x0.shape[0])
+            cfg_ode_wrapper = lambda t, x: self.network.module.ode_wrapper(
+                t, x, conditions, empty_conditions, self.cfg_strength)
+            x1_hat = self.fm.to_data(cfg_ode_wrapper, x0)
+            x1_hat = self.network.module.unnormalize(x1_hat)
+            mel = self.features.decode(x1_hat)
+            audio = self.features.vocode(mel).cpu()
+            for i in range(audio.shape[0]):
+                video_id = data['id'][i]
+                if (not self.for_training) and i == 0:
+                    # save very few videos
+                    self.test_video_joiner.join(video_id, f'{video_id}', audio[i].transpose(0, 1))
+
+                if data_cfg.output_subdir is not None:
+                    # validation
+                    if save_eval:
+                        iter_naming = f'{it:09d}'
+                    else:
+                        iter_naming = 'val-cache'
+                    audio_dir = self.log.log_audio(iter_naming,
+                                                   f'{video_id}',
+                                                   audio[i],
+                                                   it=None,
+                                                   sample_rate=self.sample_rate,
+                                                   subdir=Path(data_cfg.output_subdir))
+                    if save_eval and i == 0:
+                        self.val_video_joiner.join(video_id, f'{iter_naming}-{video_id}',
+                                                   audio[i].transpose(0, 1))
+                else:
+                    # full test set, usually
+                    audio_dir = self.log.log_audio(f'{data_cfg.tag}-sampled',
+                                                   f'{video_id}',
+                                                   audio[i],
+                                                   it=None,
+                                                   sample_rate=self.sample_rate)
+
+        return Path(audio_dir)
+
+    @torch.inference_mode()
+    def eval(self, audio_dir: Path, it: int, data_cfg: DictConfig) -> dict[str, float]:
+        # rank 0 model only, outside of AMP
+        info_if_rank_zero(self.log, 'Eval: entering barrier')
+        torch.distributed.barrier()
+        info_if_rank_zero(self.log, 'Eval: barrier resolved')
+        if local_rank == 0:
+            extract(audio_path=audio_dir,
+                    output_path=audio_dir / 'cache',
+                    device='cuda',
+                    batch_size=32,
+                    audio_length=8)
+            output_metrics = evaluate(gt_audio_cache=Path(data_cfg.gt_cache),
+                                      pred_audio_cache=audio_dir / 'cache')
+            for k, v in output_metrics.items():
+                # pad k to 10 characters
+                # pad v to 10 decimal places
+                self.log.log_scalar(f'{data_cfg.tag}/{k}', v, it)
+                self.log.info(f'{data_cfg.tag}/{k:<10}: {v:.10f}')
+        else:
+            output_metrics = None
+
+        return output_metrics
+
+    def save_weights(self, it, save_copy=False):
+        if local_rank != 0:
+            return
+
+        os.makedirs(self.run_path, exist_ok=True)
+        if save_copy:
+            model_path = self.run_path / f'{self.exp_id}_{it}.pth'
+            torch.save(self.network.module.state_dict(), model_path)
+            self.log.info(f'Network weights saved to {model_path}.')
+
+        # if last exists, move it to a shadow copy
+        model_path = self.run_path / f'{self.exp_id}_last.pth'
+        if model_path.exists():
+            shadow_path = model_path.with_name(model_path.name.replace('last', 'shadow'))
+            model_path.replace(shadow_path)
+            self.log.info(f'Network weights shadowed to {shadow_path}.')
+
+        torch.save(self.network.module.state_dict(), model_path)
+        self.log.info(f'Network weights saved to {model_path}.')
+
+    def save_checkpoint(self, it, save_copy=False):
+        if local_rank != 0:
+            return
+
+        checkpoint = {
+            'it': it,
+            'weights': self.network.module.state_dict(),
+            'optimizer': self.optimizer.state_dict(),
+            'scheduler': self.scheduler.state_dict(),
+            'ema': self.ema.state_dict() if self.ema is not None else None,
+        }
+
+        os.makedirs(self.run_path, exist_ok=True)
+        if save_copy:
+            model_path = self.run_path / f'{self.exp_id}_ckpt_{it}.pth'
+            torch.save(checkpoint, model_path)
+            self.log.info(f'Checkpoint saved to {model_path}.')
+
+        # if ckpt_last exists, move it to a shadow copy
+        model_path = self.run_path / f'{self.exp_id}_ckpt_last.pth'
+        if model_path.exists():
+            shadow_path = model_path.with_name(model_path.name.replace('last', 'shadow'))
+            model_path.replace(shadow_path)  # moves the file
+            self.log.info(f'Checkpoint shadowed to {shadow_path}.')
+
+        torch.save(checkpoint, model_path)
+        self.log.info(f'Checkpoint saved to {model_path}.')
+
+    def get_latest_checkpoint_path(self):
+        ckpt_path = self.run_path / f'{self.exp_id}_ckpt_last.pth'
+        if not ckpt_path.exists():
+            info_if_rank_zero(self.log, f'No checkpoint found at {ckpt_path}.')
+            return None
+        return ckpt_path
+
+    def get_latest_weight_path(self):
+        weight_path = self.run_path / f'{self.exp_id}_last.pth'
+        if not weight_path.exists():
+            self.log.info(f'No weight found at {weight_path}.')
+            return None
+        return weight_path
+
+    def get_final_ema_weight_path(self):
+        weight_path = self.run_path / f'{self.exp_id}_ema_final.pth'
+        if not weight_path.exists():
+            self.log.info(f'No weight found at {weight_path}.')
+            return None
+        return weight_path
+
+    def load_checkpoint(self, path):
+        # This method loads everything and should be used to resume training
+        map_location = 'cuda:%d' % local_rank
+        checkpoint = torch.load(path, map_location={'cuda:0': map_location}, weights_only=True)
+
+        it = checkpoint['it']
+        weights = checkpoint['weights']
+        optimizer = checkpoint['optimizer']
+        scheduler = checkpoint['scheduler']
+        if self.ema is not None:
+            self.ema.load_state_dict(checkpoint['ema'])
+            self.log.info(f'EMA states loaded from step {self.ema.step}')
+
+        map_location = 'cuda:%d' % local_rank
+        self.network.module.load_state_dict(weights)
+        self.optimizer.load_state_dict(optimizer)
+        self.scheduler.load_state_dict(scheduler)
+
+        self.log.info(f'Global iteration {it} loaded.')
+        self.log.info('Network weights, optimizer states, and scheduler states loaded.')
+
+        return it
+
+    def load_weights_in_memory(self, src_dict):
+        self.network.module.load_weights(src_dict)
+        self.log.info('Network weights loaded from memory.')
+
+    def load_weights(self, path):
+        # This method loads only the network weight and should be used to load a pretrained model
+        map_location = 'cuda:%d' % local_rank
+        src_dict = torch.load(path, map_location={'cuda:0': map_location}, weights_only=True)
+
+        self.log.info(f'Importing network weights from {path}...')
+        self.load_weights_in_memory(src_dict)
+
+    def weights(self):
+        return self.network.module.state_dict()
+
+    def enter_train(self):
+        self.integrator = self.train_integrator
+        self.network.train()
+        return self
+
+    def enter_val(self):
+        self.network.eval()
+        return self

reward_models/av_align.py

@@ -0,0 +1,243 @@
+"""
+AV-Align Metric: Audio-Video Alignment Evaluation
+
+AV-Align is a metric for evaluating the alignment between audio and video modalities in multimedia data.
+It assesses synchronization by detecting audio and video peaks and calculating their Intersection over Union (IoU).
+A higher IoU score indicates better alignment.
+
+Usage:
+- Provide a folder of video files as input.
+- The script calculates the AV-Align score for the set of videos.
+"""
+
+import argparse
+import glob
+import os
+
+import cv2
+import librosa
+import librosa.display
+
+import multiprocessing
+from tqdm import tqdm
+import pandas as pd
+
+
+# Function to extract frames from a video file
+def extract_frames(video_path):
+    """
+    Extract frames from a video file.
+
+    Args:
+        video_path (str): Path to the input video file.
+
+    Returns:
+        frames (list): List of frames extracted from the video.
+        frame_rate (float): Frame rate of the video.
+    """
+    frames = []
+    cap = cv2.VideoCapture(video_path)
+    frame_rate = cap.get(cv2.CAP_PROP_FPS)
+
+    if not cap.isOpened():
+        raise ValueError(f"Error: Unable to open the video file. Wrong video is {video_path}")
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frames.append(frame)
+    cap.release()
+    return frames, frame_rate
+
+
+# Function to detect audio peaks using the Onset Detection algorithm
+def detect_audio_peaks(audio_file):
+    """
+    Detect audio peaks using the Onset Detection algorithm.
+
+    Args:
+        audio_file (str): Path to the audio file.
+
+    Returns:
+        onset_times (list): List of times (in seconds) where audio peaks occur.
+    """
+    y, sr = librosa.load(audio_file)
+    # Calculate the onset envelope
+    onset_env = librosa.onset.onset_strength(y=y, sr=sr)
+    # Get the onset events
+    onset_frames = librosa.onset.onset_detect(onset_envelope=onset_env, sr=sr)
+    onset_times = librosa.frames_to_time(onset_frames, sr=sr)
+    return onset_times
+
+
+# Function to find local maxima in a list
+def find_local_max_indexes(arr, fps):
+    """
+    Find local maxima in a list.
+
+    Args:
+        arr (list): List of values to find local maxima in.
+        fps (float): Frames per second, used to convert indexes to time.
+
+    Returns:
+        local_extrema_indexes (list): List of times (in seconds) where local maxima occur.
+    """
+
+    local_extrema_indexes = []
+    n = len(arr)
+    for i in range(1, n - 1):
+        if arr[i - 1] < arr[i] > arr[i + 1]:  # Local maximum
+            local_extrema_indexes.append(i / fps)
+
+    return local_extrema_indexes
+
+
+# Function to detect video peaks using Optical Flow
+def detect_video_peaks(frames, fps):
+    """
+    Detect video peaks using Optical Flow.
+
+    Args:
+        frames (list): List of video frames.
+        fps (float): Frame rate of the video.
+
+    Returns:
+        flow_trajectory (list): List of optical flow magnitudes for each frame.
+        video_peaks (list): List of times (in seconds) where video peaks occur.
+    """
+    flow_trajectory = [compute_of(frames[0], frames[1])] + [compute_of(frames[i - 1], frames[i]) for i in
+                                                            range(1, len(frames))]
+    video_peaks = find_local_max_indexes(flow_trajectory, fps)
+    return flow_trajectory, video_peaks
+
+
+# Function to compute the optical flow magnitude between two frames
+def compute_of(img1, img2):
+    """
+    Compute the optical flow magnitude between two video frames.
+
+    Args:
+        img1 (numpy.ndarray): First video frame.
+        img2 (numpy.ndarray): Second video frame.
+
+    Returns:
+        avg_magnitude (float): Average optical flow magnitude for the frame pair.
+    """
+    # Calculate the optical flow
+    prev_gray = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)
+    curr_gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
+    flow = cv2.calcOpticalFlowFarneback(prev_gray, curr_gray, None, 0.5, 3, 15, 3, 5, 1.2, 0)
+
+    # Calculate the magnitude of the optical flow vectors
+    magnitude = cv2.magnitude(flow[..., 0], flow[..., 1])
+    avg_magnitude = cv2.mean(magnitude)[0]
+    return avg_magnitude
+
+
+# Function to calculate Intersection over Union (IoU) for audio and video peaks
+def calc_intersection_over_union(audio_peaks, video_peaks, fps):
+    """
+    Calculate Intersection over Union (IoU) between audio and video peaks.
+
+    Args:
+        audio_peaks (list): List of audio peak times (in seconds).
+        video_peaks (list): List of video peak times (in seconds).
+        fps (float): Frame rate of the video.
+
+    Returns:
+        iou (float): Intersection over Union score.
+    """
+    intersection_length = 0
+    for audio_peak in audio_peaks:
+        for video_peak in video_peaks:
+            if video_peak - 1 / fps < audio_peak < video_peak + 1 / fps:
+                intersection_length += 1
+                break
+    return intersection_length / (len(audio_peaks) + len(video_peaks) - intersection_length)
+
+
+def calculate_av_align_each_pair(video_path, audio_path):
+    try:
+        frames, fps = extract_frames(video_path)
+        audio_peaks = detect_audio_peaks(audio_path)
+        flow_trajectory, video_peaks = detect_video_peaks(frames, fps)
+        score = calc_intersection_over_union(audio_peaks, video_peaks, fps)
+        print(f'Calculated AV Align score for {os.path.basename(video_path)}')
+    except:
+        score = -1
+        print(f'Cannot Calculate AV Align score for {os.path.basename(video_path)}')
+
+    return score
+
+
+def calculate_av_align_samples(video_path, audio_paths):
+    """
+    :param video_path: only input the video path for each video id
+    :param audio_paths: input the list of generated audio file path
+    :return: score: list of av-align score
+    """
+    score = []
+    frames, fps = extract_frames(video_path)
+    flow_trajectory, video_peaks = detect_video_peaks(frames, fps)
+    for audio_path in audio_paths:
+        audio_peaks = detect_audio_peaks(audio_path)
+        each_score = calc_intersection_over_union(audio_peaks, video_peaks, fps)
+        score.append(each_score)
+    print(f'Calculated AV Align score for {os.path.basename(video_path)}')
+    return score
+
+
+def multi_wrapper(args):
+    return wrapper_cal_av_score(*args)
+
+
+def wrapper_cal_av_score(video_path, audio_path):
+    video_id = os.path.basename(video_path)[:-4]
+    try:
+        frames, fps = extract_frames(video_path)
+        audio_peaks = detect_audio_peaks(audio_path)
+        flow_trajectory, video_peaks = detect_video_peaks(frames, fps)
+        score = calc_intersection_over_union(audio_peaks, video_peaks, fps)
+        print(f'Calculated AV Align score for {os.path.basename(video_path)}')
+    except:
+        score = -1
+        print(f'Cannot Calculate AV Align score for {os.path.basename(video_path)}')
+
+    data = {
+        'video_id': video_id,
+        'score': score,
+    }
+    return data
+
+
+if __name__ == "__main__":
+
+    threshold = 0.2
+    video_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/videos'
+    audio_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/audios_vggsound'
+    output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/MMAudio/filter_dataset'
+
+    audio_file_list = os.listdir(audio_dir)
+
+    video_audio_list = []
+
+    for audio_file in tqdm(audio_file_list):
+        video_id = audio_file[:-4]
+        video_file = video_id + '.mp4'
+        video_path = os.path.join(video_dir, video_file)
+        audio_path = os.path.join(audio_dir, audio_file)
+        video_audio_list.append((video_path, audio_path))
+
+    cores = multiprocessing.cpu_count()
+    pool = multiprocessing.Pool(processes=cores)
+
+    results = list(tqdm(pool.imap(multi_wrapper, video_audio_list), total=len(video_audio_list)))
+
+    # with multiprocessing.Pool(processes=cores) as pool:
+    #    results = pool.imap(multi_wrapper, video_audio_list)
+
+    output_df = pd.DataFrame(results)
+    output_df.to_csv(os.path.join(output_dir, 'vggsound_av_align_score.tsv'), sep='\t', index=False)
+
+    print("Finished !!!")

reward_models/cavp.py

@@ -0,0 +1,128 @@
+import os
+import torch
+import json
+from torch.utils.data import Dataset, DataLoader, DistributedSampler
+from cavp_preprocess.cavp_model import Extract_CAVP_Features
+from argparse import Namespace
+from tqdm import tqdm
+import pandas as pd
+
+class VideoAudioDPO_Dataset(Dataset):
+    def __init__(self, json_path, root_dir, video_4fps_for_cavp_path):
+
+        self.root_dir = root_dir
+        self.json_path = json_path
+        self.video_4fps_for_cavp_path = video_4fps_for_cavp_path
+        with open(json_path, 'r') as f:
+            self.data = json.load(f)
+
+    def __len__(self):
+        return len(self.data)
+
+    def __getitem__(self, index):
+        each_data = self.data[index]
+        num_samples = len(each_data)
+        audio_files_list = []
+        for i in range(num_samples):
+            video_id = each_data[i]['video_id']
+            audio_path = os.path.join(self.root_dir, video_id, each_data[i]['audio_path'])
+            audio_files_list.append(audio_path)
+
+        video_4fps_file = os.path.join(self.video_4fps_for_cavp_path, f'{each_data[0]['video_id']}.mp4')
+
+        return audio_files_list, video_4fps_file
+
+
+if __name__ == "__main__":
+
+    ROOT = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/generated_videos'
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/generated_videos'
+
+    json_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/generated_videos.json'
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/generated_videos.json'
+    
+    output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema'
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema'
+    
+    video_4fps_for_cavp_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/videos_4fps_for_cavp'
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/videos_4fps_for_cavp'
+    
+    ckpt_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/video2audio/Frieren-V2A/pretrained_encoders/cavp_epoch66.ckpt'
+
+    max_duration = 8  # todo
+    batch_max_length = int(max_duration * 62.5)
+
+    audio_args = {
+        'audio_sample_rate': 16000,
+        'audio_num_mel_bins': 128, # todo
+        'fft_size': 1024,
+        'win_size': 1024,
+        'hop_size': 256,
+        'fmin': 0,
+        'fmax': 8000,
+        'batch_max_length': batch_max_length,
+        'mode': 'none',  # pad,none,
+    }
+    audio_args = Namespace(**audio_args)
+    cavp_extractor = Extract_CAVP_Features(fps=4,
+                                           batch_size=40,
+                                           device=torch.device("cuda"),
+                                           video_shape=(224, 224),
+                                           ckpt_path=ckpt_path,
+                                           audio_args=audio_args)
+
+    with open(json_path, 'r') as f:
+        data = json.load(f)
+        
+    saved_output_full = []
+    saved_output_dpo = []
+    
+    for each_data in tqdm(data):
+        num_samples = len(each_data)
+        audio_files_list = []
+        for i in range(num_samples):
+            video_id = each_data[i]['video_id']
+            audio_path = os.path.join(ROOT, video_id, each_data[i]['audio_path'])
+            audio_files_list.append(audio_path)
+
+        video_4fps_file_path = os.path.join(video_4fps_for_cavp_path, f'{each_data[0]['video_id']}.mp4')
+
+        video_features, mel_spec_features_list = cavp_extractor(video_4fps_file_path, audio_files_list)
+        #print(video_features.shape)
+        #print(mel_spec_features_list[0].shape)
+        
+        scores = []
+        for mel_spec_features in mel_spec_features_list:
+            each_score = torch.cosine_similarity(video_features, mel_spec_features, dim=-1)
+            scores.append(each_score.item())
+
+        outputs = {
+            'id': each_data[0]['video_id'],
+            'label': each_data[0]['caption'],
+        }
+
+        for i in range(num_samples):
+            outputs[f'{i + 1}'] = scores[i]
+
+        dpo_outputs = {
+            'id': each_data[0]['video_id'],
+            'label': each_data[0]['caption'],
+            'chosen': scores.index(max(scores)) + 1,
+            'reject': scores.index(min(scores)) + 1
+        }
+        
+        saved_output_full.append(outputs)
+        saved_output_dpo.append(dpo_outputs)
+        
+    
+    output_full_df = pd.DataFrame(saved_output_full)
+    output_full_df.to_csv(os.path.join(output_dir, 'av_cavp_score.tsv'), sep='\t', index=False)
+
+    output_dpo_df = pd.DataFrame(saved_output_dpo)
+    output_dpo_df.to_csv(os.path.join(output_dir, 'dpo_cavp.tsv'), sep='\t', index=False)
+
+    print("Finished !!!")
+
+
+
+

reward_models/clap.py

@@ -0,0 +1,95 @@
+import sys
+sys.path.append("..")
+sys.path.append("../..")
+import os
+import argparse
+import torch 
+import av_benchmark.av_bench.laion_clap as laion_clap
+import json
+from tqdm import tqdm
+import pandas as pd
+
+@torch.no_grad()
+def compute_clap(model, audio_files, text_data):
+    # Compute audio and text embeddings, then compute the dot product (CLAP score)
+    audio_embed = model.get_audio_embedding_from_filelist(x=audio_files, use_tensor=True)
+    text_embed = model.get_text_embedding(text_data, use_tensor=True)
+    return audio_embed @ text_embed.T
+
+
+if __name__ == "__main__":
+    
+    #device = 'cuda:0'
+    clap_model = laion_clap.CLAP_Module(enable_fusion=False)
+    #clap_model.to(device)
+    clap_model.load_ckpt()
+    clap_model.eval()
+    
+    ROOT = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/generated_videos' 
+    
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/generated_videos' 
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/generated_videos'
+    
+    json_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/generated_videos.json' 
+    
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/generated_videos.json' 
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/generated_videos.json'
+    
+    output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema'  
+    
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema' 
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema'
+    
+    with open(json_path, 'r') as f:
+        data = json.load(f)
+        
+    saved_output_full = []
+    saved_output_dpo = []
+    
+    for each_data in tqdm(data):
+        num_samples = len(each_data)
+        audio_files_list = []
+        for i in range(num_samples):
+            video_id = each_data[i]['video_id']
+            audio_path = os.path.join(ROOT, video_id, each_data[i]['audio_path'])
+            audio_files_list.append(audio_path)
+    
+        caption = [each_data[0]['caption']]
+        
+        clap_scores = compute_clap(clap_model, audio_files_list, caption)
+        
+        scores = []
+        for each_score in clap_scores:
+            scores.append(each_score.item())
+    
+        
+        outputs = {
+            'id': each_data[0]['video_id'],
+            'label': each_data[0]['caption'],
+        }
+
+        for i in range(num_samples):
+            outputs[f'{i + 1}'] = scores[i]
+
+        dpo_outputs = {
+            'id': each_data[0]['video_id'],
+            'label': each_data[0]['caption'],
+            'chosen': scores.index(max(scores)) + 1,
+            'reject': scores.index(min(scores)) + 1
+        }
+        
+        saved_output_full.append(outputs)
+        saved_output_dpo.append(dpo_outputs)
+        
+        
+    
+    output_full_df = pd.DataFrame(saved_output_full)
+    output_full_df.to_csv(os.path.join(output_dir, 'clap_score.tsv'), sep='\t', index=False)
+
+    output_dpo_df = pd.DataFrame(saved_output_dpo)
+    output_dpo_df.to_csv(os.path.join(output_dir, 'dpo_clap.tsv'), sep='\t', index=False)
+
+    print("Finished !!!")
+    
+    
+

reward_models/clap_multi_gpu.py

@@ -0,0 +1,214 @@
+import sys
+sys.path.append("..")
+sys.path.append("../..")
+import os
+import argparse
+import torch 
+import av_benchmark.av_bench.laion_clap as laion_clap
+import json
+from tqdm import tqdm
+import pandas as pd
+import multiprocessing
+
+
+ROOT = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_2000samples_av_align_iter1_for_dpo_inference_ema/generated_videos' 
+
+# '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/generated_videos'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/generated_videos'
+
+@torch.no_grad()
+def compute_clap(model, audio_files, text_data):
+    # Compute audio and text embeddings, then compute the dot product (CLAP score)
+    audio_embed = model.get_audio_embedding_from_filelist(x=audio_files, use_tensor=True)
+    text_embed = model.get_text_embedding(text_data, use_tensor=True)
+    return audio_embed @ text_embed.T
+
+def process_chunk(chunk, gpu_id, return_dict, process_id):
+    """
+    Process a chunk of the data on a specific GPU.
+    Loads the CLAP model on the designated device, then for each item in the chunk,
+    computes the CLAP scores and attaches them to the data.
+    """
+    try:
+        device = f"cuda:{gpu_id}"
+        torch.cuda.set_device(device)
+        print(f"Process {process_id}: Using device {device}")
+
+        # Initialize the CLAP model on this GPU
+        model = laion_clap.CLAP_Module(enable_fusion=False)
+        model.to(device)
+        model.load_ckpt()
+        model.eval()
+        
+        saved_output_full = []
+        saved_output_dpo = []
+
+        for j, each_data in enumerate(tqdm(chunk, desc=f"GPU {gpu_id}")):
+            # Each item is assumed to be a list of samples.
+            # Skip if already computed.
+            num_samples = len(each_data)
+            
+            # Collect audio file paths and text data (using the first caption)
+            audio_files_list = []
+            for i in range(num_samples):
+                video_id = each_data[i]['video_id']
+                audio_path = os.path.join(ROOT, video_id, each_data[i]['audio_path'])
+                audio_files_list.append(audio_path)
+
+            text_data = [each_data[0]['caption']]
+
+            try:
+                clap_scores = compute_clap(model, audio_files_list, text_data)
+            except Exception as e:
+                print(f"Error processing item index {j} on GPU {gpu_id}: {e}")
+                continue
+            
+            scores = []
+            for each_score in clap_scores:
+                scores.append(each_score.item())
+            
+            outputs = {
+                'id': each_data[0]['video_id'],
+                'label': each_data[0]['caption'],
+                }
+            
+            for i in range(num_samples):
+                outputs[f'{i + 1}'] = scores[i]
+
+            dpo_outputs = {
+                'id': each_data[0]['video_id'],
+                'label': each_data[0]['caption'],
+                'chosen': scores.index(max(scores)) + 1,
+                'reject': scores.index(min(scores)) + 1
+                }
+            
+            saved_output_full.append(outputs)
+            saved_output_dpo.append(dpo_outputs)
+             
+            # Attach the computed score to each sample in the item
+            # for k in range(num_samples):
+            #     each_data[k]['clap_score'] = clap_scores[k].item()
+
+        return_dict[process_id] = [saved_output_full, saved_output_dpo]
+        print(f"Process {process_id}: Completed processing on GPU {gpu_id}")
+    except Exception as e:
+        print(f"Process {process_id}: Error on GPU {gpu_id}: {e}")
+        return_dict[process_id] = []
+
+def split_into_chunks(data, num_chunks):
+    """
+    Splits data into num_chunks approximately equal parts.
+    """
+    avg = len(data) // num_chunks
+    chunks = []
+    for i in range(num_chunks):
+        start = i * avg
+        # Ensure the last chunk takes the remainder of the data
+        end = (i + 1) * avg if i != num_chunks - 1 else len(data)
+        chunks.append(data[start:end])
+    return chunks
+
+
+if __name__ == "__main__":
+    
+    multiprocessing.set_start_method('spawn')
+    # 
+    json_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_2000samples_av_align_iter1_for_dpo_inference_ema/generated_videos.json' 
+    
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/generated_videos.json' 
+    
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/generated_videos.json'
+    
+    output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_2000samples_av_align_iter1_for_dpo_inference_ema' 
+    
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema' 
+    
+    #'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema'
+    
+    with open(json_path, 'r') as f:
+        data = json.load(f)
+        
+    # Check GPU availability and split data accordingly
+    num_gpus = torch.cuda.device_count()
+    
+    print(f"Found {num_gpus} GPUs. Splitting data into {num_gpus} chunks.")
+    chunks = split_into_chunks(data, num_gpus)
+    
+    # Create a manager dict to collect results from all processes
+    manager = multiprocessing.Manager()
+    return_dict = manager.dict()
+    processes = []
+    
+    for i in range(num_gpus):
+        p = multiprocessing.Process(
+            target=process_chunk,
+            args=(chunks[i], i, return_dict, i)
+        )
+        processes.append(p)
+        p.start()
+        print(f"Started process {i} on GPU {i}")
+        
+    for p in processes:
+        p.join()
+        print(f"Process {p.pid} has finished.")    
+    
+    
+    # Aggregate all chunks back into a single list
+    combined_data_full = []
+    combined_data_dpo = []
+    for i in range(num_gpus):
+        combined_data_full.extend(return_dict[i][0])
+        combined_data_dpo.extend(return_dict[i][1])
+        
+    
+    # saved_output_full = []
+    # saved_output_dpo = []
+    
+    # for each_data in tqdm(data):
+    #     num_samples = len(each_data)
+    #     audio_files_list = []
+    #     for i in range(num_samples):
+    #         video_id = each_data[i]['video_id']
+    #         audio_path = os.path.join(ROOT, video_id, each_data[i]['audio_path'])
+    #         audio_files_list.append(audio_path)
+    
+    #     caption = [each_data[0]['caption']]
+        
+    #     clap_scores = compute_clap(clap_model, audio_files_list, caption)
+        
+    #     scores = []
+    #     for each_score in clap_scores:
+    #         scores.append(each_score.item())
+    
+        
+    #     outputs = {
+    #         'id': each_data[0]['video_id'],
+    #         'label': each_data[0]['caption'],
+    #     }
+
+    #     for i in range(num_samples):
+    #         outputs[f'{i + 1}'] = scores[i]
+
+    #     dpo_outputs = {
+    #         'id': each_data[0]['video_id'],
+    #         'label': each_data[0]['caption'],
+    #         'chosen': scores.index(max(scores)) + 1,
+    #         'reject': scores.index(min(scores)) + 1
+    #     }
+        
+    #     saved_output_full.append(outputs)
+    #     saved_output_dpo.append(dpo_outputs)
+        
+        
+    
+    output_full_df = pd.DataFrame(combined_data_full)
+    output_full_df.to_csv(os.path.join(output_dir, 'clap_score.tsv'), sep='\t', index=False)
+
+    output_dpo_df = pd.DataFrame(combined_data_dpo)
+    output_dpo_df.to_csv(os.path.join(output_dir, 'dpo_clap.tsv'), sep='\t', index=False)
+
+    print("Finished !!!")
+    
+    
+

reward_models/ib_at_sync.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+# for val set
+json_path=/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/generated_videos.json
+video_path=/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/generated_videos
+output_dir=/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema
+gt_batch_size=8
+
+python ib_at_sync.py --video_path ${video_path} --json_path ${json_path} --output_dir ${output_dir} --gt_batch_size ${gt_batch_size} --audio_length=8

reward_models/ib_sync.py

@@ -0,0 +1,325 @@
+import logging
+import os
+from pathlib import Path
+
+import torch
+from colorlog import ColoredFormatter
+from einops import rearrange
+
+from ib_sync_rewards.imagebind.models import imagebind_model 
+from ib_sync_rewards.imagebind.models.imagebind_model import ModalityType 
+
+from ib_sync_rewards.imagebind.models.multimodal_preprocessors import SimpleTokenizer
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from ib_sync_rewards.args import get_eval_parser
+from ib_sync_rewards.data.video_dataset import VideoDataset, pad_or_truncate, error_avoidance_collate
+from ib_sync_rewards.synchformer.synchformer import Synchformer, make_class_grid
+
+import torchaudio
+import json
+import pandas as pd
+
+_syncformer_ckpt_path = Path(__file__).parent / 'ib_sync_rewards' / 'weights' / 'synchformer_state_dict.pth'
+log = logging.getLogger()
+device = 'cuda'
+
+LOGFORMAT = "[%(log_color)s%(levelname)-8s%(reset)s]: %(log_color)s%(message)s%(reset)s"
+
+
+def setup_eval_logging(log_level: int = logging.INFO):
+    logging.root.setLevel(log_level)
+    formatter = ColoredFormatter(LOGFORMAT)
+    stream = logging.StreamHandler()
+    stream.setLevel(log_level)
+    stream.setFormatter(formatter)
+    log = logging.getLogger()
+    log.setLevel(log_level)
+    log.addHandler(stream)
+
+
+setup_eval_logging()
+
+
+def encode_video_with_sync(synchformer: Synchformer, x: torch.Tensor) -> torch.Tensor:
+    # x: (B, T, C, H, W) H/W: 224
+
+    b, t, c, h, w = x.shape
+    assert c == 3 and h == 224 and w == 224
+
+    # partition the video
+    segment_size = 16
+    step_size = 8
+    num_segments = (t - segment_size) // step_size + 1
+    segments = []
+    for i in range(num_segments):
+        segments.append(x[:, i * step_size:i * step_size + segment_size])
+    x = torch.stack(segments, dim=1)  # (B, S, T, C, H, W)
+
+    x = rearrange(x, 'b s t c h w -> (b s) 1 t c h w')
+    x = synchformer.extract_vfeats(x)
+    x = rearrange(x, '(b s) 1 t d -> b s t d', b=b)
+    return x
+
+
+def encode_video_with_imagebind(imagebind: imagebind_model, x: torch.Tensor) -> torch.Tensor:
+    # x: B * NUM_CROPS * T * C * H * W
+    clips = []
+    b, num_crops, t, c, h, w = x.shape
+    for i in range(t - 1):
+        clips.append(x[:, :, i:i + 2])
+    clips = torch.cat(clips, dim=1)
+
+    # clips: B * (NUM_CROPS * NUM_CLIPS) * 2 * C * H * W
+    clips = rearrange(clips, 'b n t c h w -> b n c t h w')
+
+    emb = imagebind({ModalityType.VISION: clips})
+    return emb[ModalityType.VISION]
+
+def encode_audio_with_sync(synchformer: Synchformer, x: torch.Tensor,
+                           mel: torchaudio.transforms.MelSpectrogram) -> torch.Tensor:
+    b, t = x.shape
+
+    # partition the video
+    segment_size = 10240
+    step_size = 10240 // 2
+    num_segments = (t - segment_size) // step_size + 1
+    segments = []
+    for i in range(num_segments):
+        segments.append(x[:, i * step_size:i * step_size + segment_size])
+    x = torch.stack(segments, dim=1)  # (B, S, T, C, H, W)
+
+    x = mel(x)
+    x = torch.log(x + 1e-6)
+    x = pad_or_truncate(x, 66)
+
+    mean = -4.2677393
+    std = 4.5689974
+    x = (x - mean) / (2 * std)
+    # x: B * S * 128 * 66
+    x = synchformer.extract_afeats(x.unsqueeze(2))
+    return x
+
+@torch.inference_mode()
+def extract(args):
+    video_path: Path = args.video_path.expanduser() # todo video_folder_path
+    json_path: Path = args.json_path # todo path to the json file
+    output_dir: Path = args.output_dir # todo path to the save the tsv file
+    audio_length: float = args.audio_length
+    num_workers: int = args.num_workers
+    batch_size: int = args.gt_batch_size
+
+    log.info('Extracting features...')
+
+
+    with open(json_path, 'r') as f:
+        data = json.load(f)
+
+    video_id_caption_dict = {}
+    for each_data in data:
+        video_id = each_data[0]['video_id']
+        caption = each_data[0]['caption']
+        video_id_caption_dict[video_id] = caption
+
+
+    # todo read all the file names
+    video_names = os.listdir(video_path)
+    video_name_paths = [video_path / f for f in video_names] # todo ./video_path/video_name
+
+    samples_per_video = sorted(list(map(int, os.listdir(video_name_paths[0]))))
+    samples_per_video = list(map(str, samples_per_video)) # todo [1, 2, ..., 10]
+
+    #samples_per_video = os.listdir(video_name_paths[0]) # todo 1,2,...,10 should be sorted?
+
+    log.info(f'{len(video_name_paths)} videos found.')
+    log.info(f'{len(samples_per_video)} samples are found in each video.')
+
+    # todo load pre-trained weights for Synchformer
+    sync_model = Synchformer().to(device).eval()
+    sd = torch.load(_syncformer_ckpt_path, weights_only=True)
+    sync_model.load_state_dict(sd)
+
+    cmp_encode_video_with_sync = encode_video_with_sync  # torch.compile(encode_video_with_sync)
+    cmp_encode_video_with_imagebind = encode_video_with_imagebind  # torch.compile(encode_video_with_imagebind)
+    cmp_encode_audio_with_sync = encode_audio_with_sync
+
+    # todo load pre-trained weights for ImageBind
+    imagebind = imagebind_model.imagebind_huge(pretrained=True).to(device).eval()
+    # todo May 9
+    tokenizer = SimpleTokenizer(bpe_path='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/reward_models/ib_sync_rewards/imagebind/bpe/bpe_simple_vocab_16e6.txt.gz')
+
+    total_outputs = []
+    for sample_idx in samples_per_video:
+        log.info(f'Starting to extracting features in sample index: {sample_idx}')
+        video_paths = [f / sample_idx / f'{os.path.basename(f)}.mp4' for f in video_name_paths]
+        audio_paths = [f / sample_idx / f'{os.path.basename(f)}.flac' for f in video_name_paths]
+
+        log.info(f'{len(video_paths)} videos found.')
+
+        dataset = VideoDataset(video_paths, audio_paths, duration_sec=audio_length, video_id_caption=video_id_caption_dict) # todo
+        loader = DataLoader(dataset,
+                            batch_size=batch_size,
+                            num_workers=num_workers,
+                            collate_fn=error_avoidance_collate
+                            ) # collate_fn=error_avoidance_collate
+
+        output_for_each_sample_idx_dict = {}
+
+        for data in tqdm(loader):
+            names = data['name']
+            # todo for video
+            ib_video = data['ib_video'].to(device)
+            sync_video = data['sync_video'].to(device)
+
+            # todo for audio
+            ib_audio = data['ib_audio'].squeeze(1).to(device)
+            sync_audio = data['sync_audio'].to(device)
+            
+            # todo for text feature extraction. # todo May 9
+            ib_text = data['label'] 
+            ib_text_tokens = [tokenizer(t).unsqueeze(0).to(device) for t in ib_text]
+            ib_text_tokens = torch.cat(ib_text_tokens, dim=0)
+            #ib_text_tokens = tokenizer(ib_text).to(device)
+            ib_text_features = imagebind({ModalityType.TEXT: ib_text_tokens})[ModalityType.TEXT].cpu().detach()
+
+            # todo for video feature extraction
+            sync_video_features = cmp_encode_video_with_sync(sync_model, sync_video)
+            ib_video_features = cmp_encode_video_with_imagebind(imagebind, ib_video)
+            ib_video_features = ib_video_features.cpu().detach()
+
+            # todo for audio feature extraction
+            ib_audio_features = imagebind({ModalityType.AUDIO: ib_audio})[ModalityType.AUDIO].cpu().detach()
+            sync_audio_features = cmp_encode_audio_with_sync(sync_model, sync_audio, dataset.sync_mel_spectrogram.to(device))
+
+            # calculate imagebind_av metrics
+            ib_av_scores = torch.cosine_similarity(ib_video_features, ib_audio_features, dim=-1) # [b]
+
+            # calculate imagebind_at metrics # todo May 9
+            ib_at_scores = torch.cosine_similarity(ib_text_features, ib_audio_features, dim=-1) 
+            
+            # calculate desync metrics todo
+            total_sync_scores = []
+            sync_grid = make_class_grid(-2, 2, 21)
+            logits_1 = sync_model.compare_v_a(sync_video_features[:, :14], sync_audio_features[:, :14])
+            top_id_1 = torch.argmax(logits_1, dim=-1).cpu().numpy()
+
+            logits_2 = sync_model.compare_v_a(sync_video_features[:, -14:], sync_audio_features[:, -14:])
+            top_id_2 = torch.argmax(logits_2, dim=-1).cpu().numpy()
+
+            for j in range(sync_video_features.shape[0]):
+                total_sync_scores.append(0.5 * (abs(sync_grid[top_id_1[j]].item()) + abs(sync_grid[top_id_2[j]].item())))
+
+            for i, n in enumerate(names):
+                each_output = {
+                    'id': n,
+                    'label': video_id_caption_dict[n],
+                    'ib_av_score' : ib_av_scores[i].item(),
+                    'av_sync_score': total_sync_scores[i],
+                    'ib_at_score': ib_at_scores[i].item()
+                }
+                output_for_each_sample_idx_dict[n] = each_output
+
+
+        total_outputs.append(output_for_each_sample_idx_dict)
+    
+
+    # todo combine different sample_idx splits
+    log.info('Combining and Saving Metrics...')
+    saved_ib_output_full = []
+    saved_sync_output_full = []
+    saved_ib_at_output_full = [] # todo May 9
+    saved_ib_output_dpo = []
+    saved_sync_output_dpo = []
+    saved_ib_at_output_dpo = [] # todo May 9
+
+    video_id_list = total_outputs[0].keys()
+    for video_id in tqdm(video_id_list):
+        outputs_ib_metrics = {
+            'id': video_id,
+            'label': video_id_caption_dict[video_id]
+        }
+
+        outputs_sync_metrics = {
+            'id': video_id,
+            'label': video_id_caption_dict[video_id]
+        }
+        
+        # todo May 9
+        outputs_ib_at_metrics = {
+            'id': video_id,
+            'label': video_id_caption_dict[video_id]
+        }
+
+        ib_scores_for_each_video = []
+        sync_scores_for_each_video = []
+        ib_at_scores_for_each_video = [] # todo May 9
+
+        for idx, each_sample_idx_dict in enumerate(total_outputs):
+            ib_scores_for_each_video.append(each_sample_idx_dict[video_id]['ib_av_score'])
+            outputs_ib_metrics[str(idx+1)] = each_sample_idx_dict[video_id]['ib_av_score']
+
+            sync_scores_for_each_video.append(each_sample_idx_dict[video_id]['av_sync_score'])
+            outputs_sync_metrics[str(idx+1)] = each_sample_idx_dict[video_id]['av_sync_score']
+            
+            # todo May 9
+            ib_at_scores_for_each_video.append(each_sample_idx_dict[video_id]['ib_at_score'])
+            outputs_ib_at_metrics[str(idx+1)] = each_sample_idx_dict[video_id]['ib_at_score']
+
+        outputs_ib_dpo = {
+            'id': video_id,
+            'label': video_id_caption_dict[video_id],
+            'chosen': ib_scores_for_each_video.index(max(ib_scores_for_each_video)) + 1,
+            'reject': ib_scores_for_each_video.index(min(ib_scores_for_each_video)) + 1
+        }
+
+        outputs_sync_dpo = {
+            'id': video_id,
+            'label': video_id_caption_dict[video_id],
+            'chosen': sync_scores_for_each_video.index(min(sync_scores_for_each_video)) + 1,
+            'reject': sync_scores_for_each_video.index(max(sync_scores_for_each_video)) + 1
+        }
+        
+        # todo May 9
+        outputs_ib_at_dpo = {
+            'id': video_id,
+            'label': video_id_caption_dict[video_id],
+            'chosen': ib_at_scores_for_each_video.index(max(ib_at_scores_for_each_video)) + 1,
+            'reject': ib_at_scores_for_each_video.index(min(ib_at_scores_for_each_video)) + 1
+        }
+
+        saved_ib_output_full.append(outputs_ib_metrics)
+        saved_sync_output_full.append(outputs_sync_metrics)
+        saved_ib_at_output_full.append(outputs_ib_at_metrics) # todo May 9
+
+        saved_ib_output_dpo.append(outputs_ib_dpo)
+        saved_sync_output_dpo.append(outputs_sync_dpo)
+        saved_ib_at_output_dpo.append(outputs_ib_at_dpo) # todo May 9
+
+    output_ib_full_df = pd.DataFrame(saved_ib_output_full)
+    output_ib_full_df.to_csv(os.path.join(output_dir, 'imagebind_score.tsv'), sep='\t', index=False)
+
+    output_ib_dpo_df = pd.DataFrame(saved_ib_output_dpo)
+    output_ib_dpo_df.to_csv(os.path.join(output_dir, 'dpo_imagebind.tsv'), sep='\t', index=False)
+
+    output_sync_full_df = pd.DataFrame(saved_sync_output_full)
+    output_sync_full_df.to_csv(os.path.join(output_dir, 'desync_score.tsv'), sep='\t', index=False)
+
+    output_sync_dpo_df = pd.DataFrame(saved_sync_output_dpo)
+    output_sync_dpo_df.to_csv(os.path.join(output_dir, 'dpo_desync.tsv'), sep='\t', index=False)
+
+    # todo May 9
+    output_ib_at_full_df = pd.DataFrame(saved_ib_at_output_full)
+    output_ib_at_full_df.to_csv(os.path.join(output_dir, 'imagebind_at_score.tsv'), sep='\t', index=False)
+
+    output_ib_at_dpo_df = pd.DataFrame(saved_ib_at_output_dpo)
+    output_ib_at_dpo_df.to_csv(os.path.join(output_dir, 'dpo_imagebind_at.tsv'), sep='\t', index=False)
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.INFO)
+
+    parser = get_eval_parser()
+    parser.add_argument('--video_path', type=Path, required=True, help='Path to the video files')
+    args = parser.parse_args()
+    extract(args)

reward_models/ib_sync.sh

@@ -0,0 +1,47 @@
+#!/bin/bash
+# for val set
+
+
+
+json_path='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/generated_videos.json'
+
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_inference_ema/generated_videos.json'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_inference_ema/generated_videos.json'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_full_reward_ib_desync_iter2_for_dpo_inference_ema/generated_videos.json'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_desync_to_ib_iter1_for_dpo_inference_ema/generated_videos.json'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/generated_videos.json'
+#/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/generated_videos.json
+
+video_path='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema/generated_videos'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_inference_ema/generated_videos'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_inference_ema/generated_videos'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_full_reward_ib_desync_iter2_for_dpo_inference_ema/generated_videos'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_desync_to_ib_iter1_for_dpo_inference_ema/generated_videos'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/generated_videos' 
+#/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/generated_videos
+
+output_dir='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_inference_ema'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_inference_ema'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_full_reward_ib_desync_iter2_for_dpo_inference_ema'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_desync_to_ib_iter1_for_dpo_inference_ema'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema'
+#/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema
+gt_batch_size=8
+
+python ib_sync.py --video_path ${video_path} --json_path ${json_path} --output_dir ${output_dir} --gt_batch_size ${gt_batch_size} --audio_length=8

reward_models/multi_reward_ib_av_at_desync_models.py

@@ -0,0 +1,93 @@
+import os 
+import pandas as pd
+
+imagebind_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_inference_ema/imagebind_score.tsv'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_inference_ema/imagebind_score.tsv'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/imagebind_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_full_reward_ib_desync_iter2_for_dpo_inference_ema/imagebind_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/imagebind_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/imagebind_score.tsv'
+
+imagebind_at_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_inference_ema/imagebind_at_score.tsv'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_inference_ema/imagebind_at_score.tsv'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/imagebind_at_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_full_reward_ib_desync_iter2_for_dpo_inference_ema/imagebind_at_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/imagebind_at_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/imagebind_at_score.tsv'
+
+desync_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_inference_ema/desync_score.tsv'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_inference_ema/desync_score.tsv'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/desync_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_full_reward_ib_desync_iter2_for_dpo_inference_ema/desync_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema/desync_score.tsv'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/desync_score.tsv'
+
+output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter2_steps5k_inference_ema'
+
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-gen_dpo_data_May17_lumina_v2a_two_stream_depth16_caption_beta20000_full_reward_ib_desync_iter1_steps5k_inference_ema'
+
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_May10_depth16_caption_2000samples_full_reward_ib_desync_iter2_for_dpo_inference_ema'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_April12_depth16_caption_10audio_per_video_inference_ema'
+#'/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema'
+
+num_samples = 5 #5
+
+imagebind_df_list = pd.read_csv(imagebind_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+desync_df_list = pd.read_csv(desync_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+imagebind_at_df_list = pd.read_csv(imagebind_at_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+imagebind_at_df_list_new = []
+
+for idx, record in enumerate(imagebind_df_list):
+    id = record['id']
+    for record_ib_at in imagebind_at_df_list:
+        if record_ib_at['id'] == id:
+            imagebind_at_df_list_new.append(record_ib_at)
+    
+
+assert len(imagebind_df_list) == len(desync_df_list) == len(imagebind_at_df_list_new) 
+
+multi_reward_output_list = []
+dpo_multi_reward_output_list = []
+
+for idx, record in enumerate(imagebind_df_list):
+    id = record['id']
+    assert id == desync_df_list[idx]['id'] == imagebind_at_df_list_new[idx]['id']  
+    label = record['label']
+    output = {
+        'id': id, 
+        'label': label
+    }
+    
+    scores = []
+    for i in range(num_samples):
+        sum_reward_score = 1 * record[f'{str(i+1)}'] + 0 * imagebind_at_df_list_new[idx][f'{str(i+1)}'] - 1 * desync_df_list[idx][f'{str(i+1)}']
+        output[f'{str(i+1)}'] = sum_reward_score
+        scores.append(sum_reward_score)
+        
+    multi_reward_output_list.append(output)
+    
+    dpo_outputs = {
+            'id': id,
+            'label': label,
+            'chosen': scores.index(max(scores)) + 1,
+            'reject': scores.index(min(scores)) + 1
+        }
+    
+    dpo_multi_reward_output_list.append(dpo_outputs)
+
+output_full_df = pd.DataFrame(multi_reward_output_list)
+output_full_df.to_csv(os.path.join(output_dir, 'full_reward_ib_desync.tsv'), sep='\t', index=False)
+
+output_dpo_df = pd.DataFrame(dpo_multi_reward_output_list)
+output_dpo_df.to_csv(os.path.join(output_dir, 'dpo_full_reward_ib_desync.tsv'), sep='\t', index=False)
+
+print("Finished !!!")
+    

reward_models/multi_reward_ib_desync_models.py

@@ -0,0 +1,53 @@
+import os 
+import pandas as pd
+
+imagebind_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/imagebind_score.tsv'
+
+desync_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/desync_score.tsv'
+
+output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema'
+
+num_samples = 5
+
+imagebind_df_list = pd.read_csv(imagebind_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+desync_df_list = pd.read_csv(desync_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+
+assert len(imagebind_df_list) == len(desync_df_list)
+
+multi_reward_output_list = []
+dpo_multi_reward_output_list = []
+
+for idx, record in enumerate(imagebind_df_list):
+    id = record['id']
+    assert id == desync_df_list[idx]['id'] 
+    label = record['label']
+    output = {
+        'id': id, 
+        'label': label
+    }
+    
+    scores = []
+    for i in range(num_samples):
+        sum_reward_score = 0.5 * (record[f'{str(i+1)}'] - 2 * desync_df_list[idx][f'{str(i+1)}'])
+        output[f'{str(i+1)}'] = sum_reward_score
+        scores.append(sum_reward_score)
+        
+    multi_reward_output_list.append(output)
+    
+    dpo_outputs = {
+            'id': id,
+            'label': label,
+            'chosen': scores.index(max(scores)) + 1,
+            'reject': scores.index(min(scores)) + 1
+        }
+    
+    dpo_multi_reward_output_list.append(dpo_outputs)
+
+output_full_df = pd.DataFrame(multi_reward_output_list)
+output_full_df.to_csv(os.path.join(output_dir, 'full_reward_ib_2desync_score.tsv'), sep='\t', index=False)
+
+output_dpo_df = pd.DataFrame(dpo_multi_reward_output_list)
+output_dpo_df.to_csv(os.path.join(output_dir, 'dpo_full_reward_ib_2desync.tsv'), sep='\t', index=False)
+
+print("Finished !!!")
+    

reward_models/multi_reward_models.py

@@ -0,0 +1,53 @@
+import os 
+import pandas as pd
+
+av_align_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/av_align_score.tsv'
+cavp_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/av_cavp_score.tsv'
+clap_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/clap_score.tsv'
+output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema'
+num_samples = 5
+
+av_align_df_list = pd.read_csv(av_align_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+cavp_df_list = pd.read_csv(cavp_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+clap_df_list = pd.read_csv(clap_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+
+assert len(av_align_df_list) == len(cavp_df_list) == len(clap_df_list)
+
+multi_reward_output_list = []
+dpo_multi_reward_output_list = []
+
+for idx, record in enumerate(av_align_df_list):
+    id = record['id']
+    assert id == cavp_df_list[idx]['id'] == clap_df_list[idx]['id'] 
+    label = record['label']
+    output = {
+        'id': id, 
+        'label': label
+    }
+    
+    scores = []
+    for i in range(num_samples):
+        sum_reward_score = record[f'{str(i+1)}'] + cavp_df_list[idx][f'{str(i+1)}'] + clap_df_list[idx][f'{str(i+1)}']
+        output[f'{str(i+1)}'] = sum_reward_score
+        scores.append(sum_reward_score)
+        
+    multi_reward_output_list.append(output)
+    
+    
+    dpo_outputs = {
+            'id': id,
+            'label': label,
+            'chosen': scores.index(max(scores)) + 1,
+            'reject': scores.index(min(scores)) + 1
+        }
+    
+    dpo_multi_reward_output_list.append(dpo_outputs)
+
+output_full_df = pd.DataFrame(multi_reward_output_list)
+output_full_df.to_csv(os.path.join(output_dir, 'full_reward_score.tsv'), sep='\t', index=False)
+
+output_dpo_df = pd.DataFrame(dpo_multi_reward_output_list)
+output_dpo_df.to_csv(os.path.join(output_dir, 'dpo_full_reward.tsv'), sep='\t', index=False)
+
+print("Finished !!!")
+    

reward_models/multi_reward_models_new.py

@@ -0,0 +1,57 @@
+import os 
+import pandas as pd
+
+av_align_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/av_align_score.tsv'
+cavp_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/av_cavp_score.tsv'
+clap_csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema/clap_score.tsv'
+output_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/small_44k/vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema'
+num_samples = 5
+threshold = 0.3
+
+av_align_df_list = pd.read_csv(av_align_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+cavp_df_list = pd.read_csv(cavp_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+clap_df_list = pd.read_csv(clap_csv_path, sep='\t', dtype={'id': str}).to_dict('records')
+
+assert len(av_align_df_list) == len(cavp_df_list) == len(clap_df_list)
+
+multi_reward_output_list = []
+dpo_multi_reward_output_list = []
+
+for idx, record in enumerate(av_align_df_list):
+    id = record['id']
+    assert id == cavp_df_list[idx]['id'] == clap_df_list[idx]['id'] 
+    label = record['label']
+    output = {
+        'id': id, 
+        'label': label
+    }
+    
+    scores = []
+    for i in range(num_samples):
+        sum_reward_score = 2*record[f'{str(i+1)}'] + cavp_df_list[idx][f'{str(i+1)}'] + 2*clap_df_list[idx][f'{str(i+1)}']
+        output[f'{str(i+1)}'] = sum_reward_score
+        scores.append(sum_reward_score)
+        
+    multi_reward_output_list.append(output)
+    
+    if (max(scores) - min(scores)) > threshold:
+        
+        dpo_outputs = {
+                'id': id,
+                'label': label,
+                'chosen': scores.index(max(scores)) + 1,
+                'reject': scores.index(min(scores)) + 1
+            }
+
+        dpo_multi_reward_output_list.append(dpo_outputs)
+
+print(f'the number of original samples is {len(multi_reward_output_list)}')
+output_full_df = pd.DataFrame(multi_reward_output_list)
+output_full_df.to_csv(os.path.join(output_dir, 'full_reward_score_2avalign_1cavp_2clap_thre03.tsv'), sep='\t', index=False)
+
+print(f'the number of final samples is {len(dpo_multi_reward_output_list)}')
+output_dpo_df = pd.DataFrame(dpo_multi_reward_output_list)
+output_dpo_df.to_csv(os.path.join(output_dir, 'dpo_full_reward_2avalign_1cavp_2clap_thre03.tsv'), sep='\t', index=False)
+
+print("Finished !!!")
+    

runer_scripts_cmd.sh

@@ -0,0 +1,87 @@
+
+1. OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 training/extract_video_training_latents.py > ./logs/extract_video_latents_16k.log 2>&1 & 
+
+2. huggingface cache dir: /root/.cache/huggingface/hub 
+
+2. torchhub cache dir: /root/.cache/torch/hub/checkpoints/
+
+2. cache dir: /root/.cache/audioldm_eval/ckpt/Cnn14_16k_mAP=0.438.pth
+
+training
+3. OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 train.py exp_id=vgg_only_small_44k model=small_44k > ./logs/train_vgg_only_small_44k.log 2>&1 &
+
+inference
+4. OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4  batch_eval.py duration_s=8 dataset=vggsound model=small_44k num_workers=8 > ./logs/inference_vgg_only_small_44k.log 2>&1 &
+
+demo example
+5. CUDA_VISIBLE_DEVICES=0 python demo.py --variant="small_16k" --duration=4 --video='' --prompt "" 
+
+CUDA_VISIBLE_DEVICES=0 python demo.py --variant="small_44k" --duration=10 --video='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/example_demo_videos/_jB-IM_77lI_000000_silent.mp4' --prompt ""
+
+CUDA_VISIBLE_DEVICES=2 python demo.py --variant="small_44k" --duration=4 --video='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/example_demo_videos/demo2.mp4' --prompt ""
+
+6. moviegen
+CUDA_VISIBLE_DEVICES=1 python demo.py --variant="small_44k" --duration=11 --video='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/example_demo_videos/moviegen/video1.mp4' --prompt ""
+
+
+7. audio waveforms for vggsound 
+/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/audios_vggsound
+
+8. demo new for paper 
+CUDA_VISIBLE_DEVICES=2 python demo.py --variant="small_44k" --duration=4 --video='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/example_demo_videos/demo_new/.mp4' --prompt ""
+
+9 training for vggsound with text caption
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 train.py exp_id=vgg_only_small_44k_caption_jan26 model=small_44k > ./logs/train_vgg_only_small_44k_caption_jan26.log 2>&1 &
+
+
+10 generate data for dpo 
+(1) change eval_for_dpo_config.yaml 
+(2) change eval_data/base.yaml
+
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4  batch_eval_dpo.py duration_s=8 dataset=vggsound_dpo model=small_44k num_workers=8 > ./logs_dpo/inference_vgg_only_small_44k_new_model_lumina_v2a_two_stream_Feb28_depth16_caption_dpo.log 2>&1 &
+
+
+11. nohup python dpo_training/create_dpo_file.py > ./logs/create_dop_file.log 2>&1 &
+nohup python reward_models/cavp.py > ./logs/create_dop_cavp_file.log 2>&1 &
+
+12. dpo training
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 train_dpo.py exp_id=vgg_only_small_44k model=small_44k > ./logs_dpo/train_vgg_only_small_44k.log 2>&1 &
+
+
+
+13. extraction features for dpo
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 dpo_training/extract_video_training_latents.py > ./logs_dpo/extract_video_latents_44k_vggsound_dpo-new_model_lumina_v2a_two_stream_Mar1_depth16_caption_inference_ema_iter1_cavp.log 2>&1 & 
+
+
+14. after generating data for dpo, how to create dpo data file 
+(1) python ./dpo_training/generated_videos_file.py    # get video json file
+(2) python ./dpo_training/create_dpo_file.py         # get av-align dpo file 
+(3) python ./reward_models/clap_multi_gpu.py (clap.py)         # get clap dpo file 
+(4) python ./reward_models/cavp.py                   # get cavp dpo file, note the reencode_video.py should be runned first for 4fps video 
+
+# after that, extract video and audio features 
+(1) change dpo_training/extract_video_training_latents.py file
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 dpo_training/extract_video_training_latents.py > ./logs_dpo/extract_video_latents_44k_vggsound_dpo-new_model_lumina_v2a_two_stream_Mar12_depth16_caption_10000samples_inference_ema_iter1_cavp.log 2>&1 & 
+
+# dpo training # change config files: train_dpo_config.yaml / dpo_base_config.yaml / ./dpo_data/base.yaml 
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 train_dpo.py exp_id=vgg_only_small_44k_lumina_v2a_two_stream_May7_depth16_caption_beta10000 model=small_44k > ./logs_dpo/train_vgg_only_small_44k_lumina_v2a_two_stream_May7_depth16_caption_beta10000.log 2>&1 &
+
+# inference: 
+(1) change the 'model_path' in ./mmaudio/eval_utils.py file
+(2) change the config files: eval_config.yaml, ./eval_data/base.yaml
+(3) OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4  batch_eval.py duration_s=8 dataset=vggsound model=small_44k num_workers=8 > ./logs_dpo/inference_vgg_only_small_44k_dpo_iter1_cavp_May7_lumina_v2a_two_stream_depth16_caption_2000samples_beta10000.log 2>&1 &
+
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4  batch_eval.py duration_s=8 dataset=moviegen model=small_44k num_workers=8 > ./logs_dpo/lumina_v2a_moviegen_Sep24_inference_ema.log 2>&1 &
+ 
+# evaluation
+(1) change ./av-benchmark/evaluate.sh 
+(2) bash evaluate.sh 
+
+
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 train_dpo.py exp_id=vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter3_steps5k model=small_44k > ./logs_dpo/train_vgg_only_small_44k_lumina_v2a_two_stream_May17_depth16_caption_beta20000_full_reward_ib_desync_iter3_steps5k.log 2>&1 &
+
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4  batch_eval.py duration_s=8 dataset=vggsound model=small_44k num_workers=8 > ./logs_dpo/inference_vgg_only_small_44k_dpo_May17_lumina_v2a_two_stream_depth16_caption_2000samples_beta20000_full_reward_ib_desync_iter3_steps5k.log 2>&1 &
+
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4  batch_eval_dpo.py duration_s=8 dataset=vggsound_dpo model=small_44k num_workers=8 > ./logs_dpo/inference_vgg_only_small_44k_new_model_lumina_v2a_two_stream_May17_depth16_caption__beta20000_full_reward_ib_desync_iter3_steps5k_for_dpo.log 2>&1 &
+
+OMP_NUM_THREADS=4 nohup torchrun --standalone --nproc_per_node=4 dpo_training/extract_video_training_latents.py > ./logs_dpo/extract_video_latents_44k_vggsound_dpo-new_model_lumina_v2a_two_stream_Mar17_depth16_caption_2000samples_steps5k_iter3_ib_desync.log 2>&1 & 

train_dpo.py

@@ -0,0 +1,216 @@
+import torch
+import logging
+import math
+import random
+from datetime import timedelta
+from pathlib import Path
+
+import hydra
+import numpy as np
+import torch
+import torch.distributed as distributed
+from hydra import compose
+from hydra.core.hydra_config import HydraConfig
+from omegaconf import DictConfig, open_dict
+from torch.distributed.elastic.multiprocessing.errors import record
+
+from mmaudio.data.data_setup import setup_training_datasets, setup_val_datasets
+from mmaudio.model.sequence_config import CONFIG_16K, CONFIG_44K
+from mmaudio.runner import Runner
+from mmaudio.sample import sample
+from mmaudio.utils.dist_utils import info_if_rank_zero, local_rank, world_size
+from mmaudio.utils.logger import TensorboardLogger
+from mmaudio.utils.synthesize_ema import synthesize_ema, synthesize_ema_dpo
+
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+
+log = logging.getLogger()
+
+
+def distributed_setup():
+    distributed.init_process_group(backend="nccl", timeout=timedelta(hours=2))
+    log.info(f'Initialized: local_rank={local_rank}, world_size={world_size}')
+    return local_rank, world_size
+
+
+@record
+@hydra.main(version_base='1.3.2', config_path='config', config_name='train_dpo_config.yaml') # todo Mar 2
+def train(cfg: DictConfig):
+    # initial setup
+    torch.cuda.set_device(local_rank)
+    torch.backends.cudnn.benchmark = cfg.cudnn_benchmark
+    distributed_setup()
+    num_gpus = world_size
+    run_dir = HydraConfig.get().run.dir
+    
+    # compose early such that it does not rely on future hard disk reading
+    eval_cfg = compose('eval_config', overrides=[f'exp_id={cfg.exp_id}'])
+
+    # patch data dim
+    if cfg.model.endswith('16k'):
+        seq_cfg = CONFIG_16K
+    elif cfg.model.endswith('44k'):
+        seq_cfg = CONFIG_44K
+    else:
+        raise ValueError(f'Unknown model: {cfg.model}')
+    with open_dict(cfg):
+        cfg.data_dim.latent_seq_len = seq_cfg.latent_seq_len
+        cfg.data_dim.clip_seq_len = seq_cfg.clip_seq_len
+        cfg.data_dim.sync_seq_len = seq_cfg.sync_seq_len
+
+    # wrap python logger with a tensorboard logger
+    log = TensorboardLogger(cfg.exp_id,
+                            run_dir,
+                            logging.getLogger(),
+                            is_rank0=(local_rank == 0),
+                            enable_email=cfg.enable_email and not cfg.debug)
+
+    info_if_rank_zero(log, f'All configuration: {cfg}')
+    info_if_rank_zero(log, f'Number of GPUs detected: {num_gpus}')
+
+    # number of dataloader workers
+    info_if_rank_zero(log, f'Number of dataloader workers (per GPU): {cfg.num_workers}')
+
+    # Set seeds to ensure the same initialization
+    torch.manual_seed(cfg.seed)
+    np.random.seed(cfg.seed)
+    random.seed(cfg.seed)
+
+    # setting up configurations
+    info_if_rank_zero(log, f'Training configuration: {cfg}')
+    cfg.batch_size //= num_gpus
+    info_if_rank_zero(log, f'Batch size (per GPU): {cfg.batch_size}')
+
+    # determine time to change max skip
+    total_iterations = cfg['num_iterations']
+
+    # setup datasets
+    dataset, sampler, loader = setup_training_datasets(cfg)
+    info_if_rank_zero(log, f'Number of training samples: {len(dataset)}')
+    info_if_rank_zero(log, f'Number of training batches: {len(loader)}')
+
+    val_dataset, val_loader, eval_loader = setup_val_datasets(cfg)
+    info_if_rank_zero(log, f'Number of val samples: {len(val_dataset)}')
+    val_cfg = cfg.dpo_data.ExtractedVGG_val
+
+    # compute and set mean and std
+    # latent_mean_chosen, latent_std_chosen, latent_mean_reject, latent_std_reject = dataset.compute_latent_stats() # todo Mar 2
+    # latent_mean_dpo = torch.stack([latent_mean_chosen, latent_mean_reject], dim=0) # todo Mar 2
+    # latent_std_dpo = torch.stack([latent_std_chosen, latent_std_reject], dim=0) # todo Mar 2
+
+    # construct the trainer
+    trainer = Runner(cfg,
+                     log=log,
+                     run_path=run_dir,
+                     for_training=True,
+                     latent_mean=None,
+                     latent_std=None,
+                     dpo_train=True).enter_train() # todo Mar 2
+    eval_rng_clone = trainer.rng.graphsafe_get_state()
+
+
+    # todo load previous checkpoint if needed (including model weights, ema, and optimizer, scheduler)
+    if cfg['checkpoint'] is not None:
+        curr_iter = trainer.load_checkpoint(cfg['checkpoint'])
+        cfg['checkpoint'] = None
+        info_if_rank_zero(log, 'Model checkpoint loaded!')
+    else:
+        # if run_dir exists, load the latest checkpoint
+        checkpoint = trainer.get_latest_checkpoint_path()
+        if checkpoint is not None:
+            curr_iter = trainer.load_checkpoint(checkpoint)
+            info_if_rank_zero(log, 'Latest checkpoint loaded!')
+        else:
+            # load previous network weights if needed # todo may be ok for dpo?
+            curr_iter = 0
+            if cfg['weights'] is not None:
+                info_if_rank_zero(log, 'Loading weights from the disk')
+                trainer.load_weights(cfg['weights'])
+                cfg['weights'] = None
+
+
+    # determine max epoch
+    total_epoch = math.ceil(total_iterations / len(loader))
+    current_epoch = curr_iter // len(loader)
+    info_if_rank_zero(log, f'We will approximately use {total_epoch} epochs.')
+
+    # training loop
+    try:
+        # Need this to select random bases in different workers
+        np.random.seed(np.random.randint(2 ** 30 - 1) + local_rank * 1000)
+        while curr_iter < total_iterations:
+            # Crucial for randomness!
+            sampler.set_epoch(current_epoch)
+            current_epoch += 1
+            log.debug(f'Current epoch: {current_epoch}')
+
+            trainer.enter_train()
+            trainer.log.data_timer.start()
+            for data in loader:
+                trainer.train_dpo_pass(data, curr_iter)
+
+                if (curr_iter + 1) % cfg.val_interval == 0:
+                    # swap into a eval rng state, i.e., use the same seed for every validation pass
+                    train_rng_snapshot = trainer.rng.graphsafe_get_state()
+                    trainer.rng.graphsafe_set_state(eval_rng_clone)
+                    info_if_rank_zero(log, f'Iteration {curr_iter}: validating')
+                    for data in val_loader:
+                        trainer.validation_pass(data, curr_iter)
+                    distributed.barrier()
+                    trainer.val_integrator.finalize('val', curr_iter, ignore_timer=True)
+                    trainer.rng.graphsafe_set_state(train_rng_snapshot)
+                # todo Jan 12
+                # if (curr_iter + 1) % cfg.eval_interval == 0:
+                #     save_eval = (curr_iter + 1) % cfg.save_eval_interval == 0
+                #     train_rng_snapshot = trainer.rng.graphsafe_get_state()
+                #     trainer.rng.graphsafe_set_state(eval_rng_clone)
+                #     info_if_rank_zero(log, f'Iteration {curr_iter}: validating')
+                #     for data in eval_loader:
+                #         audio_path = trainer.inference_pass(data,
+                #                                             curr_iter,
+                #                                             val_cfg,
+                #                                             save_eval=save_eval)
+                #     distributed.barrier()
+                #     trainer.rng.graphsafe_set_state(train_rng_snapshot)
+                #     trainer.eval(audio_path, curr_iter, 1, val_cfg)
+
+                curr_iter += 1
+
+                if curr_iter >= total_iterations:
+                    break
+    except Exception as e:
+        log.error(f'Error occurred at iteration {curr_iter}!')
+        log.critical(e.message if hasattr(e, 'message') else str(e))
+        raise
+    finally:
+        if not cfg.debug:
+            trainer.save_checkpoint(curr_iter)
+            trainer.save_weights(curr_iter)
+
+    # Inference pass
+    del trainer
+    torch.cuda.empty_cache()
+    
+    # Synthesize EMA
+    if local_rank == 0:
+        log.info(f'Synthesizing EMA with sigma={cfg.ema.default_output_sigma}')
+        ema_sigma = cfg.ema.default_output_sigma
+        state_dict = synthesize_ema(cfg, ema_sigma, step=None)
+        save_dir = Path(run_dir) / f'{cfg.exp_id}_ema_final.pth'
+        torch.save(state_dict, save_dir)
+        log.info(f'Synthesized EMA saved to {save_dir}!')
+    distributed.barrier()
+
+    # todo Jan 12
+    # log.info(f'Evaluation: {eval_cfg}')
+    # sample(eval_cfg)
+
+    # clean-up
+    log.complete()
+    distributed.barrier()
+    distributed.destroy_process_group()
+
+
+if __name__ == '__main__':
+    train()