Add files using upload-large-folder tool

.gitignore

@@ -0,0 +1,146 @@
+run_*.sh
+log/
+saves
+saves/
+weights/
+weights
+output/
+output
+pretrained/
+workspace
+workspace/
+ext_weights/
+ext_weights
+.checkpoints/
+.vscode/
+training/example_output/
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ho Kei Cheng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,177 @@
+<div align="center">
+<p align="center">
+  <h2>MMAudio</h2>
+  <a href="https://arxiv.org/abs/2412.15322">Paper</a> | <a href="https://hkchengrex.github.io/MMAudio">Webpage</a> | <a href="https://huggingface.co/hkchengrex/MMAudio/tree/main">Models</a> | <a href="https://huggingface.co/spaces/hkchengrex/MMAudio"> Huggingface Demo</a> | <a href="https://colab.research.google.com/drive/1TAaXCY2-kPk4xE4PwKB3EqFbSnkUuzZ8?usp=sharing">Colab Demo</a> | <a href="https://replicate.com/zsxkib/mmaudio">Replicate Demo</a>
+</p>
+</div>
+
+## [Taming Multimodal Joint Training for High-Quality Video-to-Audio Synthesis](https://hkchengrex.github.io/MMAudio)
+
+[Ho Kei Cheng](https://hkchengrex.github.io/), [Masato Ishii](https://scholar.google.co.jp/citations?user=RRIO1CcAAAAJ), [Akio Hayakawa](https://scholar.google.com/citations?user=sXAjHFIAAAAJ), [Takashi Shibuya](https://scholar.google.com/citations?user=XCRO260AAAAJ), [Alexander Schwing](https://www.alexander-schwing.de/), [Yuki Mitsufuji](https://www.yukimitsufuji.com/)
+
+University of Illinois Urbana-Champaign, Sony AI, and Sony Group Corporation
+
+## Highlight
+
+MMAudio generates synchronized audio given video and/or text inputs.
+Our key innovation is multimodal joint training which allows training on a wide range of audio-visual and audio-text datasets.
+Moreover, a synchronization module aligns the generated audio with the video frames.
+
+## Results
+
+(All audio from our algorithm MMAudio)
+
+Videos from Sora:
+
+https://github.com/user-attachments/assets/82afd192-0cee-48a1-86ca-bd39b8c8f330
+
+Videos from Veo 2:
+
+https://github.com/user-attachments/assets/8a11419e-fee2-46e0-9e67-dfb03c48d00e
+
+Videos from MovieGen/Hunyuan Video/VGGSound:
+
+https://github.com/user-attachments/assets/29230d4e-21c1-4cf8-a221-c28f2af6d0ca
+
+For more results, visit https://hkchengrex.com/MMAudio/video_main.html.
+
+
+## Installation
+
+We have only tested this on Ubuntu.
+
+### Prerequisites
+
+We recommend using a [miniforge](https://github.com/conda-forge/miniforge) environment.
+
+- Python 3.9+
+- PyTorch **2.5.1+** and corresponding torchvision/torchaudio (pick your CUDA version https://pytorch.org/, pip install recommended)
+<!-- - ffmpeg<7 ([this is required by torchaudio](https://pytorch.org/audio/master/installation.html#optional-dependencies), you can install it in a miniforge environment with `conda install -c conda-forge 'ffmpeg<7'`) -->
+
+**1. Install prerequisite if not yet met:**
+
+```bash
+pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 --upgrade
+```
+
+(Or any other CUDA versions that your GPUs/driver support)
+
+<!-- ```
+conda install -c conda-forge 'ffmpeg<7
+```
+(Optional, if you use miniforge and don't already have the appropriate ffmpeg) -->
+
+**2. Clone our repository:**
+
+```bash
+git clone https://github.com/hkchengrex/MMAudio.git
+```
+
+**3. Install with pip (install pytorch first before attempting this!):**
+
+```bash
+cd MMAudio
+pip install -e .
+```
+
+(If you encounter the File "setup.py" not found error, upgrade your pip with pip install --upgrade pip)
+
+
+**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
+See [MODELS.md](docs/MODELS.md) for more details.
+
+## Demo
+
+By default, these scripts use the `large_44k_v2` model. 
+In our experiments, inference only takes around 6GB of GPU memory (in 16-bit mode) which should fit in most modern GPUs.
+
+### Command-line interface
+
+With `demo.py`
+
+```bash
+python demo.py --duration=8 --video=<path to video> --prompt "your prompt" 
+```
+
+The output (audio in `.flac` format, and video in `.mp4` format) will be saved in `./output`.
+See the file for more options.
+Simply omit the `--video` option for text-to-audio synthesis.
+The default output (and training) duration is 8 seconds. Longer/shorter durations could also work, but a large deviation from the training duration may result in a lower quality.
+
+### Gradio interface
+
+Supports video-to-audio and text-to-audio synthesis.
+You can also try experimental image-to-audio synthesis which duplicates the input image to a video for processing. This might be interesting to some but it is not something MMAudio has been trained for.
+Use [port forwarding](https://unix.stackexchange.com/questions/115897/whats-ssh-port-forwarding-and-whats-the-difference-between-ssh-local-and-remot) (e.g., `ssh -L 7860:localhost:7860 server`) if necessary. The default port is `7860` which you can specify with `--port`.
+
+```bash
+python gradio_demo.py
+```
+
+### FAQ
+
+1. Video processing
+    - Processing higher-resolution videos takes longer due to encoding and decoding (which can take >95% of the processing time!), but it does not improve the quality of results.
+    - The CLIP encoder resizes input frames to 384×384 pixels. 
+    - Synchformer resizes the shorter edge to 224 pixels and applies a center crop, focusing only on the central square of each frame.
+2. Frame rates
+    - The CLIP model operates at 8 FPS, while Synchformer works at 25 FPS.
+    - Frame rate conversion happens on-the-fly via the video reader.
+    - For input videos with a frame rate below 25 FPS, frames will be duplicated to match the required rate.
+3. Failure cases
+As with most models of this type, failures can occur, and the reasons are not always clear. Below are some known failure modes. If you notice a failure mode or believe there’s a bug, feel free to open an issue in the repository.
+4. Performance variations
+We notice that there can be subtle performance variations in different hardware and software environments. Some of the reasons include using/not using `torch.compile`, video reader library/backend, inference precision, batch sizes, random seeds, etc. We (will) provide pre-computed results on standard benchmark for reference. Results obtained from this codebase should be similar but might not be exactly the same.
+
+### Known limitations
+
+1. The model sometimes generates unintelligible human speech-like sounds
+2. The model sometimes generates background music (without explicit training, it would not be high quality)
+3. The model struggles with unfamiliar concepts, e.g., it can generate "gunfires" but not "RPG firing".
+
+We believe all of these three limitations can be addressed with more high-quality training data.
+
+## Training
+
+See [TRAINING.md](docs/TRAINING.md).
+
+## Evaluation
+
+See [EVAL.md](docs/EVAL.md).
+
+## Training Datasets
+
+MMAudio was trained on several datasets, including [AudioSet](https://research.google.com/audioset/), [Freesound](https://github.com/LAION-AI/audio-dataset/blob/main/laion-audio-630k/README.md), [VGGSound](https://www.robots.ox.ac.uk/~vgg/data/vggsound/), [AudioCaps](https://audiocaps.github.io/), and [WavCaps](https://github.com/XinhaoMei/WavCaps). These datasets are subject to specific licenses, which can be accessed on their respective websites. We do not guarantee that the pre-trained models are suitable for commercial use. Please use them at your own risk.
+
+## Update Logs
+
+- 2024-12-23: Added training and batch evaluation scripts.
+- 2024-12-14: Removed the `ffmpeg<7` requirement for the demos by replacing `torio.io.StreamingMediaDecoder` with `pyav` for reading frames. The read frames are also cached, so we are not reading the same frames again during reconstruction. This should speed things up and make installation less of a hassle.
+- 2024-12-13: Improved for-loop processing in CLIP/Sync feature extraction by introducing a batch size multiplier. We can approximately use 40x batch size for CLIP/Sync without using more memory, thereby speeding up processing. Removed VAE encoder during inference -- we don't need it.
+- 2024-12-11: Replaced `torio.io.StreamingMediaDecoder` with `pyav` for reading framerate when reconstructing the input video. `torio.io.StreamingMediaDecoder` does not work reliably in huggingface ZeroGPU's environment, and I suspect that it might not work in some other environments as well.
+
+## Citation
+
+```bibtex
+@inproceedings{cheng2024taming,
+  title={Taming Multimodal Joint Training for High-Quality Video-to-Audio Synthesis},
+  author={Cheng, Ho Kei and Ishii, Masato and Hayakawa, Akio and Shibuya, Takashi and Schwing, Alexander and Mitsufuji, Yuki},
+  booktitle={arXiv},
+  year={2024}
+}
+```
+
+## Relevant Repositories
+
+- [av-benchmark](https://github.com/hkchengrex/av-benchmark) for benchmarking results.
+
+## Acknowledgement
+
+Many thanks to:
+- [Make-An-Audio 2](https://github.com/bytedance/Make-An-Audio-2) for the 16kHz BigVGAN pretrained model and the VAE architecture
+- [BigVGAN](https://github.com/NVIDIA/BigVGAN)
+- [Synchformer](https://github.com/v-iashin/Synchformer) 
+- [EDM2](https://github.com/NVlabs/edm2) for the magnitude-preserving network architecture

batch_eval_dpo.py

@@ -0,0 +1,144 @@
+import logging
+import os
+from pathlib import Path
+
+import hydra
+import torch
+import torch.distributed as distributed
+import torchaudio
+from hydra.core.hydra_config import HydraConfig
+from omegaconf import DictConfig
+from tqdm import tqdm
+
+from mmaudio.data.data_setup import setup_eval_dataset
+from mmaudio.eval_utils import ModelConfig, all_model_cfg, generate, make_video_new, load_full_video_frames, make_video, generate_dpo
+from mmaudio.model.flow_matching import FlowMatching
+from mmaudio.model.networks_new import MMAudio, get_my_mmaudio
+from mmaudio.model.utils.features_utils import FeaturesUtils
+
+torch.backends.cuda.matmul.allow_tf32 = True
+torch.backends.cudnn.allow_tf32 = True
+
+local_rank = int(os.environ['LOCAL_RANK'])
+world_size = int(os.environ['WORLD_SIZE'])
+log = logging.getLogger()
+
+
+@torch.inference_mode()
+@hydra.main(version_base='1.3.2', config_path='config', config_name='eval_for_dpo_config.yaml')
+def main(cfg: DictConfig):
+    device = 'cuda'
+    torch.cuda.set_device(local_rank)
+
+    if cfg.model not in all_model_cfg:
+        raise ValueError(f'Unknown model variant: {cfg.model}')
+    model: ModelConfig = all_model_cfg[cfg.model]
+    # model.download_if_needed()
+    seq_cfg = model.seq_cfg
+
+    run_dir = Path(HydraConfig.get().run.dir)
+    if cfg.output_name is None:
+        output_dir = run_dir / cfg.dataset
+    else:
+        output_dir = run_dir / f'{cfg.dataset}-{cfg.output_name}'
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # load a pretrained model
+    seq_cfg.duration = cfg.duration_s
+    net: MMAudio = get_my_mmaudio(cfg.model).to(device).eval()
+    
+    # todo May 10
+    if model.model_path is None:
+        if model.model_name == 'small_44k': 
+            model.model_path = Path(cfg.small_44k_pretrained_ckpt_path)
+        else:
+            raise ValueError('Given Model Is Not Supported !')
+    
+    net.load_weights(torch.load(model.model_path, map_location=device, weights_only=True))
+    log.info(f'Loaded weights from {model.model_path}')
+    net.update_seq_lengths(seq_cfg.latent_seq_len, seq_cfg.clip_seq_len, seq_cfg.sync_seq_len)
+    log.info(f'Latent seq len: {seq_cfg.latent_seq_len}')
+    log.info(f'Clip seq len: {seq_cfg.clip_seq_len}')
+    log.info(f'Sync seq len: {seq_cfg.sync_seq_len}')
+
+    # misc setup
+    rng = torch.Generator(device=device)
+    rng.manual_seed(cfg.seed)
+    fm = FlowMatching(cfg.sampling.min_sigma,
+                      inference_mode=cfg.sampling.method,
+                      num_steps=cfg.sampling.num_steps)
+
+    feature_utils = FeaturesUtils(tod_vae_ckpt=model.vae_path,
+                                  synchformer_ckpt=model.synchformer_ckpt,
+                                  enable_conditions=True,
+                                  mode=model.mode,
+                                  bigvgan_vocoder_ckpt=model.bigvgan_16k_path,
+                                  need_vae_encoder=False)
+    feature_utils = feature_utils.to(device).eval()
+
+    if cfg.compile:
+        net.preprocess_conditions = torch.compile(net.preprocess_conditions)
+        net.predict_flow = torch.compile(net.predict_flow)
+        feature_utils.compile()
+
+    dataset, loader = setup_eval_dataset(cfg.dataset, cfg)
+
+    with torch.amp.autocast(enabled=cfg.amp, dtype=torch.bfloat16, device_type=device):
+        for batch in tqdm(loader):
+            audios_bank = generate_dpo(batch.get('clip_video', None),
+                              batch.get('sync_video', None),
+                              batch.get('caption', None),
+                              feature_utils=feature_utils,
+                              net=net,
+                              fm=fm,
+                              rng=rng,
+                              cfg_strength=cfg.cfg_strength,
+                              clip_batch_size_multiplier=64,
+                              sync_batch_size_multiplier=64,
+                              num_samples_per_video=cfg.num_samples_per_video)
+
+            # load video frames
+            video_paths = batch['video_path']
+            video_info_dict = {}
+            for video_path in video_paths:
+                video_info = load_full_video_frames(video_path, cfg.duration_s)
+                video_info_dict[video_path] = video_info
+
+            # same audio and video for each sample id
+            for sample_id, audios in enumerate(audios_bank):
+
+                audios = audios.float().cpu()
+                names = batch['name']
+
+                # # todo
+                # output_dir_audio = output_dir / f'{sample_id + 1}' / 'audios'
+                # output_dir_video = output_dir / f'{sample_id + 1}' / 'videos'
+                # output_dir_audio.mkdir(parents=True, exist_ok=True)
+                # output_dir_video.mkdir(parents=True, exist_ok=True)
+
+                for audio, name, video_path in zip(audios, names, video_paths):
+                    # todo
+                    output_dir_save = output_dir / 'generated_videos' / f'{name}' / f'{sample_id + 1}'
+                    output_dir_save.mkdir(parents=True, exist_ok=True)
+        
+                    torchaudio.save(output_dir_save / f'{name}.flac', audio, seq_cfg.sampling_rate)
+                    #video_info = load_full_video_frames(video_path, cfg.duration_s) # todo should be optimized due to repeated calculation
+                    video_save_path = output_dir_save / f'{name}.mp4'
+                    make_video(video_info_dict[video_path], video_save_path, audio, sampling_rate=seq_cfg.sampling_rate)
+
+
+def distributed_setup():
+    distributed.init_process_group(backend="nccl")
+    local_rank = distributed.get_rank()
+    world_size = distributed.get_world_size()
+    log.info(f'Initialized: local_rank={local_rank}, world_size={world_size}')
+    return local_rank, world_size
+
+
+if __name__ == '__main__':
+    distributed_setup()
+
+    main()
+
+    # clean-up
+    distributed.destroy_process_group()

demo.py

@@ -0,0 +1,143 @@
+import logging
+from argparse import ArgumentParser
+from pathlib import Path
+
+import torch
+import torchaudio
+
+from mmaudio.eval_utils import (ModelConfig, all_model_cfg, generate, 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.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
+
+log = logging.getLogger()
+
+
+@torch.inference_mode()
+def main():
+    setup_eval_logging()
+
+    parser = ArgumentParser()
+    parser.add_argument('--variant',
+                        type=str,
+                        default='small_16k',
+                        help='small_16k, small_44k, medium_44k, large_44k, large_44k_v2')
+    parser.add_argument('--video', type=Path, help='Path to the video file')
+    parser.add_argument('--prompt', type=str, help='Input prompt', default='')
+    parser.add_argument('--negative_prompt', type=str, help='Negative prompt', default='')
+    parser.add_argument('--duration', type=float, default=8.0)
+    parser.add_argument('--cfg_strength', type=float, default=4.5)
+    parser.add_argument('--num_steps', type=int, default=25)
+
+    parser.add_argument('--mask_away_clip', action='store_true')
+
+    parser.add_argument('--output', type=Path, help='Output directory', default='./output/demo_lumina_v2a')
+    parser.add_argument('--seed', type=int, help='Random seed', default=42)
+    parser.add_argument('--skip_video_composite', action='store_true')
+    parser.add_argument('--full_precision', action='store_true')
+
+    args = parser.parse_args()
+
+    if args.variant not in all_model_cfg:
+        raise ValueError(f'Unknown model variant: {args.variant}')
+    model: ModelConfig = all_model_cfg[args.variant]
+    #model.download_if_needed()
+    seq_cfg = model.seq_cfg
+
+    if args.video:
+        video_path: Path = Path(args.video).expanduser()
+    else:
+        video_path = None
+    prompt: str = args.prompt
+    negative_prompt: str = args.negative_prompt
+    output_dir: str = args.output.expanduser()
+    seed: int = args.seed
+    num_steps: int = args.num_steps
+    duration: float = args.duration
+    cfg_strength: float = args.cfg_strength
+    skip_video_composite: bool = args.skip_video_composite
+    mask_away_clip: bool = args.mask_away_clip
+
+    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.float32 if args.full_precision else torch.bfloat16
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # load a pretrained model
+    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}')
+
+    # misc setup
+    rng = torch.Generator(device=device)
+    rng.manual_seed(seed)
+    fm = FlowMatching(min_sigma=0, inference_mode='euler', num_steps=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, dtype).eval()
+
+    if video_path is not None:
+        log.info(f'Using video {video_path}')
+        video_info = load_video(video_path, duration)
+        clip_frames = video_info.clip_frames
+        sync_frames = video_info.sync_frames
+        duration = video_info.duration_sec
+        if mask_away_clip:
+            clip_frames = None
+        else:
+            clip_frames = clip_frames.unsqueeze(0)
+        sync_frames = sync_frames.unsqueeze(0)
+    else:
+        log.info('No video provided -- text-to-audio mode')
+        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)
+
+    log.info(f'Prompt: {prompt}')
+    log.info(f'Negative prompt: {negative_prompt}')
+
+    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]
+    if video_path is not None:
+        save_path = output_dir / f'{video_path.stem}.flac'
+    else:
+        safe_filename = prompt.replace(' ', '_').replace('/', '_').replace('.', '')
+        save_path = output_dir / f'{safe_filename}.flac'
+    torchaudio.save(save_path, audio, seq_cfg.sampling_rate)
+
+    log.info(f'Audio saved to {save_path}')
+    if video_path is not None and not skip_video_composite:
+        video_save_path = output_dir / f'{video_path.stem}.mp4'
+        make_video(video_info, video_save_path, audio, sampling_rate=seq_cfg.sampling_rate)
+        log.info(f'Video saved to {output_dir / video_save_path}')
+
+    log.info('Memory usage: %.2f GB', torch.cuda.max_memory_allocated() / (2**30))
+
+
+if __name__ == '__main__':
+    main()

download_hg.py

@@ -0,0 +1,18 @@
+import open_clip
+from open_clip import create_model_from_pretrained
+
+#clip_model = create_model_from_pretrained('hf-hub:apple/DFN5B-CLIP-ViT-H-14-384', return_transform=False)
+#print(clip_model)
+
+#tokenizer = open_clip.get_tokenizer('ViT-H-14-378-quickgelu')  
+#print(tokenizer)
+
+#import gdown 
+#url = "https://drive.google.com/uc?id=1vxUJ6ILoBkBtj7Ji9EHJCaJvR35np6sX"
+#output = "/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/dataset/AudioCaps/test.zip"
+#gdown.download(url, output)
+
+from mmaudio.ext.bigvgan_v2.bigvgan import BigVGAN as BigVGANv2
+
+vocoder = BigVGANv2.from_pretrained('nvidia/bigvgan_v2_44khz_128band_512x', use_cuda_kernel=False)
+print(vocoder)

pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.metadata]
+allow-direct-references = true
+
+[tool.yapf]
+based_on_style = "pep8"
+indent_width = 4
+column_limit = 100
+
+[tool.isort]
+line_length = 100
+
+[project]
+name = "mmaudio"
+version = "1.0.0"
+authors = [{ name = "Rex Cheng", email = "hkchengrex@gmail.com" }]
+description = "MMAudio generates synchronized audio given video and/or text inputs"
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+dependencies = [
+  'torch >= 2.5.1',
+  'huggingface_hub >= 0.26',
+  'cython',
+  'gitpython >= 3.1',
+  'tensorboard >= 2.11',
+  'numpy >= 1.21, <2.1',
+  'Pillow >= 9.5',
+  'opencv-python >= 4.8',
+  'scipy >= 1.7',
+  'tqdm >= 4.66.1',
+  'gradio >= 3.34',
+  'einops >= 0.6',
+  'hydra-core >= 1.3.2',
+  'requests',
+  'torchdiffeq >= 0.2.5',
+  'librosa >= 0.8.1',
+  'nitrous-ema',
+  'hydra_colorlog',
+  'tensordict >= 0.6.1',
+  'colorlog',
+  'open_clip_torch >= 2.29.0',
+  'av >= 14.0.1',
+  'timm >= 1.0.12',
+  'python-dotenv',
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["mmaudio"]

reward_models/ib_at_sync.py

@@ -0,0 +1,238 @@
+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 AudioDataset, 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 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 = AudioDataset(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 audio
+            ib_audio = data['ib_audio'].squeeze(1).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 audio feature extraction
+            ib_audio_features = imagebind({ModalityType.AUDIO: ib_audio})[ModalityType.AUDIO].cpu().detach()
+
+            # calculate imagebind_at metrics # todo May 9
+            ib_at_scores = torch.cosine_similarity(ib_text_features, ib_audio_features, dim=-1) 
+        
+            for i, n in enumerate(names):
+                each_output = {
+                    'id': n,
+                    'label': video_id_caption_dict[n],
+                    '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_at_output_full = [] # todo May 9
+    saved_ib_at_output_dpo = [] # todo May 9
+
+    video_id_list = total_outputs[0].keys()
+    for video_id in tqdm(video_id_list):
+        # todo May 9
+        outputs_ib_at_metrics = {
+            'id': video_id,
+            'label': video_id_caption_dict[video_id]
+        }
+
+        ib_at_scores_for_each_video = [] # todo May 9
+
+        for idx, each_sample_idx_dict in enumerate(total_outputs):
+            # 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']
+
+        
+        # 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_at_output_full.append(outputs_ib_at_metrics) # todo May 9
+        
+        saved_ib_at_output_dpo.append(outputs_ib_at_dpo) # todo May 9
+
+    # 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)

save_ema.py

@@ -0,0 +1,31 @@
+import torch
+from typing import Optional
+
+from nitrous_ema import PostHocEMA
+
+from mmaudio.model.networks_new import get_my_mmaudio
+
+
+def synthesize_ema(sigma: float, step: Optional[int]):
+    vae = get_my_mmaudio('small_44k')
+    emas = PostHocEMA(vae,
+                      sigma_rels=[0.05, 0.1],
+                      update_every=1,
+                      checkpoint_every_num_steps=5000,
+                      checkpoint_folder='/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/vgg_only_small_44k_new_model_feb1/ema_ckpts')
+
+    synthesized_ema = emas.synthesize_ema_model(sigma_rel=sigma, step=step, device='cpu')
+    state_dict = synthesized_ema.ema_model.state_dict()
+    return state_dict
+
+
+
+# Synthesize EMA
+
+ema_sigma = 0.05
+print('Start !!!')
+state_dict = synthesize_ema(ema_sigma, step=None)
+save_dir = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/kwang/MMAudio/output/vgg_only_small_44k_new_model_feb1/vgg_only_small_44k_new_model_feb1_ema_final.pth' 
+torch.save(state_dict, save_dir)
+print('Finished !!!')
+

test_try.py

@@ -0,0 +1,18 @@
+import os 
+import pandas as pd 
+
+# '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/zhoutao-240108120126/datasets/audio-visual/vggsound/vggsound.csv' #
+csv_path = '/inspire/hdd/ws-f4d69b29-e0a5-44e6-bd92-acf4de9990f0/gaopeng/public/kwang/datasets/vggsound/vggsound-caption.csv'
+
+df = pd.read_csv(csv_path, header=None, names=['id', 'sec', 'caption', 'split']).to_dict(orient='records')
+
+for row in df:
+    start_sec = int(row['sec'])
+    video_id = str(row['id'])
+    # this is how our videos are named
+    video_name = f'{video_id}_{start_sec:06d}'
+    caption = row['caption']
+    print(start_sec)
+    print(video_id)
+    print(caption)
+    break

train.py

@@ -0,0 +1,211 @@
+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
+
+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_config.yaml')
+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.data.ExtractedVGG_val
+
+    # compute and set mean and std
+    latent_mean, latent_std = dataset.compute_latent_stats()
+
+    # construct the trainer
+    trainer = Runner(cfg,
+                     log=log,
+                     run_path=run_dir,
+                     for_training=True,
+                     latent_mean=latent_mean,
+                     latent_std=latent_std).enter_train()
+    eval_rng_clone = trainer.rng.graphsafe_get_state()
+
+    # load previous checkpoint if needed
+    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
+            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_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()

train_dpo-Copy1.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=latent_mean_dpo,
+                     latent_std=latent_std_dpo,
+                     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_dpo(cfg, ema_sigma, dpo_train=True, 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()