Upload folder using huggingface_hub

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+CoCap/poster.pdf filter=lfs diff=lfs merge=lfs -text

CoCap/.gitignore

@@ -0,0 +1,163 @@
+# 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/
+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/
+cover/
+
+# 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
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .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
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__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/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+.idea
+.DS_Store

CoCap/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Yaojie Shen
+
+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.

CoCap/README.md

@@ -0,0 +1,73 @@
+# Accurate and Fast Compressed Video Captioning
+
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/accurate-and-fast-compressed-video-captioning/video-captioning-on-msr-vtt-1)](https://paperswithcode.com/sota/video-captioning-on-msr-vtt-1?p=accurate-and-fast-compressed-video-captioning)
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/accurate-and-fast-compressed-video-captioning/video-captioning-on-msvd-1)](https://paperswithcode.com/sota/video-captioning-on-msvd-1?p=accurate-and-fast-compressed-video-captioning)
+[![PWC](https://img.shields.io/endpoint.svg?url=https://paperswithcode.com/badge/accurate-and-fast-compressed-video-captioning/video-captioning-on-vatex-1)](https://paperswithcode.com/sota/video-captioning-on-vatex-1?p=accurate-and-fast-compressed-video-captioning)
+
+
+✨This is the official implementation of ICCV 2023 paper *[Accurate and Fast Compressed Video Captioning](https://arxiv.org/abs/2309.12867)*.
+
+🚀 This code is a revised version of the original release, incorporating Hydra and PyTorch Lightning. For the original implementation, please refer to [this commit](https://github.com/Yaojie-Shen/CoCap/tree/initial_release).
+
+## Introduction
+
+In this work, we propose an end-to-end video captioning method based on compressed domain information from the encoded H.264 videos. Our approach aims to accurately generate captions for compressed videos in a fast and efficient manner.
+
+![Framework](./assets/framework.svg)
+
+By releasing this code, we hope to facilitate further research and development in the field of compressed video processing. If you find this work useful in your own research, please consider citing our paper as a reference.
+
+## Preparation
+
+### 1. Install the Requirements
+
+To run the code, please install the dependency libraries by using the following command:
+
+```shell
+sudo apt update && sudo apt install default-jre -y  # required by pycocoevalcap
+pip3 install -e . # See `requirements.txt` for exact versions used in development
+```
+
+Additionally, you will need to install the compressed video reader as described in the README.md of [Compressed-Video-Reader](https://github.com/yaojie-shen/Compressed-Video-Reader).
+
+
+### 2. Prepare the Pretrained Models
+
+Our model is based on the pretrained CLIP. You can run the following script to download the weights before training to avoid any network issues:
+
+```bash
+sudo apt update && sudo apt install aria2 -y  # install aria2
+bash model_zoo/download_model.sh
+```
+
+This will download the CLIP model to `model_zoo/clip_model`. Note that this directory is hard-coded in our code.
+
+### 3. Prepare the Data
+
+We have conducted experiments on three video caption datasets: MSRVTT, MSVD, and VATEX. The datasets are stored in the `dataset` folder under the project root. For detailed instructions on downloading and preparing the training data, please refer to [dataset/README.md](./dataset/README.md).
+
+## Training & Evaluation
+
+The training is configured using YAML, and all the configurations are listed in [`configs/compressed_video`](./configs/compressed_video). You can use the following commands to run the experiments:
+
+```shell
+# msrvtt
+python3 tools/train_net.py --config-name=exp/train/msrvtt_captioning
+# msvd
+python3 tools/train_net.py --config-name=exp/train/msvd_captioning
+# vatex
+python3 tools/train_net.py --config-name=exp/train/vatex_captioning
+```
+
+By default, the logs and results will be saved to `./logs/<experiment_name>/`. The loss and metrics are visualized using tensorboard.
+
+## Citation
+
+```text
+@inproceedings{cocap,
+      title={Accurate and Fast Compressed Video Captioning}, 
+      author={Yaojie Shen and Xin Gu and Kai Xu and Heng Fan and Longyin Wen and Libo Zhang},
+      booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision},
+      year={2023}
+}
+```

CoCap/cocap/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/15 00:45
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : __init__.py

CoCap/cocap/data/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/11 16:31
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : __init__.py

CoCap/cocap/data/datasets/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/13 02:38
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : __init__.py

CoCap/cocap/data/datasets/avcaps.py

@@ -0,0 +1,195 @@
+import os
+import json
+import random
+import torch
+import torchaudio
+import torchvision.transforms as T
+import torch.nn.functional as F
+from torch.utils.data import Dataset
+from PIL import Image
+from torch.nn.utils.rnn import pad_sequence
+from cocap.modules.clip.simple_tokenizer import SimpleTokenizer
+import logging
+try:
+    from torchvision.io import read_video
+except ImportError:
+    read_video = None
+
+logger = logging.getLogger(__name__)
+
+class AVCapsDataset(Dataset):
+    def __init__(self, root_dir, split="train", tokenizer=None, max_audio_len=1024, max_cap_len=77):
+        self.root_dir = root_dir
+        self.split = split
+        self.tokenizer = tokenizer if tokenizer else SimpleTokenizer()
+        self.max_audio_len = max_audio_len
+        self.max_cap_len = max_cap_len
+        
+        # Load JSON
+        json_path = os.path.join(root_dir, split, f"{split}_captions.json")
+        with open(json_path, 'r') as f:
+            self.data = json.load(f)
+            
+        self.video_ids = list(self.data.keys())
+        self.video_folder = os.path.join(root_dir, split, "video_240p_h264") # Assuming this is where mp4s are
+        # If videos are not here, user might need to adjust.
+        
+        # Transforms
+        self.transform = T.Compose([
+            T.Resize((224, 224)),
+            T.ToTensor(),
+            T.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))
+        ])
+        
+        # Mel Spectrogram transform for BEATs (16k, 128 bins)
+        # Matches ta_kaldi.fbank(num_mel_bins=128, sample_frequency=16000, frame_length=25, frame_shift=10)
+        # frame_length=25ms -> 400 samples, frame_shift=10ms -> 160 samples
+        self.mel_transform = torchaudio.transforms.MelSpectrogram(
+            sample_rate=16000, 
+            n_mels=128, 
+            n_fft=400, 
+            hop_length=160 
+        )
+
+    def __len__(self):
+        return len(self.video_ids)
+
+    def __getitem__(self, idx):
+        vid = self.video_ids[idx]
+        item_data = self.data[vid]
+        
+        # Get Caption
+        # "Target the audio_visual_captions key"
+        if "audio_visual_captions" in item_data and len(item_data["audio_visual_captions"]) > 0:
+            caption = random.choice(item_data["audio_visual_captions"])
+        else:
+            caption = "" # Should not happen typically
+            
+        # Tokenize Caption
+        tokens = self.tokenizer.encode(caption)
+        tokens = [49406] + tokens + [49407] # Add SOT, EOT. Check tokenizer for specific IDs. 
+        # CLIP SOT=49406, EOT=49407.
+        # Truncate
+        if len(tokens) > self.max_cap_len:
+            tokens = tokens[:self.max_cap_len]
+            tokens[-1] = 49407
+            
+        tokens = torch.tensor(tokens, dtype=torch.long)
+
+        # Load Video/Audio
+        video_path = os.path.join(self.video_folder, f"{vid}.mp4")
+        
+        pixel_values = torch.zeros(3, 224, 224)
+        audio_spec = torch.zeros(64, self.max_audio_len) # Fixed size placeholder
+        
+        try:
+            # Load Video
+            if os.path.exists(video_path):
+                # Only read needed parts to save IO. 
+                # read_video returns (video, audio, info)
+                # video: (T, H, W, C), audio: (K, T_a)
+                vframes, aframes, info = read_video(video_path, pts_unit='sec', output_format="TCHW")
+                
+                # 1. Image Processing (Sample random frame)
+                if vframes.shape[0] > 0:
+                    # Random sample
+                    frame_idx = random.randint(0, len(vframes)-1)
+                    frame = vframes[frame_idx] # (C, H, W) is default if output_format="TCHW"? 
+                    # Check torchvision version behavior. Often read_video returns (T, H, W, C).
+                    # If I used output_format="TCHW" (available in newer torchvision).
+                    # Let's assume standard behavior (T, H, W, C) to be safe if output_format not supported easily.
+                    pass 
+            else:
+                  # Try finding without extension or different ext?
+                  pass
+
+            # Safe fallback reading
+            if os.path.exists(video_path):
+                 vframes, aframes, info = read_video(video_path, pts_unit='sec')
+                 # vframes: (T, H, W, C)
+                 
+                 if vframes.shape[0] > 0:
+                    idx = random.randint(0, len(vframes) - 1)
+                    frame = vframes[idx] # (H, W, C)
+                    frame = frame.permute(2, 0, 1) # (C, H, W)
+                    pixel_values = self.transform(T.ToPILImage()(frame))
+                 
+                 if aframes.shape[0] > 0:
+                    # Mix down to mono
+                    waveform = aframes.mean(0, keepdim=True) # (1, T_audio)
+                    # Resample to 16k for BEATs
+                    if info['audio_fps'] != 16000:
+                        resampler = torchaudio.transforms.Resample(orig_freq=info['audio_fps'], new_freq=16000)
+                        waveform = resampler(waveform)
+                    
+                    audio_spec = self.mel_transform(waveform) # (1, F, T)
+                    audio_spec = audio_spec.squeeze(0) # (F, T)
+                    
+                    # Normalize for BEATs
+                    # fbank = (fbank - fbank_mean) / (2 * fbank_std)
+                    # fbank_mean=15.41663, fbank_std=6.55582
+                    audio_spec = (audio_spec - 15.41663) / (2 * 6.55582)
+                    
+                    # Trim or Pad audio
+                    if audio_spec.shape[1] > self.max_audio_len:
+                        audio_spec = audio_spec[:, :self.max_audio_len]
+                    elif audio_spec.shape[1] < self.max_audio_len:
+                        pad_amount = self.max_audio_len - audio_spec.shape[1]
+                        audio_spec = F.pad(audio_spec, (0, pad_amount))
+            
+        except Exception as e:
+            logger.warning(f"Error loading {vid}: {e}")
+            return None
+
+        # Return Tensors
+        # Since I can't actually read video here, I'll return placeholders if file doesn't exist
+        # But for the CODE generation task, I should write the logic.
+        
+        return {
+            "video_id": vid,
+            "pixel_values": pixel_values,
+            "audio_spec": audio_spec, # (F, T)
+            "caption": tokens
+        }
+
+def avcaps_collate_fn(batch):
+    # Filter failed loads
+    batch = [b for b in batch if b is not None]
+    if len(batch) == 0:
+        return None
+    
+    # Pad Captions
+    captions = [b["caption"] for b in batch]
+    captions_padded = pad_sequence(captions, batch_first=True, padding_value=0) # 0 is PAD usually
+    
+    # Create Attention Mask (1 for valid, 0 for pad)
+    caption_lengths = [len(c) for c in captions]
+    caption_mask = torch.zeros_like(captions_padded, dtype=torch.float)
+    for i, length in enumerate(caption_lengths):
+        caption_mask[i, :length] = 1.0
+        
+    # Stack Images
+    pixel_values = torch.stack([b["pixel_values"] for b in batch])
+    
+    # Pad Audio
+    # Audio specs are (F, T). T is variable.
+    # We want to pad T to max in batch or fixed max? 
+    # User said "handle variable-length audio ... and caption lengths".
+    audios = [b["audio_spec"] for b in batch]
+    # Transpose to (T, F) for pad_sequence
+    audios_T = [a.transpose(0, 1) for a in audios]
+    audios_padded = pad_sequence(audios_T, batch_first=True, padding_value=0)
+    # Transpose back to (B, T, F) or keep as is?
+    # CNN14 expects (B, 1, T, F). 
+    # Current audios_padded: (B, T, 64).
+    # We can unsqueeze later.
+    
+    video_ids = [b["video_id"] for b in batch]
+
+    return {
+        "pixel_values": pixel_values,
+        "audio_spec": audios_padded, # (B, T, 64)
+        "captions": captions_padded,
+        "caption_mask": caption_mask,
+        "video_ids": video_ids
+    }

CoCap/cocap/data/datasets/compressed_video/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# @Time    : 7/15/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : __init__.py

CoCap/cocap/data/datasets/compressed_video/compressed_video_utils.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/12/9 20:42
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : compressed_video_utils.py
+
+import numpy as np
+
+from cocap.utils.image import byte_imread, byte_imwrite
+
+
+def serialize(data_to_serialize, quality):
+    """
+    Compress rgb and residual by converting to JPEG format
+    :param data_to_serialize: python dict
+    :param quality: quality parameter for JPEG format
+    :return:
+    """
+    data = {}
+    for k, v in data_to_serialize.items():
+        if k in ["rgb_full", "rgb_gop", "residual"]:
+            data[k] = [byte_imwrite(img, quality=quality) for img in v]
+        else:
+            data[k] = v
+    return data
+
+
+def deserialize(serialized_data):
+    """
+    Reverse version of serialize()
+    :param serialized_data:
+    :return:
+    """
+    data = {}
+    for k, v in serialized_data.items():
+        if k in ["rgb_full", "rgb_gop", "residual"]:
+            data[k] = [np.array(byte_imread(img)) for img in v]
+        else:
+            data[k] = v
+    return data

CoCap/cocap/data/datasets/compressed_video/dataset_msrvtt.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/17 16:54
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : dataset_msrvtt.py
+
+import os
+import random
+from collections import defaultdict
+from typing import Literal
+
+import torch
+from torch.utils import data
+from torchvision import transforms
+
+from cocap.modules.clip import clip
+from cocap.utils.json import load_json
+from .transforms import (DictNormalize, DictCenterCrop, DictRandomHorizontalFlip)
+from .video_readers import VIDEO_READER_REGISTRY
+from .video_text_base import get_video, CVConfig
+
+
+class MSRVTTCaptioningDataset(data.Dataset):
+
+    def __init__(
+            self,
+            video_root: str,
+            max_words: int,
+            max_frames: int,
+            unfold_sentences: False,
+            video_size: tuple[int, int],
+            metadata: str,
+            video_reader: str,
+            cv_config: CVConfig,
+            split: Literal["train", "test"],
+    ):
+        self.split = split
+        self.video_root = video_root
+        self.max_words = max_words
+        self.max_frames = max_frames
+        self.unfold_sentences = unfold_sentences  # only affect the train split
+        self.height, self.width = video_size
+        self.sentences = []  # (vid, [sentence, ...])
+        self.h265_cfg = cv_config
+        metadata = load_json(metadata)
+        video_ids = [metadata['videos'][idx]['video_id'] for idx in range(len(metadata['videos']))]
+        all_split_video_ids = {"train": video_ids[:6513], "val": video_ids[6513:6513 + 497],
+                               "test": video_ids[6513 + 497:]}
+
+        split_video_ids = all_split_video_ids[split].copy()
+        if self.unfold_sentences:
+            for item in metadata["sentences"]:
+                if item["video_id"] in split_video_ids:
+                    self.sentences.append([item["video_id"], [item["caption"]]])
+                    if split == "test":
+                        split_video_ids.remove(item["video_id"])
+        else:
+            vid2sentence = defaultdict(list)
+            for item in metadata["sentences"]:
+                if item["video_id"] in split_video_ids:
+                    vid2sentence[item["video_id"]].append(item["caption"])
+            self.sentences = list(vid2sentence.items())
+
+        # self.sentences = self.sentences[:50000]
+        self.video_reader = VIDEO_READER_REGISTRY.get(video_reader)
+        # transforms
+        normalize = DictNormalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
+        if split == "train":
+            self.transform = transforms.Compose([
+                DictCenterCrop((self.height, self.width)),
+                DictRandomHorizontalFlip(),
+                normalize
+            ])
+        elif split == "test":
+            self.transform = transforms.Compose([
+                DictCenterCrop((self.height, self.width)),
+                normalize
+            ])
+        else:
+            raise NotImplementedError
+
+        if split == "test":
+            json_ref = {k: [] for k in all_split_video_ids[split]}
+            for sentence in metadata["sentences"]:
+                if sentence["video_id"] in json_ref:
+                    json_ref[sentence["video_id"]].append(sentence["caption"])
+            # verify
+            assert all(len(v) == 20 for _, v in json_ref.items())
+            self.json_ref = {k[len("video"):]: v for k, v in json_ref.items()}
+
+    def __len__(self):
+        return len(self.sentences)
+
+    def _get_video_path(self, video_id):
+        return os.path.join(self.video_root, f"{video_id}.mp4")
+
+    def _get_video(self, video_id):
+        video, video_mask = get_video(video_reader=self.video_reader,
+                                      video_path=self._get_video_path(video_id),
+                                      max_frames=self.max_frames,
+                                      sample="rand" if self.split == "train" else "uniform",
+                                      hevc_config=self.h265_cfg)
+        if self.transform is not None:
+            video = self.transform(video)
+        return video, video_mask
+
+    def __getitem__(self, idx):
+        video_id, sentence_list = self.sentences[idx]
+        sentence = random.choice(sentence_list)
+
+        input_ids = clip.tokenize(sentence, context_length=self.max_words, truncate=True)[0]
+        input_mask = torch.zeros(self.max_words, dtype=torch.long)
+        input_mask[:len(clip._tokenizer.encode(sentence)) + 2] = 1
+
+        video, video_mask = self._get_video(video_id)
+        input_labels = torch.cat((input_ids[1:], torch.IntTensor([0])))
+        return {
+            # video
+            "video": video,
+            "video_mask": video_mask,
+            # text
+            "input_ids": input_ids,
+            "input_labels": input_labels,
+            "input_mask": input_mask,
+            # metadata
+            "metadata": (video_id, sentence)
+        }

CoCap/cocap/data/datasets/compressed_video/dataset_msvd.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/17 16:54
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : dataset_msvd.py
+
+import os
+import random
+from collections import defaultdict
+from typing import Literal
+
+import torch
+from torch.utils import data
+from torchvision import transforms
+
+from cocap.modules.clip import clip
+from cocap.utils.json import load_json
+from .transforms import (DictNormalize, DictCenterCrop, DictRandomHorizontalFlip)
+from .video_readers import VIDEO_READER_REGISTRY
+from .video_text_base import get_video, CVConfig
+
+
+class MSVDCaptioningDataset(data.Dataset):
+    def __init__(
+            self,
+            video_root: str,
+            max_words: int,
+            max_frames: int,
+            unfold_sentences: False,
+            video_size: tuple[int, int],
+            metadata: str,
+            video_reader: str,
+            cv_config: CVConfig,
+            split: Literal["train", "test"],
+    ):
+        self.split = split
+        self.video_root = video_root
+        self.max_words = max_words
+        self.max_frames = max_frames
+        self.unfold_sentences = unfold_sentences  # only affect the train split
+        self.height, self.width = video_size
+        self.sentences = []  # (vid, [sentence, ...])
+        self.h265_cfg = cv_config
+        metadata = load_json(metadata)
+
+        split_video_ids = metadata[split].copy()
+        if self.unfold_sentences:
+            for item in metadata["metadata"]:
+                if item["video_id"] in split_video_ids:
+                    self.sentences.append([item["video_id"], [item["sentence"]]])
+                    if split == "test":
+                        split_video_ids.remove(item["video_id"])
+        else:
+            vid2sentence = defaultdict(list)
+            for item in metadata["metadata"]:
+                if item["video_id"] in split_video_ids:
+                    vid2sentence[item["video_id"]].append(item["sentence"])
+            self.sentences = list(vid2sentence.items())
+
+        # self.sentences = self.sentences[:50000]
+        self.video_reader = VIDEO_READER_REGISTRY.get(video_reader)
+        # transforms
+        normalize = DictNormalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
+        if split == "train":
+            self.transform = transforms.Compose([
+                DictCenterCrop((self.height, self.width)),
+                DictRandomHorizontalFlip(),
+                normalize
+            ])
+        elif split == "test":
+            self.transform = transforms.Compose([
+                DictCenterCrop((self.height, self.width)),
+                normalize
+            ])
+        else:
+            raise NotImplementedError
+
+        if split == "test":
+            json_ref = {k: [] for k in metadata[split]}
+            for sentence in metadata["metadata"]:
+                if sentence["video_id"] in json_ref:
+                    json_ref[sentence["video_id"]].append(sentence["sentence"])
+            self.json_ref = json_ref
+
+    def __len__(self):
+        return len(self.sentences)
+
+    def _get_video(self, video_id):
+        video, video_mask = get_video(video_reader=self.video_reader,
+                                      video_path=os.path.join(self.video_root, f"{video_id}.mp4"),
+                                      max_frames=self.max_frames,
+                                      sample="rand" if self.split == "train" else "uniform",
+                                      hevc_config=self.h265_cfg)
+        if self.transform is not None:
+            video = self.transform(video)
+        return video, video_mask
+
+    def __getitem__(self, idx):
+        video_id, sentence_list = self.sentences[idx]
+        sentence = random.choice(sentence_list)
+
+        input_ids = clip.tokenize(sentence, context_length=self.max_words, truncate=True)[0]
+        input_mask = torch.zeros(self.max_words, dtype=torch.long)
+        input_mask[:len(clip._tokenizer.encode(sentence)) + 2] = 1
+
+        video, video_mask = self._get_video(video_id)
+        input_labels = torch.cat((input_ids[1:], torch.IntTensor([0])))
+        return {
+            # video
+            "video": video,
+            "video_mask": video_mask,
+            # text
+            "input_ids": input_ids,
+            "input_labels": input_labels,
+            "input_mask": input_mask,
+            # metadata
+            "metadata": (video_id, sentence)
+        }

CoCap/cocap/data/datasets/compressed_video/dataset_vatex.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/17 16:54
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : dataset_vatex.py
+
+import json
+import os
+import random
+from collections import defaultdict
+from typing import Literal
+
+import torch
+from torch.utils import data
+from torchvision import transforms
+
+from cocap.modules.clip import clip
+from .transforms import (DictNormalize, DictCenterCrop, DictRandomHorizontalFlip)
+from .video_readers import VIDEO_READER_REGISTRY
+from .video_text_base import get_video, CVConfig
+
+
+def load_json(file_path):
+    with open(file_path, "r") as f:
+        return json.load(f)
+
+
+class VATEXCaptioningDataset(data.Dataset):
+
+    def __init__(
+            self,
+            video_root: str,
+            max_words: int,
+            max_frames: int,
+            unfold_sentences: False,
+            video_size: tuple[int, int],
+            metadata: str,
+            video_reader: str,
+            cv_config: CVConfig,
+            split: Literal["train", "test"],
+    ):
+        self.split = split
+        self.video_root = video_root
+        self.max_words = max_words
+        self.max_frames = max_frames
+        self.unfold_sentences = unfold_sentences  # only affect the train split
+        self.height, self.width = video_size
+        self.sentences = []  # (vid, [sentence, ...])
+        self.h265_cfg = cv_config
+        metadata = load_json(metadata)
+
+        split_video_ids = metadata[split].copy()
+        if self.unfold_sentences:
+            for item in metadata["metadata"]:
+                if item["video_id"] in split_video_ids:
+                    self.sentences.append([item["video_id"], [item["sentence"]]])
+                    if split == "test":
+                        split_video_ids.remove(item["video_id"])
+        else:
+            vid2sentence = defaultdict(list)
+            for item in metadata["metadata"]:
+                if item["video_id"] in split_video_ids:
+                    vid2sentence[item["video_id"]].append(item["sentence"])
+            self.sentences = list(vid2sentence.items())
+
+        # self.sentences = self.sentences[:50000]
+        self.video_reader = VIDEO_READER_REGISTRY.get(video_reader)
+        # transforms
+        normalize = DictNormalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
+        if split == "train":
+            self.transform = transforms.Compose([
+                DictCenterCrop((self.height, self.width)),
+                DictRandomHorizontalFlip(),
+                normalize
+            ])
+        elif split == "test":
+            self.transform = transforms.Compose([
+                DictCenterCrop((self.height, self.width)),
+                normalize
+            ])
+        else:
+            raise NotImplementedError
+
+        if split == "test":
+            json_ref = {k: [] for k in metadata[split]}
+            for sentence in metadata["metadata"]:
+                if sentence["video_id"] in json_ref:
+                    json_ref[sentence["video_id"]].append(sentence["sentence"])
+            self.json_ref = json_ref
+
+    def __len__(self):
+        return len(self.sentences)
+
+    def _get_video_path(self, video_id):
+        return os.path.join(self.video_root, f"{video_id}.mp4")
+
+    def _get_video(self, video_id):
+        video, video_mask = get_video(video_reader=self.video_reader,
+                                      video_path=self._get_video_path(video_id),
+                                      max_frames=self.max_frames,
+                                      sample="rand" if self.split == "train" else "uniform",
+                                      hevc_config=self.h265_cfg)
+        if self.transform is not None:
+            video = self.transform(video)
+        return video, video_mask
+
+    def __getitem__(self, idx):
+        video_id, sentence_list = self.sentences[idx]
+        sentence = random.choice(sentence_list)
+
+        input_ids = clip.tokenize(sentence, context_length=self.max_words, truncate=True)[0]
+        input_mask = torch.zeros(self.max_words, dtype=torch.long)
+        input_mask[:len(clip._tokenizer.encode(sentence)) + 2] = 1
+
+        video, video_mask = self._get_video(video_id)
+        input_labels = torch.cat((input_ids[1:], torch.IntTensor([0])))
+        return {
+            # video
+            "video": video,
+            "video_mask": video_mask,
+            # text
+            "input_ids": input_ids,
+            "input_labels": input_labels,
+            "input_mask": input_mask,
+            # metadata
+            "metadata": (video_id, sentence)
+        }

CoCap/cocap/data/datasets/compressed_video/transforms.py

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/7 14:51
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : transforms.py
+
+from typing import Sequence
+
+import einops
+import torch
+import torchvision.transforms.functional as F
+from torchvision import transforms
+
+__all__ = ["DictRandomResizedCrop", "DictCenterCrop", "DictResize", "DictNormalize"]
+
+"""
+Custom transforms
+"""
+
+IMAGE_KEYS = ["iframe", "residual", "motion_vector"]
+NORMALIZE_KEYS = ["iframe"]
+
+
+# iframe: ..., c, h, w
+# motion vector: n_gop, n_mv, c, h, w
+# residual: n_gop, n_res, c, h, w
+
+
+class DictRandomResizedCrop(transforms.RandomResizedCrop):
+    """apply same random resized crop to the items in dict"""
+
+    def forward(self, img: dict):
+        assert any(k in img for k in IMAGE_KEYS), "input do not contain any valid image"
+        for k in IMAGE_KEYS:
+            if k in img:
+                i, j, h, w = self.get_params(img[k], self.scale, self.ratio)
+                break
+
+        ret = {}
+        for k, v in img.items():
+            if k not in IMAGE_KEYS:
+                ret[k] = v
+                continue
+            if len(v.shape) == 5:  # handle extra dimension for GOP
+                num_gop = v.size(0)
+                num_frame = v.size(1)
+                v = einops.rearrange(v, "num_gop num_frame c h w->(num_gop num_frame) c h w")
+                if k == "motion_vector":
+                    if isinstance(self.size, Sequence) and len(self.size) == 2:
+                        mv_size = (self.size[0] // 4, self.size[1] // 4)
+                    elif isinstance(self.size, int):
+                        mv_size = self.size // 4
+                    else:
+                        raise ValueError("Image size is not supported: {}".format(self.size))
+                    v = torch.stack(
+                        [F.resized_crop(v[..., i, :, :], i // 4, j // 4, h // 4, w // 4, mv_size,
+                                        F.InterpolationMode.NEAREST)
+                         for i in range(v.size(-3))],
+                        dim=-3
+                    )
+                else:
+                    v = F.resized_crop(v, i, j, h, w, self.size, self.interpolation)
+                v = einops.rearrange(v, "(num_gop num_frame) c h w->num_gop num_frame c h w",
+                                     num_gop=num_gop, num_frame=num_frame)
+                ret[k] = v
+            else:
+                ret[k] = F.resized_crop(v, i, j, h, w, self.size, self.interpolation)
+        return ret
+
+
+class DictRandomCrop(transforms.RandomCrop):
+
+    def forward(self, img: dict):
+        assert self.padding is None and not self.pad_if_needed, "Padding is not supported by DictRandoCrop"
+
+        assert any(k in img for k in IMAGE_KEYS), "input do not contain any valid image"
+        for k in IMAGE_KEYS:
+            if k in img:
+                i, j, h, w = self.get_params(img[k], self.size)
+                break
+
+        ret = {}
+        for k, v in img.items():
+            if k not in IMAGE_KEYS:
+                ret[k] = v
+                continue
+            if len(v.shape) == 5:  # handle extra dimension for GOP
+                num_gop = v.size(0)
+                num_frame = v.size(1)
+                v = einops.rearrange(v, "num_gop num_frame c h w->(num_gop num_frame) c h w")
+                if k == "motion_vector":
+                    v = torch.stack(
+                        [F.crop(v[..., i, :, :], i // 4, j // 4, h // 4, w // 4) for i in range(v.size(-3))],
+                        dim=-3
+                    )
+                else:
+                    v = F.crop(v, i, j, h, w)
+                v = einops.rearrange(v, "(num_gop num_frame) c h w->num_gop num_frame c h w",
+                                     num_gop=num_gop, num_frame=num_frame)
+                ret[k] = v
+            else:
+                ret[k] = F.crop(v, i, j, h, w)
+        return ret
+
+
+class DictCenterCrop(transforms.CenterCrop):
+    def forward(self, img: dict):
+        ret = {}
+        for k, v in img.items():
+            if k not in IMAGE_KEYS:
+                ret[k] = v
+                continue
+            if len(v.shape) == 5:  # handle extra dimension for GOP
+                num_gop = v.size(0)
+                num_frame = v.size(1)
+                v = einops.rearrange(v, "num_gop num_frame c h w->(num_gop num_frame) c h w")
+                if k == "motion_vector":
+                    if isinstance(self.size, Sequence) and len(self.size) == 2:
+                        mv_size = (self.size[0] // 4, self.size[1] // 4)
+                    elif isinstance(self.size, int):
+                        mv_size = self.size // 4
+                    else:
+                        raise ValueError("Image size is not supported: {}".format(self.size))
+                    v = torch.stack(
+                        [F.center_crop(v[..., i, :, :], mv_size)
+                         for i in range(v.size(-3))],
+                        dim=-3
+                    )
+                else:
+                    v = F.center_crop(v, self.size)
+                v = einops.rearrange(v, "(num_gop num_frame) c h w->num_gop num_frame c h w",
+                                     num_gop=num_gop, num_frame=num_frame)
+                ret[k] = v
+            else:
+                ret[k] = F.center_crop(v, self.size)
+        return ret
+
+
+class DictResize(transforms.Resize):
+
+    def forward(self, img: dict):
+        ret = {}
+        for k, v in img.items():
+            if k not in IMAGE_KEYS:
+                ret[k] = v
+                continue
+            if len(v.shape) == 5:  # handle extra dimension for GOP
+                num_gop = v.size(0)
+                num_frame = v.size(1)
+                v = einops.rearrange(v, "num_gop num_frame c h w->(num_gop num_frame) c h w")
+                if k == "motion_vector":
+                    if isinstance(self.size, Sequence) and len(self.size) == 2:
+                        mv_size = (self.size[0] // 4, self.size[1] // 4)
+                    elif isinstance(self.size, int):
+                        mv_size = self.size // 4
+                    else:
+                        raise ValueError("Image size is not supported: {}".format(self.size))
+                    v = torch.stack(
+                        [F.resize(v[..., i, :, :], mv_size, F.InterpolationMode.NEAREST, self.max_size, self.antialias)
+                         for i in range(v.size(-3))],
+                        dim=-3
+                    )
+                else:
+                    v = F.resize(v, self.size, self.interpolation, self.max_size, self.antialias)
+                v = einops.rearrange(v, "(num_gop num_frame) c h w->num_gop num_frame c h w",
+                                     num_gop=num_gop, num_frame=num_frame)
+                ret[k] = v
+            else:
+                ret[k] = F.resize(v, self.size, self.interpolation, self.max_size, self.antialias)
+        return ret
+
+
+class DictNormalize(transforms.Normalize):
+    def forward(self, data: dict):
+        return {k: F.normalize(v, self.mean, self.std, self.inplace) if k in NORMALIZE_KEYS else v
+                for k, v in data.items()}
+
+
+class DictRandomHorizontalFlip(transforms.RandomHorizontalFlip):
+    def forward(self, img: dict):
+        if torch.rand(1) < self.p:
+            return {k: F.hflip(v) if k in IMAGE_KEYS else v for k, v in img.items()}
+        else:
+            return img

CoCap/cocap/data/datasets/compressed_video/video_readers.py

@@ -0,0 +1,347 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/8/10 14:56
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : video_readers.py
+
+# based on https://github.com/m-bain/frozen-in-time/blob/main/base/base_dataset.py
+
+
+import logging
+import pickle
+import random
+import subprocess
+import traceback
+from typing import Dict
+
+import cv_reader
+import decord
+import lz4.frame
+import numpy as np
+import torch
+import torch.nn.functional
+from fvcore.common.registry import Registry
+
+from cocap.utils.profile import Timer
+from .compressed_video_utils import deserialize
+
+logger = logging.getLogger(__name__)
+
+VIDEO_READER_REGISTRY = Registry("VIDEO_READER")
+
+
+def sample_frames(num_frames, vlen, sample='rand', fix_start=None):
+    # acc_samples = min(num_frames, vlen)
+    intervals = np.linspace(start=0, stop=vlen, num=num_frames + 1).astype(int)
+    ranges = []
+    for idx, interv in enumerate(intervals[:-1]):
+        ranges.append((interv, intervals[idx + 1]))
+    if sample == 'rand':
+        frame_idxs = [random.choice(range(x[0], x[1])) if x[0] != x[1] else x[0] for x in ranges]
+    elif fix_start is not None:
+        frame_idxs = [x[0] + fix_start for x in ranges]
+    elif sample == 'uniform':
+        frame_idxs = [(x[0] + x[1]) // 2 for x in ranges]
+    else:
+        raise NotImplementedError
+
+    return frame_idxs
+
+
+@VIDEO_READER_REGISTRY.register()
+def read_frames_cv2(video_path, num_frames, sample='rand', fix_start=None):
+    import cv2
+
+    cap = cv2.VideoCapture(video_path)
+    assert (cap.isOpened())
+    vlen = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    # get indexes of sampled frames
+    frame_idxs = sample_frames(num_frames, vlen, sample=sample, fix_start=fix_start)
+    frames = []
+    success_idxs = []
+    for index in frame_idxs:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, index - 1)
+        ret, frame = cap.read()
+        if ret:
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frame = torch.from_numpy(frame)
+            # (H x W x C) to (C x H x W)
+            frame = frame.permute(2, 0, 1)
+            frames.append(frame)
+            success_idxs.append(index)
+        else:
+            pass
+            # print(frame_idxs, ' fail ', index, f'  (vlen {vlen})')
+
+    frames = torch.stack(frames).float() / 255
+    cap.release()
+    return frames, success_idxs
+
+
+@VIDEO_READER_REGISTRY.register()
+def read_frames_av(video_path, num_frames, sample='rand', fix_start=None):
+    import av
+
+    reader = av.open(video_path)
+    try:
+        frames = []
+        frames = [torch.from_numpy(f.to_rgb().to_ndarray()) for f in reader.decode(video=0)]
+    except (RuntimeError, ZeroDivisionError) as exception:
+        print('{}: WEBM reader cannot open {}. Empty '
+              'list returned.'.format(type(exception).__name__, video_path))
+    vlen = len(frames)
+    frame_idxs = sample_frames(num_frames, vlen, sample=sample, fix_start=fix_start)
+    frames = torch.stack([frames[idx] for idx in frame_idxs]).float() / 255
+    frames = frames.permute(0, 3, 1, 2)
+    return frames, frame_idxs
+
+
+@VIDEO_READER_REGISTRY.register()
+def read_frames_decord(video_path, num_frames, sample='rand', fix_start=None):
+    import decord
+    decord.bridge.set_bridge("torch")
+
+    video_reader = decord.VideoReader(video_path, num_threads=1)
+    vlen = len(video_reader)
+    frame_idxs = sample_frames(num_frames, vlen, sample=sample, fix_start=fix_start)
+    frames = video_reader.get_batch(frame_idxs)
+    frames = frames.float() / 255
+    frames = frames.permute(0, 3, 1, 2)
+    return frames, frame_idxs
+
+
+def get_video_size(video_path):
+    import cv2
+
+    vcap = cv2.VideoCapture(video_path)  # 0=camera
+    if vcap.isOpened():
+        width = vcap.get(cv2.CAP_PROP_FRAME_WIDTH)  # float `width`
+        height = vcap.get(cv2.CAP_PROP_FRAME_HEIGHT)  # float `height`
+        return int(width), int(height)
+    else:
+        raise RuntimeError(f"VideoCapture cannot open video file: {video_path}")
+
+
+def get_frame_type(video_path):
+    command = '/usr/bin/ffprobe -v error -show_entries frame=pict_type -of default=noprint_wrappers=1'.split()
+    out = subprocess.check_output(command + [video_path]).decode()
+    frame_types = out.replace('pict_type=', '').split()
+    return frame_types
+
+
+def pad_tensor(tensor: torch.Tensor, target_size: int, dim: int, pad_value=0):
+    pad_shape = list(tensor.shape)
+    pad_shape[dim] = target_size - pad_shape[dim]
+    return torch.concat([tensor, torch.full(pad_shape, device=tensor.device, dtype=tensor.dtype, fill_value=pad_value)],
+                        dim=dim)
+
+
+@VIDEO_READER_REGISTRY.register()
+def read_frames_compressed_domain(
+        video_path: str,
+        resample_num_gop: int, resample_num_mv: int, resample_num_res: int,
+        with_residual: bool = False, with_bp_rgb: bool = False, pre_extract: bool = False,
+        sample: str = "rand"
+) -> Dict[str, np.ndarray]:
+    """
+    This function process the output of `cv_reader` to obtain the inputs for training
+    :param video_path: path to the video
+    :param resample_num_gop: number of GOP sampled from the video
+    :param resample_num_mv: number of motion vectors sampled from each GOP
+    :param resample_num_res: number of residuals sampled from each GOP
+    :param with_residual: whether to return residual
+    :param with_bp_rgb: also return the decoded RGB frames of the video
+    :param pre_extract: use pre-extracted data
+    :param sample: sample method
+    :return:
+    """
+    decord.bridge.set_bridge("torch")
+    assert sample in {"rand", "uniform", "pad"}
+    try:
+        timer = Timer()
+        reader = decord.VideoReader(video_path, num_threads=1)
+        timer("check_video_length")
+        # load data from video file/pre-extracted feature
+        if not pre_extract:
+            reader_ret = cv_reader.read_video(video_path)
+            timer("cv_reader")
+        else:
+            data = {}
+            read_type = ["pict_type", "rgb_gop"]
+            if with_residual:
+                read_type += ["residual"]
+            if with_bp_rgb:
+                read_type += ["rgb_full"]
+            else:
+                read_type += ["motion_vector"]
+            for t in read_type:
+                if t in ['motion_vector', 'rgb_full', 'residual']:
+                    with lz4.frame.open(f"{video_path}.{t}", "rb") as f:
+                        data.update(pickle.load(f))
+                else:
+                    with open(f"{video_path}.{t}", "rb") as f:
+                        data.update(pickle.load(f))
+            timer("read")
+            data = deserialize(data)
+            timer("deserialize")
+            reader_ret = [{} for _ in range(len(data["pict_type"]))]
+            for k, v_list in data.items():
+                k = "rgb" if k == "rgb_full" else k  # replace rgb_full with rgb
+                if k == "rgb_gop":
+                    idx_iframe = 0
+                    for i, t in enumerate(data["pict_type"]):
+                        if t == "I":
+                            reader_ret[i]["rgb"] = v_list[idx_iframe]
+                            idx_iframe += 1
+                    assert idx_iframe == len(v_list)
+                else:
+                    for i, v in enumerate(v_list):
+                        reader_ret[i][k] = v
+            timer("format")
+        full_frame_gop = []
+        for f in reader_ret:
+            if f["pict_type"] == "I":
+                full_frame_gop.append([f, ])
+            else:
+                full_frame_gop[-1].append(f)
+        full_frame_gop = [g for g in full_frame_gop if len(g) > 2]  # remove gop which do not contain any B/P-frame
+        # sample B/P-frame for each gop
+        i_frame_gop = []
+        mv_frame_gop = []
+        res_frame_gop = []
+        for gop_idx in range(len(full_frame_gop)):
+            i_frame_gop.append(full_frame_gop[gop_idx][0])
+            if sample == "pad":
+                mv_frame_gop.append(full_frame_gop[gop_idx][1: 1 + resample_num_mv])
+                # I-frame is not included in residual, although I-frame also contains valid residual
+                res_frame_gop.append(full_frame_gop[gop_idx][1:1 + resample_num_res])
+            else:
+                idxs = sample_frames(num_frames=resample_num_mv, vlen=len(full_frame_gop[gop_idx]) - 1, sample="rand")
+                mv_frame_gop.append([full_frame_gop[gop_idx][i + 1] for i in idxs])
+                idxs = sample_frames(num_frames=resample_num_res, vlen=len(full_frame_gop[gop_idx]) - 1, sample="rand")
+                res_frame_gop.append([full_frame_gop[gop_idx][1 + i] for i in idxs])
+        # sample gop
+        if sample == "pad":
+            i_frame_gop = i_frame_gop[:resample_num_gop]
+            mv_frame_gop = mv_frame_gop[:resample_num_gop]
+            res_frame_gop = res_frame_gop[:resample_num_gop]
+        else:
+            idxs = sample_frames(num_frames=resample_num_gop, vlen=len(mv_frame_gop), sample=sample)
+            i_frame_gop = [i_frame_gop[i] for i in idxs]
+            mv_frame_gop = [mv_frame_gop[i] for i in idxs]
+            res_frame_gop = [res_frame_gop[i] for i in idxs]
+        timer("sample")
+        # stack iframe
+        if with_bp_rgb or pre_extract:
+            iframe = [cur_gop["rgb"] for cur_gop in i_frame_gop]
+            iframe = torch.stack([torch.from_numpy(f) for f in iframe]).permute(0, 3, 1, 2) / 255
+        else:
+            iframe_idx = [cur_gop["frame_idx"] for cur_gop in i_frame_gop]
+            iframe = reader.get_batch(iframe_idx).permute(0, 3, 1, 2) / 255
+        input_mask_gop = torch.tensor([0] * iframe.size(0) + [1] * (resample_num_gop - iframe.size(0)),
+                                      dtype=torch.bool)
+        if sample == "pad" and iframe.size(0) < resample_num_gop:
+            iframe = pad_tensor(iframe, target_size=resample_num_gop, dim=0)
+        assert iframe.size(0) == resample_num_gop
+        timer("stack_iframe")
+        # encode motion
+        assert mv_frame_gop[0][0]["motion_vector"].shape[-1] == 4, \
+            "format is avc, but motion vector has {} !=4 dims".format(mv_frame_gop[0][0]["motion_vector"].shape[-1])
+        # h264 motion vector
+        for g in mv_frame_gop:
+            for f in g:
+                if "encoded" in f and f["encoded"]:
+                    continue
+                else:
+                    f["motion_vector"] = torch.from_numpy(
+                        f["motion_vector"].transpose((2, 0, 1)).astype(np.float32)
+                    )
+                    f["encoded"] = True
+        timer("encode_motion")
+        # stack mv
+        motion_vector = []
+        type_ids_mv = []
+        input_mask_mv = []
+        for gop_idx in range(len(mv_frame_gop)):
+            gop_mv = torch.stack([f["motion_vector"] for f in mv_frame_gop[gop_idx]])
+            input_mask_mv.append(torch.tensor([0] * gop_mv.size(0) + [1] * (resample_num_mv - gop_mv.size(0)),
+                                              dtype=torch.bool))
+            type_ids_mv.append(torch.tensor([0 if f["pict_type"] == "P" else 1 for f in mv_frame_gop[gop_idx]] +
+                                            [2] * (resample_num_mv - gop_mv.size(0)), dtype=torch.long))
+            if sample == "pad" and gop_mv.size(0) < resample_num_mv:  # pad for mv in each gop
+                gop_mv = pad_tensor(gop_mv, target_size=resample_num_mv, dim=0)
+            assert gop_mv.size(0) == resample_num_mv
+            motion_vector.append(gop_mv)
+        motion_vector = torch.stack(motion_vector)
+        type_ids_mv = torch.stack(type_ids_mv)
+        input_mask_mv = torch.stack(input_mask_mv)
+        # pad for gop
+        if sample == "pad" and motion_vector.size(0) < resample_num_gop:  # pad for gop number
+            motion_vector = pad_tensor(motion_vector, target_size=resample_num_gop, dim=0)
+            type_ids_mv = pad_tensor(type_ids_mv, target_size=resample_num_gop, dim=0, pad_value=2)
+            input_mask_mv = pad_tensor(input_mask_mv, target_size=resample_num_gop, dim=0, pad_value=1)
+        assert motion_vector.size(0) == resample_num_gop, \
+            "motion vector gop number is not correct, got {}, expect {}".format(motion_vector.size(0), resample_num_gop)
+        assert motion_vector.size(1) == resample_num_mv, \
+            "motion vector mv number is not correct, got {}, expect {}".format(motion_vector.size(1), resample_num_mv)
+        timer("stack_motion")
+        ret = {"iframe": iframe, "motion_vector": motion_vector,
+               "input_mask_gop": input_mask_gop, "input_mask_mv": input_mask_mv, "type_ids_mv": type_ids_mv}
+        if with_residual:
+            residual = []
+            input_mask_res = []
+            for gop_idx in range(len(mv_frame_gop)):
+                gop_res = torch.stack(
+                    [torch.from_numpy(f["residual"].transpose(2, 0, 1)) for f in res_frame_gop[gop_idx]]
+                )
+                input_mask_res.append(torch.tensor([0] * gop_res.size(0) + [1] * (resample_num_res - gop_res.size(0)),
+                                                   dtype=torch.bool))
+                if sample == "pad" and gop_res.size(0) < resample_num_res:
+                    gop_res = pad_tensor(gop_res, target_size=resample_num_res, dim=0)
+                residual.append(gop_res)
+            residual = torch.stack(residual)
+            input_mask_res = torch.stack(input_mask_res)
+            if sample == "pad" and residual.size(0) < resample_num_gop:  # pad for gop number
+                residual = pad_tensor(residual, target_size=resample_num_gop, dim=0, pad_value=128)
+                input_mask_res = pad_tensor(input_mask_res, target_size=resample_num_gop, dim=0, pad_value=1)
+            ret["residual"] = residual
+            ret["input_mask_res"] = input_mask_res
+            timer("stack_residual")
+        if with_bp_rgb:
+            # stack B/P-frame RGB
+            bp_rgb = torch.stack(
+                [torch.stack([torch.from_numpy(f["rgb"]).permute(2, 0, 1) for f in g])
+                 for g in mv_frame_gop]) / 255
+            ret["bp_rgb"] = bp_rgb
+            timer("stack_bp_rgb")
+        logger.debug(timer.get_info(averaged=False))  # debug output about speed
+        return ret, True
+    except Exception:  # TODO: too broad exception
+        print(f"video load error: {video_path}")
+        traceback.print_exc()
+        traceback.print_exc(file=open("video_reader_error.log", "a"))
+        # create a dummy return data
+        ret = {
+            "iframe": torch.zeros((resample_num_gop, 3, 224, 224), dtype=torch.float),
+            "motion_vector": torch.zeros((resample_num_gop, resample_num_mv, 4, 56, 56), dtype=torch.float),
+            "input_mask_gop": torch.ones((resample_num_gop,), dtype=torch.bool),
+            "input_mask_mv": torch.ones((resample_num_gop, resample_num_mv), dtype=torch.bool),
+            "input_mask_res": torch.ones((resample_num_gop, resample_num_mv), dtype=torch.bool),
+            "type_ids_mv": torch.zeros((resample_num_gop, resample_num_mv), dtype=torch.long)
+        }
+        if with_residual:
+            ret["residual"] = torch.zeros((resample_num_gop, resample_num_res, 3, 224, 224), dtype=torch.uint8)
+        if with_bp_rgb:
+            ret["bp_rgb"] = torch.zeros((resample_num_gop, resample_num_mv, 3, 224, 224), dtype=torch.float)
+        return ret, False
+
+
+def get_video_len(video_path):
+    import cv2
+
+    cap = cv2.VideoCapture(video_path)
+    if not (cap.isOpened()):
+        return False
+    vlen = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    cap.release()
+    return vlen

CoCap/cocap/data/datasets/compressed_video/video_text_base.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/12/3 14:54
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : video_text_base.py
+import logging
+import os.path
+import random
+from dataclasses import dataclass
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+
+def get_tokenized_words(sentence: str, tokenizer, max_words):
+    words = tokenizer.tokenize(sentence)
+    words = ["[CLS]"] + words
+    total_length_with_cls = max_words - 1
+    if len(words) > total_length_with_cls:
+        words = words[:total_length_with_cls]
+    words = words + ["[SEP]"]
+    return words
+
+
+def get_text_inputs(sentence: str, tokenizer, max_words):
+    """
+    1. tokenize
+    2. add [CLS] and [SEP] token, limit the length
+    3. create mask and token type
+    4. pad to max_words
+    :param sentence:
+    :param tokenizer:
+    :param max_words:
+    :return: 1 dim tensor, shape is (max_words,)
+    """
+    words = get_tokenized_words(sentence, tokenizer, max_words)
+    input_ids = tokenizer.convert_tokens_to_ids(words)
+    input_mask = [1] * len(input_ids)  # 1 is keep, 0 is mask out
+    segment_ids = [0] * len(input_ids)
+    while len(input_ids) < max_words:
+        input_ids.append(0)
+        input_mask.append(0)
+        segment_ids.append(0)
+    assert len(input_ids) == len(input_mask) == len(segment_ids) == max_words
+    return torch.tensor(input_ids), torch.tensor(input_mask), torch.tensor(segment_ids)
+
+
+def get_text_inputs_with_mlm(sentence: str, tokenizer, max_words):
+    """
+    Add mlm inputs and labels based on `get_text_inputs`
+    :param sentence:
+    :param tokenizer:
+    :param max_words:
+    :return: 1 dim tensor, shape is (max_words,)
+    """
+    input_ids, input_mask, segment_ids = get_text_inputs(sentence, tokenizer, max_words)
+
+    # Mask Language Model <-----
+    token_labels = []
+    masked_tokens = get_tokenized_words(sentence, tokenizer, max_words)
+    for token_id, token in enumerate(masked_tokens):
+        if token_id == 0 or token_id == len(masked_tokens) - 1:
+            token_labels.append(-1)
+            continue
+        prob = random.random()
+        # mask token with 15% probability
+        if prob < 0.15:
+            prob /= 0.15
+            # 80% randomly change token to mask token
+            if prob < 0.8:
+                masked_tokens[token_id] = "[MASK]"
+            # 10% randomly change token to random token
+            elif prob < 0.9:
+                masked_tokens[token_id] = random.choice(list(tokenizer.vocab.items()))[0]
+            # -> rest 10% randomly keep current token
+            # append current token to output (we will predict these later)
+            try:
+                token_labels.append(tokenizer.vocab[token])
+            except KeyError:
+                # For unknown words (should not occur with BPE vocab)
+                token_labels.append(tokenizer.vocab["[UNK]"])
+                logger.debug("Cannot find token '{}' in vocab. Using [UNK] instead".format(token))
+        else:
+            # no masking token (will be ignored by loss function later)
+            token_labels.append(-1)
+    # -----> Mask Language Model
+    masked_token_ids = tokenizer.convert_tokens_to_ids(masked_tokens)
+
+    while len(masked_token_ids) < max_words:
+        masked_token_ids.append(0)
+        token_labels.append(-1)
+    assert len(masked_token_ids) == len(token_labels) == max_words
+    return input_ids, input_mask, segment_ids, torch.tensor(masked_token_ids), torch.tensor(token_labels)
+
+
+@dataclass
+class CVConfig:
+    num_gop: int
+    num_mv: int
+    num_res: int
+    with_residual: bool
+    use_pre_extract: bool
+    sample: str
+
+
+def get_video(video_reader, video_path, max_frames, sample, hevc_config: None | CVConfig = None):
+    assert os.path.exists(video_path), f"Video file not found: {video_path}"
+    video_mask = torch.ones((max_frames,), dtype=torch.int)
+    if video_reader.__name__ in ["read_frames_compressed_domain"]:
+        assert hevc_config is not None, "hevc_config should be set when using read_frames_compressed_domain"
+        video, _ = video_reader(video_path,
+                                resample_num_gop=hevc_config.num_gop, resample_num_mv=hevc_config.num_mv,
+                                resample_num_res=hevc_config.num_res,
+                                with_residual=hevc_config.with_residual,
+                                pre_extract=hevc_config.use_pre_extract,
+                                sample=hevc_config.sample if hevc_config.sample == "pad" else sample)
+    else:
+        video, _ = video_reader(video_path, max_frames, sample)
+    return video, video_mask

CoCap/cocap/modeling/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/11 16:24
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : __init__.py

CoCap/cocap/modeling/av_captioner.py

@@ -0,0 +1,219 @@
+import torch
+import torch.nn as nn
+from cocap.modules.clip.model import ModifiedResNet
+from cocap.modules.audio_encoder import CNN14, BEATsAudioEncoder
+
+class AVCaptioner(nn.Module):
+    def __init__(
+        self,
+        embed_dim=1024, 
+        vision_layers=[3, 4, 6, 3], 
+        vision_width=64,
+        vision_heads=32, 
+        audio_pretrained=False,
+        vocab_size=49408, 
+        max_len=77,
+        num_decoder_layers=6,
+        num_heads=8,
+        dim_feedforward=2048,
+        dropout=0.1,
+        clip_path=None,
+        audio_path=None,
+        audio_enc_type="beats" # "cnn14" or "beats"
+    ):
+        super().__init__()
+        
+        # Visual Encoder
+        self.visual_encoder = ModifiedResNet(
+            layers=vision_layers,
+            output_dim=1024, 
+            heads=vision_heads,
+            input_resolution=224,
+            width=vision_width
+        )
+        
+        embed_dim = 1024 
+        
+        # Audio Encoder
+        if audio_enc_type == "beats":
+            self.audio_encoder = BEATsAudioEncoder(model_path=audio_path)
+            # BEATs Base outputs 768. Large 1024.
+            # Assuming Base (768) for "iter3+ as2m" standard checkpoint.
+            audio_dim = 768 
+            # If large, use 1024. Check config? 
+            # We can check self.audio_encoder.cfg.encoder_embed_dim
+            if hasattr(self.audio_encoder, 'cfg'):
+                audio_dim = self.audio_encoder.cfg.encoder_embed_dim
+                
+        else:
+            self.audio_encoder = CNN14() 
+            audio_dim = 2048
+            if audio_path:
+                self.audio_encoder.load_from_pretrain(audio_path)
+            
+        self.audio_proj = nn.Linear(audio_dim, embed_dim)
+        
+        # Decoder
+        decoder_layer = nn.TransformerDecoderLayer(
+            d_model=embed_dim,
+            nhead=num_heads,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout,
+            batch_first=True
+        )
+        self.decoder = nn.TransformerDecoder(decoder_layer, num_layers=num_decoder_layers)
+        
+        # Embeddings
+        self.token_embedding = nn.Embedding(vocab_size, embed_dim)
+        self.positional_embedding = nn.Parameter(torch.randn(max_len, embed_dim))
+        
+        self.vocab_size = vocab_size
+        self.max_len = max_len
+        self.head = nn.Linear(embed_dim, vocab_size, bias=False)
+        
+        # Share weights
+        self.head.weight = self.token_embedding.weight
+        
+        if clip_path:
+            self.load_visual_weights(clip_path)
+
+    def load_visual_weights(self, path):
+        import os
+        if not os.path.exists(path):
+            print(f"CLIP model not found at {path}")
+            return
+            
+        print(f"Loading CLIP from {path}")
+        jit_model = torch.jit.load(path, map_location="cpu")
+        state_dict = jit_model.state_dict()
+        
+        visual_sd = {}
+        for k, v in state_dict.items():
+            if k.startswith("visual."):
+                new_key = k[7:] # remove "visual."
+                visual_sd[new_key] = v
+        
+        msg = self.visual_encoder.load_state_dict(visual_sd, strict=False)
+        print(f"Visual Encoder Loaded: {msg}")
+
+    def forward(self, images, audios, captions, caption_mask=None):
+        """
+        images: (B, 3, H, W)
+        audios: (B, T_audio, F_mel) or (B, 1, T, F)
+        captions: (B, L_cap) indices
+        caption_mask: (B, L_cap) boolean or 0/1 mask. True/1 means valid.
+        """
+        
+        # 1. Encode Images
+        # ModifiedResNet returns (B, embed_dim) ?? 
+        # Wait, let's check ModifiedResNet output. 
+        # It calls attnpool which returns (B, embed_dim).
+        # We usually want a sequence for cross-attention, or at least we want the spatial features.
+        # But the prompt says "Visual Encoder: Use the ModifiedResNet ... AttentionPool2d"
+        # AttentionPool2d reduces spatial dim to 1 vector in standard CLIP.
+        # If we want detailed attention, we might want to skip the final pooling or unsqueeze it.
+        # Let's assume we use the global visual feature for now as typically done in simple captioners,
+        # OR we can modify it to return spatial features.
+        # For "High performance", spatial features are better. 
+        # The attnpool in existing code:
+        # x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
+        # x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
+        # x, _ = F.multi_head_attention_forward(...) -> returns x.squeeze(0) which is (B, D).
+        # So it returns a single vector.
+        # Let's stick to using this single vector 'v' plus audio vector 'a'. 
+        # Or expand them.
+        
+        v_features = self.visual_encoder(images) # (B, D)
+        v_features = v_features.unsqueeze(1) # (B, 1, D)
+        
+        # 2. Encode Audio
+        a_features = self.audio_encoder(audios) # (B, 2048)
+        a_features = self.audio_proj(a_features) # (B, D)
+        a_features = a_features.unsqueeze(1) # (B, 1, D)
+        
+        # 3. Concatenate
+        memory = torch.cat([v_features, a_features], dim=1) # (B, 2, D)
+        
+        # 4. Decode
+        # captions: (B, L)
+        # Shift captions for teacher forcing
+        # targets usually: captions[:, 1:]
+        # inputs: captions[:, :-1]
+        
+        tgt_seq = captions
+        tgt_emb = self.token_embedding(tgt_seq) # (B, L, D)
+        
+        # Add position embeddings
+        seq_len = tgt_seq.size(1)
+        positions = torch.arange(0, seq_len, device=tgt_seq.device).unsqueeze(0)
+        tgt_emb = tgt_emb + self.positional_embedding[positions]
+        
+        # Causal Mask
+        tgt_mask = self.generate_square_subsequent_mask(seq_len).to(tgt_seq.device)
+        
+        # Padding Mask (for key_padding_mask)
+        # caption_mask is 1 for valid, 0 for pad.
+        # nn.Transformer expects True for PAD (to ignore).
+        # If caption_mask is provided as 1=valid, 0=pad, we invert it.
+        key_padding_mask = None
+        if caption_mask is not None:
+             key_padding_mask = (caption_mask == 0)
+
+        output = self.decoder(
+            tgt=tgt_emb,
+            memory=memory,
+            tgt_mask=tgt_mask,
+            tgt_key_padding_mask=key_padding_mask
+        )
+        
+        logits = self.head(output)
+        return logits
+
+    @torch.no_grad()
+    def generate(self, images, audios, max_len=20, start_token=49406, end_token=49407):
+        """
+        Greedy decoding.
+        """
+        B = images.size(0)
+        
+        # Encode
+        v_features = self.visual_encoder(images).unsqueeze(1) # (B, 1, D)
+        a_features = self.audio_proj(self.audio_encoder(audios)).unsqueeze(1) # (B, 1, D)
+        memory = torch.cat([v_features, a_features], dim=1)
+        
+        # Decode
+        # Start token
+        tgt = torch.full((B, 1), start_token, dtype=torch.long, device=images.device)
+        
+        finished = torch.zeros(B, dtype=torch.bool, device=images.device)
+        
+        for i in range(max_len):
+            tgt_emb = self.token_embedding(tgt)
+            # Positional
+            seq_len = tgt.size(1)
+            positions = torch.arange(0, seq_len, device=images.device).unsqueeze(0)
+            tgt_emb = tgt_emb + self.positional_embedding[positions]
+            
+            # Mask ? Not needed for inference if we pass all past tokens, 
+            # transformer decoder is autoregressive but usually we pass full sequence so far 
+            # and it outputs all steps. Use the last one.
+            # Efficient implementation uses cache, but here we just re-forward.
+            
+            tgt_mask = self.generate_square_subsequent_mask(seq_len).to(images.device)
+            
+            output = self.decoder(tgt_emb, memory, tgt_mask=tgt_mask)
+            logits = self.head(output[:, -1, :]) # Take last step
+            
+            next_token = logits.argmax(dim=-1, keepdim=True) # (B, 1)
+            
+            tgt = torch.cat([tgt, next_token], dim=1)
+            
+            # Check for end token
+            finished |= (next_token.squeeze(-1) == end_token)
+            if finished.all():
+                break
+                
+        return tgt
+        mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)
+        mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))
+        return mask

CoCap/cocap/modeling/eval_captioning.py

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+# @Time    : 6/17/25
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : eval_captioning.py
+import logging
+
+from pycocoevalcap.bleu.bleu import Bleu
+from pycocoevalcap.cider.cider import Cider
+from pycocoevalcap.meteor.meteor import Meteor
+from pycocoevalcap.rouge.rouge import Rouge
+from pycocoevalcap.spice.spice import Spice
+from pycocoevalcap.tokenizer.ptbtokenizer import PTBTokenizer
+
+logger = logging.getLogger(__name__)
+
+
+class EvalCap:
+    def __init__(self, annos, rests, cls_tokenizer=PTBTokenizer,
+                 use_scorers=('Bleu', 'METEOR', 'ROUGE_L', 'CIDEr')):
+        self.evalImgs = []
+        self.eval = {}
+        self.imgToEval = {}
+        self.annos = annos
+        self.rests = rests
+        self.Tokenizer = cls_tokenizer
+        self.use_scorers = use_scorers
+
+    def evaluate(self):
+        res = {}
+        for r in self.rests:
+            res[str(r['image_id'])] = [{'caption': r['caption']}]
+
+        gts = {}
+        for imgId in self.annos:
+            gts[str(imgId)] = [{'caption': c} for c in self.annos[imgId]]
+
+        # =================================================
+        # Set up scorers
+        # =================================================
+        # print('tokenization...')
+        tokenizer = self.Tokenizer()
+        gts = tokenizer.tokenize(gts)
+        res = tokenizer.tokenize(res)
+        # =================================================
+        # Set up scorers
+        # =================================================
+        # print('setting up scorers...')
+        use_scorers = self.use_scorers
+        scorers = []
+        if 'Bleu' in use_scorers:
+            scorers.append((Bleu(4), ["Bleu_1", "Bleu_2", "Bleu_3", "Bleu_4"]))
+        if 'METEOR' in use_scorers:
+            scorers.append((Meteor(), "METEOR"))
+        if 'ROUGE_L' in use_scorers:
+            scorers.append((Rouge(), "ROUGE_L"))
+        if 'CIDEr' in use_scorers:
+            scorers.append((Cider(), "CIDEr"))
+        if 'SPICE' in use_scorers:
+            scorers.append((Spice(), "SPICE"))
+
+        # =================================================
+        # Compute scores
+        # =================================================
+        for scorer, method in scorers:
+            score, scores = scorer.compute_score(gts, res)
+            if type(method) == list:
+                for sc, scs, m in zip(score, scores, method):
+                    self.setEval(sc, m)
+                    self.setImgToEvalImgs(scs, gts.keys(), m)
+            else:
+                self.setEval(score, method)
+                self.setImgToEvalImgs(scores, gts.keys(), method)
+        self.setEvalImgs()
+
+    def setEval(self, score, method):
+        self.eval[method] = score
+
+    def setImgToEvalImgs(self, scores, imgIds, method):
+        for imgId, score in zip(imgIds, scores):
+            if not imgId in self.imgToEval:
+                self.imgToEval[imgId] = {}
+                self.imgToEval[imgId]["image_id"] = imgId
+            self.imgToEval[imgId][method] = score
+
+    def setEvalImgs(self):
+        self.evalImgs = [eval for imgId, eval in self.imgToEval.items()]
+
+
+def evaluate(submission, reference):
+    tokenizer = PTBTokenizer  # for English
+    annos = reference
+    data = submission['results']
+    rests = []
+    for name, value in data.items():
+        rests.append({'image_id': str(name), 'caption': value[0]['sentence']})
+    eval_cap = EvalCap(annos, rests, tokenizer)
+
+    eval_cap.evaluate()
+
+    all_score = {}
+    for metric, score in eval_cap.eval.items():
+        all_score[metric] = score
+    return all_score

CoCap/cocap/modeling/lm_cocap.py

@@ -0,0 +1,242 @@
+# -*- coding: utf-8 -*-
+# @Time    : 6/16/25
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : cocap.py
+import copy
+import logging
+import os
+from collections import defaultdict
+
+import pytorch_lightning as pl
+import torch
+import torch.distributed as dist
+import torch.nn as nn
+from hydra_zen import builds
+from pytorch_lightning.utilities.types import OptimizerLRScheduler
+from torch.optim.lr_scheduler import LambdaLR
+
+from cocap.modules.bert import BertLayerNorm
+from cocap.modules.compressed_video import CompressedVideoCaptioner, compressed_video_captioner_pretrained_cfg
+from .eval_captioning import evaluate
+from .loss import LossBase, label_smoothing_loss_cfg
+from .optimization import BertAdam
+from ..utils.json import save_json
+from ..utils.train_utils import gather_object_multiple_gpu, get_timestamp
+
+logger = logging.getLogger(__name__)
+
+
+def convert_ids_to_sentence(tokens):
+    from cocap.modules.clip.clip import _tokenizer
+    text = _tokenizer.decode(tokens)
+    text_list = text.split(" ")
+    new = []
+    for i in range(len(text_list)):
+        if i == 0:
+            new.append(text_list[i].split(">")[-1])
+        elif "<|endoftext|>" in text_list[i]:
+            break
+        else:
+            new.append(text_list[i])
+    return " ".join(new)
+
+
+class CoCapLM(pl.LightningModule):
+    """CoCap Lightning Module"""
+
+    def __init__(
+            self,
+            cocap_model: CompressedVideoCaptioner,
+            loss: LossBase,
+            lr: float = 1e-4,
+            clip_lr: float = 1e-6,
+            warmup_ratio: float = 0.05,
+            lr_decay_gamma: float = 0.95,
+    ):
+        super().__init__()
+        self.model = cocap_model
+        self.loss = loss
+        self.lr = lr
+        self.clip_lr = clip_lr
+        self.warmup_ratio = warmup_ratio
+        self.lr_decay_gamma = lr_decay_gamma
+
+        self.batch_res = None
+
+    @property
+    def total_steps(self):
+        return self.trainer.estimated_stepping_batches
+
+    @property
+    def epoch_steps(self):
+        return self.trainer.estimated_stepping_batches // self.trainer.max_epochs
+
+    def configure_optimizers(self) -> OptimizerLRScheduler:
+        # based on:
+        # https://github.com/karpathy/minGPT/blob/3ed14b2cec0dfdad3f4b2831f2b4a86d11aef150/mingpt/model.py#L136
+        model = self.model
+
+        decay = set()
+        no_decay = set()
+
+        pretrained_modules = [
+            "compressed_video_transformer.rgb_encoder.conv1",
+            "compressed_video_transformer.rgb_encoder.class_embedding",
+            "compressed_video_transformer.rgb_encoder.positional_embedding",
+            "compressed_video_transformer.rgb_encoder.ln_pre",
+            "compressed_video_transformer.rgb_encoder.transformer",
+            "compressed_video_transformer.rgb_encoder.ln_post",
+            "compressed_video_transformer.rgb_encoder.proj",
+            "caption_head.cap_sa_decoder.word_embeddings",
+            "caption_head.prediction_head.decoder",
+        ]
+        whitelist_weight_modules = (nn.Linear, nn.MultiheadAttention, nn.Conv2d)
+        blacklist_weight_modules = (nn.LayerNorm, nn.BatchNorm2d, nn.Embedding, BertLayerNorm)
+        for mn, m in model.named_modules():
+            for pn, p in m.named_parameters():
+                fpn = '%s.%s' % (mn, pn) if mn else pn  # full param name
+
+                if any(fpn.startswith(p_fpn) for p_fpn in pretrained_modules):  # pretrained
+                    no_decay.add(fpn)
+                elif pn.endswith("bias"):
+                    no_decay.add(fpn)
+                elif pn.endswith("proj") or pn.endswith("projection"):
+                    decay.add(fpn)
+                elif fpn.endswith("embedding"):
+                    no_decay.add(fpn)
+                elif pn.endswith("weight") and isinstance(m, whitelist_weight_modules):
+                    decay.add(fpn)
+                elif pn.endswith("weight") and isinstance(m, blacklist_weight_modules):
+                    no_decay.add(fpn)
+
+        param_dict = {pn: p for pn, p in model.named_parameters()}
+        inter_params = decay & no_decay
+        union_params = decay | no_decay
+        assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params),)
+        assert len(param_dict.keys() - union_params) == 0, \
+            "parameters %s were not separated into either decay/no_decay set!" % (
+                str(param_dict.keys() - union_params),)
+
+        pretrained_no_decay = [pn for pn in sorted(list(no_decay)) if
+                               any(pn.startswith(p_pn) for p_pn in pretrained_modules)]
+        not_pretrained_no_decay = [pn for pn in sorted(list(no_decay)) if
+                                   not any(pn.startswith(p_pn) for p_pn in pretrained_modules)]
+
+        logger.debug("Parameter group decay_param: %s",
+                     "\n   " + "\n   ".join([pn for pn in sorted(list(decay))]))
+        logger.debug("Parameter group no_decay_pretrained_param: %s",
+                     "\n   " + "\n   ".join([pn for pn in sorted(list(pretrained_no_decay))]))
+        logger.debug("Parameter group no_decay_not_pretrained_param: %s",
+                     "\n   " + "\n   ".join([pn for pn in sorted(list(not_pretrained_no_decay))]))
+
+        decay_param = [param_dict[pn] for pn in sorted(list(decay))]
+        no_decay_pretrained_param = [param_dict[pn] for pn in sorted(list(pretrained_no_decay))]
+        no_decay_not_pretrained_param = [param_dict[pn] for pn in sorted(list(not_pretrained_no_decay))]
+
+        optimizer_grouped_parameters = [
+            {"params": decay_param},
+            {"params": no_decay_pretrained_param, "weight_decay": 0.0, "lr": self.clip_lr},
+            {"params": no_decay_not_pretrained_param, "weight_decay": 0.0}
+        ]
+
+        optimizer = BertAdam(
+            optimizer_grouped_parameters,
+            lr=self.lr,
+            weight_decay=0.01,
+            max_grad_norm=1.0
+        )
+
+        def lr_lambda(current_step):
+            warmup_steps = self.warmup_ratio * self.total_steps
+            if current_step < warmup_steps:
+                return current_step / warmup_steps
+            else:
+                return self.lr_decay_gamma ** ((current_step - warmup_steps) // self.epoch_steps)
+
+        # Step-based warmup, epoch-based decay scheduler
+        warmup_decay_scheduler = LambdaLR(optimizer, lr_lambda=lr_lambda)
+
+        return {
+            "optimizer": optimizer,
+            "lr_scheduler": {
+                "scheduler": warmup_decay_scheduler,
+                "interval": "step",
+                "frequency": 1,
+                "name": "warmup_decay"
+            }
+        }
+
+    def training_step(self, batch, batch_idx):
+        outputs = self.model(batch)
+        loss = self.loss(batch, outputs)
+        self.log("loss", loss, on_step=True, on_epoch=True, prog_bar=True, logger=True,
+                 batch_size=batch["input_labels"].size(0))
+        return loss
+
+    def on_validation_epoch_start(self) -> None:
+        self.batch_res = {"version": "VERSION 1.0",
+                          "results": defaultdict(list),
+                          "external_data": {"used": "true", "details": "ay"}}
+
+    def validation_step(self, batch, batch_idx):
+        inputs_ids = batch["input_ids"]
+        input_masks = batch["input_mask"]
+        max_t_len = self.model.caption_head.cap_config.max_t_len  # hard-code sentence length, for speed test, set it to 21
+        inputs_ids[:, :] = 0.
+        input_masks[:, :] = 0.
+        assert torch.sum(input_masks[:, :]) == 0, "Initially, all text tokens should be masked"
+        bsz = len(inputs_ids)
+        next_symbols = torch.IntTensor([self.model.caption_head.cap_config.BOS_id] * bsz)  # (N, )
+
+        warn_visual_output = False
+        for dec_idx in range(max_t_len):
+            inputs_ids[:, dec_idx] = next_symbols.clone()
+            input_masks[:, dec_idx] = 1
+            outputs = self.model(batch)
+            pred_scores = outputs["prediction_scores"]
+            next_words = pred_scores[:, dec_idx].max(1)[1]
+            next_symbols = next_words.cpu()
+            if "visual_output" in outputs:
+                batch["visual_output"] = outputs["visual_output"]
+            elif not warn_visual_output:
+                logger.warning("visual_output is not in the output of model, this may slow down the caption test")
+                warn_visual_output = True
+        dec_seq = inputs_ids
+
+        for example_idx, (cur_gen_sen, cur_meta) in enumerate(zip(dec_seq, batch['metadata'][1])):
+            cur_data = {
+                "sentence": convert_ids_to_sentence(cur_gen_sen.tolist()),
+                "gt_sentence": cur_meta
+            }
+            self.batch_res["results"][batch['metadata'][0][example_idx].split("video")[-1]].append(cur_data)
+
+    def on_validation_epoch_end(self) -> None:
+        json_res = copy.deepcopy(self.batch_res)
+        if dist.is_initialized():
+            all_results = gather_object_multiple_gpu(list(json_res["results"].items()))
+            json_res['results'] = {k: v for k, v in all_results}
+            logger.debug("Caption test length: %s", len(json_res["results"].items()))
+
+        # save result tp log for debug
+        if not dist.is_initialized() or dist.get_rank() == 0:
+            res_filepath = os.path.join(self.trainer.default_root_dir,
+                                        "caption_greedy_pred_validation_{}.json".format(get_timestamp()))
+            os.makedirs(os.path.dirname(res_filepath), exist_ok=True)
+            save_json(json_res, res_filepath, save_pretty=True)
+
+        if not dist.is_initialized() or dist.get_rank() == 0:
+            json_ref = self.trainer.val_dataloaders.dataset.json_ref
+            metrics = evaluate(json_res, json_ref)
+            self.log_dict(metrics, on_step=False, on_epoch=True, logger=True)
+
+        if dist.is_initialized():
+            dist.barrier()
+
+
+cocap_lm_cfg = builds(
+    CoCapLM,
+    cocap_model=compressed_video_captioner_pretrained_cfg,
+    loss=label_smoothing_loss_cfg,
+    populate_full_signature=True
+)

CoCap/cocap/modeling/loss.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# @Time    : 7/19/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : loss.py
+
+__all__ = [
+    "LossBase",
+    "LabelSmoothingLoss",
+    "label_smoothing_loss_cfg"
+]
+
+import logging
+from abc import abstractmethod
+
+import torch
+import torch.nn.functional as F
+from hydra_zen import builds
+from torch import Tensor, nn
+
+logger = logging.getLogger(__name__)
+
+
+class LossBase(nn.Module):
+    @abstractmethod
+    def forward(self, inputs, outputs) -> Tensor:
+        """Compute loss."""
+
+
+class LabelSmoothingLoss(LossBase):
+    def __init__(self, label_smoothing=0.1, target_vocab_size=49408, ignore_index=0):
+        assert 0.0 < label_smoothing <= 1.0
+
+        super().__init__()
+
+        self.tgt_vocab_size = target_vocab_size
+        self.ignore_index = ignore_index
+
+        self.log_softmax = nn.LogSoftmax(dim=-1)
+
+        smoothing_value = label_smoothing / (self.tgt_vocab_size - 1)  # count for the ground-truth word
+        one_hot = torch.full((self.tgt_vocab_size,), smoothing_value)
+        # one_hot[self.ignore_index] = 0
+        self.register_buffer("one_hot", one_hot.unsqueeze(0))
+
+        self.confidence = 1.0 - label_smoothing
+
+    def forward(self, target, output):
+        output = output["prediction_scores"]
+        output = output.view(-1, self.tgt_vocab_size)
+        target = target['input_labels'].reshape(-1).long()
+        valid_indices = target != self.ignore_index  # ignore examples with target value -1
+        target = target[valid_indices]
+        output = self.log_softmax(output[valid_indices])
+
+        model_prob = self.one_hot.repeat(target.size(0), 1).to(target.device)
+        model_prob.scatter_(1, target.unsqueeze(1), self.confidence)
+        return F.kl_div(output, model_prob, reduction="sum")
+
+
+# Build configs for organizing modules with hydra
+label_smoothing_loss_cfg = builds(LabelSmoothingLoss, populate_full_signature=True)

CoCap/cocap/modeling/optimization.py

@@ -0,0 +1,185 @@
+# coding=utf-8
+# Copyright 2018 The Google AI Language Team Authors and The HugginFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""PyTorch optimization for BERT model."""
+
+__all__ = [
+    "BertAdam",
+    "bert_adam_cfg",
+]
+
+import logging
+
+import math
+import torch
+from hydra_zen import builds
+from torch.nn.utils import clip_grad_norm_
+from torch.optim import Optimizer
+from torch.optim.optimizer import required
+
+logger = logging.getLogger(__name__)
+
+
+def warmup_cosine(x, warmup=0.002):
+    if x < warmup:
+        return x / warmup
+    return 0.5 * (1.0 + torch.cos(math.pi * x))
+
+
+def warmup_constant(x, warmup=0.002):
+    """ Linearly increases learning rate over `warmup`*`t_total` (as provided to BertAdam) training steps.
+        Learning rate is 1. afterwards. """
+    if x < warmup:
+        return x / warmup
+    return 1.0
+
+
+def warmup_linear(x, warmup=0.002):
+    """ Specifies a triangular learning rate schedule where peak is reached at `warmup`*`t_total`-th (as provided to BertAdam) training step.
+        After `t_total`-th training step, learning rate is zero. """
+    if x < warmup:
+        return x / warmup
+    return max((x - 1.) / (warmup - 1.), 0)
+
+
+SCHEDULES = {
+    'warmup_cosine': warmup_cosine,
+    'warmup_constant': warmup_constant,
+    'warmup_linear': warmup_linear,
+}
+
+
+class BertAdam(Optimizer):
+    """Implements BERT version of Adam algorithm with weight decay fix.
+    Params:
+        lr: learning rate
+        warmup: portion of t_total for the warmup, -1  means no warmup. Default: -1
+        t_total: total number of training steps for the learning
+            rate schedule, -1  means constant learning rate. Default: -1
+        schedule: schedule to use for the warmup (see above). Default: 'warmup_linear'
+        b1: Adams b1. Default: 0.9
+        b2: Adams b2. Default: 0.999
+        e: Adams epsilon. Default: 1e-6
+        weight_decay: Weight decay. Default: 0.01
+        max_grad_norm: Maximum norm for the gradients (-1 means no clipping). Default: 1.0
+    """
+
+    def __init__(self, params, lr=required, warmup=-1, t_total=-1, schedule='warmup_linear',
+                 b1=0.9, b2=0.999, e=1e-6, weight_decay=0.01,
+                 max_grad_norm=1.0):
+        if lr is not required and lr < 0.0:
+            raise ValueError("Invalid learning rate: {} - should be >= 0.0".format(lr))
+        if schedule not in SCHEDULES:
+            raise ValueError("Invalid schedule parameter: {}".format(schedule))
+        if not 0.0 <= warmup < 1.0 and not warmup == -1:
+            raise ValueError("Invalid warmup: {} - should be in [0.0, 1.0[ or -1".format(warmup))
+        if not 0.0 <= b1 < 1.0:
+            raise ValueError("Invalid b1 parameter: {} - should be in [0.0, 1.0[".format(b1))
+        if not 0.0 <= b2 < 1.0:
+            raise ValueError("Invalid b2 parameter: {} - should be in [0.0, 1.0[".format(b2))
+        if not e >= 0.0:
+            raise ValueError("Invalid epsilon value: {} - should be >= 0.0".format(e))
+        defaults = dict(lr=lr, schedule=schedule, warmup=warmup, t_total=t_total,
+                        b1=b1, b2=b2, e=e, weight_decay=weight_decay,
+                        max_grad_norm=max_grad_norm)
+        super(BertAdam, self).__init__(params, defaults)
+
+    def get_lr(self):
+        lr = []
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                state = self.state[p]
+                if len(state) == 0:
+                    return [0]
+                if group['t_total'] != -1:
+                    schedule_fct = SCHEDULES[group['schedule']]
+                    lr_scheduled = group['lr'] * schedule_fct(state['step'] / group['t_total'], group['warmup'])
+                else:
+                    lr_scheduled = group['lr']
+                lr.append(lr_scheduled)
+        return lr
+
+    def step(self, closure=None):
+        """Performs a single optimization step.
+        Arguments:
+            closure (callable, optional): A closure that reevaluates the model
+                and returns the loss.
+        """
+        loss = None
+        if closure is not None:
+            loss = closure()
+
+        for group in self.param_groups:
+            for p in group['params']:
+                if p.grad is None:
+                    continue
+                grad = p.grad.data
+                if grad.is_sparse:
+                    raise RuntimeError('Adam does not support sparse gradients, please consider SparseAdam instead')
+
+                state = self.state[p]
+
+                # State initialization
+                if len(state) == 0:
+                    state['step'] = 0
+                    # Exponential moving average of gradient values
+                    state['next_m'] = torch.zeros_like(p.data)
+                    # Exponential moving average of squared gradient values
+                    state['next_v'] = torch.zeros_like(p.data)
+
+                next_m, next_v = state['next_m'], state['next_v']
+                beta1, beta2 = group['b1'], group['b2']
+
+                # Add grad clipping
+                if group['max_grad_norm'] > 0:
+                    clip_grad_norm_(p, group['max_grad_norm'])
+
+                # Decay the first and second moment running average coefficient
+                # In-place operations to update the averages at the same time
+                # next_m.mul_(beta1).add_(1 - beta1, grad) --> pytorch 1.7
+                next_m.mul_(beta1).add_(grad, alpha=1 - beta1)
+                # next_v.mul_(beta2).addcmul_(1 - beta2, grad, grad) --> pytorch 1.7
+                next_v.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
+                update = next_m / (next_v.sqrt() + group['e'])
+
+                # Just adding the square of the weights to the loss function is *not*
+                # the correct way of using L2 regularization/weight decay with Adam,
+                # since that will interact with the m and v parameters in strange ways.
+                #
+                # Instead we want to decay the weights in a manner that doesn't interact
+                # with the m/v parameters. This is equivalent to adding the square
+                # of the weights to the loss with plain (non-momentum) SGD.
+                if group['weight_decay'] > 0.0:
+                    update += group['weight_decay'] * p.data
+
+                if group['t_total'] != -1:
+                    schedule_fct = SCHEDULES[group['schedule']]
+                    progress = state['step'] / group['t_total']
+                    lr_scheduled = group['lr'] * schedule_fct(progress, group['warmup'])
+                else:
+                    lr_scheduled = group['lr']
+
+                update_with_lr = lr_scheduled * update
+                p.data.add_(-update_with_lr)
+
+                state['step'] += 1
+
+        return loss
+
+
+# Build configs for organizing modules with hydra
+bert_adam_cfg = builds(BertAdam, populate_full_signature=True)

CoCap/cocap/modules/README.md

@@ -0,0 +1,2 @@
+# layers
+

CoCap/cocap/modules/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# @Time    : 5/30/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : __init__.py

CoCap/cocap/modules/audio_encoder.py

@@ -0,0 +1,194 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import os
+from cocap.modules.beats import BEATs, BEATsConfig
+
+class BEATsAudioEncoder(nn.Module):
+    def __init__(self, model_path=None, model_cfg=None):
+        super().__init__()
+        # Default Config for BEATs iter3+ (as2m) usually matches Base or Large?
+        # Let's assume Base (768) unless specified.
+        # If the checkpoint is loaded, it might have a config.
+        
+        # Load config logic
+        checkpoint = torch.load(model_path, map_location='cpu') if model_path else None
+        cfg_dict = checkpoint['cfg'] if checkpoint and 'cfg' in checkpoint else None
+        
+        # Create Config
+        self.cfg = BEATsConfig(cfg_dict)
+        if model_cfg:
+            self.cfg.update(model_cfg)
+            
+        self.model = BEATs(self.cfg)
+        
+        if checkpoint:
+             if 'model' in checkpoint:
+                 self.model.load_state_dict(checkpoint['model'], strict=False)
+             else:
+                 self.model.load_state_dict(checkpoint, strict=False)
+             print(f"BEATs loaded from {model_path}")
+             
+    def forward(self, input, padding_mask=None):
+        """
+        Input: (B, T, F) - Mel Spectrogram (already normalized in dataset)
+        BEATs expects (B, T, F) but extract_features assumes input is waveform OR fbank.
+        If fbank, expects (B, T, F)?
+        Let's check BEATs.extract_features:
+          fbank = fbank.unsqueeze(1) # (B, 1, T, F) ?? 
+          features = self.patch_embedding(fbank)
+         
+        Standard BEATs:
+        fbank = self.preprocess(source) -> returns (B, T, 128)
+        Then fbank.unsqueeze(1) -> (B, 1, T, 128)
+        Then Conv2d(1, embed, patch, stride)
+        
+        So input should be (B, T, F).
+        """
+        # (B, T, F) -> BEATs
+        # We modified BEATs to take is_fbank=True
+        
+        # We need padding mask? 
+        # AVCapsDataset returns audio_spec padded with 0.
+        # We can generate padding mask from 0s? Or just computed mask?
+        # Dataset currently uses pad_sequence with padding_value=0.
+        
+        # Create padding mask (1 for padded, 0 for valid) in BEATs convention?
+        # BEATs: "padding_mask of shape (batch_size, seq_len) with 1 for positions to ignore"
+        # Since we just have padded input, we can infer it or pass it.
+        # Ideally, we should update Dataset to return a mask.
+        # For now, let's assume all valid or simple padding 0 check if robust.
+        # But 0 can be a valid mel value?
+        # Audio Spec is normalized. 0 might be valid.
+        # Best to treat all as valid for now or pass mask.
+        
+        x, _ = self.model.extract_features(input, padding_mask=padding_mask, is_fbank=True)
+        # x: (B, T_out, 768)
+        
+        # Global pooling? 
+        # BEATs returns sequence. To get global, we can mean pool.
+        x = x.mean(dim=1) 
+        return x
+
+class CNN14(nn.Module):
+    def __init__(self, sample_rate=32000, window_size=1024, hop_size=320, mel_bins=64, fmin=50, fmax=14000, classes_num=527):
+        super(CNN14, self).__init__()
+        
+        # Logmel spectrogram extractor (Assuming input is waveform, if input is spec, this part is skipped)
+        # However, usually we use Torchaudio or similar. 
+        # For this implementation, we will assume the input is already a Mel Spectrogram 
+        # or we implement a simple Conv2d backbone.
+        
+        self.bn0 = nn.BatchNorm2d(64)
+
+        self.conv_block1 = ConvBlock(in_channels=1, out_channels=64)
+        self.conv_block2 = ConvBlock(in_channels=64, out_channels=128)
+        self.conv_block3 = ConvBlock(in_channels=128, out_channels=256)
+        self.conv_block4 = ConvBlock(in_channels=256, out_channels=512)
+        self.conv_block5 = ConvBlock(in_channels=512, out_channels=1024)
+        self.conv_block6 = ConvBlock(in_channels=1024, out_channels=2048)
+
+        self.fc1 = nn.Linear(2048, 2048, bias=True)
+        self.fc_audioset = nn.Linear(2048, classes_num, bias=True)
+
+    def forward(self, input, mixup_lambda=None):
+        """
+        Input: (batch_size, 1, time_steps, mel_bins) or (batch_size, time_steps, mel_bins)
+        """
+        if input.dim() == 3:
+            input = input.unsqueeze(1) # Add channel dim
+
+        x = input.transpose(1, 3) # (batch, 1, time, mel) -> (batch, mel, time, 1) ? 
+        # Standard PANNs takes (batch, 1, time_steps, mel_bins). Let's assume input matches that logic 
+        # BUT usually PANNs expects (Batch, 1, Time, Freq).
+        # We will enforce input as (Batch, 1, Time, Freq)
+        
+        # However, checking common implementations, usually it is (Batch, 1, Freq, Time) for Conv2d
+        # Let's permute to (Batch, 1, Freq, Time)
+        x = input.permute(0, 1, 3, 2) 
+
+        x = self.conv_block1(x, pool_size=(2, 2), pool_type='avg')
+        x = torch.dropout(x, p=0.2, train=self.training)
+        
+        x = self.conv_block2(x, pool_size=(2, 2), pool_type='avg')
+        x = torch.dropout(x, p=0.2, train=self.training)
+        
+        x = self.conv_block3(x, pool_size=(2, 2), pool_type='avg')
+        x = torch.dropout(x, p=0.2, train=self.training)
+        
+        x = self.conv_block4(x, pool_size=(2, 2), pool_type='avg')
+        x = torch.dropout(x, p=0.2, train=self.training)
+        
+        x = self.conv_block5(x, pool_size=(2, 2), pool_type='avg')
+        x = torch.dropout(x, p=0.2, train=self.training)
+        
+        x = self.conv_block6(x, pool_size=(1, 1), pool_type='avg')
+        x = torch.dropout(x, p=0.2, train=self.training)
+
+        # Global pooling
+        x = torch.mean(x, dim=3) # Average over time
+        (x1, _) = torch.max(x, dim=2) # Max over freq
+        x2 = torch.mean(x, dim=2) # Mean over freq
+        
+        x = x1 + x2 # Sum global pooling
+        
+        x = F.relu_(self.fc1(x))
+        # embedding = torch.dropout(x, p=0.5, train=self.training)
+        # clip_output = torch.sigmoid(self.fc_audioset(x))
+        
+        # we return the global embedding
+        return x
+
+    def load_from_pretrain(self, path):
+        if not os.path.exists(path):
+            print(f"Pretrained model not found at {path}")
+            return
+        
+        print(f"Loading Audio Encoder from {path}")
+        checkpoint = torch.load(path, map_location='cpu')
+        
+        if 'model' in checkpoint:
+            state_dict = checkpoint['model']
+        else:
+            state_dict = checkpoint
+            
+        # PANNs checkpoint might have 'module.' prefix if trained with DataParallel
+        new_state_dict = {}
+        for k, v in state_dict.items():
+            if k.startswith('module.'):
+                new_state_dict[k[7:]] = v
+            else:
+                new_state_dict[k] = v
+                
+        # Filter out fc_audioset if sizes don't match (we defined classes_num=527 which is standard, but just in case)
+        # Also FC1 might differ if not 2048.
+        
+        msg = self.load_state_dict(new_state_dict, strict=False)
+        print(f"Audio Encoder Loaded: {msg}")
+
+import os
+class ConvBlock(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(ConvBlock, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=out_channels,
+                              kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        self.conv2 = nn.Conv2d(in_channels=out_channels, out_channels=out_channels,
+                              kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        self.bn1 = nn.BatchNorm2d(out_channels)
+        self.bn2 = nn.BatchNorm2d(out_channels)
+
+    def forward(self, input, pool_size=(2, 2), pool_type='avg'):
+        x = input
+        x = F.relu_(self.bn1(self.conv1(x)))
+        x = F.relu_(self.bn2(self.conv2(x)))
+        if pool_type == 'max':
+            x = F.max_pool2d(x, kernel_size=pool_size)
+        elif pool_type == 'avg':
+            x = F.avg_pool2d(x, kernel_size=pool_size)
+        elif pool_type == 'avg+max':
+            x1 = F.avg_pool2d(x, kernel_size=pool_size)
+            x2 = F.max_pool2d(x, kernel_size=pool_size)
+            x = x1 + x2
+        else:
+            raise Exception('Incorrect argument!')
+        return x

CoCap/cocap/modules/beats/BEATs.py

@@ -0,0 +1,183 @@
+# --------------------------------------------------------
+# BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)
+# Github source: https://github.com/microsoft/unilm/tree/master/beats
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+
+import torch
+import torch.nn as nn
+from torch.nn import LayerNorm
+import torchaudio.compliance.kaldi as ta_kaldi
+
+from .backbone import (
+    TransformerEncoder,
+)
+
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+
+class BEATsConfig:
+    def __init__(self, cfg=None):
+        self.input_patch_size: int = -1  # path size of patch embedding
+        self.embed_dim: int = 512  # patch embedding dimension
+        self.conv_bias: bool = False  # include bias in conv encoder
+
+        self.encoder_layers: int = 12  # num encoder layers in the transformer
+        self.encoder_embed_dim: int = 768  # encoder embedding dimension
+        self.encoder_ffn_embed_dim: int = 3072  # encoder embedding dimension for FFN
+        self.encoder_attention_heads: int = 12  # num encoder attention heads
+        self.activation_fn: str = "gelu"  # activation function to use
+
+        self.layer_wise_gradient_decay_ratio: float = 1.0  # ratio for layer-wise gradient decay
+        self.layer_norm_first: bool = False  # apply layernorm first in the transformer
+        self.deep_norm: bool = False  # apply deep_norm first in the transformer
+
+        # dropouts
+        self.dropout: float = 0.1  # dropout probability for the transformer
+        self.attention_dropout: float = 0.1  # dropout probability for attention weights
+        self.activation_dropout: float = 0.0  # dropout probability after activation in FFN
+        self.encoder_layerdrop: float = 0.0  # probability of dropping a tarnsformer layer
+        self.dropout_input: float = 0.0  # dropout to apply to the input (after feat extr)
+
+        # positional embeddings
+        self.conv_pos: int = 128  # number of filters for convolutional positional embeddings
+        self.conv_pos_groups: int = 16  # number of groups for convolutional positional embedding
+
+        # relative position embedding
+        self.relative_position_embedding: bool = False  # apply relative position embedding
+        self.num_buckets: int = 320  # number of buckets for relative position embedding
+        self.max_distance: int = 1280  # maximum distance for relative position embedding
+        self.gru_rel_pos: bool = False  # apply gated relative position embedding
+
+        # label predictor
+        self.finetuned_model: bool = False  # whether the model is a fine-tuned model.
+        self.predictor_dropout: float = 0.1  # dropout probability for the predictor
+        self.predictor_class: int = 527  # target class number for the predictor
+
+        if cfg is not None:
+            self.update(cfg)
+
+    def update(self, cfg: dict):
+        self.__dict__.update(cfg)
+
+
+class BEATs(nn.Module):
+    def __init__(
+            self,
+            cfg: BEATsConfig,
+    ) -> None:
+        super().__init__()
+        logger.info(f"BEATs Config: {cfg.__dict__}")
+
+        self.cfg = cfg
+
+        self.embed = cfg.embed_dim
+        self.post_extract_proj = (
+            nn.Linear(self.embed, cfg.encoder_embed_dim)
+            if self.embed != cfg.encoder_embed_dim
+            else None
+        )
+
+        self.input_patch_size = cfg.input_patch_size
+        self.patch_embedding = nn.Conv2d(1, self.embed, kernel_size=self.input_patch_size, stride=self.input_patch_size,
+                                         bias=cfg.conv_bias)
+
+        self.dropout_input = nn.Dropout(cfg.dropout_input)
+
+        assert not cfg.deep_norm or not cfg.layer_norm_first
+        self.encoder = TransformerEncoder(cfg)
+        self.layer_norm = LayerNorm(self.embed)
+
+        if cfg.finetuned_model:
+            self.predictor_dropout = nn.Dropout(cfg.predictor_dropout)
+            self.predictor = nn.Linear(cfg.encoder_embed_dim, cfg.predictor_class)
+        else:
+            self.predictor = None
+
+    def forward_padding_mask(
+            self,
+            features: torch.Tensor,
+            padding_mask: torch.Tensor,
+    ) -> torch.Tensor:
+        extra = padding_mask.size(1) % features.size(1)
+        if extra > 0:
+            padding_mask = padding_mask[:, :-extra]
+        padding_mask = padding_mask.view(
+            padding_mask.size(0), features.size(1), -1
+        )
+        padding_mask = padding_mask.all(-1)
+        return padding_mask
+
+    def preprocess(
+            self,
+            source: torch.Tensor,
+            fbank_mean: float = 15.41663,
+            fbank_std: float = 6.55582,
+    ) -> torch.Tensor:
+        fbanks = []
+        for waveform in source:
+            waveform = waveform.unsqueeze(0) * 2 ** 15
+            fbank = ta_kaldi.fbank(waveform, num_mel_bins=128, sample_frequency=16000, frame_length=25, frame_shift=10)
+            fbanks.append(fbank)
+        fbank = torch.stack(fbanks, dim=0)
+        fbank = (fbank - fbank_mean) / (2 * fbank_std)
+        return fbank
+
+    def extract_features(
+            self,
+            source: torch.Tensor,
+            padding_mask: Optional[torch.Tensor] = None,
+            fbank_mean: float = 15.41663,
+            fbank_std: float = 6.55582,
+            is_fbank: bool = False, 
+    ):
+        if is_fbank:
+            fbank = source
+        else:
+            fbank = self.preprocess(source, fbank_mean=fbank_mean, fbank_std=fbank_std)
+
+        if padding_mask is not None:
+            padding_mask = self.forward_padding_mask(fbank, padding_mask)
+
+        fbank = fbank.unsqueeze(1)
+        features = self.patch_embedding(fbank)
+        features = features.reshape(features.shape[0], features.shape[1], -1)
+        features = features.transpose(1, 2)
+        features = self.layer_norm(features)
+
+        if padding_mask is not None:
+            padding_mask = self.forward_padding_mask(features, padding_mask)
+
+        if self.post_extract_proj is not None:
+            features = self.post_extract_proj(features)
+
+        x = self.dropout_input(features)
+
+        x, layer_results = self.encoder(
+            x,
+            padding_mask=padding_mask,
+        )
+
+        if self.predictor is not None:
+            x = self.predictor_dropout(x)
+            logits = self.predictor(x)
+
+            if padding_mask is not None and padding_mask.any():
+                logits[padding_mask] = 0
+                logits = logits.sum(dim=1)
+                logits = logits / (~padding_mask).sum(dim=1).unsqueeze(-1).expand_as(logits)
+            else:
+                logits = logits.mean(dim=1)
+
+            lprobs = torch.sigmoid(logits)
+
+            return lprobs, padding_mask
+        else:
+            return x, padding_mask

CoCap/cocap/modules/beats/__init__.py

@@ -0,0 +1 @@
+from .BEATs import BEATs, BEATsConfig

CoCap/cocap/modules/beats/backbone.py

@@ -0,0 +1,783 @@
+# --------------------------------------------------------
+# BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)
+# Github source: https://github.com/microsoft/unilm/tree/master/beats
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+import math
+import numpy as np
+from typing import Dict, Optional, Tuple
+import torch
+from torch import Tensor, nn
+import torch.nn.functional as F
+from torch.nn import LayerNorm, Parameter
+from .modules import (
+    GradMultiply,
+    SamePad,
+    get_activation_fn,
+    GLU_Linear,
+    quant_noise,
+)
+
+
+class TransformerEncoder(nn.Module):
+    def __init__(self, args):
+        super().__init__()
+
+        self.dropout = args.dropout
+        self.embedding_dim = args.encoder_embed_dim
+
+        self.pos_conv = nn.Conv1d(
+            self.embedding_dim,
+            self.embedding_dim,
+            kernel_size=args.conv_pos,
+            padding=args.conv_pos // 2,
+            groups=args.conv_pos_groups,
+        )
+        dropout = 0
+        std = math.sqrt((4 * (1.0 - dropout)) / (args.conv_pos * self.embedding_dim))
+        nn.init.normal_(self.pos_conv.weight, mean=0, std=std)
+        nn.init.constant_(self.pos_conv.bias, 0)
+
+        self.pos_conv = nn.utils.weight_norm(self.pos_conv, name="weight", dim=2)
+        self.pos_conv = nn.Sequential(self.pos_conv, SamePad(args.conv_pos), nn.GELU())
+
+        if hasattr(args, "relative_position_embedding"):
+            self.relative_position_embedding = args.relative_position_embedding
+            self.num_buckets = args.num_buckets
+            self.max_distance = args.max_distance
+        else:
+            self.relative_position_embedding = False
+            self.num_buckets = 0
+            self.max_distance = 0
+
+        self.layers = nn.ModuleList(
+            [
+                TransformerSentenceEncoderLayer(
+                    embedding_dim=self.embedding_dim,
+                    ffn_embedding_dim=args.encoder_ffn_embed_dim,
+                    num_attention_heads=args.encoder_attention_heads,
+                    dropout=self.dropout,
+                    attention_dropout=args.attention_dropout,
+                    activation_dropout=args.activation_dropout,
+                    activation_fn=args.activation_fn,
+                    layer_norm_first=args.layer_norm_first,
+                    deep_norm=args.deep_norm,
+                    has_relative_attention_bias=self.relative_position_embedding,
+                    num_buckets=self.num_buckets,
+                    max_distance=self.max_distance,
+                    gru_rel_pos=args.gru_rel_pos,
+                    encoder_layers=args.encoder_layers,
+                )
+                for i in range(args.encoder_layers)
+            ]
+        )
+        if self.relative_position_embedding:
+            for i in range(1, args.encoder_layers):
+                del self.layers[i].self_attn.relative_attention_bias
+                self.layers[i].self_attn.relative_attention_bias = self.layers[0].self_attn.relative_attention_bias
+
+        self.layer_norm_first = args.layer_norm_first
+        self.layer_norm = LayerNorm(self.embedding_dim)
+        self.layerdrop = args.encoder_layerdrop
+
+        self.apply(init_bert_params)
+
+        if args.deep_norm:
+            deep_norm_beta = math.pow(8 * args.encoder_layers, -1 / 4)
+            for i in range(args.encoder_layers):
+                nn.init.xavier_normal_(self.layers[i].self_attn.k_proj.weight, gain=1)
+                nn.init.xavier_normal_(self.layers[i].self_attn.v_proj.weight, gain=deep_norm_beta)
+                nn.init.xavier_normal_(self.layers[i].self_attn.q_proj.weight, gain=1)
+                nn.init.xavier_normal_(self.layers[i].self_attn.out_proj.weight, gain=deep_norm_beta)
+                nn.init.xavier_normal_(self.layers[i].fc1.weight, gain=deep_norm_beta)
+                nn.init.xavier_normal_(self.layers[i].fc2.weight, gain=deep_norm_beta)
+
+        self.layer_wise_gradient_decay_ratio = getattr(args, "layer_wise_gradient_decay_ratio", 1)
+
+    def forward(self, x, padding_mask=None, layer=None):
+        x, layer_results = self.extract_features(x, padding_mask, layer)
+
+        if self.layer_norm_first and layer is None:
+            x = self.layer_norm(x)
+
+        return x, layer_results
+
+    def extract_features(self, x, padding_mask=None, tgt_layer=None):
+
+        if padding_mask is not None:
+            x[padding_mask] = 0
+
+        x_conv = self.pos_conv(x.transpose(1, 2))
+        x_conv = x_conv.transpose(1, 2)
+        x = x + x_conv
+
+        if not self.layer_norm_first:
+            x = self.layer_norm(x)
+
+        x = F.dropout(x, p=self.dropout, training=self.training)
+
+        # B x T x C -> T x B x C
+        x = x.transpose(0, 1)
+
+        layer_results = []
+        z = None
+        if tgt_layer is not None:
+            layer_results.append((x, z))
+        r = None
+        pos_bias = None
+        for i, layer in enumerate(self.layers):
+            if self.layer_wise_gradient_decay_ratio != 1.0:
+                x = GradMultiply.apply(x, self.layer_wise_gradient_decay_ratio)
+            dropout_probability = np.random.random()
+            if not self.training or (dropout_probability > self.layerdrop):
+                x, z, pos_bias = layer(x, self_attn_padding_mask=padding_mask, need_weights=False, pos_bias=pos_bias)
+            if tgt_layer is not None:
+                layer_results.append((x, z))
+            if i == tgt_layer:
+                r = x
+                break
+
+        if r is not None:
+            x = r
+
+        # T x B x C -> B x T x C
+        x = x.transpose(0, 1)
+
+        return x, layer_results
+
+
+class TransformerSentenceEncoderLayer(nn.Module):
+    def __init__(
+            self,
+            embedding_dim: float = 768,
+            ffn_embedding_dim: float = 3072,
+            num_attention_heads: float = 8,
+            dropout: float = 0.1,
+            attention_dropout: float = 0.1,
+            activation_dropout: float = 0.1,
+            activation_fn: str = "relu",
+            layer_norm_first: bool = False,
+            deep_norm: bool = False,
+            has_relative_attention_bias: bool = False,
+            num_buckets: int = 0,
+            max_distance: int = 0,
+            rescale_init: bool = False,
+            gru_rel_pos: bool = False,
+            encoder_layers: int = 0,
+    ) -> None:
+
+        super().__init__()
+        self.embedding_dim = embedding_dim
+        self.dropout = dropout
+        self.activation_dropout = activation_dropout
+
+        self.activation_name = activation_fn
+        self.activation_fn = get_activation_fn(activation_fn)
+        self.self_attn = MultiheadAttention(
+            self.embedding_dim,
+            num_attention_heads,
+            dropout=attention_dropout,
+            self_attention=True,
+            has_relative_attention_bias=has_relative_attention_bias,
+            num_buckets=num_buckets,
+            max_distance=max_distance,
+            rescale_init=rescale_init,
+            gru_rel_pos=gru_rel_pos,
+        )
+
+        self.dropout1 = nn.Dropout(dropout)
+        self.dropout2 = nn.Dropout(self.activation_dropout)
+        self.dropout3 = nn.Dropout(dropout)
+
+        self.layer_norm_first = layer_norm_first
+
+        self.self_attn_layer_norm = LayerNorm(self.embedding_dim)
+
+        if self.activation_name == "glu":
+            self.fc1 = GLU_Linear(self.embedding_dim, ffn_embedding_dim, "swish")
+        else:
+            self.fc1 = nn.Linear(self.embedding_dim, ffn_embedding_dim)
+        self.fc2 = nn.Linear(ffn_embedding_dim, self.embedding_dim)
+
+        self.final_layer_norm = LayerNorm(self.embedding_dim)
+
+        self.deep_norm = deep_norm
+        if self.deep_norm:
+            self.deep_norm_alpha = math.pow(2 * encoder_layers, 1 / 4)
+        else:
+            self.deep_norm_alpha = 1
+
+    def forward(
+            self,
+            x: torch.Tensor,
+            self_attn_mask: torch.Tensor = None,
+            self_attn_padding_mask: torch.Tensor = None,
+            need_weights: bool = False,
+            pos_bias=None
+    ):
+        residual = x
+
+        if self.layer_norm_first:
+            x = self.self_attn_layer_norm(x)
+            x, attn, pos_bias = self.self_attn(
+                query=x,
+                key=x,
+                value=x,
+                key_padding_mask=self_attn_padding_mask,
+                need_weights=False,
+                attn_mask=self_attn_mask,
+                position_bias=pos_bias
+            )
+            x = self.dropout1(x)
+            x = residual + x
+
+            residual = x
+            x = self.final_layer_norm(x)
+            if self.activation_name == "glu":
+                x = self.fc1(x)
+            else:
+                x = self.activation_fn(self.fc1(x))
+            x = self.dropout2(x)
+            x = self.fc2(x)
+            x = self.dropout3(x)
+            x = residual + x
+        else:
+            x, attn, pos_bias = self.self_attn(
+                query=x,
+                key=x,
+                value=x,
+                key_padding_mask=self_attn_padding_mask,
+                need_weights=need_weights,
+                attn_mask=self_attn_mask,
+                position_bias=pos_bias
+            )
+
+            x = self.dropout1(x)
+            x = residual * self.deep_norm_alpha + x
+
+            x = self.self_attn_layer_norm(x)
+
+            residual = x
+            if self.activation_name == "glu":
+                x = self.fc1(x)
+            else:
+                x = self.activation_fn(self.fc1(x))
+            x = self.dropout2(x)
+            x = self.fc2(x)
+            x = self.dropout3(x)
+            x = residual * self.deep_norm_alpha + x
+            x = self.final_layer_norm(x)
+
+        return x, attn, pos_bias
+
+
+class MultiheadAttention(nn.Module):
+    """Multi-headed attention.
+
+    See "Attention Is All You Need" for more details.
+    """
+
+    def __init__(
+            self,
+            embed_dim,
+            num_heads,
+            kdim=None,
+            vdim=None,
+            dropout=0.0,
+            bias=True,
+            add_bias_kv=False,
+            add_zero_attn=False,
+            self_attention=False,
+            encoder_decoder_attention=False,
+            q_noise=0.0,
+            qn_block_size=8,
+            has_relative_attention_bias=False,
+            num_buckets=32,
+            max_distance=128,
+            gru_rel_pos=False,
+            rescale_init=False,
+    ):
+        super().__init__()
+        self.embed_dim = embed_dim
+        self.kdim = kdim if kdim is not None else embed_dim
+        self.vdim = vdim if vdim is not None else embed_dim
+        self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim
+
+        self.num_heads = num_heads
+        self.dropout_module = nn.Dropout(dropout)
+
+        self.has_relative_attention_bias = has_relative_attention_bias
+        self.num_buckets = num_buckets
+        self.max_distance = max_distance
+        if self.has_relative_attention_bias:
+            self.relative_attention_bias = nn.Embedding(num_buckets, num_heads)
+
+        self.head_dim = embed_dim // num_heads
+        self.q_head_dim = self.head_dim
+        self.k_head_dim = self.head_dim
+        assert (
+                self.head_dim * num_heads == self.embed_dim
+        ), "embed_dim must be divisible by num_heads"
+        self.scaling = self.head_dim ** -0.5
+
+        self.self_attention = self_attention
+        self.encoder_decoder_attention = encoder_decoder_attention
+
+        assert not self.self_attention or self.qkv_same_dim, (
+            "Self-attention requires query, key and " "value to be of the same size"
+        )
+
+        k_bias = True
+        if rescale_init:
+            k_bias = False
+
+        k_embed_dim = embed_dim
+        q_embed_dim = embed_dim
+
+        self.k_proj = quant_noise(
+            nn.Linear(self.kdim, k_embed_dim, bias=k_bias), q_noise, qn_block_size
+        )
+        self.v_proj = quant_noise(
+            nn.Linear(self.vdim, embed_dim, bias=bias), q_noise, qn_block_size
+        )
+        self.q_proj = quant_noise(
+            nn.Linear(embed_dim, q_embed_dim, bias=bias), q_noise, qn_block_size
+        )
+
+        self.out_proj = quant_noise(
+            nn.Linear(embed_dim, embed_dim, bias=bias), q_noise, qn_block_size
+        )
+
+        if add_bias_kv:
+            self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))
+            self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))
+        else:
+            self.bias_k = self.bias_v = None
+
+        self.add_zero_attn = add_zero_attn
+
+        self.gru_rel_pos = gru_rel_pos
+        if self.gru_rel_pos:
+            self.grep_linear = nn.Linear(self.q_head_dim, 8)
+            self.grep_a = nn.Parameter(torch.ones(1, num_heads, 1, 1))
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        if self.qkv_same_dim:
+            # Empirically observed the convergence to be much better with
+            # the scaled initialization
+            nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2))
+            nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2))
+            nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2))
+        else:
+            nn.init.xavier_uniform_(self.k_proj.weight)
+            nn.init.xavier_uniform_(self.v_proj.weight)
+            nn.init.xavier_uniform_(self.q_proj.weight)
+
+        nn.init.xavier_uniform_(self.out_proj.weight)
+        if self.out_proj.bias is not None:
+            nn.init.constant_(self.out_proj.bias, 0.0)
+        if self.bias_k is not None:
+            nn.init.xavier_normal_(self.bias_k)
+        if self.bias_v is not None:
+            nn.init.xavier_normal_(self.bias_v)
+        if self.has_relative_attention_bias:
+            nn.init.xavier_normal_(self.relative_attention_bias.weight)
+
+    def _relative_positions_bucket(self, relative_positions, bidirectional=True):
+        num_buckets = self.num_buckets
+        max_distance = self.max_distance
+        relative_buckets = 0
+
+        if bidirectional:
+            num_buckets = num_buckets // 2
+            relative_buckets += (relative_positions > 0).to(torch.long) * num_buckets
+            relative_positions = torch.abs(relative_positions)
+        else:
+            relative_positions = -torch.min(relative_positions, torch.zeros_like(relative_positions))
+
+        max_exact = num_buckets // 2
+        is_small = relative_positions < max_exact
+
+        relative_postion_if_large = max_exact + (
+                torch.log(relative_positions.float() / max_exact)
+                / math.log(max_distance / max_exact)
+                * (num_buckets - max_exact)
+        ).to(torch.long)
+        relative_postion_if_large = torch.min(
+            relative_postion_if_large, torch.full_like(relative_postion_if_large, num_buckets - 1)
+        )
+
+        relative_buckets += torch.where(is_small, relative_positions, relative_postion_if_large)
+        return relative_buckets
+
+    def compute_bias(self, query_length, key_length):
+        context_position = torch.arange(query_length, dtype=torch.long)[:, None]
+        memory_position = torch.arange(key_length, dtype=torch.long)[None, :]
+        relative_position = memory_position - context_position
+        relative_position_bucket = self._relative_positions_bucket(
+            relative_position,
+            bidirectional=True
+        )
+        relative_position_bucket = relative_position_bucket.to(self.relative_attention_bias.weight.device)
+        values = self.relative_attention_bias(relative_position_bucket)
+        values = values.permute([2, 0, 1])
+        return values
+
+    def forward(
+            self,
+            query,
+            key: Optional[Tensor],
+            value: Optional[Tensor],
+            key_padding_mask: Optional[Tensor] = None,
+            incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,
+            need_weights: bool = True,
+            static_kv: bool = False,
+            attn_mask: Optional[Tensor] = None,
+            before_softmax: bool = False,
+            need_head_weights: bool = False,
+            position_bias: Optional[Tensor] = None
+    ) -> Tuple[Tensor, Optional[Tensor], Optional[Tensor]]:
+        """Input shape: Time x Batch x Channel
+
+        Args:
+            key_padding_mask (ByteTensor, optional): mask to exclude
+                keys that are pads, of shape `(batch, src_len)`, where
+                padding elements are indicated by 1s.
+            need_weights (bool, optional): return the attention weights,
+                averaged over heads (default: False).
+            attn_mask (ByteTensor, optional): typically used to
+                implement causal attention, where the mask prevents the
+                attention from looking forward in time (default: None).
+            before_softmax (bool, optional): return the raw attention
+                weights and values before the attention softmax.
+            need_head_weights (bool, optional): return the attention
+                weights for each head. Implies *need_weights*. Default:
+                return the average attention weights over all heads.
+        """
+        if need_head_weights:
+            need_weights = True
+
+        is_tpu = query.device.type == "xla"
+
+        tgt_len, bsz, embed_dim = query.size()
+        src_len = tgt_len
+        assert embed_dim == self.embed_dim
+        assert list(query.size()) == [tgt_len, bsz, embed_dim]
+        if key is not None:
+            src_len, key_bsz, _ = key.size()
+            if not torch.jit.is_scripting():
+                assert key_bsz == bsz
+                assert value is not None
+                assert src_len, bsz == value.shape[:2]
+
+        if self.has_relative_attention_bias and position_bias is None:
+            position_bias = self.compute_bias(tgt_len, src_len)
+            position_bias = position_bias.unsqueeze(0).repeat(bsz, 1, 1, 1).view(bsz * self.num_heads, tgt_len, src_len)
+
+        if incremental_state is not None:
+            saved_state = self._get_input_buffer(incremental_state)
+            if saved_state is not None and "prev_key" in saved_state:
+                # previous time steps are cached - no need to recompute
+                # key and value if they are static
+                if static_kv:
+                    assert self.encoder_decoder_attention and not self.self_attention
+                    key = value = None
+        else:
+            saved_state = None
+
+        if self.self_attention:
+            q = self.q_proj(query)
+            k = self.k_proj(query)
+            v = self.v_proj(query)
+        elif self.encoder_decoder_attention:
+            # encoder-decoder attention
+            q = self.q_proj(query)
+            if key is None:
+                assert value is None
+                k = v = None
+            else:
+                k = self.k_proj(key)
+                v = self.v_proj(key)
+
+        else:
+            assert key is not None and value is not None
+            q = self.q_proj(query)
+            k = self.k_proj(key)
+            v = self.v_proj(value)
+        q *= self.scaling
+        alpha = 32
+        q *= 1 / alpha
+
+        if self.bias_k is not None:
+            assert self.bias_v is not None
+            k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])
+            v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])
+            if attn_mask is not None:
+                attn_mask = torch.cat(
+                    [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
+                )
+            if key_padding_mask is not None:
+                key_padding_mask = torch.cat(
+                    [
+                        key_padding_mask,
+                        key_padding_mask.new_zeros(key_padding_mask.size(0), 1),
+                    ],
+                    dim=1,
+                )
+
+        q = (
+            q.contiguous()
+                .view(tgt_len, bsz * self.num_heads, self.q_head_dim)
+                .transpose(0, 1)
+        )
+        if k is not None:
+            k = (
+                k.contiguous()
+                    .view(-1, bsz * self.num_heads, self.k_head_dim)
+                    .transpose(0, 1)
+            )
+        if v is not None:
+            v = (
+                v.contiguous()
+                    .view(-1, bsz * self.num_heads, self.head_dim)
+                    .transpose(0, 1)
+            )
+
+        if saved_state is not None:
+            # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)
+            if "prev_key" in saved_state:
+                _prev_key = saved_state["prev_key"]
+                assert _prev_key is not None
+                prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim)
+                if static_kv:
+                    k = prev_key
+                else:
+                    assert k is not None
+                    k = torch.cat([prev_key, k], dim=1)
+                src_len = k.size(1)
+            if "prev_value" in saved_state:
+                _prev_value = saved_state["prev_value"]
+                assert _prev_value is not None
+                prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim)
+                if static_kv:
+                    v = prev_value
+                else:
+                    assert v is not None
+                    v = torch.cat([prev_value, v], dim=1)
+            prev_key_padding_mask: Optional[Tensor] = None
+            if "prev_key_padding_mask" in saved_state:
+                prev_key_padding_mask = saved_state["prev_key_padding_mask"]
+            assert k is not None and v is not None
+            key_padding_mask = MultiheadAttention._append_prev_key_padding_mask(
+                key_padding_mask=key_padding_mask,
+                prev_key_padding_mask=prev_key_padding_mask,
+                batch_size=bsz,
+                src_len=k.size(1),
+                static_kv=static_kv,
+            )
+
+            saved_state["prev_key"] = k.view(bsz, self.num_heads, -1, self.head_dim)
+            saved_state["prev_value"] = v.view(bsz, self.num_heads, -1, self.head_dim)
+            saved_state["prev_key_padding_mask"] = key_padding_mask
+            # In this branch incremental_state is never None
+            assert incremental_state is not None
+            incremental_state = self._set_input_buffer(incremental_state, saved_state)
+        assert k is not None
+        assert k.size(1) == src_len
+
+        # This is part of a workaround to get around fork/join parallelism
+        # not supporting Optional types.
+        if key_padding_mask is not None and key_padding_mask.dim() == 0:
+            key_padding_mask = None
+
+        if key_padding_mask is not None:
+            assert key_padding_mask.size(0) == bsz
+            assert key_padding_mask.size(1) == src_len
+
+        if self.add_zero_attn:
+            assert v is not None
+            src_len += 1
+            k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)
+            v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)
+            if attn_mask is not None:
+                attn_mask = torch.cat(
+                    [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1
+                )
+            if key_padding_mask is not None:
+                key_padding_mask = torch.cat(
+                    [
+                        key_padding_mask,
+                        torch.zeros(key_padding_mask.size(0), 1).type_as(
+                            key_padding_mask
+                        ),
+                    ],
+                    dim=1,
+                )
+
+        attn_weights = torch.bmm(q, k.transpose(1, 2))
+        attn_weights = (attn_weights - attn_weights.max(dim=-1, keepdim=True)[0]) * alpha
+        attn_weights = self.apply_sparse_mask(attn_weights, tgt_len, src_len, bsz)
+
+        assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]
+
+        if attn_mask is not None:
+            attn_mask = attn_mask.unsqueeze(0)
+            attn_weights += attn_mask
+
+        if key_padding_mask is not None:
+            # don't attend to padding symbols
+            attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)
+            if not is_tpu:
+                attn_weights = attn_weights.masked_fill(
+                    key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool),
+                    float("-inf"),
+                )
+            else:
+                attn_weights = attn_weights.transpose(0, 2)
+                attn_weights = attn_weights.masked_fill(key_padding_mask, float("-inf"))
+                attn_weights = attn_weights.transpose(0, 2)
+            attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)
+
+        if before_softmax:
+            return attn_weights, v, position_bias
+
+        if position_bias is not None:
+            attn_mask_rel_pos = position_bias
+            if self.gru_rel_pos == 1:
+                query_layer = q.view(bsz, self.num_heads, tgt_len, self.q_head_dim) * alpha / self.scaling
+                _B, _H, _L, __ = query_layer.size()
+                gate_a, gate_b = torch.sigmoid(self.grep_linear(query_layer).view(
+                    _B, _H, _L, 2, 4).sum(-1, keepdim=False)).chunk(2, dim=-1)
+                gate_a_1 = gate_a * (gate_b * self.grep_a - 1.0) + 2.0
+                attn_mask_rel_pos = gate_a_1.view(bsz * self.num_heads, tgt_len, 1) * position_bias
+
+            attn_mask_rel_pos = attn_mask_rel_pos.view(attn_weights.size())
+
+            attn_weights = attn_weights + attn_mask_rel_pos
+
+        attn_weights_float = F.softmax(
+            attn_weights, dim=-1
+        )
+        attn_weights = attn_weights_float.type_as(attn_weights)
+        attn_probs = self.dropout_module(attn_weights)
+
+        assert v is not None
+        attn = torch.bmm(attn_probs, v)
+        assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]
+        attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)
+        attn = self.out_proj(attn)
+        attn_weights: Optional[Tensor] = None
+        if need_weights:
+            attn_weights = attn_weights_float.view(
+                bsz, self.num_heads, tgt_len, src_len
+            ).transpose(1, 0)
+            if not need_head_weights:
+                # average attention weights over heads
+                attn_weights = attn_weights.mean(dim=0)
+
+        return attn, attn_weights, position_bias
+
+    @staticmethod
+    def _append_prev_key_padding_mask(
+            key_padding_mask: Optional[Tensor],
+            prev_key_padding_mask: Optional[Tensor],
+            batch_size: int,
+            src_len: int,
+            static_kv: bool,
+    ) -> Optional[Tensor]:
+        # saved key padding masks have shape (bsz, seq_len)
+        if prev_key_padding_mask is not None and static_kv:
+            new_key_padding_mask = prev_key_padding_mask
+        elif prev_key_padding_mask is not None and key_padding_mask is not None:
+            new_key_padding_mask = torch.cat(
+                [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1
+            )
+        # During incremental decoding, as the padding token enters and
+        # leaves the frame, there will be a time when prev or current
+        # is None
+        elif prev_key_padding_mask is not None:
+            if src_len > prev_key_padding_mask.size(1):
+                filler = torch.zeros(
+                    (batch_size, src_len - prev_key_padding_mask.size(1)),
+                    device=prev_key_padding_mask.device,
+                )
+                new_key_padding_mask = torch.cat(
+                    [prev_key_padding_mask.float(), filler.float()], dim=1
+                )
+            else:
+                new_key_padding_mask = prev_key_padding_mask.float()
+        elif key_padding_mask is not None:
+            if src_len > key_padding_mask.size(1):
+                filler = torch.zeros(
+                    (batch_size, src_len - key_padding_mask.size(1)),
+                    device=key_padding_mask.device,
+                )
+                new_key_padding_mask = torch.cat(
+                    [filler.float(), key_padding_mask.float()], dim=1
+                )
+            else:
+                new_key_padding_mask = key_padding_mask.float()
+        else:
+            new_key_padding_mask = prev_key_padding_mask
+        return new_key_padding_mask
+
+    def _get_input_buffer(
+            self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]
+    ) -> Dict[str, Optional[Tensor]]:
+        result = self.get_incremental_state(incremental_state, "attn_state")
+        if result is not None:
+            return result
+        else:
+            empty_result: Dict[str, Optional[Tensor]] = {}
+            return empty_result
+
+    def _set_input_buffer(
+            self,
+            incremental_state: Dict[str, Dict[str, Optional[Tensor]]],
+            buffer: Dict[str, Optional[Tensor]],
+    ):
+        return self.set_incremental_state(incremental_state, "attn_state", buffer)
+
+    def apply_sparse_mask(self, attn_weights, tgt_len: int, src_len: int, bsz: int):
+        return attn_weights
+
+
+def init_bert_params(module):
+    """
+    Initialize the weights specific to the BERT Model.
+    This overrides the default initializations depending on the specified arguments.
+        1. If normal_init_linear_weights is set then weights of linear
+           layer will be initialized using the normal distribution and
+           bais will be set to the specified value.
+        2. If normal_init_embed_weights is set then weights of embedding
+           layer will be initialized using the normal distribution.
+        3. If normal_init_proj_weights is set then weights of
+           in_project_weight for MultiHeadAttention initialized using
+           the normal distribution (to be validated).
+    """
+
+    def normal_(data):
+        # with FSDP, module params will be on CUDA, so we cast them back to CPU
+        # so that the RNG is consistent with and without FSDP
+        data.copy_(
+            data.cpu().normal_(mean=0.0, std=0.02).to(data.device)
+        )
+
+    if isinstance(module, nn.Linear):
+        normal_(module.weight.data)
+        if module.bias is not None:
+            module.bias.data.zero_()
+    if isinstance(module, nn.Embedding):
+        normal_(module.weight.data)
+        if module.padding_idx is not None:
+            module.weight.data[module.padding_idx].zero_()
+    if isinstance(module, MultiheadAttention):
+        normal_(module.q_proj.weight.data)
+        normal_(module.k_proj.weight.data)
+        normal_(module.v_proj.weight.data)

CoCap/cocap/modules/beats/modules.py

@@ -0,0 +1,219 @@
+# --------------------------------------------------------
+# BEATs: Audio Pre-Training with Acoustic Tokenizers (https://arxiv.org/abs/2212.09058)
+# Github source: https://github.com/microsoft/unilm/tree/master/beats
+# Copyright (c) 2022 Microsoft
+# Licensed under The MIT License [see LICENSE for details]
+# Based on fairseq code bases
+# https://github.com/pytorch/fairseq
+# --------------------------------------------------------
+
+import math
+import warnings
+import torch
+from torch import Tensor, nn
+import torch.nn.functional as F
+
+
+class GradMultiply(torch.autograd.Function):
+    @staticmethod
+    def forward(ctx, x, scale):
+        ctx.scale = scale
+        res = x.new(x)
+        return res
+
+    @staticmethod
+    def backward(ctx, grad):
+        return grad * ctx.scale, None
+
+
+class SamePad(nn.Module):
+    def __init__(self, kernel_size, causal=False):
+        super().__init__()
+        if causal:
+            self.remove = kernel_size - 1
+        else:
+            self.remove = 1 if kernel_size % 2 == 0 else 0
+
+    def forward(self, x):
+        if self.remove > 0:
+            x = x[:, :, : -self.remove]
+        return x
+
+
+class Swish(nn.Module):
+    def __init__(self):
+        super(Swish, self).__init__()
+        self.act = torch.nn.Sigmoid()
+
+    def forward(self, x):
+        return x * self.act(x)
+
+
+class GLU_Linear(nn.Module):
+    def __init__(self, input_dim, output_dim, glu_type="sigmoid", bias_in_glu=True):
+        super(GLU_Linear, self).__init__()
+
+        self.glu_type = glu_type
+        self.output_dim = output_dim
+
+        if glu_type == "sigmoid":
+            self.glu_act = torch.nn.Sigmoid()
+        elif glu_type == "swish":
+            self.glu_act = Swish()
+        elif glu_type == "relu":
+            self.glu_act = torch.nn.ReLU()
+        elif glu_type == "gelu":
+            self.glu_act = torch.nn.GELU()
+
+        if bias_in_glu:
+            self.linear = nn.Linear(input_dim, output_dim * 2, True)
+        else:
+            self.linear = nn.Linear(input_dim, output_dim * 2, False)
+
+    def forward(self, x):
+        # to be consistent with GLU_Linear, we assume the input always has the #channel (#dim) in the last dimension of the tensor, so need to switch the dimension first for 1D-Conv case
+        x = self.linear(x)
+
+        if self.glu_type == "bilinear":
+            x = (x[:, :, 0:self.output_dim] * x[:, :, self.output_dim:self.output_dim * 2])
+        else:
+            x = (x[:, :, 0:self.output_dim] * self.glu_act(x[:, :, self.output_dim:self.output_dim * 2]))
+
+        return x
+
+
+def gelu_accurate(x):
+    if not hasattr(gelu_accurate, "_a"):
+        gelu_accurate._a = math.sqrt(2 / math.pi)
+    return (
+        0.5 * x * (1 + torch.tanh(gelu_accurate._a * (x + 0.044715 * torch.pow(x, 3))))
+    )
+
+
+def gelu(x: torch.Tensor) -> torch.Tensor:
+    return torch.nn.functional.gelu(x.float()).type_as(x)
+
+
+def get_activation_fn(activation: str):
+    """Returns the activation function corresponding to `activation`"""
+
+    if activation == "relu":
+        return F.relu
+    elif activation == "gelu":
+        return gelu
+    elif activation == "gelu_fast":
+        warnings.warn(
+            "--activation-fn=gelu_fast has been renamed to gelu_accurate"
+        )
+        return gelu_accurate
+    elif activation == "gelu_accurate":
+        return gelu_accurate
+    elif activation == "tanh":
+        return torch.tanh
+    elif activation == "linear":
+        return lambda x: x
+    elif activation == "glu":
+        return lambda x: x
+    else:
+        raise RuntimeError("--activation-fn {} not supported".format(activation))
+
+
+def quant_noise(module, p, block_size):
+    """
+    Wraps modules and applies quantization noise to the weights for
+    subsequent quantization with Iterative Product Quantization as
+    described in "Training with Quantization Noise for Extreme Model Compression"
+
+    Args:
+        - module: nn.Module
+        - p: amount of Quantization Noise
+        - block_size: size of the blocks for subsequent quantization with iPQ
+
+    Remarks:
+        - Module weights must have the right sizes wrt the block size
+        - Only Linear, Embedding and Conv2d modules are supported for the moment
+        - For more detail on how to quantize by blocks with convolutional weights,
+          see "And the Bit Goes Down: Revisiting the Quantization of Neural Networks"
+        - We implement the simplest form of noise here as stated in the paper
+          which consists in randomly dropping blocks
+    """
+
+    # if no quantization noise, don't register hook
+    if p <= 0:
+        return module
+
+    # supported modules
+    assert isinstance(module, (nn.Linear, nn.Embedding, nn.Conv2d))
+
+    # test whether module.weight has the right sizes wrt block_size
+    is_conv = module.weight.ndim == 4
+
+    # 2D matrix
+    if not is_conv:
+        assert (
+            module.weight.size(1) % block_size == 0
+        ), "Input features must be a multiple of block sizes"
+
+    # 4D matrix
+    else:
+        # 1x1 convolutions
+        if module.kernel_size == (1, 1):
+            assert (
+                module.in_channels % block_size == 0
+            ), "Input channels must be a multiple of block sizes"
+        # regular convolutions
+        else:
+            k = module.kernel_size[0] * module.kernel_size[1]
+            assert k % block_size == 0, "Kernel size must be a multiple of block size"
+
+    def _forward_pre_hook(mod, input):
+        # no noise for evaluation
+        if mod.training:
+            if not is_conv:
+                # gather weight and sizes
+                weight = mod.weight
+                in_features = weight.size(1)
+                out_features = weight.size(0)
+
+                # split weight matrix into blocks and randomly drop selected blocks
+                mask = torch.zeros(
+                    in_features // block_size * out_features, device=weight.device
+                )
+                mask.bernoulli_(p)
+                mask = mask.repeat_interleave(block_size, -1).view(-1, in_features)
+
+            else:
+                # gather weight and sizes
+                weight = mod.weight
+                in_channels = mod.in_channels
+                out_channels = mod.out_channels
+
+                # split weight matrix into blocks and randomly drop selected blocks
+                if mod.kernel_size == (1, 1):
+                    mask = torch.zeros(
+                        int(in_channels // block_size * out_channels),
+                        device=weight.device,
+                    )
+                    mask.bernoulli_(p)
+                    mask = mask.repeat_interleave(block_size, -1).view(-1, in_channels)
+                else:
+                    mask = torch.zeros(
+                        weight.size(0), weight.size(1), device=weight.device
+                    )
+                    mask.bernoulli_(p)
+                    mask = (
+                        mask.unsqueeze(2)
+                        .unsqueeze(3)
+                        .repeat(1, 1, mod.kernel_size[0], mod.kernel_size[1])
+                    )
+
+            # scale weights and apply mask
+            mask = mask.to(
+                torch.bool
+            )  # x.bool() is not currently supported in TorchScript
+            s = 1 / (1 - p)
+            mod.weight.data = s * weight.masked_fill(mask, 0)
+
+    module.register_forward_pre_hook(_forward_pre_hook)
+    return module
+

CoCap/cocap/modules/bert.py

@@ -0,0 +1,403 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2023/2/18 13:57
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : bert.py
+
+import math
+import torch
+import torch.nn as nn
+
+
+def make_shifted_mask(input_mask, max_v_len, max_t_len, memory_len=0):
+    """
+    Args:
+        input_mask: (N, L) with `1` indicates valid bits, `0` indicates pad
+        max_v_len: int, the first `max_v_len` is for video and its padding, the length
+            of the rest of the bits is `max_t_len`. We have L = `max_v_len` + `max_t_len`.
+            Note max_v_len may also include the memory len (M), thus max_v_len += M
+        max_t_len: int
+        memory_len: int, M
+    Returns:
+
+    >>> max_v_len = 2; max_t_len=3; input_mask = torch.randn(2, 5)
+    >>> make_pad_shifted_mask(input_mask, max_v_len, max_t_len)[0]
+    tensor([[1., 1., 0., 0., 0.],
+            [1., 1., 0., 0., 0.],
+            [1., 1., 1., 0., 0.],
+            [1., 1., 1., 1., 0.],
+            [1., 1., 1., 1., 1.]])
+    """
+    bsz, seq_len = input_mask.shape
+    assert max_v_len + max_t_len + memory_len == seq_len, f"{max_v_len} {max_t_len} {memory_len} {seq_len}"
+    shifted_mask = input_mask.new_zeros(bsz, max_v_len + max_t_len, seq_len)  # (N, L, M+L)
+    shifted_mask[:, :, :memory_len + max_v_len] = 1
+    shifted_mask[:, max_v_len:, memory_len + max_v_len:] = torch.tril(input_mask.new_ones(max_t_len, max_t_len),
+                                                                      diagonal=0)
+    return shifted_mask
+
+
+def make_pad_shifted_mask(input_mask, max_v_len, max_t_len, memory_len=0):
+    """input_mask: (N, L), """
+    shifted_mask = make_shifted_mask(input_mask, max_v_len, max_t_len, memory_len=memory_len)
+    kg_masks = shifted_mask * input_mask.unsqueeze(1)
+    return kg_masks
+
+
+class BertSelfAttention(nn.Module):
+    def __init__(self, config):
+        super(BertSelfAttention, self).__init__()
+        if config.hidden_size % config.num_attention_heads != 0:
+            raise ValueError(
+                "The hidden size (%d) is not a multiple of the number of attention "
+                "heads (%d)" % (config.hidden_size, config.num_attention_heads))
+        self.num_attention_heads = config.num_attention_heads
+        self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
+        self.all_head_size = self.num_attention_heads * self.attention_head_size
+
+        self.query = nn.Linear(config.hidden_size, self.all_head_size)
+        self.key = nn.Linear(config.hidden_size, self.all_head_size)
+        self.value = nn.Linear(config.hidden_size, self.all_head_size)
+
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def transpose_for_scores(self, x):
+        new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)  # (N, L, nh, dh)
+        x = x.view(*new_x_shape)
+        return x.permute(0, 2, 1, 3)  # (N, nh, L, dh)
+
+    def forward(self, query_states, key_states, value_states, attention_mask):
+        """
+        Args:
+            query_states: (N, Lq, D)
+            key_states: (N, L, D)
+            value_states: (N, L, D)
+            attention_mask: (N, Lq, L)
+
+        Returns:
+
+        """
+        # only need to mask the dimension where the softmax (last dim) is applied, as another dim (second last)
+        # will be ignored in future computation anyway
+        mixed_query_layer = self.query(query_states)
+        mixed_key_layer = self.key(key_states)
+        mixed_value_layer = self.value(value_states)
+
+        query_layer = self.transpose_for_scores(mixed_query_layer)  # (N, nh, Lq, dh)
+        key_layer = self.transpose_for_scores(mixed_key_layer)  # (N, nh, L, dh)
+        value_layer = self.transpose_for_scores(mixed_value_layer)  # (N, nh, L, dh)
+
+        # Take the dot product between "query" and "key" to get the raw attention scores.
+        attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))  # (N, nh, Lq, L)
+        attention_scores = attention_scores / math.sqrt(self.attention_head_size)
+        # Apply the attention mask is (precomputed for all modules in BertModel forward() function)
+        if attention_mask != None:
+            attention_mask = (1 - attention_mask.unsqueeze(1)) * -10000.  # (N, 1, Lq, L)
+            attention_scores = attention_scores + attention_mask
+
+        # Normalize the attention scores to probabilities.
+        attention_probs = nn.Softmax(dim=-1)(attention_scores)
+
+        # This is actually dropping out entire tokens to attend to, which might
+        # seem a bit unusual, but is taken from the original Transformer paper.
+        attention_probs = self.dropout(attention_probs)
+
+        context_layer = torch.matmul(attention_probs, value_layer)
+        context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
+        new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
+        context_layer = context_layer.view(*new_context_layer_shape)
+        return context_layer
+
+
+class BertSelfOutput(nn.Module):
+    def __init__(self, config):
+        super(BertSelfOutput, self).__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+
+class BertAttention(nn.Module):
+    def __init__(self, config):
+        super(BertAttention, self).__init__()
+        self.self = BertSelfAttention(config)
+        self.output = BertSelfOutput(config)
+
+    def forward(self, input_tensor, attention_mask):
+        self_output = self.self(input_tensor, input_tensor, input_tensor, attention_mask)
+        attention_output = self.output(self_output, input_tensor)
+        return attention_output
+
+
+class BertAttention_Cross(nn.Module):
+    def __init__(self, config):
+        super(BertAttention_Cross, self).__init__()
+        self.self = BertSelfAttention(config)
+        self.output = BertSelfOutput(config)
+
+    def forward(self, q, kv, attention_mask=None):
+        self_output = self.self(q, kv, kv, attention_mask)
+        attention_output = self.output(self_output, q)
+        return attention_output
+
+
+def gelu(x):
+    """Implementation of the gelu activation function.
+        For information: OpenAI GPT"s gelu is slightly different (and gives slightly different results):
+        0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))
+        Also see https://arxiv.org/abs/1606.08415
+    """
+    return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))
+
+
+class BertIntermediate(nn.Module):
+    def __init__(self, config):
+        super(BertIntermediate, self).__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.intermediate_act_fn = gelu
+
+    def forward(self, hidden_states):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.intermediate_act_fn(hidden_states)
+        return hidden_states
+
+
+class BertLayerNorm(nn.Module):
+    def __init__(self, hidden_size, eps=1e-12):
+        """Construct a layernorm module in the TF style (epsilon inside the square root).
+        """
+        super(BertLayerNorm, self).__init__()
+        self.weight = nn.Parameter(torch.ones(hidden_size))
+        self.bias = nn.Parameter(torch.zeros(hidden_size))
+        self.variance_epsilon = eps
+
+    def forward(self, x):
+        u = x.mean(-1, keepdim=True)
+        s = (x - u).pow(2).mean(-1, keepdim=True)
+        x = (x - u) / torch.sqrt(s + self.variance_epsilon)
+        return self.weight * x + self.bias
+
+
+class BertOutput(nn.Module):
+    def __init__(self, config):
+        super(BertOutput, self).__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+        self.dropout = nn.Dropout(config.hidden_dropout_prob)
+
+    def forward(self, hidden_states, input_tensor):
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states + input_tensor)
+        return hidden_states
+
+
+class BertLayerNoMemory(nn.Module):
+    def __init__(self, config):
+        super(BertLayerNoMemory, self).__init__()
+        self.config = config
+        self.attention = BertAttention(config)
+        self.hidden_intermediate = BertIntermediate(config)
+        self.memory_intermediate = BertIntermediate(config)
+        self.output = BertOutput(config)
+
+    def forward(self, hidden_states, attention_mask, n_v, n_t):
+        """
+        Args:
+            hidden_states: (N, L, D)
+            attention_mask: (N, L)
+        Returns:
+
+        """
+        # self-attention, need to shift right
+        shifted_self_mask = make_pad_shifted_mask(attention_mask, n_v, n_t)  # (N, L, L)
+        attention_output = self.attention(hidden_states, shifted_self_mask)  # (N, L, D)
+        intermediate_output = self.hidden_intermediate(attention_output)  # (N, L, D)
+        layer_output = self.output(intermediate_output, attention_output)  # (N, L, D)
+        return layer_output
+
+
+class BertSelfEncoder(nn.Module):
+    def __init__(self, cap_config):
+        super(BertSelfEncoder, self).__init__()
+        self.word_embeddings = nn.Embedding(cap_config.vocab_size, cap_config.word_vec_size, padding_idx=0)  # 词嵌入
+        self.word_fc = nn.Sequential(  # 300->768
+            BertLayerNorm(cap_config.word_vec_size, eps=cap_config.layer_norm_eps),
+            nn.Dropout(cap_config.hidden_dropout_prob),
+            nn.Linear(cap_config.word_vec_size, cap_config.hidden_size),
+            nn.ReLU(True),
+            BertLayerNorm(cap_config.hidden_size, eps=cap_config.layer_norm_eps),
+        )
+        self.video_embeddings = nn.Sequential(
+            BertLayerNorm(cap_config.video_feature_size, eps=cap_config.layer_norm_eps),
+            nn.Dropout(cap_config.hidden_dropout_prob),
+            nn.Linear(cap_config.video_feature_size, cap_config.hidden_size),
+            nn.ReLU(True),
+            BertLayerNorm(cap_config.hidden_size, eps=cap_config.layer_norm_eps),
+        )
+        self.position_embeddings = PositionEncoding(n_filters=cap_config.hidden_size, max_len=1000)
+        self.token_type_embeddings = nn.Embedding(3, cap_config.hidden_size)
+        self.LayerNorm = BertLayerNorm(cap_config.hidden_size, eps=cap_config.layer_norm_eps)
+        self.dropout = nn.Dropout(cap_config.hidden_dropout_prob)
+
+        self.config = cap_config
+        self.layers = cap_config.num_hidden_layers
+        self.layer_sa = nn.ModuleList([BertLayerNoMemory(cap_config) for _ in range(self.layers)])
+
+    def forward(self, vhidden_states, thidden_states, attention_mask, type_ids, encoded=False):
+        if not encoded:
+            # thidden_states could be encoded (pre-encoded using another text encoder), if not, add word embedding
+            thidden_states = self.word_embeddings(thidden_states)
+        thidden_states = self.word_fc(thidden_states)
+
+        vhidden_states = self.video_embeddings(vhidden_states)
+        hidden_states = torch.cat((vhidden_states, thidden_states), dim=1)
+
+        token_type_embeddings = self.token_type_embeddings(type_ids)
+        hidden_states = hidden_states + token_type_embeddings
+        hidden_states = self.position_embeddings(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states)
+        hidden_states = self.dropout(hidden_states)
+
+        for i in range(self.layers):
+            hidden_states = self.layer_sa[i](hidden_states, attention_mask, self.config.max_v_len,
+                                             self.config.max_t_len)
+        return hidden_states
+
+
+class BertLayerNoMemory_Cross(nn.Module):
+    def __init__(self, config):
+        super(BertLayerNoMemory_Cross, self).__init__()
+        self.config = config
+        self.attention = BertAttention_Cross(config)
+        self.hidden_intermediate = BertIntermediate(config)
+        self.output = BertOutput(config)
+
+    def forward(self, q, kv):
+        # shifted_self_mask = make_pad_cross_mask()  # (N, L, L)
+        attention_output = self.attention(q, kv)  # (N, L, D)
+        intermediate_output = self.hidden_intermediate(attention_output)  # (N, L, D)
+        layer_output = self.output(intermediate_output, attention_output)  # (N, L, D)
+        return layer_output
+
+
+class BertCrosEncoder(nn.Module):
+    def __init__(self, cap_config):
+        super(BertCrosEncoder, self).__init__()
+        self.word_fc = nn.Sequential(  # 300->768
+            BertLayerNorm(cap_config.word_vec_size, eps=cap_config.layer_norm_eps),
+            nn.Dropout(cap_config.hidden_dropout_prob),
+            nn.Linear(cap_config.word_vec_size, cap_config.hidden_size),
+            nn.ReLU(True),
+            BertLayerNorm(cap_config.hidden_size, eps=cap_config.layer_norm_eps),
+        )
+        self.video_embeddings = nn.Sequential(
+            BertLayerNorm(cap_config.video_feature_size, eps=cap_config.layer_norm_eps),
+            nn.Dropout(cap_config.hidden_dropout_prob),
+            nn.Linear(cap_config.video_feature_size, cap_config.hidden_size),
+            nn.ReLU(True),
+            BertLayerNorm(cap_config.hidden_size, eps=cap_config.layer_norm_eps),
+        )
+        self.layers = cap_config.num_hidden_layers
+        self.layer_sa = nn.ModuleList([BertLayerNoMemory(cap_config) for _ in range(self.layers)])
+        self.layer_ca = nn.ModuleList([BertLayerNoMemory_Cross(cap_config) for _ in range(self.layers)])
+        self.max_t_len = cap_config.max_t_len
+
+    def forward(self, vhidden_states, thidden_states, tmask, type_ids):
+        thidden_states = self.word_fc(thidden_states)
+        vhidden_states = self.video_embeddings(vhidden_states)
+        for i in range(self.layers):
+            # thidden_states = self.layer_sa[i](thidden_states, tmask.int(), 0, self.max_t_len) 加上效果变差
+            thidden_states = self.layer_ca[i](thidden_states, vhidden_states)
+        return thidden_states
+
+
+class BertPredictionHeadTransform(nn.Module):
+    def __init__(self, config):
+        super(BertPredictionHeadTransform, self).__init__()
+        self.dense = nn.Linear(config.hidden_size, config.hidden_size)
+        self.transform_act_fn = gelu
+        self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
+
+    def forward(self, hidden_states):
+        """(N, L, D)"""
+        hidden_states = self.dense(hidden_states)
+        hidden_states = self.transform_act_fn(hidden_states)
+        hidden_states = self.LayerNorm(hidden_states)
+        return hidden_states
+
+
+class BertLMPredictionHead(nn.Module):
+    def __init__(self, config, bert_model_embedding_weights=None):
+        super(BertLMPredictionHead, self).__init__()
+        self.transform = BertPredictionHeadTransform(config)
+
+        # The output weights are the same as the input embeddings, but there is
+        # an output-only bias for each token.
+        if config.share_wd_cls_weight:
+            assert bert_model_embedding_weights is not None, \
+                "bert_model_embedding_weights should not be None " \
+                "when setting --share_wd_cls_weight flag to be true"
+            assert config.hidden_size == bert_model_embedding_weights.size(1), \
+                "hidden size has be the same as word embedding size when " \
+                "sharing word embedding weight and classifier weight"
+            self.decoder = nn.Linear(bert_model_embedding_weights.size(1),
+                                     bert_model_embedding_weights.size(0),
+                                     bias=False)
+            self.decoder.weight = torch.nn.Parameter(bert_model_embedding_weights.clone())
+        else:
+            self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
+
+        self.bias = nn.Parameter(torch.zeros(config.vocab_size))
+
+    def forward(self, hidden_states):
+        """(N, L, D)"""
+        hidden_states = self.transform(hidden_states)
+        hidden_states = self.decoder(hidden_states) + self.bias
+        return hidden_states  # (N, L, vocab_size)
+
+
+class PositionEncoding(nn.Module):
+    """
+    Add positional information to input tensor.
+    :Examples:
+        >>> model = PositionEncoding(d_model=6, max_len=10, dropout=0)
+        >>> test_input1 = torch.zeros(3, 10, 6)
+        >>> output1 = model(test_input1)
+        >>> output1.size()
+        >>> test_input2 = torch.zeros(5, 3, 9, 6)
+        >>> output2 = model(test_input2)
+        >>> output2.size()
+    """
+
+    def __init__(self, n_filters=128, max_len=500):
+        """
+        :param n_filters: same with input hidden size
+        :param max_len: maximum sequence length
+        """
+        super(PositionEncoding, self).__init__()
+        # Compute the positional encodings once in log space.
+        pe = torch.zeros(max_len, n_filters)  # (L, D)
+        position = torch.arange(0, max_len).float().unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, n_filters, 2).float() * - (math.log(10000.0) / n_filters))
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        self.register_buffer("pe", pe)  # buffer is a tensor, not a variable, (L, D)
+
+    def forward(self, x):
+        """
+        :Input: (*, L, D)
+        :Output: (*, L, D) the same size as input
+        """
+        pe = self.pe.data[:x.size(-2), :]  # (#x.size(-2), n_filters)
+        extra_dim = len(x.size()) - 2
+        for _ in range(extra_dim):
+            pe = pe.unsqueeze(0)
+        x = x + pe
+        return x

CoCap/cocap/modules/clip/__init__.py

@@ -0,0 +1 @@
+from .clip import *

CoCap/cocap/modules/clip/bpe_simple_vocab_16e6.txt.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:924691ac288e54409236115652ad4aa250f48203de50a9e4722a6ecd48d6804a
+size 1356917

CoCap/cocap/modules/clip/clip.py

@@ -0,0 +1,250 @@
+import hashlib
+import os
+import urllib
+import warnings
+from typing import Optional
+from typing import Union, List
+
+import torch
+from PIL import Image
+from pkg_resources import packaging
+from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
+from tqdm import tqdm
+
+from .model import build_model
+from .simple_tokenizer import SimpleTokenizer as _Tokenizer
+
+try:
+    from torchvision.transforms import InterpolationMode
+
+    BICUBIC = InterpolationMode.BICUBIC
+except ImportError:
+    BICUBIC = Image.BICUBIC
+
+if packaging.version.parse(torch.__version__) < packaging.version.parse("1.7.1"):
+    warnings.warn("PyTorch version 1.7.1 or higher is recommended")
+
+__all__ = ["available_models", "load", "tokenize", "get_model_path"]
+_tokenizer = _Tokenizer()
+
+_MODELS = {
+    "RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt",
+    "RN101": "https://openaipublic.azureedge.net/clip/models/8fa8567bab74a42d41c5915025a8e4538c3bdbe8804a470a72f30b0d94fab599/RN101.pt",
+    "RN50x4": "https://openaipublic.azureedge.net/clip/models/7e526bd135e493cef0776de27d5f42653e6b4c8bf9e0f653bb11773263205fdd/RN50x4.pt",
+    "RN50x16": "https://openaipublic.azureedge.net/clip/models/52378b407f34354e150460fe41077663dd5b39c54cd0bfd2b27167a4a06ec9aa/RN50x16.pt",
+    "RN50x64": "https://openaipublic.azureedge.net/clip/models/be1cfb55d75a9666199fb2206c106743da0f6468c9d327f3e0d0a543a9919d9c/RN50x64.pt",
+    "ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt",
+    "ViT-B/16": "https://openaipublic.azureedge.net/clip/models/5806e77cd80f8b59890b7e101eabd078d9fb84e6937f9e85e4ecb61988df416f/ViT-B-16.pt",
+    "ViT-L/14": "https://openaipublic.azureedge.net/clip/models/b8cca3fd41ae0c99ba7e8951adf17d267cdb84cd88be6f7c2e0eca1737a03836/ViT-L-14.pt",
+    "ViT-L/14@336px": "https://openaipublic.azureedge.net/clip/models/3035c92b350959924f9f00213499208652fc7ea050643e8b385c2dac08641f02/ViT-L-14-336px.pt",
+}
+
+
+def _download(url: str, root: str):
+    os.makedirs(root, exist_ok=True)
+    filename = os.path.basename(url)
+
+    expected_sha256 = url.split("/")[-2]
+    download_target = os.path.join(root, filename)
+
+    if os.path.exists(download_target) and not os.path.isfile(download_target):
+        raise RuntimeError(f"{download_target} exists and is not a regular file")
+
+    if os.path.isfile(download_target):
+        if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256:
+            return download_target
+        else:
+            warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file")
+
+    with urllib.request.urlopen(url) as source, open(download_target, "wb") as output:
+        with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True,
+                  unit_divisor=1024) as loop:
+            while True:
+                buffer = source.read(8192)
+                if not buffer:
+                    break
+
+                output.write(buffer)
+                loop.update(len(buffer))
+
+    if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256:
+        raise RuntimeError("Model has been downloaded but the SHA256 checksum does not not match")
+
+    return download_target
+
+
+def _convert_image_to_rgb(image):
+    return image.convert("RGB")
+
+
+def _transform(n_px):
+    return Compose([
+        Resize(n_px, interpolation=BICUBIC),
+        CenterCrop(n_px),
+        _convert_image_to_rgb,
+        ToTensor(),
+        Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),
+    ])
+
+
+def available_models() -> List[str]:
+    """Returns the names of available CLIP modeling"""
+    return list(_MODELS.keys())
+
+
+def get_model_path(name: str, download_root: Optional[str] = None) -> str:
+    if name in _MODELS:
+        model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip"))
+    elif os.path.isfile(name):
+        model_path = name
+    else:
+        raise RuntimeError(f"Model {name} not found; available modeling = {available_models()}")
+    return model_path
+
+
+def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu",
+         jit: bool = False, download_root: str = None):
+    """Load a CLIP model
+
+    Parameters
+    ----------
+    name : str
+        A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict
+
+    device : Union[str, torch.device]
+        The device to put the loaded model
+
+    jit : bool
+        Whether to load the optimized JIT model or more hackable non-JIT model (default).
+
+    download_root: str
+        path to download the model files; by default, it uses "~/.cache/clip"
+
+    Returns
+    -------
+    model : torch.nn.Module
+        The CLIP model
+
+    preprocess : Callable[[PIL.Image], torch.Tensor]
+        A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input
+    """
+    if name in _MODELS:
+        model_path = _download(_MODELS[name], download_root or os.path.expanduser("~/.cache/clip"))
+    elif os.path.isfile(name):
+        model_path = name
+    else:
+        raise RuntimeError(f"Model {name} not found; available modeling = {available_models()}")
+
+    with open(model_path, 'rb') as opened_file:
+        try:
+            # loading JIT archive
+            model = torch.jit.load(opened_file, map_location=device if jit else "cpu").eval()
+            state_dict = None
+        except RuntimeError:
+            # loading saved state dict
+            if jit:
+                warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead")
+                jit = False
+            state_dict = torch.load(opened_file, map_location="cpu")
+
+    if not jit:
+        model = build_model(state_dict or model.state_dict()).to(device)
+        if str(device) == "cpu":
+            model.float()
+        return model, _transform(model.visual.input_resolution)
+
+    # patch the device names
+    device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
+    device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1]
+
+    def patch_device(module):
+        try:
+            graphs = [module.graph] if hasattr(module, "graph") else []
+        except RuntimeError:
+            graphs = []
+
+        if hasattr(module, "forward1"):
+            graphs.append(module.forward1.graph)
+
+        for graph in graphs:
+            for node in graph.findAllNodes("prim::Constant"):
+                if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"):
+                    node.copyAttributes(device_node)
+
+    model.apply(patch_device)
+    patch_device(model.encode_image)
+    patch_device(model.encode_text)
+
+    # patch dtype to float32 on CPU
+    if str(device) == "cpu":
+        float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[])
+        float_input = list(float_holder.graph.findNode("aten::to").inputs())[1]
+        float_node = float_input.node()
+
+        def patch_float(module):
+            try:
+                graphs = [module.graph] if hasattr(module, "graph") else []
+            except RuntimeError:
+                graphs = []
+
+            if hasattr(module, "forward1"):
+                graphs.append(module.forward1.graph)
+
+            for graph in graphs:
+                for node in graph.findAllNodes("aten::to"):
+                    inputs = list(node.inputs())
+                    for i in [1, 2]:  # dtype can be the second or third argument to aten::to()
+                        if inputs[i].node()["value"] == 5:
+                            inputs[i].node().copyAttributes(float_node)
+
+        model.apply(patch_float)
+        patch_float(model.encode_image)
+        patch_float(model.encode_text)
+
+        model.float()
+
+    return model, _transform(model.input_resolution.item())
+
+
+def tokenize(texts: Union[str, List[str]], context_length: int = 77, truncate: bool = False) -> Union[
+    torch.IntTensor, torch.LongTensor]:
+    """
+    Returns the tokenized representation of given input string(s)
+
+    Parameters
+    ----------
+    texts : Union[str, List[str]]
+        An input string or a list of input strings to tokenize
+
+    context_length : int
+        The context length to use; all CLIP modeling use 77 as the context length
+
+    truncate: bool
+        Whether to truncate the text in case its encoding is longer than the context length
+
+    Returns
+    -------
+    A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length].
+    We return LongTensor when torch version is <1.8.0, since older index_select requires indices to be long.
+    """
+    if isinstance(texts, str):
+        texts = [texts]
+
+    sot_token = _tokenizer.encoder["<|startoftext|>"]
+    eot_token = _tokenizer.encoder["<|endoftext|>"]
+    all_tokens = [[sot_token] + _tokenizer.encode(text) + [eot_token] for text in texts]
+    if packaging.version.parse(torch.__version__) < packaging.version.parse("1.8.0"):
+        result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
+    else:
+        result = torch.zeros(len(all_tokens), context_length, dtype=torch.int)
+
+    for i, tokens in enumerate(all_tokens):
+        if len(tokens) > context_length:
+            if truncate:
+                tokens = tokens[:context_length]
+                tokens[-1] = eot_token
+            else:
+                raise RuntimeError(f"Input {texts[i]} is too long for context length {context_length}")
+        result[i, :len(tokens)] = torch.tensor(tokens)
+
+    return result

CoCap/cocap/modules/clip/model.py

@@ -0,0 +1,500 @@
+# For visualizing the attention map, we adopted some changes from
+# https://github.com/ricardodeazambuja/CLIP/blob/attn_weights/clip/model.py
+
+
+import logging
+from collections import OrderedDict
+from typing import Tuple, Union
+
+import einops
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+
+logger = logging.getLogger(__name__)
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1):
+        super().__init__()
+
+        # all conv modules have stride 1. an avgpool is performed after the second convolution when stride > 1
+        self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.relu1 = nn.ReLU(inplace=True)
+
+        self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.relu2 = nn.ReLU(inplace=True)
+
+        self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
+
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
+        self.bn3 = nn.BatchNorm2d(planes * self.expansion)
+        self.relu3 = nn.ReLU(inplace=True)
+
+        self.downsample = None
+        self.stride = stride
+
+        if stride > 1 or inplanes != planes * Bottleneck.expansion:
+            # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
+            self.downsample = nn.Sequential(OrderedDict([
+                ("-1", nn.AvgPool2d(stride)),
+                ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)),
+                ("1", nn.BatchNorm2d(planes * self.expansion))
+            ]))
+
+    def forward(self, x: torch.Tensor):
+        identity = x
+
+        out = self.relu1(self.bn1(self.conv1(x)))
+        out = self.relu2(self.bn2(self.conv2(out)))
+        out = self.avgpool(out)
+        out = self.bn3(self.conv3(out))
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out += identity
+        out = self.relu3(out)
+        return out
+
+
+class AttentionPool2d(nn.Module):
+    def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None):
+        super().__init__()
+        self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
+        self.k_proj = nn.Linear(embed_dim, embed_dim)
+        self.q_proj = nn.Linear(embed_dim, embed_dim)
+        self.v_proj = nn.Linear(embed_dim, embed_dim)
+        self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
+        self.num_heads = num_heads
+
+    def forward(self, x):
+        x = x.flatten(start_dim=2).permute(2, 0, 1)  # NCHW -> (HW)NC
+        x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0)  # (HW+1)NC
+        x = x + self.positional_embedding[:, None, :].to(x.dtype)  # (HW+1)NC
+        x, _ = F.multi_head_attention_forward(
+            query=x[:1], key=x, value=x,
+            embed_dim_to_check=x.shape[-1],
+            num_heads=self.num_heads,
+            q_proj_weight=self.q_proj.weight,
+            k_proj_weight=self.k_proj.weight,
+            v_proj_weight=self.v_proj.weight,
+            in_proj_weight=None,
+            in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
+            bias_k=None,
+            bias_v=None,
+            add_zero_attn=False,
+            dropout_p=0,
+            out_proj_weight=self.c_proj.weight,
+            out_proj_bias=self.c_proj.bias,
+            use_separate_proj_weight=True,
+            training=self.training,
+            need_weights=False
+        )
+        return x.squeeze(0)
+
+
+class ModifiedResNet(nn.Module):
+    """
+    A ResNet class that is similar to torchvision's but contains the following changes:
+    - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool.
+    - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1
+    - The final pooling layer is a QKV attention instead of an average pool
+    """
+
+    def __init__(self, layers, output_dim, heads, input_resolution=224, width=64):
+        super().__init__()
+        self.output_dim = output_dim
+        self.input_resolution = input_resolution
+
+        # the 3-layer stem
+        self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(width // 2)
+        self.relu1 = nn.ReLU(inplace=True)
+        self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(width // 2)
+        self.relu2 = nn.ReLU(inplace=True)
+        self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(width)
+        self.relu3 = nn.ReLU(inplace=True)
+        self.avgpool = nn.AvgPool2d(2)
+
+        # residual modules
+        self._inplanes = width  # this is a *mutable* variable used during construction
+        self.layer1 = self._make_layer(width, layers[0])
+        self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
+        self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
+        self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
+
+        embed_dim = width * 32  # the ResNet feature dimension
+        self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim)
+
+    def _make_layer(self, planes, blocks, stride=1):
+        layers = [Bottleneck(self._inplanes, planes, stride)]
+
+        self._inplanes = planes * Bottleneck.expansion
+        for _ in range(1, blocks):
+            layers.append(Bottleneck(self._inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        def stem(x):
+            x = self.relu1(self.bn1(self.conv1(x)))
+            x = self.relu2(self.bn2(self.conv2(x)))
+            x = self.relu3(self.bn3(self.conv3(x)))
+            x = self.avgpool(x)
+            return x
+
+        x = x.type(self.conv1.weight.dtype)
+        x = stem(x)
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+        x = self.attnpool(x)
+
+        return x
+
+
+class LayerNorm(nn.LayerNorm):
+    """Subclass torch's LayerNorm to handle fp16."""
+
+    def forward(self, x: torch.Tensor):
+        orig_type = x.dtype
+        ret = super().forward(x.type(torch.float32))
+        return ret.type(orig_type)
+
+
+class QuickGELU(nn.Module):
+    def forward(self, x: torch.Tensor):
+        return x * torch.sigmoid(1.702 * x)
+
+
+class ResidualAttentionBlock(nn.Module):
+    def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
+        super().__init__()
+
+        self.attn = nn.MultiheadAttention(d_model, n_head)
+        self.ln_1 = LayerNorm(d_model)
+        self.mlp = nn.Sequential(OrderedDict([
+            ("c_fc", nn.Linear(d_model, d_model * 4)),
+            ("gelu", QuickGELU()),
+            ("c_proj", nn.Linear(d_model * 4, d_model))
+        ]))
+        self.ln_2 = LayerNorm(d_model)
+        self.attn_mask = attn_mask
+
+    def attention(self, x: torch.Tensor, padding_mask: torch.Tensor = None):
+        self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
+        return self.attn(x, x, x, need_weights=True, attn_mask=self.attn_mask, key_padding_mask=padding_mask,
+                         average_attn_weights=False)
+
+    def forward(self, x: torch.Tensor):
+        attention_res = self.attention(self.ln_1(x))
+        x, weights = x + attention_res[0], attention_res[1]
+        x = x + self.mlp(self.ln_2(x))
+        return x, weights
+
+
+class Transformer(nn.Module):
+    def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None):
+        super().__init__()
+        self.width = width
+        self.layers = layers
+        self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])
+
+    def forward(self, x: torch.Tensor):
+        weights_all_blocks = []
+
+        # Go through all the blocks (modules)
+        for block in self.resblocks:
+            x, weight = block(x)
+            weights_all_blocks.append(weight)
+
+        return x, torch.stack(weights_all_blocks)
+
+
+class VisionTransformer(nn.Module):
+    def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int,
+                 in_channels: int = 3):
+        super().__init__()
+        self.input_resolution = input_resolution
+        self.output_dim = output_dim
+        self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=width, kernel_size=patch_size, stride=patch_size,
+                               bias=False)
+
+        scale = width ** -0.5
+        self.class_embedding = nn.Parameter(scale * torch.randn(width))
+        self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width))
+        self.ln_pre = LayerNorm(width)
+
+        self.transformer = Transformer(width, layers, heads)
+
+        self.ln_post = LayerNorm(width)
+        self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
+
+    def forward(self, x: torch.Tensor, output_all_features: bool = False, output_attention_map: bool = False):
+        x = self.conv1(x)  # shape = [*, width, grid, grid]
+        grid = x.size(2)
+        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
+        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
+        x = torch.cat(
+            [self.class_embedding.to(x.dtype) +
+             torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x],
+            dim=1
+        )  # shape = [*, grid ** 2 + 1, width]
+        x = x + self.positional_embedding.to(x.dtype)
+        x = self.ln_pre(x)
+
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        x, attn = self.transformer(x)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+
+        cls_feature = self.ln_post(x[:, 0, :]) @ self.proj
+
+        outputs = (cls_feature,)
+        if output_all_features:
+            # cls token is not included
+            outputs += (x[:, 1:, :],)
+        if output_attention_map:
+            # attention_map: n_layers, batch_size, n_heads, h, w
+            outputs += (einops.rearrange(attn[:, :, :, 0, 1:],
+                                         "n_layers b n_heads (h w)->n_layers b n_heads h w", h=grid, w=grid),)
+        return outputs
+
+
+class CrossResidualAttentionBlock(ResidualAttentionBlock):
+    """modified version of ResidualAttentionBlock to support the encoder-decoder attention between I-frame tokens and
+    motion vector/residual"""
+
+    def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None,
+                 enc_dec_attn_mask: torch.Tensor = None):
+        super().__init__(d_model=d_model, n_head=n_head, attn_mask=attn_mask)
+        self.attn2 = nn.MultiheadAttention(d_model, n_head)
+        self.ln_3 = LayerNorm(d_model)
+        self.ln_4 = LayerNorm(d_model)
+        self.enc_dec_attn_mask = enc_dec_attn_mask
+
+    def enc_dec_attention(self, highway: torch.Tensor, iframe: torch.Tensor):
+        self.enc_dec_attn_mask = self.enc_dec_attn_mask.to(dtype=highway.dtype,
+                                                           device=highway.device) if self.enc_dec_attn_mask is not None else None
+        return self.attn2(highway, iframe, iframe, need_weights=False, attn_mask=self.enc_dec_attn_mask)[0]
+
+    def forward(self, x: [torch.Tensor, torch.Tensor, torch.LongTensor]):
+        highway, iframe, self_mask = x
+        # self-attention
+        out, attn = self.attention(self.ln_1(highway), padding_mask=self_mask)
+        x = highway + out
+        # enc-dec attention
+        if iframe is not None:
+            x = x + self.enc_dec_attention(self.ln_3(x), self.ln_4(iframe))
+        # mlp
+        x = x + self.mlp(self.ln_2(x))
+        return [x, iframe, self_mask]
+
+
+class CLIP(nn.Module):
+    def __init__(self,
+                 embed_dim: int,
+                 # vision
+                 image_resolution: int,
+                 vision_layers: Union[Tuple[int, int, int, int], int],
+                 vision_width: int,
+                 vision_patch_size: int,
+                 # text
+                 context_length: int,
+                 vocab_size: int,
+                 transformer_width: int,
+                 transformer_heads: int,
+                 transformer_layers: int
+                 ):
+        super().__init__()
+
+        self.context_length = context_length
+
+        if isinstance(vision_layers, (tuple, list)):
+            vision_heads = vision_width * 32 // 64
+            self.visual = ModifiedResNet(
+                layers=vision_layers,
+                output_dim=embed_dim,
+                heads=vision_heads,
+                input_resolution=image_resolution,
+                width=vision_width
+            )
+        else:
+            vision_heads = vision_width // 64
+            self.visual = VisionTransformer(
+                input_resolution=image_resolution,
+                patch_size=vision_patch_size,
+                width=vision_width,
+                layers=vision_layers,
+                heads=vision_heads,
+                output_dim=embed_dim
+            )
+
+        self.transformer = Transformer(
+            width=transformer_width,
+            layers=transformer_layers,
+            heads=transformer_heads,
+            attn_mask=self.build_attention_mask()
+        )
+
+        self.vocab_size = vocab_size
+        self.token_embedding = nn.Embedding(vocab_size, transformer_width)
+        self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width))
+        self.ln_final = LayerNorm(transformer_width)
+
+        self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim))
+        self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
+
+        self.initialize_parameters()
+
+    def initialize_parameters(self):
+        nn.init.normal_(self.token_embedding.weight, std=0.02)
+        nn.init.normal_(self.positional_embedding, std=0.01)
+
+        if isinstance(self.visual, ModifiedResNet):
+            if self.visual.attnpool is not None:
+                std = self.visual.attnpool.c_proj.in_features ** -0.5
+                nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std)
+                nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std)
+
+            for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]:
+                for name, param in resnet_block.named_parameters():
+                    if name.endswith("bn3.weight"):
+                        nn.init.zeros_(param)
+
+        proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)
+        attn_std = self.transformer.width ** -0.5
+        fc_std = (2 * self.transformer.width) ** -0.5
+        for block in self.transformer.resblocks:
+            nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
+            nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
+            nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
+            nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)
+
+        if self.text_projection is not None:
+            nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)
+
+    def build_attention_mask(self):
+        # lazily create causal attention mask, with full attention between the vision tokens
+        # pytorch uses additive attention mask; fill with -inf
+        mask = torch.empty(self.context_length, self.context_length)
+        mask.fill_(float("-inf"))
+        mask.triu_(1)  # zero out the lower diagonal
+        return mask
+
+    @property
+    def dtype(self):
+        return self.visual.conv1.weight.dtype
+
+    def encode_image(self, image, output_all_features=False, output_attention_map=False):
+        return self.visual(image.type(self.dtype), output_all_features, output_attention_map)
+
+    def encode_text(self, text, output_all_features=False):
+        x = self.token_embedding(text).type(self.dtype)  # [batch_size, n_ctx, d_model]
+
+        x = x + self.positional_embedding.type(self.dtype)
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        x, _ = self.transformer(x)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+        x = self.ln_final(x).type(self.dtype)
+
+        # x.shape = [batch_size, n_ctx, transformer.width]
+        if output_all_features:
+            return x
+        else:
+            # take features from the eot embedding (eot_token is the highest number in each sequence)
+            x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
+
+        return x
+
+    def forward(self, image, text):
+        image_features = self.encode_image(image)
+        text_features = self.encode_text(text)
+
+        # normalized features
+        image_features = image_features / image_features.norm(dim=1, keepdim=True)
+        text_features = text_features / text_features.norm(dim=1, keepdim=True)
+
+        # cosine similarity as logits
+        logit_scale = self.logit_scale.exp()
+        logits_per_image = logit_scale * image_features @ text_features.t()
+        logits_per_text = logits_per_image.t()
+
+        # shape = [global_batch_size, global_batch_size]
+        return logits_per_image, logits_per_text
+
+
+def convert_weights(model: nn.Module):
+    """Convert applicable model parameters to fp16"""
+
+    def _convert_weights_to_fp16(l):
+        if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
+            l.weight.data = l.weight.data.half()
+            if l.bias is not None:
+                l.bias.data = l.bias.data.half()
+
+        if isinstance(l, nn.MultiheadAttention):
+            for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
+                tensor = getattr(l, attr)
+                if tensor is not None:
+                    tensor.data = tensor.data.half()
+
+        for name in ["text_projection", "proj"]:
+            if hasattr(l, name):
+                attr = getattr(l, name)
+                if attr is not None:
+                    attr.data = attr.data.half()
+
+    model.apply(_convert_weights_to_fp16)
+
+
+def build_model(state_dict: dict):
+    vit = "visual.proj" in state_dict
+
+    if vit:
+        vision_width = state_dict["visual.conv1.weight"].shape[0]
+        vision_layers = len(
+            [k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
+        vision_patch_size = state_dict["visual.conv1.weight"].shape[-1]
+        grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
+        image_resolution = vision_patch_size * grid_size
+    else:
+        counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in
+                        [1, 2, 3, 4]]
+        vision_layers = tuple(counts)
+        vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0]
+        output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5)
+        vision_patch_size = None
+        assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0]
+        image_resolution = output_width * 32
+
+    embed_dim = state_dict["text_projection"].shape[1]
+    context_length = state_dict["positional_embedding"].shape[0]
+    vocab_size = state_dict["token_embedding.weight"].shape[0]
+    transformer_width = state_dict["ln_final.weight"].shape[0]
+    transformer_heads = transformer_width // 64
+    transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks")))
+
+    model = CLIP(
+        embed_dim,
+        image_resolution, vision_layers, vision_width, vision_patch_size,
+        context_length, vocab_size, transformer_width, transformer_heads, transformer_layers
+    )
+
+    for key in ["input_resolution", "context_length", "vocab_size"]:
+        if key in state_dict:
+            del state_dict[key]
+
+    convert_weights(model)
+    model.load_state_dict(state_dict)
+    return model.eval()

CoCap/cocap/modules/clip/simple_tokenizer.py

@@ -0,0 +1,134 @@
+import gzip
+import html
+import os
+from functools import lru_cache
+
+import ftfy
+import regex as re
+
+
+@lru_cache()
+def default_bpe():
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz")
+
+
+@lru_cache()
+def bytes_to_unicode():
+    """
+    Returns list of utf-8 byte and a corresponding list of unicode strings.
+    The reversible bpe codes work on unicode strings.
+    This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.
+    When you're at something like a 10B token dataset you end up needing around 5K for decent coverage.
+    This is a signficant percentage of your normal, say, 32K bpe vocab.
+    To avoid that, we want lookup tables between utf-8 bytes and unicode strings.
+    And avoids mapping to whitespace/control characters the bpe code barfs on.
+    """
+    bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1)) + list(range(ord("®"), ord("ÿ") + 1))
+    cs = bs[:]
+    n = 0
+    for b in range(2 ** 8):
+        if b not in bs:
+            bs.append(b)
+            cs.append(2 ** 8 + n)
+            n += 1
+    cs = [chr(n) for n in cs]
+    return dict(zip(bs, cs))
+
+
+def get_pairs(word):
+    """Return set of symbol pairs in a word.
+    Word is represented as tuple of symbols (symbols being variable-length strings).
+    """
+    pairs = set()
+    prev_char = word[0]
+    for char in word[1:]:
+        pairs.add((prev_char, char))
+        prev_char = char
+    return pairs
+
+
+def basic_clean(text):
+    text = ftfy.fix_text(text)
+    text = html.unescape(html.unescape(text))
+    return text.strip()
+
+
+def whitespace_clean(text):
+    text = re.sub(r'\s+', ' ', text)
+    text = text.strip()
+    return text
+
+
+class SimpleTokenizer(object):
+    def __init__(self, bpe_path: str = default_bpe()):
+        self.byte_encoder = bytes_to_unicode()
+        self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
+        merges = gzip.open(bpe_path).read().decode("utf-8").split('\n')
+        merges = merges[1:49152 - 256 - 2 + 1]
+        merges = [tuple(merge.split()) for merge in merges]
+        vocab = list(bytes_to_unicode().values())
+        vocab = vocab + [v + '</w>' for v in vocab]
+        for merge in merges:
+            vocab.append(''.join(merge))
+        vocab.extend(['<|startoftext|>', '<|endoftext|>'])
+        self.encoder = dict(zip(vocab, range(len(vocab))))
+        self.decoder = {v: k for k, v in self.encoder.items()}
+        self.bpe_ranks = dict(zip(merges, range(len(merges))))
+        self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'}
+        self.pat = re.compile(
+            r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""",
+            re.IGNORECASE)
+
+    def bpe(self, token):
+        if token in self.cache:
+            return self.cache[token]
+        word = tuple(token[:-1]) + (token[-1] + '</w>',)
+        pairs = get_pairs(word)
+
+        if not pairs:
+            return token + '</w>'
+
+        while True:
+            bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float('inf')))
+            if bigram not in self.bpe_ranks:
+                break
+            first, second = bigram
+            new_word = []
+            i = 0
+            while i < len(word):
+                try:
+                    j = word.index(first, i)
+                    new_word.extend(word[i:j])
+                    i = j
+                except:
+                    new_word.extend(word[i:])
+                    break
+
+                if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
+                    new_word.append(first + second)
+                    i += 2
+                else:
+                    new_word.append(word[i])
+                    i += 1
+            new_word = tuple(new_word)
+            word = new_word
+            if len(word) == 1:
+                break
+            else:
+                pairs = get_pairs(word)
+        word = ' '.join(word)
+        self.cache[token] = word
+        return word
+
+    def encode(self, text):
+        bpe_tokens = []
+        text = whitespace_clean(basic_clean(text)).lower()
+        for token in re.findall(self.pat, text):
+            token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8'))
+            bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' '))
+        return bpe_tokens
+
+    def decode(self, tokens):
+        text = ''.join([self.decoder[token] for token in tokens])
+        text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('</w>', ' ')
+        return text

CoCap/cocap/modules/compressed_video/__init__.py

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+# @Time    : 4/24/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : __init__.py
+
+from .compressed_video_captioner import *
+from .compressed_video_transformer import *

CoCap/cocap/modules/compressed_video/compressed_video_captioner.py

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+# @Time    : 8/6/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : compressed_video_captioner.py
+
+__all__ = [
+    "CaptionHead",
+    "CompressedVideoCaptioner",
+    "caption_head_cfg",
+    "caption_head_pretrained_cfg",
+    "compressed_video_captioner_cfg",
+    "compressed_video_captioner_pretrained_cfg",
+]
+
+import logging
+from typing import *
+
+import numpy as np
+import torch
+from easydict import EasyDict as edict
+from hydra_zen import builds
+from torch import Tensor
+from torch import nn
+
+from cocap.modules.bert import BertSelfEncoder, BertLMPredictionHead
+from cocap.modules.clip.clip import get_model_path
+from cocap.modules.clip.model import CLIP
+from cocap.modules.compressed_video.compressed_video_transformer import CompressedVideoTransformer, \
+    compressed_video_transformer_pretrained_cfg, compressed_video_transformer_cfg
+
+logger = logging.getLogger(__name__)
+
+
+class CaptionHead(nn.Module):
+
+    def __init__(
+            self,
+            word_embedding_size: int, visual_feature_size: int,
+            max_v_len: int, max_t_len: int, hidden_size: int,
+            vocab_size: int, verbose: Optional[Union[int, bool]] = False
+    ):
+        super(CaptionHead, self).__init__()
+        self.model_network = "Self"
+        self.cap_config = edict(
+            word_vec_size=word_embedding_size,
+            max_v_len=max_v_len,
+            max_t_len=max_t_len,
+            hidden_size=hidden_size,
+            video_feature_size=visual_feature_size,
+            layer_norm_eps=1e-12,  # bert layernorm
+            hidden_dropout_prob=0.1,  # applies everywhere except attention
+            num_hidden_layers=2,  # number of transformer modules
+            num_attention_heads=8,
+            share_wd_cls_weight=False,
+            vocab_size=vocab_size,
+            BOS_id=vocab_size - 2,
+            EOS_id=vocab_size - 1,
+            PAD_id=0
+        )
+        logger.debug("Caption Head Configuration: %s", self.cap_config)
+        self.cap_sa_decoder = BertSelfEncoder(self.cap_config)
+        self.prediction_head = BertLMPredictionHead(self.cap_config, self.cap_sa_decoder.word_embeddings.weight)
+        # debug output cfgs
+        if verbose:
+            if isinstance(verbose, bool):
+                self.log_interval = 1
+            else:
+                self.log_interval = int(verbose)
+        else:
+            self.log_interval = float("inf")
+        self.step_counter = 1
+
+    @staticmethod
+    @torch.no_grad()
+    def probability2text(predict_scores=None):
+        predict_ids = predict_scores.max(-1)[1]
+        return CaptionHead.ids2text(predict_ids)
+
+    @staticmethod
+    @torch.no_grad()
+    def ids2text(gt_ids: Union[np.ndarray, Tensor]):
+        from cocap.trainer.cocap_trainer import convert_ids_to_sentence
+        if isinstance(gt_ids, np.ndarray) or isinstance(gt_ids, Tensor):
+            assert 0 < len(gt_ids.shape) <= 2, f"gt_ids should be a 1 dim or 2 dim array/tensor, got {gt_ids.shape}"
+        else:
+            raise ValueError("gt_ids should be np.ndarray or Tensor")
+        if isinstance(gt_ids, Tensor):
+            gt_ids = gt_ids.detach().cpu().numpy()
+        if len(gt_ids.shape) == 1:
+            return convert_ids_to_sentence(gt_ids.tolist())
+        else:
+            return [convert_ids_to_sentence(_gt_ids) for _gt_ids in gt_ids.tolist()]
+
+    def forward(self, visual_output, input_ids, input_mask):
+        assert input_ids.size(1) == self.cap_config.max_t_len, f"{input_ids.size(1)} vs {self.cap_config.max_t_len}"
+
+        input_types = torch.concat(
+            [
+                torch.full((visual_output["feature_context"].size(0), visual_output["feature_context"].size(1)),
+                           fill_value=1, dtype=torch.long, device=visual_output["feature_context"].device),
+                torch.full((visual_output["feature_action"].size(0), visual_output["feature_action"].size(1)),
+                           fill_value=0, dtype=torch.long, device=visual_output["feature_action"].device),
+                torch.full((input_ids.size(0), input_ids.size(1)),
+                           fill_value=2, dtype=torch.long, device=input_ids.device)
+            ], dim=1
+        )
+        visual_output = torch.cat([visual_output["feature_context"], visual_output["feature_action"]], dim=1)
+        input_mask = torch.concat(
+            [
+                torch.ones(size=(visual_output.size(0), visual_output.size(1)),
+                           dtype=torch.long, device=visual_output.device),
+                input_mask
+            ], dim=1
+        )
+        hidden = self.cap_sa_decoder.forward(visual_output, input_ids, input_mask, input_types)
+        prediction_scores = self.prediction_head(hidden[:, -self.cap_config.max_t_len:])
+        if self.step_counter % self.log_interval == 0:
+            logger.debug("GT  : %s", self.ids2text(input_ids))
+            logger.debug("Pred: %s", self.probability2text(prediction_scores))
+        self.step_counter += 1
+        return prediction_scores
+
+    @classmethod
+    def from_pretrained(
+            cls,
+            pretrained_clip_name_or_path: str = "ViT-B/16", max_v_len: int = 8 * 2, max_t_len: int = 77,
+            verbose: Optional[Union[int, bool]] = False
+    ):
+        model_path = get_model_path(pretrained_clip_name_or_path, download_root="model_zoo/clip_model")
+        pretrained_model: CLIP = torch.jit.load(model_path, map_location="cpu")
+        state_dict = pretrained_model.state_dict()
+
+        embed_dim = state_dict["text_projection"].shape[1]
+        vocab_size = state_dict["token_embedding.weight"].shape[0]
+        transformer_width = state_dict["ln_final.weight"].shape[0]
+
+        head = cls(
+            word_embedding_size=transformer_width,
+            visual_feature_size=embed_dim,
+            max_v_len=max_v_len,
+            max_t_len=max_t_len,
+            hidden_size=embed_dim,
+            vocab_size=vocab_size,
+            verbose=verbose
+        )
+        logger.debug(
+            "Pretrained embedding parameters: %s",
+            [k for k, v in state_dict.items() if k.startswith("token_embedding")]
+        )
+        pretrained_embedding = {k.lstrip("token_embedding."): v for k, v in state_dict.items()
+                                if k.startswith("token_embedding")}
+        head.cap_sa_decoder.word_embeddings.load_state_dict(pretrained_embedding, strict=True)
+        head.prediction_head.decoder.load_state_dict(pretrained_embedding, strict=True)
+        assert torch.equal(head.cap_sa_decoder.word_embeddings.weight, head.prediction_head.decoder.weight)
+        return head
+
+
+class CompressedVideoCaptioner(nn.Module):
+
+    def __init__(
+            self,
+            compressed_video_transformer: CompressedVideoTransformer,
+            caption_head: CaptionHead,
+            motion_dropout_prob: float = 0.2,
+            residual_dropout_prob: float = 0.2,
+    ):
+        super().__init__()
+        self.compressed_video_transformer = compressed_video_transformer
+        self.caption_head = caption_head
+
+        self.dropout_motion = nn.Dropout(motion_dropout_prob)
+        self.dropout_residual = nn.Dropout(residual_dropout_prob)
+
+    def forward(self, inputs: Dict[str, Union[Tensor, Dict[str, Tensor]]]):
+        """
+
+        :param inputs:
+            video:
+                iframe:         batch_size n_gop c h w
+                motion_vector:  batch_size n_gop n_mv c=4|9 h/4 w/4
+                residual:       batch_size n_gop n_res c h w
+                input_mask_gop: batch_size n_gop
+                input_mask_mv:  batch_size n_gop n_mv
+        :return:
+        """
+        if "visual_output" not in inputs:
+            iframe = inputs["video"]["iframe"]
+            motion = inputs["video"]["motion_vector"]
+            residual = inputs["video"]["residual"] / 128 - 1  # for saving memory
+            bp_type_ids = inputs["video"]["type_ids_mv"]
+
+            motion = self.dropout_motion(motion)
+            residual = self.dropout_residual(residual)
+            compressed_visual_features = self.compressed_video_transformer(
+                iframe=iframe,
+                motion=motion,
+                residual=residual,
+                bp_type_ids=bp_type_ids
+            )
+        else:
+            # reuse pre-extracted visual features
+            compressed_visual_features = inputs["visual_output"]
+
+        prediction_scores = self.caption_head(
+            compressed_visual_features,
+            inputs["input_ids"],
+            inputs["input_mask"],
+        )
+        return {"prediction_scores": prediction_scores, "visual_output": compressed_visual_features}
+
+
+# Build configs for organizing modules with hydra
+caption_head_cfg = builds(CaptionHead, populate_full_signature=True)
+caption_head_pretrained_cfg = builds(CaptionHead.from_pretrained, populate_full_signature=True)
+
+compressed_video_captioner_cfg = builds(
+    CompressedVideoCaptioner,
+    compressed_video_transformer=compressed_video_transformer_cfg,
+    caption_head=caption_head_cfg,
+    populate_full_signature=True
+)
+compressed_video_captioner_pretrained_cfg = builds(
+    CompressedVideoCaptioner,
+    compressed_video_transformer=compressed_video_transformer_pretrained_cfg,
+    caption_head=caption_head_pretrained_cfg,
+    populate_full_signature=True
+)

CoCap/cocap/modules/compressed_video/compressed_video_transformer.py

@@ -0,0 +1,317 @@
+# -*- coding: utf-8 -*-
+# @Time    : 8/2/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : compressed_video_transformer.py
+
+__all__ = [
+    "IFrameEncoder",
+    "ActionEncoder",
+    "CompressedVideoTransformer",
+    "iframe_encoder_cfg",
+    "iframe_encoder_pretrained_cfg",
+    "action_encoder_cfg",
+    "motion_encoder_cfg",
+    "compressed_video_transformer_cfg",
+    "compressed_video_transformer_pretrained_cfg",
+]
+
+import logging
+from typing import Optional, Dict, Tuple
+
+import einops
+import torch
+import torch.nn as nn
+from hydra_zen import builds
+
+from cocap.modules.clip.clip import get_model_path
+from cocap.modules.clip.model import VisionTransformer, CrossResidualAttentionBlock, LayerNorm, CLIP
+
+logger = logging.getLogger(__name__)
+
+
+class IFrameEncoder(VisionTransformer):
+    def __init__(
+            self,
+            input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int,
+            in_channels: int = 3
+    ):
+        super().__init__(
+            input_resolution=input_resolution, patch_size=patch_size, width=width, layers=layers, heads=heads,
+            output_dim=output_dim, in_channels=in_channels
+        )
+
+        scale = width ** -0.5
+        self.ln_post_hidden = LayerNorm(width)
+        self.proj_hidden = nn.Parameter(scale * torch.randn(width, output_dim))
+
+    def forward(self, x: torch.Tensor, output_all_features: bool = False, output_attention_map: bool = False):
+        x = self.conv1(x)  # shape = [*, width, grid, grid]
+        grid = x.size(2)
+        x = x.reshape(x.shape[0], x.shape[1], -1)  # shape = [*, width, grid ** 2]
+        x = x.permute(0, 2, 1)  # shape = [*, grid ** 2, width]
+        x = torch.cat(
+            [self.class_embedding.to(x.dtype) +
+             torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x],
+            dim=1
+        )  # shape = [*, grid ** 2 + 1, width]
+        x = x + self.positional_embedding.to(x.dtype)
+        x = self.ln_pre(x)
+
+        x = x.permute(1, 0, 2)  # NLD -> LND
+        x, attn = self.transformer(x)
+        x = x.permute(1, 0, 2)  # LND -> NLD
+
+        cls_feature = self.ln_post(x[:, 0, :]) @ self.proj
+
+        outputs = (cls_feature,)
+        if output_all_features:
+            # cls token is not included
+            outputs += (self.ln_post_hidden(x[:, 1:, :]) @ self.proj_hidden,)
+        if output_attention_map:
+            # attention_map: n_layers, batch_size, n_heads, h, w
+            outputs += (einops.rearrange(attn[:, :, :, 0, 1:],
+                                         "n_layers b n_heads (h w)->n_layers b n_heads h w", h=grid, w=grid),)
+        return outputs
+
+    @classmethod
+    def from_pretrained(cls, pretrained_clip_name_or_path: str) -> Tuple["IFrameEncoder", int, int, int]:
+        """
+        Load from pretrained CLIP model
+        :param pretrained_clip_name_or_path: the name of pretrained CLIP model
+        :return: IFrameEncoder, image_resolution, vision_width, embed_dim
+        """
+        model_path = get_model_path(pretrained_clip_name_or_path)
+        pretrained_model: CLIP = torch.jit.load(model_path, map_location="cpu")
+        state_dict = pretrained_model.state_dict()
+
+        vision_width: int = state_dict["visual.conv1.weight"].shape[0]
+        vision_layers: int = len([k for k in state_dict.keys()
+                                  if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
+        embed_dim: int = state_dict["text_projection"].shape[1]
+        vision_patch_size: int = state_dict["visual.conv1.weight"].shape[-1]
+        grid_size: int = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
+        image_resolution: int = vision_patch_size * grid_size
+        vision_heads = vision_width // 64
+
+        rgb_encoder = cls(
+            input_resolution=image_resolution,
+            patch_size=vision_patch_size,
+            width=vision_width, layers=vision_layers, heads=vision_heads,
+            output_dim=embed_dim
+        )
+        visual_state_dict = pretrained_model.visual.state_dict()
+        # manually build the state dict to make sure pretrained weights are loaded exactly
+        visual_state_dict.update({k: v for k, v in rgb_encoder.state_dict().items() if k.startswith("ln_post_hidden")})
+        visual_state_dict.update({k: v for k, v in rgb_encoder.state_dict().items() if k.startswith("proj_hidden")})
+        rgb_encoder.load_state_dict(visual_state_dict, strict=True)
+
+        return rgb_encoder, image_resolution, vision_width, embed_dim
+
+
+class ActionEncoder(nn.Module):
+    def __init__(self, width: int, layers: int, heads: int, n_bp: int, n_bp_type: int, attn_mask: torch.Tensor = None):
+        super().__init__()
+        self.width = width
+        self.layers = layers
+        self.resblocks = nn.Sequential(*[CrossResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])
+
+        self.positional_embedding = nn.Embedding(n_bp, width)
+        self.bp_type_embedding = nn.Embedding(n_bp_type, width)
+
+        self.ln_post = LayerNorm(width)
+
+    def forward(
+            self,
+            feature_bp: torch.FloatTensor,
+            bp_type_ids: torch.LongTensor,
+            feature_ctx: torch.FloatTensor = None,
+            self_mask: torch.Tensor = None
+    ):
+        """
+        Fuse I-frames, motion vectors and residuals.
+        The feature dimension of feature_bp and feature_ctx are the same.
+        :param feature_bp:  (bsz n_gop) n_bp c
+        :param bp_type_ids: (bsz n_gop) n_bp
+        :param feature_ctx: (bsz n_gop) (h w) c
+        :param self_mask: attention mask
+        :return:
+        """
+        assert feature_bp.size(1) == self.positional_embedding.num_embeddings
+        bsz = feature_bp.size(0)
+
+        positional_embedding = self.positional_embedding(
+            torch.LongTensor(list(range(feature_bp.size(1)))).to(feature_bp.device).unsqueeze(0).repeat(bsz, 1)
+        )
+        bp_type_embedding = self.bp_type_embedding(bp_type_ids)
+        feature_bp = feature_bp + positional_embedding + bp_type_embedding
+
+        feature_bp, _, _ = self.resblocks([feature_bp.permute(1, 0, 2), feature_ctx.permute(1, 0, 2), self_mask])
+        feature_bp = torch.mean(feature_bp.permute(1, 0, 2), dim=1)  # pooling
+        return self.ln_post(feature_bp)
+
+
+class CompressedVideoTransformer(nn.Module):
+    def __init__(
+            self,
+            rgb_encoder: nn.Module,
+            motion_encoder: Optional[nn.Module],
+            residual_encoder: Optional[nn.Module],
+            action_encoder: Optional[nn.Module],
+            output_dim: int,
+    ):
+        """
+        Encode visual feature from video compressed domain
+        :param rgb_encoder:
+        :param motion_encoder:
+        :param residual_encoder:
+        :param action_encoder: ActionEncoder used to fuse the rgb, motion and residual features
+        :param output_dim: width of output visual feature
+        """
+        super().__init__()
+        assert motion_encoder is not None or residual_encoder is not None
+        self.rgb_encoder = rgb_encoder
+        self.motion_encoder = motion_encoder
+        self.residual_encoder = residual_encoder
+        self.action_encoder = action_encoder
+        self.output_dim = output_dim
+
+    def forward(
+            self,
+            iframe: torch.FloatTensor,
+            motion: torch.FloatTensor,
+            residual: torch.FloatTensor,
+            bp_type_ids: torch.LongTensor
+    ) -> Dict[str, torch.Tensor]:
+        """
+
+        :param iframe:      bsz n_gop c h w
+        :param motion:      bsz n_gop n_bp c_mv h/4 w/4
+        :param residual:    bsz n_gop n_bp c h w
+        :param bp_type_ids: bsz n_gop n_bp
+        """
+        # a long list of dimension check
+        assert (len(iframe.shape) == 5 and len(motion.shape) == 6 and len(residual.shape) == 6 and
+                len(bp_type_ids.shape) == 3)
+        assert iframe.size(0) == motion.size(0) == residual.size(0) == bp_type_ids.size(0), "batch size should be equal"
+        assert iframe.size(1) == motion.size(1) == residual.size(1) == bp_type_ids.size(1), "n_gop should be equal"
+        assert motion.size(2) == residual.size(2) == bp_type_ids.size(2), "n_mv and n_res should be equal"
+        assert iframe.size(2) == 3 and motion.size(3) == 4 and residual.size(3) == 3, "channel number is not correct"
+        assert iframe.size(3) == residual.size(4) and motion.size(4) == iframe.size(3) // 4, "height is not correct"
+        assert iframe.size(4) == residual.size(5) and motion.size(5) == iframe.size(4) // 4, "width is not correct"
+
+        _bsz, n_gop, n_bp = iframe.size(0), motion.size(1), motion.size(2)
+
+        # encode iframe in batches
+        f_ctx_cls, f_ctx_all_hidden, iframe_attn = self.rgb_encoder(
+            einops.rearrange(iframe, "bsz n_gop c h w->(bsz n_gop) c h w"),
+            output_all_features=True, output_attention_map=True
+        )
+        f_ctx_cls = einops.rearrange(f_ctx_cls, "(bsz n_gop) c->bsz n_gop c", bsz=_bsz)
+        f_ctx_all_hidden = einops.rearrange(f_ctx_all_hidden, "(bsz n_gop) hw c->bsz n_gop hw c", bsz=_bsz)
+        iframe_attn = einops.rearrange(
+            iframe_attn, "n_layers (bsz n_gop) n_heads h w->n_layers bsz n_gop n_heads h w",
+            bsz=_bsz
+        )
+        # encode motion in batches
+        mv_cls, mv_attn = self.motion_encoder(
+            einops.rearrange(motion, "bsz n_gop n_bp c_mv h_4 w_4->(bsz n_gop n_bp) c_mv h_4 w_4"),
+            output_all_features=False, output_attention_map=True
+        )
+        mv_cls = einops.rearrange(mv_cls, "(bsz n_gop n_bp) c->bsz n_gop n_bp c",
+                                  bsz=_bsz, n_gop=n_gop, n_bp=n_bp)
+        mv_attn = einops.rearrange(
+            mv_attn, "n_layers (bsz n_gop n_bp) n_heads h_4 w_4->n_layers bsz n_gop n_bp n_heads h_4 w_4",
+            bsz=_bsz, n_gop=n_gop, n_bp=n_bp
+        )
+        # encode residual in batches
+        res_cls, res_attn = self.residual_encoder(
+            einops.rearrange(residual, "bsz n_gop n_bp c h w->(bsz n_gop n_bp) c h w"),
+            output_all_features=False, output_attention_map=True
+        )
+        res_cls = einops.rearrange(res_cls, "(bsz n_gop n_bp) c->bsz n_gop n_bp c",
+                                   bsz=_bsz, n_gop=n_gop, n_bp=n_bp)
+        res_attn = einops.rearrange(
+            res_attn, "n_layers (bsz n_gop n_bp) n_heads h w->n_layers bsz n_gop n_bp n_heads h w",
+            bsz=_bsz, n_gop=n_gop, n_bp=n_bp
+        )
+
+        # fuse rgb, mv and res features through action encoder
+        f_bp = mv_cls + res_cls
+        f_act = self.action_encoder(  # squeeze n_gop into batch before forwarding
+            einops.rearrange(f_bp, "bsz n_gop n_bp c->(bsz n_gop) n_bp c"),
+            einops.rearrange(bp_type_ids, "bsz n_gop n_bp->(bsz n_gop) n_bp"),
+            einops.rearrange(f_ctx_all_hidden, "bsz n_gop hw c->(bsz n_gop) hw c")
+        )
+        f_act = einops.rearrange(f_act, "(bsz n_gop) c->bsz n_gop c", bsz=_bsz, n_gop=n_gop)
+
+        return {
+            "feature_context": f_ctx_cls,
+            "feature_action": f_act,
+            "iframe_attention_map": iframe_attn,
+            "motion_vector_attention_map": mv_attn,
+            "residual_attention_map": res_attn,
+        }
+
+    @classmethod
+    def from_pretrained(
+            cls,
+            # rgb encoder cfgs
+            pretrained_clip_name_or_path: str = "ViT-B/16",
+            # motion encoder cfgs
+            motion_patch_size: int = 8, motion_layers: int = 2, motion_heads: int = 8,
+            # residual encoder cfgs
+            residual_patch_size: int = 64, residual_layers: int = 2, residual_heads: int = 8,
+            # action encoder cfgs
+            action_layers: int = 1, action_heads: int = 8, n_bp: int = 59
+    ):
+        rgb_encoder, image_resolution, vision_width, embed_dim = IFrameEncoder.from_pretrained(
+            pretrained_clip_name_or_path
+        )
+
+        motion_encoder = VisionTransformer(
+            input_resolution=image_resolution // 4,
+            patch_size=motion_patch_size,
+            width=vision_width // 4, layers=motion_layers, heads=motion_heads,
+            output_dim=embed_dim,
+            in_channels=4
+        )
+        residual_encoder = VisionTransformer(
+            input_resolution=image_resolution,
+            patch_size=residual_patch_size,
+            width=vision_width, layers=residual_layers, heads=residual_heads,
+            output_dim=embed_dim,
+            in_channels=3
+        )
+        action_encoder = ActionEncoder(
+            width=embed_dim, layers=action_layers, heads=action_heads, n_bp=n_bp, n_bp_type=2
+        )
+        return cls(
+            rgb_encoder=rgb_encoder,
+            motion_encoder=motion_encoder,
+            residual_encoder=residual_encoder,
+            action_encoder=action_encoder,
+            output_dim=embed_dim
+        )
+
+
+# Build configs for organizing modules with hydra
+iframe_encoder_cfg = builds(IFrameEncoder, populate_full_signature=True)
+iframe_encoder_pretrained_cfg = builds(IFrameEncoder.from_pretrained, populate_full_signature=True)
+
+action_encoder_cfg = builds(ActionEncoder, populate_full_signature=True)
+
+motion_encoder_cfg = residual_encoder_cfg = builds(VisionTransformer, populate_full_signature=True)
+
+compressed_video_transformer_cfg = builds(
+    CompressedVideoTransformer,
+    rgb_encoder=iframe_encoder_cfg,
+    motion_encoder=motion_encoder_cfg,
+    residual_encoder=residual_encoder_cfg,
+    action_encoder=action_encoder_cfg,
+    populate_full_signature=True
+)
+compressed_video_transformer_pretrained_cfg = builds(
+    CompressedVideoTransformer.from_pretrained,
+    populate_full_signature=True
+)

CoCap/cocap/utils/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/12 22:30
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : __init__.py

CoCap/cocap/utils/checkpoint.py

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/13 00:25
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : checkpoint.py
+
+
+import logging
+import os
+from collections import OrderedDict
+from typing import *
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+
+def auto_resume(ckpt_folder):
+    try:
+        ckpt_files = [ckpt for ckpt in os.listdir(ckpt_folder) if ckpt.endswith(".pth")]
+    except FileNotFoundError:
+        ckpt_files = []
+    if len(ckpt_files) > 0:
+        return max([os.path.join(ckpt_folder, file) for file in ckpt_files], key=os.path.getmtime)
+    else:
+        return None
+
+
+def save_checkpoint(ckpt_folder, epoch, model, optimizer, scheduler, config, prefix="checkpoint"):
+    if hasattr(model, 'module'):
+        model = model.module
+    stat_dict = {
+        "epoch": epoch,
+        "model": model.state_dict(),
+        "optimizer": optimizer.state_dict(),
+        "scheduler": scheduler.state_dict() if scheduler is not None else "",
+        "config": config
+    }
+    ckpt_path = os.path.join(ckpt_folder, f"{prefix}_{epoch}.pth")
+    os.makedirs(ckpt_folder, exist_ok=True)
+    torch.save(stat_dict, ckpt_path)
+    return ckpt_path
+
+
+def load_checkpoint(ckpt_file, model: torch.nn.Module, optimizer: Union[torch.optim.Optimizer, None], scheduler: Any,
+                    restart_train=False, rewrite: Tuple[str, str] = None):
+    if hasattr(model, 'module'):
+        model = model.module
+    state_dict = torch.load(ckpt_file, map_location="cpu")
+    if rewrite is not None:
+        logger.info("rewrite model checkpoint prefix: %s->%s", *rewrite)
+        state_dict["model"] = {k.replace(*rewrite) if k.startswith(rewrite[0]) else k: v
+                               for k, v in state_dict["model"].items()}
+    try:
+        missing = model.load_state_dict(state_dict["model"], strict=False)
+        logger.debug(f"checkpoint key missing: {missing}")
+    except RuntimeError:
+        print("fail to directly recover from checkpoint, try to match each modules...")
+        net_dict = model.state_dict()
+        print("find %s modules", len(state_dict["model"].items()))
+        missing_keys = [k for k, v in state_dict["model"].items() if k not in net_dict or net_dict[k].shape != v.shape]
+        print("missing key: %s", missing_keys)
+        state_dict["model"] = {k: v for k, v in state_dict["model"].items() if
+                               (k in net_dict and net_dict[k].shape == v.shape)}
+        print("resume %s modules from checkpoint", len(state_dict["model"].items()))
+        net_dict.update(state_dict["model"])
+        model.load_state_dict(OrderedDict(net_dict))
+
+    if not restart_train:
+        if optimizer is not None and state_dict["optimizer"]:
+            optimizer.load_state_dict(state_dict["optimizer"])
+        if scheduler is not None and state_dict["scheduler"]:
+            scheduler.load_state_dict(state_dict["scheduler"])
+        epoch = state_dict["epoch"]
+    else:
+        logger.info("restart train, optimizer and scheduler will not be resumed")
+        epoch = 0
+
+    del state_dict
+    torch.cuda.empty_cache()
+    return epoch  # start epoch
+
+
+def save_model(model_file: str, model: torch.nn.Module):
+    if hasattr(model, "module"):
+        model = model.module
+    torch.save(model.state_dict(), model_file)
+
+
+def load_model(model_file: str, model: torch.nn.Module, strict=True):
+    if hasattr(model, "module"):
+        model = model.module
+    state_dict = torch.load(model_file, map_location="cpu")
+
+    missing_keys: List[str] = []
+    unexpected_keys: List[str] = []
+    error_msgs: List[str] = []
+
+    # copy state_dict so _load_from_state_dict can modify it
+    metadata = getattr(state_dict, '_metadata', None)
+    state_dict = state_dict.copy()
+    if metadata is not None:
+        # mypy isn't aware that "_metadata" exists in state_dict
+        state_dict._metadata = metadata  # type: ignore[attr-defined]
+
+    def load(module, prefix=''):
+        local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})
+        module._load_from_state_dict(
+            state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs)
+        for name, child in module._modules.items():
+            if child is not None:
+                load(child, prefix + name + '.')
+
+    load(model)
+    del load
+
+    if len(missing_keys) > 0:
+        logger.info("Weights of {} not initialized from pretrained model: {}"
+                    .format(model.__class__.__name__, "\n   " + "\n   ".join(missing_keys)))
+    if len(unexpected_keys) > 0:
+        logger.info("Weights from pretrained model not used in {}: {}"
+                    .format(model.__class__.__name__, "\n   " + "\n   ".join(unexpected_keys)))
+    if len(error_msgs) > 0:
+        logger.info("Weights from pretrained model cause errors in {}: {}"
+                    .format(model.__class__.__name__, "\n   " + "\n   ".join(error_msgs)))
+
+    if len(missing_keys) == 0 and len(unexpected_keys) == 0 and len(error_msgs) == 0:
+        logger.info("All keys loaded successfully for {}".format(model.__class__.__name__))
+
+    if strict and len(error_msgs) > 0:
+        raise RuntimeError('Error(s) in loading state_dict for {}:\n\t{}'.format(
+            model.__class__.__name__, "\n\t".join(error_msgs)))

CoCap/cocap/utils/image.py

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+# @Time    : 9/5/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : image.py
+
+
+from io import BytesIO
+
+from PIL import Image
+
+__all__ = ['byte_imread', "byte_imwrite"]
+
+
+def byte_imread(data):
+    return Image.open(BytesIO(data))
+
+
+def byte_imwrite(image, quality=100, subsampling=0):
+    image = Image.fromarray(image)
+    with BytesIO() as f:
+        image.save(f, format="JPEG", quality=quality, subsampling=subsampling)
+        data = f.getvalue()
+    return data

CoCap/cocap/utils/json.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2023/2/18 06:03
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : json.py
+
+import json
+from typing import Union, List, Dict
+
+
+def load_json(file_path: str):
+    with open(file_path, "r") as f:
+        return json.load(f)
+
+
+def save_json(data: Union[List, Dict], filename: str, save_pretty: bool = False, sort_keys: bool = False):
+    class MyEncoder(json.JSONEncoder):
+
+        def default(self, obj):
+            if isinstance(obj, bytes):  # bytes->str
+                return str(obj, encoding='utf-8')
+            return json.JSONEncoder.default(self, obj)
+
+    with open(filename, "w") as f:
+        if save_pretty:
+            f.write(json.dumps(data, cls=MyEncoder, indent=4, sort_keys=sort_keys))
+        else:
+            json.dump(data, f)

CoCap/cocap/utils/logging.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/12 22:32
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : logging.py
+
+
+import logging
+import os
+
+import colorlog
+import torch.distributed as dist
+
+level_dict = {
+    "critical": logging.CRITICAL,
+    "error": logging.ERROR,
+    "warning": logging.WARNING,
+    "info": logging.INFO,
+    "debug": logging.DEBUG,
+    "notset": logging.NOTSET
+}
+
+
+# noinspection SpellCheckingInspection
+def setup_logging(cfg):
+    # log file
+    if len(str(cfg.LOG.LOGGER_FILE).split(".")) == 2:
+        file_name, extension = str(cfg.LOG.LOGGER_FILE).split(".")
+        log_file_debug = os.path.join(cfg.LOG.DIR, f"{file_name}_debug.{extension}")
+        log_file_info = os.path.join(cfg.LOG.DIR, f"{file_name}_info.{extension}")
+    elif len(str(cfg.LOG.LOGGER_FILE).split(".")) == 1:
+        file_name = cfg.LOG.LOGGER_FILE
+        log_file_debug = os.path.join(cfg.LOG.DIR, f"{file_name}_debug")
+        log_file_info = os.path.join(cfg.LOG.DIR, f"{file_name}_info")
+    else:
+        raise ValueError("cfg.LOG.LOGGER_FILE is invalid: %s", cfg.LOG.LOGGER_FILE)
+    logger = logging.getLogger(__name__.split(".")[0])
+    logger.setLevel(logging.DEBUG)
+    logger.handlers.clear()
+    formatter = logging.Formatter(
+        f"[%(asctime)s][%(levelname)s]{f'[Rank {dist.get_rank()}]' if dist.is_initialized() else ''} "
+        "%(filename)s: %(lineno)3d: %(message)s",
+        datefmt="%m/%d %H:%M:%S",
+    )
+    color_formatter = colorlog.ColoredFormatter(
+        f"%(log_color)s%(bold)s%(levelname)-8s%(reset)s"
+        f"%(log_color)s[%(asctime)s]"
+        f"{f'[Rank {dist.get_rank()}]' if dist.is_initialized() else ''}"
+        "[%(filename)s: %(lineno)3d]:%(reset)s "
+        "%(message)s",
+        datefmt="%m/%d %H:%M:%S",
+    )
+    # log file
+    if os.path.dirname(log_file_debug):  # dir name is not empty
+        os.makedirs(os.path.dirname(log_file_debug), exist_ok=True)
+    # console
+    handler_console = logging.StreamHandler()
+    assert cfg.LOG.LOGGER_CONSOLE_LEVEL.lower() in level_dict, \
+        f"Log level {cfg.LOG.LOGGER_CONSOLE_LEVEL} is invalid"
+    handler_console.setLevel(level_dict[cfg.LOG.LOGGER_CONSOLE_LEVEL.lower()])
+    handler_console.setFormatter(color_formatter if cfg.LOG.LOGGER_CONSOLE_COLORFUL else formatter)
+    logger.addHandler(handler_console)
+    # debug level
+    handler_debug = logging.FileHandler(log_file_debug, mode="a")
+    handler_debug.setLevel(logging.DEBUG)
+    handler_debug.setFormatter(formatter)
+    logger.addHandler(handler_debug)
+    # info level
+    handler_info = logging.FileHandler(log_file_info, mode="a")
+    handler_info.setLevel(logging.INFO)
+    handler_info.setFormatter(formatter)
+    logger.addHandler(handler_info)
+
+    logger.propagate = False
+
+
+def show_registry():
+    from cocap.data.build import DATASET_REGISTRY, COLLATE_FN_REGISTER
+    from cocap.modeling.model import MODEL_REGISTRY
+    from cocap.modeling.optimizer import OPTIMIZER_REGISTRY
+    from cocap.modeling.loss import LOSS_REGISTRY
+    from cocap.modeling.meter import METER_REGISTRY
+
+    logger = logging.getLogger(__name__)
+    logger.debug(DATASET_REGISTRY)
+    logger.debug(COLLATE_FN_REGISTER)
+    logger.debug(MODEL_REGISTRY)
+    logger.debug(OPTIMIZER_REGISTRY)
+    logger.debug(LOSS_REGISTRY)
+    logger.debug(METER_REGISTRY)

CoCap/cocap/utils/profile.py

@@ -0,0 +1,102 @@
+# -*- coding: utf-8 -*-
+# @Time    : 7/12/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : profile.py
+
+import functools
+import logging
+import time
+from collections import defaultdict, deque
+
+import numpy as np
+import torch
+from tabulate import tabulate
+
+logger = logging.getLogger(__name__)
+
+
+def format_time(s: float) -> str:
+    """Return a nice string representation of `s` seconds."""
+    m = int(s / 60)
+    s -= m * 60
+    h = int(m / 60)
+    m -= h * 60
+    ms = int(s * 100000) / 100
+    s = int(s * 100) / 100.0
+    return ("" if h == 0 else str(h) + "h") + ("" if m == 0 else str(m) + "m") + ("" if s == 0 else str(s) + "s") + \
+        (str(ms) + "ms" if s == 0 else "")
+
+
+class Timer(object):
+    def __init__(self, msg="", synchronize: bool = False, history_size: int = 1000, precision: int = 3):
+        """
+
+        :param msg:
+        :param synchronize: Call `torch.cuda.synchronize()` when getting time
+        :param history_size:
+        :param precision: round seconds to a given precision in decimal digits to avoid verbose
+        """
+        self.msg = msg
+        self.synchronize = synchronize
+        self.precision = precision
+
+        if self.msg:
+            logger.info("%s", msg)
+
+        self.start = self.get_time()
+        self.last_checkpoint = self.start
+
+        self.time_history = defaultdict(functools.partial(deque, maxlen=history_size))
+        self.history_size = history_size
+
+    def get_time(self):
+        if self.synchronize and torch.cuda.is_available():
+            torch.cuda.synchronize()
+        return round(time.time(), self.precision)
+
+    def reset(self):
+        self.last_checkpoint = self.get_time()
+
+    def __enter__(self):
+        self.start = self.get_time()
+        return self
+
+    def __exit__(self, typ, value, traceback):
+        self._duration = self.get_time() - self.start
+        if self.msg:
+            logger.info("%s [took %s]", self.msg, format_time(self._duration))
+
+    def __call__(self, stage_name: str):
+        current_time = self.get_time()
+        duration = (current_time - self.last_checkpoint)
+        self.last_checkpoint = current_time
+        self.time_history[stage_name].append(duration)
+        return duration
+
+    def get_info(self, averaged=True):
+        return {
+            k: round(float(np.mean(v)), self.precision) if averaged else round(v[-1], self.precision)
+            for k, v in self.time_history.items()
+        }
+
+    def __str__(self):
+        return str(self.get_info())
+
+    def print(self):
+        data = [[k, format_time(np.mean(v).item())] for k, v in self.time_history.items()]
+        return tabulate(data, headers=["Stage", "Time (ms)"], tablefmt="simple")
+
+
+if __name__ == '__main__':
+    with Timer("Running...") as f:
+        time.sleep(1.12)
+
+    timer = Timer()
+    time.sleep(0.5)
+    timer("s1")
+    time.sleep(0.21)
+    timer("s2")
+    timer.print()
+    print(timer)
+    print(timer.get_info())

CoCap/cocap/utils/registry.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2023/2/19 23:23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : registry.py
+
+
+from typing import Any
+
+from fvcore.common.registry import Registry
+
+
+class LooseRegistry(Registry):
+    def get(self, name: str) -> Any:
+        ret = None
+        for obj_name, obj in self._obj_map.items():
+            if name in obj_name:
+                ret = obj
+                break
+        if ret is None:
+            raise KeyError(
+                "No object contains '{}' found in '{}' registry!".format(name, self._name)
+            )
+        return ret
+
+
+class PrefixRegistry(Registry):
+    def get(self, name: str) -> Any:
+        ret = None
+        for obj_name, obj in self._obj_map.items():
+            if obj_name.startswith(name):
+                ret = obj
+                break
+        if ret is None:
+            raise KeyError(
+                "No object starts with '{}' found in '{}' registry!".format(name, self._name)
+            )
+        return ret
+
+
+class PostfixRegistry(Registry):
+    def get(self, name: str) -> Any:
+        ret = None
+        for obj_name, obj in self._obj_map.items():
+            if obj_name.endswith(name):
+                ret = obj
+                break
+        if ret is None:
+            raise KeyError(
+                "No object ends with '{}' found in '{}' registry!".format(name, self._name)
+            )
+        return ret

CoCap/cocap/utils/train_utils.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/12 22:31
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : train_utils.py
+
+import datetime
+import hashlib
+import itertools
+import logging
+import os
+import pickle
+import random
+import time
+import typing
+from typing import *
+
+import numpy as np
+import torch
+import torch.distributed as dist
+from fvcore.common.config import CfgNode
+
+logger = logging.getLogger(__name__)
+
+
+class CudaPreFetcher:
+    def __init__(self, data_loader):
+        self.dl = data_loader
+        self.loader = iter(data_loader)
+        self.stream = torch.cuda.Stream()
+        self.batch = None
+
+    def preload(self):
+        try:
+            self.batch = next(self.loader)
+        except StopIteration:
+            self.batch = None
+            return
+        with torch.cuda.stream(self.stream):
+            self.batch = self.cuda(self.batch)
+
+    @staticmethod
+    def cuda(x: typing.Any):
+        if isinstance(x, list) or isinstance(x, tuple):
+            return [CudaPreFetcher.cuda(i) for i in x]
+        elif isinstance(x, dict):
+            return {k: CudaPreFetcher.cuda(v) for k, v in x.items()}
+        elif isinstance(x, torch.Tensor):
+            return x.cuda(non_blocking=True)
+        else:
+            return x
+
+    def __next__(self):
+        torch.cuda.current_stream().wait_stream(self.stream)
+        batch = self.batch
+        if batch is None:
+            raise StopIteration
+        self.preload()
+        return batch
+
+    def __iter__(self):
+        self.preload()
+        return self
+
+    def __len__(self):
+        return len(self.dl)
+
+
+def manual_seed(cfg: CfgNode):
+    if cfg.SYS.DETERMINISTIC:
+        torch.manual_seed(cfg.SYS.SEED)
+        random.seed(cfg.SYS.SEED)
+        np.random.seed(cfg.SYS.SEED)
+        torch.cuda.manual_seed(cfg.SYS.SEED)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = True
+        logger.debug("Manual seed is set")
+    else:
+        logger.warning("Manual seed is not used")
+
+
+def init_distributed(proc: int, cfg: CfgNode):
+    if cfg.SYS.MULTIPROCESS:  # initialize multiprocess
+        word_size = cfg.SYS.NUM_GPU * cfg.SYS.NUM_SHARDS
+        rank = cfg.SYS.NUM_GPU * cfg.SYS.SHARD_ID + proc
+        dist.init_process_group(backend="nccl", init_method=cfg.SYS.INIT_METHOD, world_size=word_size, rank=rank)
+        torch.cuda.set_device(cfg.SYS.GPU_DEVICES[proc])
+
+
+def save_config(cfg: CfgNode):
+    if not dist.is_initialized() or dist.get_rank() == 0:
+        config_file = os.path.join(cfg.LOG.DIR, f"config_{get_timestamp()}.yaml")
+        with open(config_file, "w") as f:
+            f.write(cfg.dump())
+        logger.debug("config is saved to %s", config_file)
+
+
+def get_timestamp():
+    return datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')
+
+
+def gather_object_multiple_gpu(list_object: List[Any], backend: AnyStr = "nccl", shared_folder=None,
+                               retry=600, sleep=0.1):
+    """
+    gather a list of something from multiple GPU
+    """
+    assert type(list_object) == list, "`list_object` only receive list."
+    assert backend in ["nccl", "filesystem"]
+    if backend == "nccl":
+        gathered_objects = [None for _ in range(dist.get_world_size())]
+        dist.all_gather_object(gathered_objects, list_object)
+        return list(itertools.chain(*gathered_objects))
+    else:
+        assert shared_folder is not None, "`share_folder` should be set if backend is `filesystem`"
+        os.makedirs(shared_folder, exist_ok=True)
+        uuid = torch.randint(99999999, 99999999999, size=(1,), dtype=torch.long).cuda()
+        dist.all_reduce(uuid)
+        uuid = hex(uuid.cpu().item())[-8:]
+        with open(os.path.join(shared_folder, f"{uuid}_rank_{dist.get_rank():04d}.pkl"), "wb") as f:
+            data = pickle.dumps(list_object)
+            f.write(data)
+        with open(os.path.join(shared_folder, f"{uuid}_rank_{dist.get_rank():04d}.md5"), "wb") as f:
+            checksum = hashlib.md5(data).hexdigest()
+            pickle.dump(checksum, f)
+        gathered_list = []
+        dist.barrier()
+        for rank in range(dist.get_world_size()):
+            data_filename = os.path.join(shared_folder, f"{uuid}_rank_{rank:04d}.pkl")
+            checksum_filename = os.path.join(shared_folder, f"{uuid}_rank_{rank:04d}.md5")
+            data = None
+            for _ in range(retry):
+                time.sleep(sleep)
+                try:
+                    if not os.path.exists(data_filename):
+                        continue
+                    if not os.path.exists(checksum_filename):
+                        continue
+                    raw_data = open(data_filename, "rb").read()
+                    checksum = pickle.load(open(checksum_filename, "rb"))
+                    assert checksum == hashlib.md5(raw_data).hexdigest()
+                    data = pickle.loads(raw_data)
+                    break
+                except Exception:
+                    pass
+            assert data is not None, f"Gather from filesystem failed after retry for {retry} times."
+            gathered_list.extend(data)
+        dist.barrier()
+        return gathered_list

CoCap/cocap/utils/video.py

@@ -0,0 +1,98 @@
+# -*- coding: utf-8 -*-
+# @Time    : 8/7/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : video.py
+
+
+import os
+import subprocess
+from typing import *
+
+import cv2
+from joblib import Parallel, delayed
+
+__all__ = ["get_duration_info", "convert_video"]
+
+
+def _get_single_video_duration_info(video_path) -> (float, float, int):
+    """
+    return video duration in seconds
+    :param video_path: video path
+    :return: video duration, fps, frame count
+    """
+    video = cv2.VideoCapture(video_path)
+    fps = video.get(cv2.CAP_PROP_FPS)
+    frame_count = video.get(cv2.CAP_PROP_FRAME_COUNT)
+    return frame_count / fps, fps, int(frame_count)
+
+
+def get_duration_info(video_paths: Union[str, Iterable]) -> (float, float, int):
+    """
+
+    :param video_paths: video path or a list of video path
+    :return: video duration, fps, frame count
+    """
+    if isinstance(video_paths, str):
+        return _get_single_video_duration_info(video_paths)
+    else:
+        return Parallel(n_jobs=os.cpu_count())(
+            delayed(_get_single_video_duration_info)(path) for path in video_paths
+        )
+
+
+def convert_video(input_file: AnyStr, output_file: AnyStr,
+                  ffmpeg_exec: AnyStr = "/usr/bin/ffmpeg",
+                  codec="libx264",
+                  keyint: int = None,
+                  overwrite: bool = False,
+                  verbose: bool = False,
+                  resize: tuple = None) -> None:
+    """
+    :param input_file:
+    :param output_file:
+    :param ffmpeg_exec:
+    :param codec: supported video codec, e.g., libx264 and libx265
+    :param keyint:
+    :param overwrite:
+    :param verbose:
+    :param resize:
+    """
+    assert codec is None or codec in ["libx264", "libx265"], "Video codec {} is not supported.".format(codec)
+    assert keyint is None or codec is not None, "Codec must be specified if keyint is not None."
+
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+    command = [ffmpeg_exec, "-i", f"{input_file}", "-max_muxing_queue_size", "9999"]
+    if codec is not None:
+        # use specified codec
+        command += ["-c:v", codec]
+        if codec == "libx265":
+            command += ["-vtag", "hvc1"]
+        if keyint is not None and codec == "libx264":
+            command += ["-x264-params", f"keyint={keyint}"]
+        elif keyint is not None and codec == "libx265":
+            command += ["-x265-params", f"keyint={keyint}"]
+    if resize is not None:
+        if isinstance(resize, int):  # resize height
+            assert resize % 2 == 0, "size is not divisible by 2"
+            command += [
+                "-vf",
+                f"scale='if(gt(ih,iw),{resize},trunc(oh*a/2)*2)':'if(gt(ih, iw),trunc(ow/a/2)*2,{resize})'"
+            ]
+        elif (isinstance(resize, type) or isinstance(resize, list)) and len(resize) == 2:
+            assert isinstance(resize[0], int) and isinstance(resize[1], int), "size should be int"
+            assert resize[0] % 2 == 0 and resize[1] % 2 == 0, "size is not divisible by 2"
+            command += ["-vf", f"scale={resize[0]}:{resize[1]}"]
+        else:
+            raise ValueError("size is not supported: {}".format(resize))
+    command += ["-c:a", "copy", "-movflags", "faststart", f"{output_file}"]
+
+    if overwrite:
+        command += ["-y"]
+    else:
+        command += ["-n"]
+    subprocess.run(command,
+                   stderr=subprocess.DEVNULL if not verbose else None,
+                   stdout=subprocess.DEVNULL if not verbose else None)
+    # TODO: return

CoCap/cocap/utils/visualize.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+# @Time    : 9/5/23
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : visualize.py
+
+import numpy as np
+import torch
+from PIL import Image
+from torchvision.transforms.functional import normalize
+
+
+def _convert_to_numpy_array(data):
+    # convert any type to numpy array
+    if isinstance(data, np.ndarray):
+        pass
+    elif isinstance(data, torch.Tensor):
+        data = data.detach().cpu().numpy()
+    elif isinstance(data, Image.Image):
+        data = np.array(data)
+    else:
+        raise ValueError("Data type is not supported to convert to numpy array: {}".format(type(data)))
+    return data
+
+
+def _convert_to_torch_tensor(data):
+    # convert any type tot torch tensor
+    if isinstance(data, torch.Tensor):
+        pass
+    elif isinstance(data, np.ndarray):
+        data = torch.from_numpy(data)
+    else:
+        raise ValueError("Data type is not supported to convert to torch.Tensor: {}".format(type(data)))
+    return data.detach().cpu()
+
+
+def inv_normalize(image_or_video, mean, std):
+    # convert to torch.Tensor
+    data = _convert_to_torch_tensor(image_or_video)
+    data = normalize(data, mean=[-m / s for m, s in zip(mean, std)], std=[1 / s for s in std])
+    return data.numpy()

CoCap/cocap/utils/writer.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+# @Time    : 2022/11/13 00:41
+# @Author  : Yaojie Shen
+# @Project : CoCap
+# @File    : writer.py
+
+import torch.distributed as dist
+from torch.utils.tensorboard import SummaryWriter
+
+
+class DummySummaryWriter:
+    """
+    Issue: https://github.com/pytorch/pytorch/issues/24236
+    """
+
+    def __init__(*args, **kwargs):
+        pass
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+    def __getattr__(self, *args, **kwargs):
+        return self
+
+
+def get_writer(*args, **kwargs):
+    if not dist.is_initialized() or dist.get_rank() == 0:
+        return SummaryWriter(*args, **kwargs)
+    else:
+        return DummySummaryWriter()