Add files using upload-large-folder tool

.gitattributes

@@ -0,0 +1,11 @@
+example_demo_videos/demo7.mp4 filter=lfs diff=lfs merge=lfs -text
+example_demo_videos/demo3.mp4 filter=lfs diff=lfs merge=lfs -text
+example_demo_videos/demo1_rep.mp4 filter=lfs diff=lfs merge=lfs -text
+example_demo_videos/demo2_rep.mp4 filter=lfs diff=lfs merge=lfs -text
+example_demo_videos/_jB-IM_77lI_000000_silent.mp4 filter=lfs diff=lfs merge=lfs -text
+example_demo_videos/demo2.mp4 filter=lfs diff=lfs merge=lfs -text
+example_demo_videos/demo5.mp4 filter=lfs diff=lfs merge=lfs -text
+example_demo_videos/demo6.mp4 filter=lfs diff=lfs merge=lfs -text
+example_demo_videos/demo1.mp4 filter=lfs diff=lfs merge=lfs -text
+eval_gt/gt_audio_test/LC79lWBAlR4_000410.wav filter=lfs diff=lfs merge=lfs -text
+eval_gt/gt_audio_test/LBXYlTnm0Fw_000054.wav filter=lfs diff=lfs merge=lfs -text

eval_gt/gt_audio_test/LBXYlTnm0Fw_000054.wav

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

eval_gt/gt_audio_test/LC79lWBAlR4_000410.wav

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e1f395c03b0fb69d2ebe62c93e833e0674fa7b1e619f7b20923f1df2eced9bd
+size 1771130

example_demo_videos/_jB-IM_77lI_000000_silent.mp4

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

example_demo_videos/demo1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8ed1fbaf07d800b0a3c51d9662a9a72a89f7b414e5aaaac840bfb4402341143d
+size 825708

example_demo_videos/demo1_rep.mp4

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

example_demo_videos/demo2.mp4

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

example_demo_videos/demo2_rep.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:347d2922ebec6dd3bb3445c65d18f51c38fd6b841de92a897a589caf2f0babd2
+size 1529000

example_demo_videos/demo3.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:599e563ed57339c95658a70fbbaf9601f4b1792800ed733bdf027dd922eb5615
+size 624675

example_demo_videos/demo5.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:481d36bebaf00c2aaf5dccb5b71491badb09f9e96e60f226952fbdb6261af34c
+size 484500

example_demo_videos/demo6.mp4

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

example_demo_videos/demo7.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5662d82ae7b64677d3fd92205adfd1b40ec136ef14f2c36674d96cf171fc98b4
+size 821786

reward_models/ib_sync_rewards/args.py

@@ -0,0 +1,36 @@
+from argparse import ArgumentParser
+from pathlib import Path
+
+
+def get_eval_parser() -> ArgumentParser:
+    parser = ArgumentParser()
+
+    # maximum length; does not pad if under (except internally in like PaSST)
+    parser.add_argument('--audio_length', type=float)
+    parser.add_argument('--num_workers', type=int, default=32)
+
+    # only bs=1 supports variable audio length
+    parser.add_argument('--gt_batch_size', type=int, default=1)
+    # typically your generations would have the same length; so larger batch sizes can be used
+    parser.add_argument('--pred_batch_size', type=int, default=64)
+
+    parser.add_argument('--gt_audio', type=Path)
+    parser.add_argument('--gt_cache', type=Path)
+    parser.add_argument('--pred_audio', type=Path)
+    parser.add_argument('--pred_cache', type=Path)
+    parser.add_argument('--json_path', type=Path) # todo newly added
+    parser.add_argument('--output_dir', type=Path) # todo newly added
+
+    parser.add_argument('--recompute_gt_cache', action='store_true')
+    parser.add_argument('--recompute_pred_cache', action='store_true')
+
+    # only single sample is supported
+    # parser.add_argument('--num_samples', type=int, default=1)
+    parser.add_argument('--unpaired', action='store_true')
+
+    parser.add_argument('--skip_video_related',
+                        action='store_true',
+                        help='skips ImageBind and SynchFormer computation')
+    parser.add_argument('--skip_clap', action='store_true', help='skips CLAP computation')
+
+    return parser

reward_models/ib_sync_rewards/data/video_dataset.py

@@ -0,0 +1,428 @@
+import logging
+from pathlib import Path
+
+import torch
+from torch.utils.data.dataloader import default_collate
+from torch.utils.data.dataset import Dataset
+from torchvision.transforms import v2
+from torio.io import StreamingMediaDecoder
+
+from ib_sync_rewards.data.ib_data import SpatialCrop
+
+# todo
+from typing import List
+import torchaudio
+from ib_sync_rewards.imagebind.pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
+
+
+log = logging.getLogger()
+
+# https://github.com/facebookresearch/ImageBind/blob/main/imagebind/data.py
+# https://pytorchvideo.readthedocs.io/en/latest/_modules/pytorchvideo/transforms/functional.html
+_IMAGEBIND_SIZE = 224
+_IMAGEBIND_FPS = 0.5
+
+_SYNC_SIZE = 224
+_SYNC_FPS = 25.0
+
+
+def error_avoidance_collate(batch):
+    batch = list(filter(lambda x: x is not None, batch))
+    return default_collate(batch)
+
+# todo
+# from ImageBind
+def get_clip_timepoints(clip_sampler, duration):
+    # Read out all clips in this video
+    all_clips_timepoints = []
+    is_last_clip = False
+    end = 0.0
+    while not is_last_clip:
+        start, end, _, _, is_last_clip = clip_sampler(end, duration, annotation=None)
+        all_clips_timepoints.append((start, end))
+    return all_clips_timepoints
+
+
+# from ImageBind
+def waveform2melspec(waveform, sample_rate, num_mel_bins, target_length):
+    # Based on https://github.com/YuanGongND/ast/blob/d7d8b4b8e06cdaeb6c843cdb38794c1c7692234c/src/dataloader.py#L102
+    waveform -= waveform.mean()
+    fbank = torchaudio.compliance.kaldi.fbank(
+        waveform,
+        htk_compat=True,
+        sample_frequency=sample_rate,
+        use_energy=False,
+        window_type="hanning",
+        num_mel_bins=num_mel_bins,
+        dither=0.0,
+        frame_length=25,
+        frame_shift=10,
+    )
+    # Convert to [mel_bins, num_frames] shape
+    fbank = fbank.transpose(0, 1)
+    # Pad to target_length
+    n_frames = fbank.size(1)
+    p = target_length - n_frames
+    # if p is too large (say >20%), flash a warning
+    if abs(p) / n_frames > 0.2:
+        logging.warning(
+            "Large gap between audio n_frames(%d) and "
+            "target_length (%d). Is the audio_target_length "
+            "setting correct?",
+            n_frames,
+            target_length,
+        )
+    # cut and pad
+    if p > 0:
+        fbank = torch.nn.functional.pad(fbank, (0, p), mode="constant", value=0)
+    elif p < 0:
+        fbank = fbank[:, 0:target_length]
+    # Convert to [1, mel_bins, num_frames] shape, essentially like a 1
+    # channel image
+    fbank = fbank.unsqueeze(0)
+    return fbank
+
+
+# from synchformer
+def pad_or_truncate(audio: torch.Tensor,
+                    max_spec_t: int,
+                    pad_mode: str = 'constant',
+                    pad_value: float = 0.0):
+    difference = max_spec_t - audio.shape[-1]  # safe for batched input
+    # pad or truncate, depending on difference
+    if difference > 0:
+        # pad the last dim (time) -> (..., n_mels, 0+time+difference)  # safe for batched input
+        pad_dims = (0, difference)
+        audio = torch.nn.functional.pad(audio, pad_dims, pad_mode, pad_value)
+    elif difference < 0:
+        log.warning(f'Truncating spec ({audio.shape}) to max_spec_t ({max_spec_t}).')
+        audio = audio[..., :max_spec_t]  # safe for batched input
+    return audio
+
+
+def pad_short_audio(audio, min_samples=32000):
+    if (audio.size(-1) < min_samples):
+        audio = torch.nn.functional.pad(audio, (0, min_samples - audio.size(-1)),
+                                        mode='constant',
+                                        value=0.0)
+    return audio
+
+
+
+# todo integrate imagebind and syncformer
+# todo extracting audio+video+text
+class VideoDataset(Dataset):
+
+    def __init__(
+        self,
+        video_paths: list[Path],
+        audio_paths: list[Path],
+        *,
+        duration_sec: float = 8.0,
+        video_id_caption={}
+    ):
+        self.video_paths = video_paths # todo for video
+        self.audio_paths = audio_paths #[f'{f[:-4]}.flac' for f in video_paths] # todo for audio
+        self.video_id_caption = video_id_caption # todo May 9
+        
+        self.duration_sec = duration_sec
+
+        self.ib_expected_length = int(_IMAGEBIND_FPS * self.duration_sec)
+        self.sync_expected_length = int(_SYNC_FPS * self.duration_sec)
+
+        self.ib_transform = v2.Compose([
+            v2.Resize(_IMAGEBIND_SIZE, interpolation=v2.InterpolationMode.BICUBIC),
+            v2.ToImage(),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
+                         std=[0.26862954, 0.26130258, 0.27577711]),
+        ])
+
+        self.sync_transform = v2.Compose([
+            v2.Resize(_SYNC_SIZE, interpolation=v2.InterpolationMode.BICUBIC),
+            v2.CenterCrop(_SYNC_SIZE),
+            v2.ToImage(),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+        ])
+
+        self.crop = SpatialCrop(_IMAGEBIND_SIZE, 3)
+
+        self.resampler = {} # todo for synchformer
+        self.sync_mel_spectrogram = torchaudio.transforms.MelSpectrogram(
+            sample_rate=16000,
+            win_length=400,
+            hop_length=160,
+            n_fft=1024,
+            n_mels=128,
+        )
+
+    # todo for imagebind audio
+    def load_and_transform_audio_data_for_ib(
+        self,
+        audio_path,
+        num_mel_bins=128,
+        target_length=204,
+        sample_rate=16000,
+        clip_duration=2,
+        clips_per_video=3,
+        mean=-4.268,
+        std=9.138,
+    ):
+
+        audio_outputs = []
+        clip_sampler = ConstantClipsPerVideoSampler(clip_duration=clip_duration,
+                                                    clips_per_video=clips_per_video)
+
+        waveform, sr = torchaudio.load(audio_path)
+        if sample_rate != sr:
+            waveform = torchaudio.functional.resample(waveform, orig_freq=sr, new_freq=sample_rate)
+        all_clips_timepoints = get_clip_timepoints(clip_sampler, waveform.size(1) / sample_rate)
+        all_clips = []
+        for clip_timepoints in all_clips_timepoints:
+            waveform_clip = waveform[
+                :,
+                int(clip_timepoints[0] * sample_rate):int(clip_timepoints[1] * sample_rate),
+            ]
+            waveform_melspec = waveform2melspec(waveform_clip, sample_rate, num_mel_bins,
+                                                target_length)
+            all_clips.append(waveform_melspec)
+
+        normalize = v2.Normalize(mean=[mean], std=[std])
+        all_clips = [normalize(ac) for ac in all_clips]
+
+        all_clips = torch.stack(all_clips, dim=0)
+        audio_outputs.append(all_clips)
+
+        return torch.stack(audio_outputs, dim=0)
+
+    # todo for synchformer audio
+    def load_and_transform_audio_data_for_sync(self, audio_path):
+        waveform, sr = torchaudio.load(audio_path)
+        waveform = waveform.mean(dim=0)
+
+        if sr != 16000:
+            if sr not in self.resampler:
+                self.resampler[sr] = torchaudio.transforms.Resample(sr, 16000)
+            waveform = self.resampler[sr](waveform)
+
+        waveform = waveform[:int(self.duration_sec * 16000)]
+        if waveform.shape[0] != int(self.duration_sec * 16000):
+            raise ValueError(f'Audio {audio_path} is too short')
+
+        waveform = waveform.squeeze()
+
+        return waveform
+
+    def sample(self, idx: int) -> dict[str, torch.Tensor]:
+        video_path = self.video_paths[idx] # todo for video path
+        audio_path = self.audio_paths[idx] # todo for audio path
+        caption = self.video_id_caption[video_path.stem] # todo May 9
+        
+        # todo for video extraction
+        reader = StreamingMediaDecoder(video_path)
+        reader.add_basic_video_stream(
+            frames_per_chunk=int(_IMAGEBIND_FPS * self.duration_sec),
+            frame_rate=_IMAGEBIND_FPS,
+            format='rgb24',
+        )
+        reader.add_basic_video_stream(
+            frames_per_chunk=int(_SYNC_FPS * self.duration_sec),
+            frame_rate=_SYNC_FPS,
+            format='rgb24',
+        )
+
+        reader.fill_buffer()
+        data_chunk = reader.pop_chunks()
+
+        ib_chunk = data_chunk[0]
+        sync_chunk = data_chunk[1]
+        if ib_chunk is None:
+            raise RuntimeError(f'IB video returned None {video_path}')
+        if ib_chunk.shape[0] < self.ib_expected_length:
+            raise RuntimeError(
+                f'IB video too short {video_path}, expected {self.ib_expected_length}, got {ib_chunk.shape[0]}'
+            )
+
+        if sync_chunk is None:
+            raise RuntimeError(f'Sync video returned None {video_path}')
+        if sync_chunk.shape[0] < self.sync_expected_length:
+            raise RuntimeError(
+                f'Sync video too short {video_path}, expected {self.sync_expected_length}, got {sync_chunk.shape[0]}'
+            )
+
+        # truncate the video
+        ib_chunk = ib_chunk[:self.ib_expected_length]
+        if ib_chunk.shape[0] != self.ib_expected_length:
+            raise RuntimeError(f'IB video wrong length {video_path}, '
+                               f'expected {self.ib_expected_length}, '
+                               f'got {ib_chunk.shape[0]}')
+        ib_chunk = self.ib_transform(ib_chunk)
+
+        sync_chunk = sync_chunk[:self.sync_expected_length]
+        if sync_chunk.shape[0] != self.sync_expected_length:
+            raise RuntimeError(f'Sync video wrong length {video_path}, '
+                               f'expected {self.sync_expected_length}, '
+                               f'got {sync_chunk.shape[0]}')
+        sync_chunk = self.sync_transform(sync_chunk)
+
+        ib_chunk = self.crop([ib_chunk])
+        ib_chunk = torch.stack(ib_chunk)
+
+        # todo for audio extraction
+        ib_audio = self.load_and_transform_audio_data_for_ib(audio_path)
+        sync_audio = self.load_and_transform_audio_data_for_sync(audio_path)
+
+        data = {
+            'name': video_path.stem,
+            'label': caption, # todo May 9
+            'ib_video': ib_chunk,
+            'sync_video': sync_chunk,
+            'ib_audio': ib_audio,
+            'sync_audio': sync_audio,
+        }
+
+        return data
+
+    def __getitem__(self, idx: int) -> dict[str, torch.Tensor]:
+                
+        try:
+            return self.sample(idx)
+        except Exception as e:
+            log.error(f'Error loading video {self.video_paths[idx]}: {e}')
+            return None
+
+    def __len__(self):
+        return len(self.video_paths)
+
+
+
+class AudioDataset(Dataset):
+
+    def __init__(
+        self,
+        video_paths: list[Path],
+        audio_paths: list[Path],
+        *,
+        duration_sec: float = 8.0,
+        video_id_caption={}
+    ):
+        self.video_paths = video_paths # todo for video
+        self.audio_paths = audio_paths #[f'{f[:-4]}.flac' for f in video_paths] # todo for audio
+        self.video_id_caption = video_id_caption # todo May 9
+        
+        self.duration_sec = duration_sec
+
+        self.ib_expected_length = int(_IMAGEBIND_FPS * self.duration_sec)
+        self.sync_expected_length = int(_SYNC_FPS * self.duration_sec)
+
+        self.ib_transform = v2.Compose([
+            v2.Resize(_IMAGEBIND_SIZE, interpolation=v2.InterpolationMode.BICUBIC),
+            v2.ToImage(),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=[0.48145466, 0.4578275, 0.40821073],
+                         std=[0.26862954, 0.26130258, 0.27577711]),
+        ])
+
+        self.sync_transform = v2.Compose([
+            v2.Resize(_SYNC_SIZE, interpolation=v2.InterpolationMode.BICUBIC),
+            v2.CenterCrop(_SYNC_SIZE),
+            v2.ToImage(),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5]),
+        ])
+
+        self.crop = SpatialCrop(_IMAGEBIND_SIZE, 3)
+
+        self.resampler = {} # todo for synchformer
+        self.sync_mel_spectrogram = torchaudio.transforms.MelSpectrogram(
+            sample_rate=16000,
+            win_length=400,
+            hop_length=160,
+            n_fft=1024,
+            n_mels=128,
+        )
+
+    # todo for imagebind audio
+    def load_and_transform_audio_data_for_ib(
+        self,
+        audio_path,
+        num_mel_bins=128,
+        target_length=204,
+        sample_rate=16000,
+        clip_duration=2,
+        clips_per_video=3,
+        mean=-4.268,
+        std=9.138,
+    ):
+
+        audio_outputs = []
+        clip_sampler = ConstantClipsPerVideoSampler(clip_duration=clip_duration,
+                                                    clips_per_video=clips_per_video)
+
+        waveform, sr = torchaudio.load(audio_path)
+        if sample_rate != sr:
+            waveform = torchaudio.functional.resample(waveform, orig_freq=sr, new_freq=sample_rate)
+        all_clips_timepoints = get_clip_timepoints(clip_sampler, waveform.size(1) / sample_rate)
+        all_clips = []
+        for clip_timepoints in all_clips_timepoints:
+            waveform_clip = waveform[
+                :,
+                int(clip_timepoints[0] * sample_rate):int(clip_timepoints[1] * sample_rate),
+            ]
+            waveform_melspec = waveform2melspec(waveform_clip, sample_rate, num_mel_bins,
+                                                target_length)
+            all_clips.append(waveform_melspec)
+
+        normalize = v2.Normalize(mean=[mean], std=[std])
+        all_clips = [normalize(ac) for ac in all_clips]
+
+        all_clips = torch.stack(all_clips, dim=0)
+        audio_outputs.append(all_clips)
+
+        return torch.stack(audio_outputs, dim=0)
+
+    # todo for synchformer audio
+    def load_and_transform_audio_data_for_sync(self, audio_path):
+        waveform, sr = torchaudio.load(audio_path)
+        waveform = waveform.mean(dim=0)
+
+        if sr != 16000:
+            if sr not in self.resampler:
+                self.resampler[sr] = torchaudio.transforms.Resample(sr, 16000)
+            waveform = self.resampler[sr](waveform)
+
+        waveform = waveform[:int(self.duration_sec * 16000)]
+        if waveform.shape[0] != int(self.duration_sec * 16000):
+            raise ValueError(f'Audio {audio_path} is too short')
+
+        waveform = waveform.squeeze()
+
+        return waveform
+
+    def sample(self, idx: int) -> dict[str, torch.Tensor]:
+        video_path = self.video_paths[idx] # todo for video path
+        audio_path = self.audio_paths[idx] # todo for audio path
+        caption = self.video_id_caption[video_path.stem] # todo May 9
+
+        # todo for audio extraction
+        ib_audio = self.load_and_transform_audio_data_for_ib(audio_path)
+
+        data = {
+            'name': video_path.stem,
+            'label': caption, # todo May 9
+            'ib_audio': ib_audio,
+        }
+
+        return data
+
+    def __getitem__(self, idx: int) -> dict[str, torch.Tensor]:
+                
+        try:
+            return self.sample(idx)
+        except Exception as e:
+            log.error(f'Error loading video {self.video_paths[idx]}: {e}')
+            return None
+
+    def __len__(self):
+        return len(self.video_paths)

reward_models/ib_sync_rewards/imagebind/data.py

@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+# Portions Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+
+# This source code is licensed under the license found in the
+# LICENSE file in the root directory of this source tree.
+
+import logging
+import math
+import pkg_resources
+
+import torch
+import torch.nn as nn
+import torchaudio
+from PIL import Image
+from ib_sync_rewards.imagebind.pytorchvideo import transforms as pv_transforms
+from ib_sync_rewards.imagebind.pytorchvideo.data.clip_sampling import ConstantClipsPerVideoSampler
+from ib_sync_rewards.imagebind.pytorchvideo.data.encoded_video import EncodedVideo
+from torchvision import transforms
+
+from ib_sync_rewards.imagebind.models.multimodal_preprocessors import SimpleTokenizer
+
+DEFAULT_AUDIO_FRAME_SHIFT_MS = 10  # in milliseconds
+
+def normalize(clip, mean, std, inplace=False):
+    """
+    Args:
+        clip (torch.tensor): Video clip to be normalized. Size is (C, T, H, W)
+        mean (tuple): pixel RGB mean. Size is (3)
+        std (tuple): pixel standard deviation. Size is (3)
+    Returns:
+        normalized clip (torch.tensor): Size is (C, T, H, W)
+    """
+    if not len(clip.shape) == 4:
+        raise ValueError("clip should be a 4D torch.tensor")
+    if not inplace:
+        clip = clip.clone()
+    mean = torch.as_tensor(mean, dtype=clip.dtype, device=clip.device)
+    std = torch.as_tensor(std, dtype=clip.dtype, device=clip.device)
+    clip.sub_(mean[:, None, None, None]).div_(std[:, None, None, None])
+    return clip
+
+class NormalizeVideo:
+    """
+    Normalize the video clip by mean subtraction and division by standard deviation
+    Args:
+        mean (3-tuple): pixel RGB mean
+        std (3-tuple): pixel RGB standard deviation
+        inplace (boolean): whether do in-place normalization
+    """
+
+    def __init__(self, mean, std, inplace=False):
+        self.mean = mean
+        self.std = std
+        self.inplace = inplace
+
+    def __call__(self, clip):
+        """
+        Args:
+            clip (torch.tensor): video clip to be normalized. Size is (C, T, H, W)
+        """
+        return normalize(clip, self.mean, self.std, self.inplace)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(mean={self.mean}, std={self.std}, inplace={self.inplace})"
+
+def return_bpe_path():
+    return pkg_resources.resource_filename(
+        "imagebind", "bpe/bpe_simple_vocab_16e6.txt.gz"
+    )
+
+
+def waveform2melspec(waveform, sample_rate, num_mel_bins, target_length):
+    # Based on https://github.com/YuanGongND/ast/blob/d7d8b4b8e06cdaeb6c843cdb38794c1c7692234c/src/dataloader.py#L102
+    waveform -= waveform.mean()
+    fbank = torchaudio.compliance.kaldi.fbank(
+        waveform,
+        htk_compat=True,
+        sample_frequency=sample_rate,
+        use_energy=False,
+        window_type="hanning",
+        num_mel_bins=num_mel_bins,
+        dither=0.0,
+        frame_length=25,
+        frame_shift=DEFAULT_AUDIO_FRAME_SHIFT_MS,
+    )
+    # Convert to [mel_bins, num_frames] shape
+    fbank = fbank.transpose(0, 1)
+    # Pad to target_length
+    n_frames = fbank.size(1)
+    p = target_length - n_frames
+    # if p is too large (say >20%), flash a warning
+    if abs(p) / n_frames > 0.2:
+        logging.warning(
+            "Large gap between audio n_frames(%d) and "
+            "target_length (%d). Is the audio_target_length "
+            "setting correct?",
+            n_frames,
+            target_length,
+        )
+    # cut and pad
+    if p > 0:
+        fbank = torch.nn.functional.pad(fbank, (0, p), mode="constant", value=0)
+    elif p < 0:
+        fbank = fbank[:, 0:target_length]
+    # Convert to [1, mel_bins, num_frames] shape, essentially like a 1
+    # channel image
+    fbank = fbank.unsqueeze(0)
+    return fbank
+
+
+def get_clip_timepoints(clip_sampler, duration):
+    # Read out all clips in this video
+    all_clips_timepoints = []
+    is_last_clip = False
+    end = 0.0
+    while not is_last_clip:
+        start, end, _, _, is_last_clip = clip_sampler(end, duration, annotation=None)
+        all_clips_timepoints.append((start, end))
+    return all_clips_timepoints
+
+
+def load_and_transform_vision_data(image_paths, device):
+    if image_paths is None:
+        return None
+
+    image_outputs = []
+
+    data_transform = transforms.Compose(
+        [
+            transforms.Resize(224, interpolation=transforms.InterpolationMode.BICUBIC),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(
+                mean=(0.48145466, 0.4578275, 0.40821073),
+                std=(0.26862954, 0.26130258, 0.27577711),
+            ),
+        ]
+    )
+
+    for image_path in image_paths:
+        with open(image_path, "rb") as fopen:
+            image = Image.open(fopen).convert("RGB")
+
+        image = data_transform(image).to(device)
+        image_outputs.append(image)
+    return torch.stack(image_outputs, dim=0)
+
+
+def load_and_transform_text(text, device):
+    if text is None:
+        return None
+    tokenizer = SimpleTokenizer(bpe_path=return_bpe_path())
+    tokens = [tokenizer(t).unsqueeze(0).to(device) for t in text]
+    tokens = torch.cat(tokens, dim=0)
+    return tokens
+
+
+def load_and_transform_audio_data(
+    audio_paths,
+    device,
+    num_mel_bins=128,
+    target_length=204,
+    sample_rate=16000,
+    clip_duration=2,
+    clips_per_video=3,
+    mean=-4.268,
+    std=9.138,
+):
+    if audio_paths is None:
+        return None
+
+    audio_outputs = []
+    clip_sampler = ConstantClipsPerVideoSampler(
+        clip_duration=clip_duration, clips_per_video=clips_per_video
+    )
+
+    for audio_path in audio_paths:
+        waveform, sr = torchaudio.load(audio_path)
+        if sample_rate != sr:
+            waveform = torchaudio.functional.resample(
+                waveform, orig_freq=sr, new_freq=sample_rate
+            )
+        all_clips_timepoints = get_clip_timepoints(
+            clip_sampler, waveform.size(1) / sample_rate
+        )
+        all_clips = []
+        for clip_timepoints in all_clips_timepoints:
+            waveform_clip = waveform[
+                :,
+                int(clip_timepoints[0] * sample_rate) : int(
+                    clip_timepoints[1] * sample_rate
+                ),
+            ]
+            waveform_melspec = waveform2melspec(
+                waveform_clip, sample_rate, num_mel_bins, target_length
+            )
+            all_clips.append(waveform_melspec)
+
+        normalize = transforms.Normalize(mean=mean, std=std)
+        all_clips = [normalize(ac).to(device) for ac in all_clips]
+
+        all_clips = torch.stack(all_clips, dim=0)
+        audio_outputs.append(all_clips)
+
+    return torch.stack(audio_outputs, dim=0)
+
+
+def crop_boxes(boxes, x_offset, y_offset):
+    """
+    Perform crop on the bounding boxes given the offsets.
+    Args:
+        boxes (ndarray or None): bounding boxes to perform crop. The dimension
+            is `num boxes` x 4.
+        x_offset (int): cropping offset in the x axis.
+        y_offset (int): cropping offset in the y axis.
+    Returns:
+        cropped_boxes (ndarray or None): the cropped boxes with dimension of
+            `num boxes` x 4.
+    """
+    cropped_boxes = boxes.copy()
+    cropped_boxes[:, [0, 2]] = boxes[:, [0, 2]] - x_offset
+    cropped_boxes[:, [1, 3]] = boxes[:, [1, 3]] - y_offset
+
+    return cropped_boxes
+
+
+def uniform_crop(images, size, spatial_idx, boxes=None, scale_size=None):
+    """
+    Perform uniform spatial sampling on the images and corresponding boxes.
+    Args:
+        images (tensor): images to perform uniform crop. The dimension is
+            `num frames` x `channel` x `height` x `width`.
+        size (int): size of height and weight to crop the images.
+        spatial_idx (int): 0, 1, or 2 for left, center, and right crop if width
+            is larger than height. Or 0, 1, or 2 for top, center, and bottom
+            crop if height is larger than width.
+        boxes (ndarray or None): optional. Corresponding boxes to images.
+            Dimension is `num boxes` x 4.
+        scale_size (int): optinal. If not None, resize the images to scale_size before
+            performing any crop.
+    Returns:
+        cropped (tensor): images with dimension of
+            `num frames` x `channel` x `size` x `size`.
+        cropped_boxes (ndarray or None): the cropped boxes with dimension of
+            `num boxes` x 4.
+    """
+    assert spatial_idx in [0, 1, 2]
+    ndim = len(images.shape)
+    if ndim == 3:
+        images = images.unsqueeze(0)
+    height = images.shape[2]
+    width = images.shape[3]
+
+    if scale_size is not None:
+        if width <= height:
+            width, height = scale_size, int(height / width * scale_size)
+        else:
+            width, height = int(width / height * scale_size), scale_size
+        images = torch.nn.functional.interpolate(
+            images,
+            size=(height, width),
+            mode="bilinear",
+            align_corners=False,
+        )
+
+    y_offset = int(math.ceil((height - size) / 2))
+    x_offset = int(math.ceil((width - size) / 2))
+
+    if height > width:
+        if spatial_idx == 0:
+            y_offset = 0
+        elif spatial_idx == 2:
+            y_offset = height - size
+    else:
+        if spatial_idx == 0:
+            x_offset = 0
+        elif spatial_idx == 2:
+            x_offset = width - size
+    cropped = images[:, :, y_offset : y_offset + size, x_offset : x_offset + size]
+    cropped_boxes = crop_boxes(boxes, x_offset, y_offset) if boxes is not None else None
+    if ndim == 3:
+        cropped = cropped.squeeze(0)
+    return cropped, cropped_boxes
+
+
+class SpatialCrop(nn.Module):
+    """
+    Convert the video into 3 smaller clips spatially. Must be used after the
+        temporal crops to get spatial crops, and should be used with
+        -2 in the spatial crop at the slowfast augmentation stage (so full
+        frames are passed in here). Will return a larger list with the
+        3x spatial crops as well.
+    """
+
+    def __init__(self, crop_size: int = 224, num_crops: int = 3):
+        super().__init__()
+        self.crop_size = crop_size
+        if num_crops == 3:
+            self.crops_to_ext = [0, 1, 2]
+            self.flipped_crops_to_ext = []
+        elif num_crops == 1:
+            self.crops_to_ext = [1]
+            self.flipped_crops_to_ext = []
+        else:
+            raise NotImplementedError("Nothing else supported yet")
+
+    def forward(self, videos):
+        """
+        Args:
+            videos: A list of C, T, H, W videos.
+        Returns:
+            videos: A list with 3x the number of elements. Each video converted
+                to C, T, H', W' by spatial cropping.
+        """
+        assert isinstance(videos, list), "Must be a list of videos after temporal crops"
+        assert all([video.ndim == 4 for video in videos]), "Must be (C,T,H,W)"
+        res = []
+        for video in videos:
+            for spatial_idx in self.crops_to_ext:
+                res.append(uniform_crop(video, self.crop_size, spatial_idx)[0])
+            if not self.flipped_crops_to_ext:
+                continue
+            flipped_video = transforms.functional.hflip(video)
+            for spatial_idx in self.flipped_crops_to_ext:
+                res.append(uniform_crop(flipped_video, self.crop_size, spatial_idx)[0])
+        return res
+
+
+def load_and_transform_video_data(
+    video_paths,
+    device,
+    clip_duration=2,
+    clips_per_video=5,
+    sample_rate=16000,
+):
+    if video_paths is None:
+        return None
+
+    video_outputs = []
+    video_transform = transforms.Compose(
+        [
+            pv_transforms.ShortSideScale(224),
+            NormalizeVideo(
+                mean=(0.48145466, 0.4578275, 0.40821073),
+                std=(0.26862954, 0.26130258, 0.27577711),
+            ),
+        ]
+    )
+
+    clip_sampler = ConstantClipsPerVideoSampler(
+        clip_duration=clip_duration, clips_per_video=clips_per_video
+    )
+    frame_sampler = pv_transforms.UniformTemporalSubsample(num_samples=clip_duration)
+
+    for video_path in video_paths:
+        video = EncodedVideo.from_path(
+            video_path,
+            decoder="decord",
+            decode_audio=False,
+            **{"sample_rate": sample_rate},
+        )
+
+        all_clips_timepoints = get_clip_timepoints(clip_sampler, video.duration)
+
+        all_video = []
+        for clip_timepoints in all_clips_timepoints:
+            # Read the clip, get frames
+            clip = video.get_clip(clip_timepoints[0], clip_timepoints[1])
+            if clip is None:
+                raise ValueError("No clip found")
+            video_clip = frame_sampler(clip["video"])
+            video_clip = video_clip / 255.0  # since this is float, need 0-1
+
+            all_video.append(video_clip)
+
+        all_video = [video_transform(clip) for clip in all_video]
+        all_video = SpatialCrop(224, num_crops=3)(all_video)
+
+        all_video = torch.stack(all_video, dim=0)
+        video_outputs.append(all_video)
+
+    return torch.stack(video_outputs, dim=0).to(device)

reward_models/ib_sync_rewards/imagebind/pytorchvideo/accelerator/deployment/common/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.

reward_models/ib_sync_rewards/imagebind/pytorchvideo/accelerator/deployment/mobile_cpu/transmuter/__init__.py

@@ -0,0 +1,10 @@
+from pytorchvideo.accelerator.deployment.common.model_transmuter import (
+    EFFICIENT_BLOCK_TRANSMUTER_REGISTRY,
+)
+
+from .transmuter_mobile_cpu import EFFICIENT_BLOCK_TRANSMUTER_MOBILE_CPU
+
+
+EFFICIENT_BLOCK_TRANSMUTER_REGISTRY["mobile_cpu"] = (
+    EFFICIENT_BLOCK_TRANSMUTER_MOBILE_CPU
+)

reward_models/ib_sync_rewards/imagebind/pytorchvideo/accelerator/efficient_blocks/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.

reward_models/ib_sync_rewards/imagebind/pytorchvideo/accelerator/efficient_blocks/no_op_convert_block.py

@@ -0,0 +1,26 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import torch.nn as nn
+
+from .efficient_block_base import EfficientBlockBase
+
+
+class NoOpConvertBlock(EfficientBlockBase):
+    """
+    This class provides an interface with EfficientBlockBase for modules that do not
+    need convert.
+    Args:
+        model (nn.Module): NoOpConvertBlock takes model as input and generate a wrapper
+            instance of EfficientBlockBase with same functionality as model, with no change
+            applied when convert() is called.
+    """
+
+    def __init__(self, model: nn.Module):
+        super().__init__()
+        self.model = model
+
+    def convert(self, *args, **kwargs):
+        pass
+
+    def forward(self, x):
+        return self.model(x)

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from .ava import Ava  # noqa
+from .charades import Charades  # noqa
+from .clip_sampling import (  # noqa; noqa
+    ClipSampler,
+    make_clip_sampler,
+    RandomClipSampler,
+    UniformClipSampler,
+)
+from .domsev import DomsevFrameDataset, DomsevVideoDataset  # noqa
+from .epic_kitchen_forecasting import EpicKitchenForecasting  # noqa
+from .epic_kitchen_recognition import EpicKitchenRecognition  # noqa
+from .hmdb51 import Hmdb51  # noqa
+from .kinetics import Kinetics  # noqa
+from .labeled_video_dataset import labeled_video_dataset, LabeledVideoDataset  # noqa
+from .ssv2 import SSv2
+from .ucf101 import Ucf101  # noqa

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/clip_sampling.py

@@ -0,0 +1,410 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import random
+from abc import ABC, abstractmethod
+from fractions import Fraction
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union
+
+
+class ClipInfo(NamedTuple):
+    """
+    Named-tuple for clip information with:
+        clip_start_sec  (Union[float, Fraction]): clip start time.
+        clip_end_sec (Union[float, Fraction]): clip end time.
+        clip_index (int): clip index in the video.
+        aug_index (int): augmentation index for the clip. Different augmentation methods
+            might generate multiple views for the same clip.
+        is_last_clip (bool): a bool specifying whether there are more clips to be
+            sampled from the video.
+    """
+
+    clip_start_sec: Union[float, Fraction]
+    clip_end_sec: Union[float, Fraction]
+    clip_index: int
+    aug_index: int
+    is_last_clip: bool
+
+
+class ClipInfoList(NamedTuple):
+    """
+    Named-tuple for clip information with:
+        clip_start_sec  (float): clip start time.
+        clip_end_sec (float): clip end time.
+        clip_index (int): clip index in the video.
+        aug_index (int): augmentation index for the clip. Different augmentation methods
+            might generate multiple views for the same clip.
+        is_last_clip (bool): a bool specifying whether there are more clips to be
+            sampled from the video.
+    """
+
+    clip_start_sec: List[float]
+    clip_end_sec: List[float]
+    clip_index: List[float]
+    aug_index: List[float]
+    is_last_clip: List[float]
+
+
+class ClipSampler(ABC):
+    """
+    Interface for clip samplers that take a video time, previous sampled clip time,
+    and returns a named-tuple ``ClipInfo``.
+    """
+
+    def __init__(self, clip_duration: Union[float, Fraction]) -> None:
+        self._clip_duration = Fraction(clip_duration)
+        self._current_clip_index = 0
+        self._current_aug_index = 0
+
+    @abstractmethod
+    def __call__(
+        self,
+        last_clip_end_time: Union[float, Fraction],
+        video_duration: Union[float, Fraction],
+        annotation: Dict[str, Any],
+    ) -> ClipInfo:
+        pass
+
+    def reset(self) -> None:
+        """Resets any video-specific attributes in preperation for next video"""
+        pass
+
+
+def make_clip_sampler(sampling_type: str, *args) -> ClipSampler:
+    """
+    Constructs the clip samplers found in ``pytorchvideo.data.clip_sampling`` from the
+    given arguments.
+
+    Args:
+        sampling_type (str): choose clip sampler to return. It has three options:
+
+            * uniform: constructs and return ``UniformClipSampler``
+            * random: construct and return ``RandomClipSampler``
+            * constant_clips_per_video: construct and return ``ConstantClipsPerVideoSampler``
+
+        *args: the args to pass to the chosen clip sampler constructor.
+    """
+    if sampling_type == "uniform":
+        return UniformClipSampler(*args)
+    elif sampling_type == "random":
+        return RandomClipSampler(*args)
+    elif sampling_type == "constant_clips_per_video":
+        return ConstantClipsPerVideoSampler(*args)
+    elif sampling_type == "random_multi":
+        return RandomMultiClipSampler(*args)
+    else:
+        raise NotImplementedError(f"{sampling_type} not supported")
+
+
+class UniformClipSampler(ClipSampler):
+    """
+    Evenly splits the video into clips of size clip_duration.
+    """
+
+    def __init__(
+        self,
+        clip_duration: Union[float, Fraction],
+        stride: Optional[Union[float, Fraction]] = None,
+        backpad_last: bool = False,
+        eps: float = 1e-6,
+    ):
+        """
+        Args:
+            clip_duration (Union[float, Fraction]):
+                The length of the clip to sample (in seconds).
+            stride (Union[float, Fraction], optional):
+                The amount of seconds to offset the next clip by
+                default value of None is equivalent to no stride => stride == clip_duration.
+            eps (float):
+                Epsilon for floating point comparisons. Used to check the last clip.
+            backpad_last (bool):
+                Whether to include the last frame(s) by "back padding".
+
+                For instance, if we have a video of 39 frames (30 fps = 1.3s)
+                with a stride of 16 (0.533s) with a clip duration of 32 frames
+                (1.0667s). The clips will be (in frame numbers):
+
+                with backpad_last = False
+                - [0, 31]
+
+                with backpad_last = True
+                - [0, 31]
+                - [8, 39], this is "back-padded" from [16, 48] to fit the last window
+        Note that you can use Fraction for clip_duration and stride if you want to
+        avoid float precision issue and need accurate frames in each clip.
+        """
+        super().__init__(clip_duration)
+        self._stride = stride if stride is not None else self._clip_duration
+        self._eps = eps
+        self._backpad_last = backpad_last
+
+        assert self._stride > 0, "stride must be positive"
+
+    def _clip_start_end(
+        self,
+        last_clip_end_time: Union[float, Fraction],
+        video_duration: Union[float, Fraction],
+        backpad_last: bool,
+    ) -> Tuple[Fraction, Fraction]:
+        """
+        Helper to calculate the start/end clip with backpad logic
+        """
+        delta = self._stride - self._clip_duration
+        last_end_time = -delta if last_clip_end_time is None else last_clip_end_time
+        clip_start = Fraction(last_end_time + delta)
+        clip_end = Fraction(clip_start + self._clip_duration)
+        if backpad_last:
+            buffer_amount = max(0, clip_end - video_duration)
+            clip_start -= buffer_amount
+            clip_start = Fraction(max(0, clip_start))  # handle rounding
+            clip_end = Fraction(clip_start + self._clip_duration)
+
+        return clip_start, clip_end
+
+    def __call__(
+        self,
+        last_clip_end_time: Optional[float],
+        video_duration: float,
+        annotation: Dict[str, Any],
+    ) -> ClipInfo:
+        """
+        Args:
+            last_clip_end_time (float): the last clip end time sampled from this video. This
+                should be 0.0 if the video hasn't had clips sampled yet.
+            video_duration: (float): the duration of the video that's being sampled in seconds
+            annotation (Dict): Not used by this sampler.
+        Returns:
+            clip_info: (ClipInfo): includes the clip information (clip_start_time,
+            clip_end_time, clip_index, aug_index, is_last_clip), where the times are in
+            seconds and is_last_clip is False when there is still more of time in the video
+            to be sampled.
+        """
+        clip_start, clip_end = self._clip_start_end(
+            last_clip_end_time, video_duration, backpad_last=self._backpad_last
+        )
+
+        # if they both end at the same time - it's the last clip
+        _, next_clip_end = self._clip_start_end(
+            clip_end, video_duration, backpad_last=self._backpad_last
+        )
+        if self._backpad_last:
+            is_last_clip = abs(next_clip_end - clip_end) < self._eps
+        else:
+            is_last_clip = (next_clip_end - video_duration) > self._eps
+
+        clip_index = self._current_clip_index
+        self._current_clip_index += 1
+
+        if is_last_clip:
+            self.reset()
+
+        return ClipInfo(clip_start, clip_end, clip_index, 0, is_last_clip)
+
+    def reset(self):
+        self._current_clip_index = 0
+
+
+class UniformClipSamplerTruncateFromStart(UniformClipSampler):
+    """
+    Evenly splits the video into clips of size clip_duration.
+    If truncation_duration is set, clips sampled from [0, truncation_duration].
+    If truncation_duration is not set, defaults to UniformClipSampler.
+    """
+
+    def __init__(
+        self,
+        clip_duration: Union[float, Fraction],
+        stride: Optional[Union[float, Fraction]] = None,
+        backpad_last: bool = False,
+        eps: float = 1e-6,
+        truncation_duration: float = None,
+    ) -> None:
+        super().__init__(clip_duration, stride, backpad_last, eps)
+        self.truncation_duration = truncation_duration
+
+    def __call__(
+        self,
+        last_clip_end_time: float,
+        video_duration: float,
+        annotation: Dict[str, Any],
+    ) -> ClipInfo:
+        truncated_video_duration = video_duration
+        if self.truncation_duration is not None:
+            truncated_video_duration = min(self.truncation_duration, video_duration)
+
+        return super().__call__(
+            last_clip_end_time, truncated_video_duration, annotation
+        )
+
+
+class RandomClipSampler(ClipSampler):
+    """
+    Randomly samples clip of size clip_duration from the videos.
+    """
+
+    def __call__(
+        self,
+        last_clip_end_time: float,
+        video_duration: float,
+        annotation: Dict[str, Any],
+    ) -> ClipInfo:
+        """
+        Args:
+            last_clip_end_time (float): Not used for RandomClipSampler.
+            video_duration: (float): the duration (in seconds) for the video that's
+                being sampled
+            annotation (Dict): Not used by this sampler.
+        Returns:
+            clip_info (ClipInfo): includes the clip information of (clip_start_time,
+            clip_end_time, clip_index, aug_index, is_last_clip). The times are in seconds.
+            clip_index, aux_index and is_last_clip are always 0, 0 and True, respectively.
+
+        """
+        max_possible_clip_start = max(video_duration - self._clip_duration, 0)
+        clip_start_sec = Fraction(random.uniform(0, max_possible_clip_start))
+        return ClipInfo(
+            clip_start_sec, clip_start_sec + self._clip_duration, 0, 0, True
+        )
+
+
+class RandomMultiClipSampler(RandomClipSampler):
+    """
+    Randomly samples multiple clips of size clip_duration from the videos.
+    """
+
+    def __init__(self, clip_duration: float, num_clips: int) -> None:
+        super().__init__(clip_duration)
+        self._num_clips = num_clips
+
+    def __call__(
+        self,
+        last_clip_end_time: Optional[float],
+        video_duration: float,
+        annotation: Dict[str, Any],
+    ) -> ClipInfoList:
+        (
+            clip_start_list,
+            clip_end_list,
+            clip_index_list,
+            aug_index_list,
+            is_last_clip_list,
+        ) = (
+            self._num_clips * [None],
+            self._num_clips * [None],
+            self._num_clips * [None],
+            self._num_clips * [None],
+            self._num_clips * [None],
+        )
+        for i in range(self._num_clips):
+            (
+                clip_start_list[i],
+                clip_end_list[i],
+                clip_index_list[i],
+                aug_index_list[i],
+                is_last_clip_list[i],
+            ) = super().__call__(last_clip_end_time, video_duration, annotation)
+
+        return ClipInfoList(
+            clip_start_list,
+            clip_end_list,
+            clip_index_list,
+            aug_index_list,
+            is_last_clip_list,
+        )
+
+
+class RandomMultiClipSamplerTruncateFromStart(RandomMultiClipSampler):
+    """
+    Randomly samples multiple clips of size clip_duration from the videos.
+    If truncation_duration is set, clips sampled from [0, truncation_duration].
+    If truncation_duration is not set, defaults to RandomMultiClipSampler.
+    """
+
+    def __init__(
+        self, clip_duration: float, num_clips: int, truncation_duration: float = None
+    ) -> None:
+        super().__init__(clip_duration, num_clips)
+        self.truncation_duration = truncation_duration
+
+    def __call__(
+        self,
+        last_clip_end_time: Optional[float],
+        video_duration: float,
+        annotation: Dict[str, Any],
+    ) -> ClipInfoList:
+        truncated_video_duration = video_duration
+        if self.truncation_duration is not None:
+            truncated_video_duration = min(self.truncation_duration, video_duration)
+
+        return super().__call__(
+            last_clip_end_time, truncated_video_duration, annotation
+        )
+
+
+class ConstantClipsPerVideoSampler(ClipSampler):
+    """
+    Evenly splits the video into clips_per_video increments and samples clips of size
+    clip_duration at these increments.
+    """
+
+    def __init__(
+        self, clip_duration: float, clips_per_video: int, augs_per_clip: int = 1
+    ) -> None:
+        super().__init__(clip_duration)
+        self._clips_per_video = clips_per_video
+        self._augs_per_clip = augs_per_clip
+
+    def __call__(
+        self,
+        last_clip_end_time: Optional[float],
+        video_duration: float,
+        annotation: Dict[str, Any],
+    ) -> ClipInfo:
+        """
+        Args:
+            last_clip_end_time (float): Not used for ConstantClipsPerVideoSampler.
+            video_duration: (float): the duration (in seconds) for the video that's
+                being sampled.
+            annotation (Dict): Not used by this sampler.
+        Returns:
+            a named-tuple `ClipInfo`: includes the clip information of (clip_start_time,
+                clip_end_time, clip_index, aug_index, is_last_clip). The times are in seconds.
+                is_last_clip is True after clips_per_video clips have been sampled or the end
+                of the video is reached.
+
+        """
+        max_possible_clip_start = Fraction(max(video_duration - self._clip_duration, 0))
+        uniform_clip = Fraction(
+            max_possible_clip_start, max(self._clips_per_video - 1, 1)
+        )
+        clip_start_sec = uniform_clip * self._current_clip_index
+        clip_index = self._current_clip_index
+        aug_index = self._current_aug_index
+
+        self._current_aug_index += 1
+        if self._current_aug_index >= self._augs_per_clip:
+            self._current_clip_index += 1
+            self._current_aug_index = 0
+
+        # Last clip is True if sampled self._clips_per_video or if end of video is reached.
+        is_last_clip = False
+        if (
+            self._current_clip_index >= self._clips_per_video
+            or uniform_clip * self._current_clip_index > max_possible_clip_start
+        ):
+            self._current_clip_index = 0
+            is_last_clip = True
+
+        if is_last_clip:
+            self.reset()
+
+        return ClipInfo(
+            clip_start_sec,
+            clip_start_sec + self._clip_duration,
+            clip_index,
+            aug_index,
+            is_last_clip,
+        )
+
+    def reset(self):
+        self._current_clip_index = 0
+        self._current_aug_index = 0

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/dataset_manifest_utils.py

@@ -0,0 +1,314 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import datetime
+import os
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, Optional, Union
+
+from ib_sync_rewards.imagebind.pytorchvideo.data.encoded_video import EncodedVideo
+from ib_sync_rewards.imagebind.pytorchvideo.data.frame_video import FrameVideo
+from ib_sync_rewards.imagebind.pytorchvideo.data.utils import (
+    DataclassFieldCaster,
+    load_dataclass_dict_from_csv,
+    save_dataclass_objs_to_headered_csv,
+)
+from ib_sync_rewards.imagebind.pytorchvideo.data.video import Video
+
+
+@dataclass
+class EncodedVideoInfo(DataclassFieldCaster):
+    """
+    Class representing the location of an available encoded video.
+    """
+
+    video_id: str
+    file_path: str
+
+
+@dataclass
+class VideoFrameInfo(DataclassFieldCaster):
+    """
+    Class representing the locations of all frames that compose a video.
+    """
+
+    video_id: str
+    location: str
+    frame_file_stem: str
+    frame_string_length: int
+    min_frame_number: int
+    max_frame_number: int
+    file_extension: str
+
+
+@dataclass
+class VideoInfo(DataclassFieldCaster):
+    """
+    Class representing the video-level metadata of a video from an arbitrary video dataset.
+    """
+
+    video_id: str
+    resolution: str
+    duration: float
+    fps: float
+
+
+@dataclass
+class VideoClipInfo(DataclassFieldCaster):
+    video_id: str
+    start_time: float
+    stop_time: float
+
+
+@dataclass
+class ImageFrameInfo(DataclassFieldCaster):
+    """
+    Class representing the metadata (and labels) for a single frame
+    """
+
+    video_id: str
+    frame_id: str
+    frame_number: int
+    frame_file_path: str
+
+
+class VideoDatasetType(Enum):
+    Frame = 1
+    EncodedVideo = 2
+
+
+class ImageDataset:
+    @staticmethod
+    def _load_images(
+        frame_manifest_file_path: Optional[str],
+        video_info_file_path: str,
+        multithreaded_io: bool,
+    ) -> Dict[str, ImageFrameInfo]:
+        video_infos: Dict[str, VideoInfo] = load_dataclass_dict_from_csv(
+            video_info_file_path, VideoInfo, "video_id"
+        )
+        video_frames: Dict[str, VideoFrameInfo] = load_dataclass_dict_from_csv(
+            frame_manifest_file_path, VideoFrameInfo, "video_id"
+        )
+        VideoDataset._remove_video_info_missing_or_incomplete_videos(
+            video_frames, video_infos
+        )
+
+        image_infos = {}
+        for video_id in video_infos:
+            frame_filepaths = VideoDataset._frame_number_to_filepaths(
+                video_id, video_frames, video_infos
+            )
+            video_info = video_infos[video_id]
+            video_frame_info = video_frames[video_info.video_id]
+            for frame_filepath, frame_number in zip(
+                frame_filepaths,
+                range(
+                    video_frame_info.min_frame_number, video_frame_info.max_frame_number
+                ),
+            ):
+                frame_id = os.path.splitext(os.path.basename(frame_filepath))[0]
+                image_infos[frame_id] = ImageFrameInfo(
+                    video_id, frame_id, frame_number, frame_filepath
+                )
+        return image_infos
+
+
+class VideoDataset:
+    @staticmethod
+    def _load_videos(
+        video_data_manifest_file_path: Optional[str],
+        video_info_file_path: str,
+        multithreaded_io: bool,
+        dataset_type: VideoDatasetType,
+    ) -> Dict[str, Video]:
+        video_infos: Dict[str, VideoInfo] = load_dataclass_dict_from_csv(
+            video_info_file_path, VideoInfo, "video_id"
+        )
+        if dataset_type == VideoDatasetType.Frame:
+            return VideoDataset._load_frame_videos(
+                video_data_manifest_file_path, video_infos, multithreaded_io
+            )
+        elif dataset_type == VideoDatasetType.EncodedVideo:
+            return VideoDataset._load_encoded_videos(
+                video_data_manifest_file_path, video_infos
+            )
+
+    @staticmethod
+    def _load_frame_videos(
+        frame_manifest_file_path: str,
+        video_infos: Dict[str, VideoInfo],
+        multithreaded_io: bool,
+    ):
+        video_frames: Dict[str, VideoFrameInfo] = load_dataclass_dict_from_csv(
+            frame_manifest_file_path, VideoFrameInfo, "video_id"
+        )
+        VideoDataset._remove_video_info_missing_or_incomplete_videos(
+            video_frames, video_infos
+        )
+        return {
+            video_id: FrameVideo(
+                video_frame_paths=VideoDataset._frame_number_to_filepaths(
+                    video_id, video_frames, video_infos
+                ),
+                duration=video_infos[video_id].duration,
+                fps=video_infos[video_id].fps,
+                multithreaded_io=multithreaded_io,
+            )
+            for video_id in video_infos
+        }
+
+    @staticmethod
+    def _load_encoded_videos(
+        encoded_video_manifest_file_path: str,
+        video_infos: Dict[str, VideoInfo],
+    ):
+        encoded_video_infos: Dict[str, EncodedVideoInfo] = load_dataclass_dict_from_csv(
+            encoded_video_manifest_file_path, EncodedVideoInfo, "video_id"
+        )
+        VideoDataset._remove_video_info_missing_or_incomplete_videos(
+            encoded_video_infos, video_infos
+        )
+
+        return {
+            video_id: EncodedVideo.from_path(encoded_video_info.file_path)
+            for video_id, encoded_video_info in encoded_video_infos.items()
+        }
+
+    @staticmethod
+    def _frame_number_to_filepaths(
+        video_id: str,
+        video_frames: Dict[str, VideoFrameInfo],
+        video_infos: Dict[str, VideoInfo],
+    ) -> Optional[str]:
+        video_info = video_infos[video_id]
+        video_frame_info = video_frames[video_info.video_id]
+
+        frame_filepaths = []
+        num_frames = (
+            video_frame_info.max_frame_number - video_frame_info.min_frame_number + 1
+        )
+        for frame_index in range(num_frames):
+            frame_number = frame_index + video_frame_info.min_frame_number
+            if (
+                frame_number < video_frame_info.min_frame_number
+                or frame_number > video_frame_info.max_frame_number
+            ):
+                return None
+
+            frame_path_index = str(frame_number)
+            frame_prefix = video_frame_info.frame_file_stem
+            num_zero_pad = (
+                video_frame_info.frame_string_length
+                - len(frame_path_index)
+                - len(frame_prefix)
+            )
+            zero_padding = "0" * num_zero_pad
+            frame_component = (
+                f"{frame_prefix}{zero_padding}{frame_path_index}"
+                f".{video_frame_info.file_extension}"
+            )
+            frame_filepaths.append(f"{video_frame_info.location}/{frame_component}")
+        return frame_filepaths
+
+    @staticmethod
+    def _remove_video_info_missing_or_incomplete_videos(
+        video_data_infos: Dict[str, Union[VideoFrameInfo, EncodedVideoInfo]],
+        video_infos: Dict[str, VideoInfo],
+    ) -> None:
+        # Avoid deletion keys from dict during iteration over keys
+        video_ids = list(video_infos)
+        for video_id in video_ids:
+            video_info = video_infos[video_id]
+
+            # Remove videos we have metadata for but don't have video data
+            if video_id not in video_data_infos:
+                del video_infos[video_id]
+                continue
+
+            # Remove videos we have metadata for but don't have the right number of frames
+            if type(video_data_infos[video_id]) == VideoFrameInfo:
+                video_frames_info = video_data_infos[video_id]
+                expected_frames = round(video_info.duration * video_info.fps)
+                num_frames = (
+                    video_frames_info.max_frame_number
+                    - video_frames_info.min_frame_number
+                )
+                if abs(num_frames - expected_frames) > video_info.fps:
+                    del video_data_infos[video_id]
+                    del video_infos[video_id]
+
+        video_ids = list(video_data_infos)  # Avoid modifying dict during iteration
+        for video_id in video_ids:
+            # Remove videos we have video data for but don't have metadata
+            if video_id not in video_infos:
+                del video_data_infos[video_id]
+
+
+def get_seconds_from_hms_time(time_str: str) -> float:
+    """
+    Get Seconds from timestamp of form 'HH:MM:SS'.
+
+    Args:
+        time_str (str)
+
+    Returns:
+        float of seconds
+
+    """
+    for fmt in ("%H:%M:%S.%f", "%H:%M:%S"):
+        try:
+            time_since_min_time = datetime.datetime.strptime(time_str, fmt)
+            min_time = datetime.datetime.strptime("", "")
+            return float((time_since_min_time - min_time).total_seconds())
+        except ValueError:
+            pass
+    raise ValueError(f"No valid data format found for provided string {time_str}.")
+
+
+def save_encoded_video_manifest(
+    encoded_video_infos: Dict[str, EncodedVideoInfo], file_name: str = None
+) -> str:
+    """
+    Saves the encoded video dictionary as a csv file that can be read for future usage.
+
+    Args:
+        video_frames (Dict[str, EncodedVideoInfo]):
+            Dictionary mapping video_ids to metadata about the location of
+            their video data.
+
+        file_name (str):
+            location to save file (will be automatically generated if None).
+
+    Returns:
+        string of the filename where the video info is stored.
+    """
+    file_name = (
+        f"{os.getcwd()}/encoded_video_manifest.csv" if file_name is None else file_name
+    )
+    save_dataclass_objs_to_headered_csv(list(encoded_video_infos.values()), file_name)
+    return file_name
+
+
+def save_video_frame_info(
+    video_frames: Dict[str, VideoFrameInfo], file_name: str = None
+) -> str:
+    """
+    Saves the video frame dictionary as a csv file that can be read for future usage.
+
+    Args:
+        video_frames (Dict[str, VideoFrameInfo]):
+            Dictionary mapping video_ids to metadata about the location of
+            their video frame files.
+
+        file_name (str):
+            location to save file (will be automatically generated if None).
+
+    Returns:
+        string of the filename where the video info is stored.
+    """
+    file_name = (
+        f"{os.getcwd()}/video_frame_metadata.csv" if file_name is None else file_name
+    )
+    save_dataclass_objs_to_headered_csv(list(video_frames.values()), file_name)
+    return file_name

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/decoder.py

@@ -0,0 +1,8 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+from enum import Enum
+
+
+class DecoderType(Enum):
+    PYAV = "pyav"
+    TORCHVISION = "torchvision"
+    DECORD = "decord"

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/ego4d/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from .ego4d_dataset import Ego4dMomentsDataset

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/encoded_video.py

@@ -0,0 +1,75 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import io
+import logging
+import pathlib
+from typing import Any, Dict
+
+from iopath.common.file_io import g_pathmgr
+from ib_sync_rewards.imagebind.pytorchvideo.data.decoder import DecoderType
+
+from .video import Video
+
+
+logger = logging.getLogger(__name__)
+
+
+def select_video_class(decoder: str) -> Video:
+    """
+    Select the class for accessing clips based on provided decoder string
+
+    Args:
+        decoder (str): Defines what type of decoder used to decode a video.
+    """
+    if DecoderType(decoder) == DecoderType.PYAV:
+        from .encoded_video_pyav import EncodedVideoPyAV
+
+        video_cls = EncodedVideoPyAV
+    elif DecoderType(decoder) == DecoderType.TORCHVISION:
+        from .encoded_video_torchvision import EncodedVideoTorchVision
+
+        video_cls = EncodedVideoTorchVision
+    elif DecoderType(decoder) == DecoderType.DECORD:
+        from .encoded_video_decord import EncodedVideoDecord
+
+        video_cls = EncodedVideoDecord
+    else:
+        raise NotImplementedError(f"Unknown decoder type {decoder}")
+
+    return video_cls
+
+
+class EncodedVideo(Video):
+    """
+    EncodedVideo is an abstraction for accessing clips from an encoded video.
+    It supports selective decoding when header information is available.
+    """
+
+    @classmethod
+    def from_path(
+        cls,
+        file_path: str,
+        decode_video: bool = True,
+        decode_audio: bool = True,
+        decoder: str = "pyav",
+        **other_args: Dict[str, Any],
+    ):
+        """
+        Fetches the given video path using PathManager (allowing remote uris to be
+        fetched) and constructs the EncodedVideo object.
+
+        Args:
+            file_path (str): a PathManager file-path.
+        """
+        # We read the file with PathManager so that we can read from remote uris.
+        with g_pathmgr.open(file_path, "rb") as fh:
+            video_file = io.BytesIO(fh.read())
+
+        video_cls = select_video_class(decoder)
+        return video_cls(
+            file=video_file,
+            video_name=pathlib.Path(file_path).name,
+            decode_video=decode_video,
+            decode_audio=decode_audio,
+            **other_args,
+        )

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/encoded_video_decord.py

@@ -0,0 +1,199 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import logging
+import math
+from typing import BinaryIO, Dict, Optional, TypeVar
+
+import torch
+
+from .utils import thwc_to_cthw
+from .video import Video
+
+
+logger = logging.getLogger(__name__)
+
+try:
+    import decord
+except ImportError:
+    _HAS_DECORD = False
+else:
+    _HAS_DECORD = True
+
+if _HAS_DECORD:
+    decord.bridge.set_bridge("torch")
+
+DecordDevice = TypeVar("DecordDevice")
+
+
+class EncodedVideoDecord(Video):
+    """
+
+    Accessing clips from an encoded video using Decord video reading API
+    as the decoding backend. For more details, please refer to -
+    `Decord <https://github.com/dmlc/decord>`
+    """
+
+    def __init__(
+        self,
+        file: BinaryIO,
+        video_name: Optional[str] = None,
+        decode_video: bool = True,
+        decode_audio: bool = True,
+        sample_rate: int = 44100,
+        mono: bool = True,
+        width: int = -1,
+        height: int = -1,
+        num_threads: int = 0,
+        fault_tol: int = -1,
+    ) -> None:
+        """
+        Args:
+            file (BinaryIO): a file-like object (e.g. io.BytesIO or io.StringIO) that
+                contains the encoded video.
+            video_name (str): An optional name assigned to the video.
+            decode_video (bool): If disabled, video is not decoded.
+            decode_audio (bool): If disabled, audio is not decoded.
+            sample_rate: int, default is -1
+                Desired output sample rate of the audio, unchanged if `-1` is specified.
+            mono: bool, default is True
+                Desired output channel layout of the audio. `True` is mono layout. `False`
+                is unchanged.
+            width : int, default is -1
+                Desired output width of the video, unchanged if `-1` is specified.
+            height : int, default is -1
+                Desired output height of the video, unchanged if `-1` is specified.
+            num_threads : int, default is 0
+                Number of decoding thread, auto if `0` is specified.
+            fault_tol : int, default is -1
+                The threshold of corupted and recovered frames. This is to prevent silent fault
+                tolerance when for example 50% frames of a video cannot be decoded and duplicate
+                frames are returned. You may find the fault tolerant feature sweet in many
+                cases, but not for training models. Say `N = # recovered frames`
+                If `fault_tol` < 0, nothing will happen.
+                If 0 < `fault_tol` < 1.0, if N > `fault_tol * len(video)`,
+                raise `DECORDLimitReachedError`.
+                If 1 < `fault_tol`, if N > `fault_tol`, raise `DECORDLimitReachedError`.
+        """
+        if not decode_video:
+            raise NotImplementedError()
+
+        self._decode_audio = decode_audio
+        self._video_name = video_name
+        if not _HAS_DECORD:
+            raise ImportError(
+                "decord is required to use EncodedVideoDecord decoder. Please "
+                "install with 'pip install decord' for CPU-only version and refer to"
+                "'https://github.com/dmlc/decord' for GPU-supported version"
+            )
+        try:
+            if self._decode_audio:
+                self._av_reader = decord.AVReader(
+                    uri=file,
+                    ctx=decord.cpu(0),
+                    sample_rate=sample_rate,
+                    mono=mono,
+                    width=width,
+                    height=height,
+                    num_threads=num_threads,
+                    fault_tol=fault_tol,
+                )
+            else:
+                self._av_reader = decord.VideoReader(
+                    uri=file,
+                    ctx=decord.cpu(0),
+                    width=width,
+                    height=height,
+                    num_threads=num_threads,
+                    fault_tol=fault_tol,
+                )
+        except Exception as e:
+            raise RuntimeError(f"Failed to open video {video_name} with Decord. {e}")
+
+        if self._decode_audio:
+            self._fps = self._av_reader._AVReader__video_reader.get_avg_fps()
+        else:
+            self._fps = self._av_reader.get_avg_fps()
+
+        self._duration = float(len(self._av_reader)) / float(self._fps)
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        Returns:
+            name: the name of the stored video if set.
+        """
+        return self._video_name
+
+    @property
+    def duration(self) -> float:
+        """
+        Returns:
+            duration: the video's duration/end-time in seconds.
+        """
+        return self._duration
+
+    def close(self):
+        if self._av_reader is not None:
+            del self._av_reader
+            self._av_reader = None
+
+    def get_clip(
+        self, start_sec: float, end_sec: float
+    ) -> Dict[str, Optional[torch.Tensor]]:
+        """
+        Retrieves frames from the encoded video at the specified start and end times
+        in seconds (the video always starts at 0 seconds).
+
+        Args:
+            start_sec (float): the clip start time in seconds
+            end_sec (float): the clip end time in seconds
+        Returns:
+            clip_data:
+                A dictionary mapping the entries at "video" and "audio" to a tensors.
+
+                "video": A tensor of the clip's RGB frames with shape:
+                (channel, time, height, width). The frames are of type torch.float32 and
+                in the range [0 - 255].
+
+                "audio": A tensor of the clip's audio samples with shape:
+                (samples). The samples are of type torch.float32 and
+                in the range [0 - 255].
+
+            Returns None if no video or audio found within time range.
+
+        """
+        if start_sec > end_sec or start_sec > self._duration:
+            raise RuntimeError(
+                f"Incorrect time window for Decord decoding for video: {self._video_name}."
+            )
+
+        start_idx = math.ceil(self._fps * start_sec)
+        end_idx = math.ceil(self._fps * end_sec)
+        end_idx = min(end_idx, len(self._av_reader))
+        frame_idxs = list(range(start_idx, end_idx))
+        audio = None
+
+        try:
+            outputs = self._av_reader.get_batch(frame_idxs)
+        except Exception as e:
+            logger.debug(f"Failed to decode video with Decord: {self._video_name}. {e}")
+            raise e
+
+        if self._decode_audio:
+            audio, video = outputs
+            if audio is not None:
+                audio = list(audio)
+                audio = torch.cat(audio, dim=1)
+                audio = torch.flatten(audio)
+                audio = audio.to(torch.float32)
+        else:
+            video = outputs
+
+        if video is not None:
+            video = video.to(torch.float32)
+            video = thwc_to_cthw(video)
+
+        return {
+            "video": video,
+            "audio": audio,
+        }

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/encoded_video_pyav.py

@@ -0,0 +1,364 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import logging
+import math
+from fractions import Fraction
+from typing import BinaryIO, Dict, List, Optional, Tuple, Union
+
+import av
+import numpy as np
+import torch
+from pytorchvideo.data.encoded_video import EncodedVideo
+
+from .utils import pts_to_secs, secs_to_pts, thwc_to_cthw
+
+
+logger = logging.getLogger(__name__)
+
+
+class EncodedVideoPyAV(EncodedVideo):
+    """
+    EncodedVideoPyAV is an abstraction for accessing clips from an encoded video using
+    PyAV as the decoding backend. It supports selective decoding when header information
+    is available.
+    """
+
+    def __init__(
+        self,
+        file: BinaryIO,
+        video_name: Optional[str] = None,
+        decode_video: bool = True,
+        decode_audio: bool = True,
+        perform_seek: bool = True,
+    ) -> None:
+        """
+        Args:
+            file (BinaryIO): a file-like object (e.g. io.BytesIO or io.StringIO) that
+                contains the encoded video.
+            perform_seek:
+                Whether or not to seek time to the underlying video container.
+
+                NOTE: seeks may be slow on larger files, e.g. on a networked filesystem
+        """
+        self.perform_seek = perform_seek
+        self._video_name = video_name
+        self._decode_video = decode_video
+        self._decode_audio = decode_audio
+
+        try:
+            self._container = av.open(file)
+        except Exception as e:
+            raise RuntimeError(f"Failed to open video {video_name}. {e}")
+
+        if self._container is None or len(self._container.streams.video) == 0:
+            raise RuntimeError(f"Video stream not found {video_name}")
+
+        # Retrieve video header information if available.
+        video_stream = self._container.streams.video[0]
+        self._video_time_base = video_stream.time_base
+        self._video_start_pts = video_stream.start_time
+        if self._video_start_pts is None:
+            self._video_start_pts = 0.0
+
+        video_duration = video_stream.duration
+
+        # Retrieve audio header information if available.
+        audio_duration = None
+        self._has_audio = None
+        if self._decode_audio:
+            self._has_audio = self._container.streams.audio
+            if self._has_audio:
+                self._audio_time_base = self._container.streams.audio[0].time_base
+                self._audio_start_pts = self._container.streams.audio[0].start_time
+                if self._audio_start_pts is None:
+                    self._audio_start_pts = 0.0
+
+                audio_duration = self._container.streams.audio[0].duration
+
+        # If duration isn't found in header the whole video is decoded to
+        # determine the duration.
+        self._video, self._audio, self._selective_decoding = (None, None, True)
+        if audio_duration is None and video_duration is None:
+            self._selective_decoding = False
+            self._video, self._audio = self._pyav_decode_video()
+            if self._video is None:
+                raise RuntimeError("Unable to decode video stream")
+
+            video_duration = self._video[-1][1]
+            if self._audio is not None:
+                audio_duration = self._audio[-1][1]
+
+        # Take the largest duration of either video or duration stream.
+        if audio_duration is not None and video_duration is not None:
+            self._duration = max(
+                pts_to_secs(
+                    video_duration, self._video_time_base, self._video_start_pts
+                ),
+                pts_to_secs(
+                    audio_duration, self._audio_time_base, self._audio_start_pts
+                ),
+            )
+        elif video_duration is not None:
+            self._duration = pts_to_secs(
+                video_duration, self._video_time_base, self._video_start_pts
+            )
+
+        elif audio_duration is not None:
+            self._duration = pts_to_secs(
+                audio_duration, self._audio_time_base, self._audio_start_pts
+            )
+
+    @property
+    def rate(self) -> Union[str, Fraction]:
+        """
+        Returns:
+            rate: the frame rate of the video
+        """
+        return self._container.streams.video[0].rate
+
+    @property
+    def bit_rate(self) -> int:
+        """
+        Returns:
+            bit_rate: the bit rate of the underlying video
+        """
+        return self._container.streams.video[0].bit_rate
+
+    @property
+    def pix_fmt(self) -> int:
+        """
+        Returns:
+            pix_fmt: the pixel format of the underlying video
+        """
+        return self._container.streams.video[0].pix_fmt
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        Returns:
+            name: the name of the stored video if set.
+        """
+        return self._video_name
+
+    @property
+    def duration(self) -> float:
+        """
+        Returns:
+            duration: the video's duration/end-time in seconds.
+        """
+        return self._duration
+
+    def get_clip(
+        self, start_sec: float, end_sec: float
+    ) -> Dict[str, Optional[torch.Tensor]]:
+        """
+        Retrieves frames from the encoded video at the specified start and end times
+        in seconds (the video always starts at 0 seconds). Returned frames will be in
+        [start_sec, end_sec). Note that 1) if you want to avoid float precision issue
+        and need accurate frames, please use Fraction for start_sec and end_sec.
+        2) As end_sec is exclusive, so you may need to use
+        `get_clip(start_sec, duration + EPS)` to get the last frame.
+
+        Args:
+            start_sec (float): the clip start time in seconds
+            end_sec (float): the clip end time in seconds
+        Returns:
+            clip_data:
+                A dictionary mapping the entries at "video" and "audio" to a tensors.
+
+                "video": A tensor of the clip's RGB frames with shape:
+                (channel, time, height, width). The frames are of type torch.float32 and
+                in the range [0 - 255].
+
+                "audio": A tensor of the clip's audio samples with shape:
+                (samples). The samples are of type torch.float32 and
+                in the range [0 - 255].
+
+            Returns None if no video or audio found within time range.
+
+        """
+        if self._selective_decoding:
+            self._video, self._audio = self._pyav_decode_video(start_sec, end_sec)
+
+        video_frames = None
+        if self._video is not None:
+            video_start_pts = secs_to_pts(
+                start_sec,
+                self._video_time_base,
+                self._video_start_pts,
+                round_mode="ceil",
+            )
+            video_end_pts = secs_to_pts(
+                end_sec,
+                self._video_time_base,
+                self._video_start_pts,
+                round_mode="ceil",
+            )
+
+            video_frames = [
+                f
+                for f, pts in self._video
+                if pts >= video_start_pts and pts < video_end_pts
+            ]
+
+        audio_samples = None
+        if self._has_audio and self._audio is not None:
+            audio_start_pts = secs_to_pts(
+                start_sec,
+                self._audio_time_base,
+                self._audio_start_pts,
+                round_mode="ceil",
+            )
+            audio_end_pts = secs_to_pts(
+                end_sec,
+                self._audio_time_base,
+                self._audio_start_pts,
+                round_mode="ceil",
+            )
+            audio_samples = [
+                f
+                for f, pts in self._audio
+                if pts >= audio_start_pts and pts < audio_end_pts
+            ]
+            audio_samples = torch.cat(audio_samples, axis=0)
+            audio_samples = audio_samples.to(torch.float32)
+
+        if video_frames is None or len(video_frames) == 0:
+            logger.debug(
+                f"No video found within {start_sec} and {end_sec} seconds. "
+                f"Video starts at time 0 and ends at {self.duration}."
+            )
+
+            video_frames = None
+
+        if video_frames is not None:
+            video_frames = thwc_to_cthw(torch.stack(video_frames)).to(torch.float32)
+
+        return {
+            "video": video_frames,
+            "audio": audio_samples,
+        }
+
+    def close(self):
+        """
+        Closes the internal video container.
+        """
+        if self._container is not None:
+            self._container.close()
+
+    def _pyav_decode_video(
+        self, start_secs: float = 0.0, end_secs: float = math.inf
+    ) -> float:
+        """
+        Selectively decodes a video between start_pts and end_pts in time units of the
+        self._video's timebase.
+        """
+        video_and_pts = None
+        audio_and_pts = None
+        try:
+            if self._decode_video:
+                pyav_video_frames, _ = _pyav_decode_stream(
+                    self._container,
+                    secs_to_pts(
+                        start_secs,
+                        self._video_time_base,
+                        self._video_start_pts,
+                        round_mode="ceil",
+                    ),
+                    secs_to_pts(
+                        end_secs,
+                        self._video_time_base,
+                        self._video_start_pts,
+                        round_mode="ceil",
+                    ),
+                    self._container.streams.video[0],
+                    {"video": 0},
+                    perform_seek=self.perform_seek,
+                )
+                if len(pyav_video_frames) > 0:
+                    video_and_pts = [
+                        (torch.from_numpy(frame.to_rgb().to_ndarray()), frame.pts)
+                        for frame in pyav_video_frames
+                    ]
+
+            if self._has_audio:
+                pyav_audio_frames, _ = _pyav_decode_stream(
+                    self._container,
+                    secs_to_pts(
+                        start_secs,
+                        self._audio_time_base,
+                        self._audio_start_pts,
+                        round_mode="ceil",
+                    ),
+                    secs_to_pts(
+                        end_secs,
+                        self._audio_time_base,
+                        self._audio_start_pts,
+                        round_mode="ceil",
+                    ),
+                    self._container.streams.audio[0],
+                    {"audio": 0},
+                    perform_seek=self.perform_seek,
+                )
+
+                if len(pyav_audio_frames) > 0:
+                    audio_and_pts = [
+                        (
+                            torch.from_numpy(np.mean(frame.to_ndarray(), axis=0)),
+                            frame.pts,
+                        )
+                        for frame in pyav_audio_frames
+                    ]
+
+        except Exception as e:
+            logger.debug(f"Failed to decode video: {self._video_name}. {e}")
+
+        return video_and_pts, audio_and_pts
+
+
+def _pyav_decode_stream(
+    container: av.container.input.InputContainer,
+    start_pts: int,
+    end_pts: int,
+    stream: av.video.stream.VideoStream,
+    stream_name: dict,
+    buffer_size: int = 0,
+    perform_seek: bool = True,
+) -> Tuple[List, float]:
+    """
+    Decode the video with PyAV decoder.
+    Args:
+        container (container): PyAV container.
+        start_pts (int): the starting Presentation TimeStamp to fetch the
+            video frames.
+        end_pts (int): the ending Presentation TimeStamp of the decoded frames.
+        stream (stream): PyAV stream.
+        stream_name (dict): a dictionary of streams. For example, {"video": 0}
+            means video stream at stream index 0.
+    Returns:
+        result (list): list of decoded frames.
+        max_pts (int): max Presentation TimeStamp of the video sequence.
+    """
+
+    # Seeking in the stream is imprecise. Thus, seek to an earlier pts by a
+    # margin pts.
+    margin = 1024
+
+    # NOTE:
+    # Don't want to seek if iterating through a video due to slow-downs. I
+    # believe this is some PyAV bug where seeking after a certain point causes
+    # major slow-downs
+    if perform_seek:
+        seek_offset = max(start_pts - margin, 0)
+        container.seek(int(seek_offset), any_frame=False, backward=True, stream=stream)
+    frames = {}
+    max_pts = 0
+    for frame in container.decode(**stream_name):
+        max_pts = max(max_pts, frame.pts)
+        if frame.pts >= start_pts and frame.pts < end_pts:
+            frames[frame.pts] = frame
+        elif frame.pts >= end_pts:
+            break
+
+    result = [frames[pts] for pts in sorted(frames)]
+    return result, max_pts

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/encoded_video_torchvision.py

@@ -0,0 +1,276 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import logging
+from fractions import Fraction
+from typing import BinaryIO, Dict, Optional
+
+import numpy as np
+import torch
+
+from .utils import pts_to_secs, secs_to_pts, thwc_to_cthw
+from .video import Video
+
+
+logger = logging.getLogger(__name__)
+
+
+class EncodedVideoTorchVision(Video):
+    """
+
+    Accessing clips from an encoded video using Torchvision video reading API
+    (torch.ops.video_reader.read_video_from_memory) as the decoding backend.
+    """
+
+    """
+    av_seek_frame is imprecise so seek to a timestamp earlier by a margin
+    The unit of margin is second
+    """
+    SEEK_FRAME_MARGIN = 0.25
+
+    def __init__(
+        self,
+        file: BinaryIO,
+        video_name: Optional[str] = None,
+        decode_video: bool = True,
+        decode_audio: bool = True,
+    ) -> None:
+        if not decode_video:
+            raise NotImplementedError()
+
+        self._video_tensor = torch.tensor(
+            np.frombuffer(file.getvalue(), dtype=np.uint8)
+        )
+        self._video_name = video_name
+        self._decode_audio = decode_audio
+
+        (
+            self._video,
+            self._video_time_base,
+            self._video_start_pts,
+            video_duration,
+            self._audio,
+            self._audio_time_base,
+            self._audio_start_pts,
+            audio_duration,
+        ) = self._torch_vision_decode_video()
+
+        # Take the largest duration of either video or duration stream.
+        if audio_duration is not None and video_duration is not None:
+            self._duration = max(
+                pts_to_secs(
+                    video_duration, self._video_time_base, self._video_start_pts
+                ),
+                pts_to_secs(
+                    audio_duration, self._audio_time_base, self._audio_start_pts
+                ),
+            )
+        elif video_duration is not None:
+            self._duration = pts_to_secs(
+                video_duration, self._video_time_base, self._video_start_pts
+            )
+
+        elif audio_duration is not None:
+            self._duration = pts_to_secs(
+                audio_duration, self._audio_time_base, self._audio_start_pts
+            )
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        Returns:
+            name: the name of the stored video if set.
+        """
+        return self._video_name
+
+    @property
+    def duration(self) -> float:
+        """
+        Returns:
+            duration: the video's duration/end-time in seconds.
+        """
+        return self._duration
+
+    def close(self):
+        pass
+
+    def get_clip(
+        self, start_sec: float, end_sec: float
+    ) -> Dict[str, Optional[torch.Tensor]]:
+        """
+        Retrieves frames from the encoded video at the specified start and end times
+        in seconds (the video always starts at 0 seconds). Returned frames will be in
+        [start_sec, end_sec). Note that 1) if you want to avoid float precision issue
+        and need accurate frames, please use Fraction for start_sec and end_sec.
+        2) As end_sec is exclusive, so you may need to use
+        `get_clip(start_sec, duration + EPS)` to get the last frame.
+
+        Args:
+            start_sec (float): the clip start time in seconds
+            end_sec (float): the clip end time in seconds
+        Returns:
+            clip_data:
+                A dictionary mapping the entries at "video" and "audio" to a tensors.
+
+                "video": A tensor of the clip's RGB frames with shape:
+                (channel, time, height, width). The frames are of type torch.float32 and
+                in the range [0 - 255].
+
+                "audio": A tensor of the clip's audio samples with shape:
+                (samples). The samples are of type torch.float32 and
+                in the range [0 - 255].
+
+            Returns None if no video or audio found within time range.
+
+        """
+        video_frames = None
+        if self._video is not None:
+            video_start_pts = secs_to_pts(
+                start_sec,
+                self._video_time_base,
+                self._video_start_pts,
+                round_mode="ceil",
+            )
+            video_end_pts = secs_to_pts(
+                end_sec,
+                self._video_time_base,
+                self._video_start_pts,
+                round_mode="ceil",
+            )
+            video_frames = [
+                f
+                for f, pts in self._video
+                if pts >= video_start_pts and pts < video_end_pts
+            ]
+
+        audio_samples = None
+        if self._decode_audio and self._audio:
+            audio_start_pts = secs_to_pts(
+                start_sec,
+                self._audio_time_base,
+                self._audio_start_pts,
+                round_mode="ceil",
+            )
+            audio_end_pts = secs_to_pts(
+                end_sec,
+                self._audio_time_base,
+                self._audio_start_pts,
+                round_mode="ceil",
+            )
+            audio_samples = [
+                f
+                for f, pts in self._audio
+                if pts >= audio_start_pts and pts < audio_end_pts
+            ]
+            audio_samples = torch.cat(audio_samples, axis=0)
+            audio_samples = audio_samples.to(torch.float32)
+
+        if video_frames is None or len(video_frames) == 0:
+            logger.warning(
+                f"No video found within {start_sec} and {end_sec} seconds. "
+                f"Video starts at time 0 and ends at {self.duration}."
+            )
+
+            video_frames = None
+
+        if video_frames is not None:
+            video_frames = thwc_to_cthw(torch.stack(video_frames)).to(torch.float32)
+
+        return {
+            "video": video_frames,
+            "audio": audio_samples,
+        }
+
+    def _torch_vision_decode_video(
+        self, start_pts: int = 0, end_pts: int = -1
+    ) -> float:
+        """
+        Decode the video in the PTS range [start_pts, end_pts]
+        """
+        video_and_pts = None
+        audio_and_pts = None
+
+        width, height, min_dimension, max_dimension = 0, 0, 0, 0
+        video_start_pts, video_end_pts = start_pts, end_pts
+        video_timebase_num, video_timebase_den = 0, 1
+
+        samples, channels = 0, 0
+        audio_start_pts, audio_end_pts = start_pts, end_pts
+        audio_timebase_num, audio_timebase_den = 0, 1
+
+        try:
+            tv_result = torch.ops.video_reader.read_video_from_memory(
+                self._video_tensor,
+                self.SEEK_FRAME_MARGIN,
+                # Set getPtsOnly=0, i.e., read full video rather than just header
+                0,
+                # Read video stream
+                1,
+                width,
+                height,
+                min_dimension,
+                max_dimension,
+                video_start_pts,
+                video_end_pts,
+                video_timebase_num,
+                video_timebase_den,
+                # Read audio stream
+                self._decode_audio,
+                samples,
+                channels,
+                audio_start_pts,
+                audio_end_pts,
+                audio_timebase_num,
+                audio_timebase_den,
+            )
+        except Exception as e:
+            logger.warning(f"Failed to decode video of name {self._video_name}. {e}")
+            raise e
+
+        (
+            vframes,
+            vframes_pts,
+            vtimebase,
+            _,
+            vduration,
+            aframes,
+            aframe_pts,
+            atimebase,
+            _,
+            aduration,
+        ) = tv_result
+
+        if vduration < 0:
+            # No header information to infer video duration
+            video_duration = int(vframes_pts[-1])
+        else:
+            video_duration = int(vduration)
+
+        video_and_pts = list(zip(vframes, vframes_pts))
+        video_start_pts = int(vframes_pts[0])
+        video_time_base = Fraction(int(vtimebase[0]), int(vtimebase[1]))
+
+        audio_and_pts = None
+        audio_time_base = None
+        audio_start_pts = None
+        audio_duration = None
+        if self._decode_audio:
+            if aduration < 0:
+                # No header information to infer audio duration
+                audio_duration = int(aframe_pts[-1])
+            else:
+                audio_duration = int(aduration)
+
+            audio_and_pts = list(zip(aframes, aframe_pts))
+            audio_start_pts = int(aframe_pts[0])
+            audio_time_base = Fraction(int(atimebase[0]), int(atimebase[1]))
+
+        return (
+            video_and_pts,
+            video_time_base,
+            video_start_pts,
+            video_duration,
+            audio_and_pts,
+            audio_time_base,
+            audio_start_pts,
+            audio_duration,
+        )

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/epic_kitchen/epic_kitchen_dataset.py

@@ -0,0 +1,205 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import ast
+from dataclasses import dataclass, fields as dataclass_fields
+from typing import Any, Callable, Dict, List, Optional
+
+import torch
+from ib_sync_rewards.imagebind.pytorchvideo.data.dataset_manifest_utils import (
+    EncodedVideoInfo,
+    get_seconds_from_hms_time,
+    VideoClipInfo,
+    VideoDataset,
+    VideoDatasetType,
+    VideoFrameInfo,
+    VideoInfo,
+)
+from ib_sync_rewards.imagebind.pytorchvideo.data.frame_video import FrameVideo
+from ib_sync_rewards.imagebind.pytorchvideo.data.utils import DataclassFieldCaster, load_dataclass_dict_from_csv
+from ib_sync_rewards.imagebind.pytorchvideo.data.video import Video
+
+
+@dataclass
+class ActionData(DataclassFieldCaster):
+    """
+    Class representing an action from the Epic Kitchen dataset.
+    """
+
+    participant_id: str
+    video_id: str
+    narration: str
+    start_timestamp: str
+    stop_timestamp: str
+    start_frame: int
+    stop_frame: int
+    verb: str
+    verb_class: int
+    noun: str
+    noun_class: int
+    all_nouns: list = DataclassFieldCaster.complex_initialized_dataclass_field(
+        ast.literal_eval
+    )
+    all_noun_classes: list = DataclassFieldCaster.complex_initialized_dataclass_field(
+        ast.literal_eval
+    )
+
+    @property
+    def start_time(self) -> float:
+        return get_seconds_from_hms_time(self.start_timestamp)
+
+    @property
+    def stop_time(self) -> float:
+        return get_seconds_from_hms_time(self.stop_timestamp)
+
+
+class EpicKitchenDataset(torch.utils.data.Dataset):
+    """
+    Video dataset for EpicKitchen-55 Dataset
+    <https://epic-kitchens.github.io/2019/>
+
+    This dataset handles the loading, decoding, and configurable clip
+    sampling for the videos.
+    """
+
+    def __init__(
+        self,
+        video_info_file_path: str,
+        actions_file_path: str,
+        clip_sampler: Callable[
+            [Dict[str, Video], Dict[str, List[ActionData]]], List[VideoClipInfo]
+        ],
+        video_data_manifest_file_path: str,
+        dataset_type: VideoDatasetType = VideoDatasetType.Frame,
+        transform: Optional[Callable[[Dict[str, Any]], Any]] = None,
+        frame_filter: Optional[Callable[[List[int]], List[int]]] = None,
+        multithreaded_io: bool = True,
+    ) -> None:
+        f"""
+        Args:
+            video_info_file_path (str):
+                Path or URI to manifest with basic metadata of each video.
+                File must be a csv (w/header) with columns:
+                {[f.name for f in dataclass_fields(VideoInfo)]}
+
+            actions_file_path (str):
+                Path or URI to manifest with action annotations for each video.
+                File must ber a csv (w/header) with columns:
+                {[f.name for f in dataclass_fields(ActionData)]}
+
+            clip_sampler (Callable[[Dict[str, Video]], List[VideoClipInfo]]):
+                This callable takes as input all available videos and outputs a list of clips to
+                be loaded by the dataset.
+
+            video_data_manifest_file_path (str):
+                The path to a json file outlining the available video data for the
+                associated videos.  File must be a csv (w/header) with columns:
+                {[f.name for f in dataclass_fields(VideoFrameInfo)]}
+
+                or
+                {[f.name for f in dataclass_fields(EncodedVideoInfo)]}
+
+                To generate this file from a directory of video frames, see helper
+                functions in Module: pytorchvideo.data.epic_kitchen.utils
+
+            dataset_type (VideoDatasetType): The dataformat in which dataset
+                video data is store (e.g. video frames, encoded video etc).
+
+            transform (Optional[Callable[[Dict[str, Any]], Any]]):
+                This callable is evaluated on the clip output before the clip is returned.
+                It can be used for user-defined preprocessing and augmentations to the clips.
+
+                    The clip input is a dictionary with the following format:
+                        {{
+                            'video': <video_tensor>,
+                            'audio': <audio_tensor>,
+                            'actions': <List[ActionData]>,
+                            'start_time': <float>,
+                            'stop_time': <float>
+                        }}
+
+                If transform is None, the raw clip output in the above format is
+                returned unmodified.
+
+            frame_filter (Optional[Callable[[List[int]], List[int]]]):
+                This callable is evaluated on the set of available frame inidices to be
+                included in a sampled clip. This can be used to subselect frames within
+                a clip to be loaded.
+
+            multithreaded_io (bool):
+                Boolean to control whether parllelizable io operations are performed across
+                multiple threads.
+
+        """
+
+        torch._C._log_api_usage_once("PYTORCHVIDEO.dataset.EpicKitchenDataset.__init__")
+
+        assert video_info_file_path
+        assert actions_file_path
+        assert video_data_manifest_file_path
+        assert clip_sampler
+
+        # Populate video and metadata data providers
+        self._videos: Dict[str, Video] = VideoDataset._load_videos(
+            video_data_manifest_file_path,
+            video_info_file_path,
+            multithreaded_io,
+            dataset_type,
+        )
+
+        self._actions: Dict[str, List[ActionData]] = load_dataclass_dict_from_csv(
+            actions_file_path, ActionData, "video_id", list_per_key=True
+        )
+        # Sample datapoints
+        self._clips: List[VideoClipInfo] = clip_sampler(self._videos, self._actions)
+
+        self._transform = transform
+        self._frame_filter = frame_filter
+
+    def __getitem__(self, index) -> Dict[str, Any]:
+        """
+        Samples a video clip associated to the given index.
+
+        Args:
+            index (int): index for the video clip.
+
+        Returns:
+            A video clip with the following format if transform is None:
+                {{
+                    'video_id': <str>,
+                    'video': <video_tensor>,
+                    'audio': <audio_tensor>,
+                    'actions': <df[ActionData]>,
+                    'start_time': <float>,
+                    'stop_time': <float>
+                }}
+            Otherwise, the transform defines the clip output.
+        """
+        clip = self._clips[index]
+        video = self._videos[clip.video_id]
+
+        if isinstance(video, FrameVideo):
+            clip_dict = video.get_clip(
+                clip.start_time, clip.stop_time, self._frame_filter
+            )
+        else:
+            clip_dict = video.get_clip(clip.start_time, clip.stop_time)
+
+        clip_data = {
+            "video_id": clip.video_id,
+            **clip_dict,
+            "actions": self._actions[clip.video_id],
+            "start_time": clip.start_time,
+            "stop_time": clip.stop_time,
+        }
+
+        if self._transform:
+            clip_data = self._transform(clip_data)
+
+        return clip_data
+
+    def __len__(self) -> int:
+        """
+        Returns:
+            The number of video clips in the dataset.
+        """
+        return len(self._clips)

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/epic_kitchen/utils.py

@@ -0,0 +1,195 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from typing import Dict
+
+from iopath.common.file_io import g_pathmgr
+from ib_sync_rewards.imagebind.pytorchvideo.data.dataset_manifest_utils import EncodedVideoInfo, VideoFrameInfo
+from ib_sync_rewards.imagebind.pytorchvideo.data.utils import optional_threaded_foreach
+
+
+def build_frame_manifest_from_flat_directory(
+    data_directory_path: str, multithreaded: bool
+) -> Dict[str, VideoFrameInfo]:
+    """
+    Args:
+        data_directory_path (str): Path or URI to EpicKitchenDataset data.
+                Data at this path must be a folder of structure:
+                    {
+                        "{video_id}": [
+                            "frame_{frame_number}.{file_extension}",
+                            "frame_{frame_number}.{file_extension}",
+                            "frame_{frame_number}.{file_extension}",
+                        ...]
+                    ...}
+        multithreaded (bool):
+            controls whether io operations are performed across multiple threads.
+
+    Returns:
+        Dictionary mapping video_id of available videos to the locations of their
+        underlying frame files.
+    """
+
+    video_frames = {}
+    video_ids = g_pathmgr.ls(str(data_directory_path))
+
+    def add_video_frames(video_id: str, video_path: str) -> None:
+        video_frame_file_names = sorted(g_pathmgr.ls(video_path))
+        for frame in video_frame_file_names:
+            file_extension = frame.split(".")[-1]
+            frame_name = frame[: -(len(file_extension) + 1)]
+            stem, path_frame_id = frame_name.split("_")
+            if video_id not in video_frames:
+                video_frames[video_id] = VideoFrameInfo(
+                    video_id=video_id,
+                    location=video_path,
+                    frame_file_stem=f"{stem}_",
+                    frame_string_length=len(frame_name),
+                    min_frame_number=int(path_frame_id),
+                    max_frame_number=int(path_frame_id),
+                    file_extension=file_extension,
+                )
+            else:
+                video_frame_info = video_frames[video_id]
+                # Check that this new frame is of the same format as other frames for this video
+                # and that it is the next frame in order, if so update the frame info for this
+                # video to reflect there is an additional frame.
+                # We don't need to check video_id or frame_file_stem as they are function of
+                # video_id which is aligned within the dictionary
+                assert video_frame_info.frame_string_length == len(frame_name)
+                assert video_frame_info.location == video_path, (
+                    f"Frames for {video_id} found in two paths: "
+                    f"{video_frame_info.location} and {video_path}"
+                )
+                assert video_frame_info.max_frame_number + 1 == int(path_frame_id)
+                assert (
+                    video_frame_info.file_extension == file_extension
+                ), f"Frames with two different file extensions found for video {video_id}"
+                video_frames[video_id] = VideoFrameInfo(
+                    video_id=video_frame_info.video_id,
+                    location=video_frame_info.location,
+                    frame_file_stem=video_frame_info.frame_file_stem,
+                    frame_string_length=video_frame_info.frame_string_length,
+                    min_frame_number=video_frame_info.min_frame_number,
+                    max_frame_number=int(path_frame_id),  # Update
+                    file_extension=video_frame_info.file_extension,
+                )
+
+    video_paths = [
+        (video_id, f"{data_directory_path}/{video_id}") for video_id in video_ids
+    ]
+    # Kick off frame indexing for all participants
+    optional_threaded_foreach(add_video_frames, video_paths, multithreaded)
+
+    return video_frames
+
+
+def build_frame_manifest_from_nested_directory(
+    data_directory_path: str, multithreaded: bool
+) -> Dict[str, VideoFrameInfo]:
+    """
+    Args:
+        data_directory_path (str): Path or URI to EpicKitchenDataset data.
+            If this dataset is to load from the frame-based dataset:
+                Data at this path must be a folder of structure:
+    {
+        "{participant_id}" : [
+            "{participant_id}_{participant_video_id}_{frame_number}.{file_extension}",
+
+        ...],
+    ...}
+
+        multithreaded (bool):
+                controls whether io operations are performed across multiple threads.
+
+        Returns:
+            Dictionary mapping video_id of available videos to the locations of their
+            underlying frame files.
+    """
+
+    participant_ids = g_pathmgr.ls(str(data_directory_path))
+    video_frames = {}
+
+    # Create function to execute in parallel that lists files available for each participant
+    def add_participant_video_frames(
+        participant_id: str, participant_path: str
+    ) -> None:
+        participant_frames = sorted(g_pathmgr.ls(str(participant_path)))
+        for frame_file_name in participant_frames:
+            file_extension = frame_file_name.split(".")[-1]
+            frame_name = frame_file_name[: -(len(file_extension) + 1)]
+            [path_participant_id, path_video_id, path_frame_id] = frame_name.split("_")
+            assert path_participant_id == participant_id
+            video_id = f"{path_participant_id}_{path_video_id}"
+            if (
+                video_id not in video_frames
+            ):  # This is the first frame we have seen from video w/ video_id
+                video_frames[video_id] = VideoFrameInfo(
+                    video_id=video_id,
+                    location=participant_path,
+                    frame_file_stem=f"{video_id}_",
+                    frame_string_length=len(frame_name),
+                    min_frame_number=int(path_frame_id),
+                    max_frame_number=int(path_frame_id),
+                    file_extension=file_extension,
+                )
+            else:
+                video_frame_info = video_frames[video_id]
+                # Check that this new frame is of the same format as other frames for this video
+                # and that it is the next frame in order, if so update the frame info for this
+                # video to reflect there is an additional frame.
+                # We don't need to check video_id or frame_file_stem as they are function of
+                # video_id which is aligned within the dictionary
+                assert video_frame_info.frame_string_length == len(frame_name)
+                assert video_frame_info.location == participant_path, (
+                    f"Frames for {video_id} found in two paths: "
+                    f"{video_frame_info.location} and {participant_path}"
+                )
+                assert video_frame_info.max_frame_number + 1 == int(path_frame_id)
+                assert (
+                    video_frame_info.file_extension == file_extension
+                ), f"Frames with two different file extensions found for video {video_id}"
+                video_frames[video_id] = VideoFrameInfo(
+                    video_id=video_frame_info.video_id,
+                    location=video_frame_info.location,
+                    frame_file_stem=video_frame_info.frame_file_stem,
+                    frame_string_length=video_frame_info.frame_string_length,
+                    min_frame_number=video_frame_info.min_frame_number,
+                    max_frame_number=int(path_frame_id),  # Update
+                    file_extension=video_frame_info.file_extension,
+                )
+
+    particpant_paths = [
+        (participant_id, f"{data_directory_path}/{participant_id}")
+        for participant_id in participant_ids
+    ]
+    # Kick off frame indexing for all participants
+    optional_threaded_foreach(
+        add_participant_video_frames, particpant_paths, multithreaded
+    )
+
+    return video_frames
+
+
+def build_encoded_manifest_from_nested_directory(
+    data_directory_path: str,
+) -> Dict[str, EncodedVideoInfo]:
+    """
+    Creates a dictionary from video_id to EncodedVideoInfo for
+    encoded videos in the given directory.
+
+    Args:
+        data_directory_path (str): The folder to ls to find encoded
+        video files.
+
+    Returns:
+        Dict[str, EncodedVideoInfo] mapping video_id to EncodedVideoInfo
+        for each file in 'data_directory_path'
+    """
+    encoded_video_infos = {}
+    for participant_id in g_pathmgr.ls(data_directory_path):
+        participant_folder_path = f"{data_directory_path}/{participant_id}"
+        for video_file_name in g_pathmgr.ls(participant_folder_path):
+            video_id = video_file_name[:6]
+            video_full_path = f"{participant_folder_path}/{video_file_name}"
+            encoded_video_infos[video_id] = EncodedVideoInfo(video_id, video_full_path)
+    return encoded_video_infos

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/epic_kitchen_forecasting.py

@@ -0,0 +1,295 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from dataclasses import fields as dataclass_fields
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional
+
+import torch
+from ib_sync_rewards.imagebind.pytorchvideo.data.dataset_manifest_utils import (
+    EncodedVideoInfo,
+    VideoClipInfo,
+    VideoDatasetType,
+    VideoFrameInfo,
+    VideoInfo,
+)
+from ib_sync_rewards.imagebind.pytorchvideo.data.epic_kitchen import ActionData, EpicKitchenDataset
+from ib_sync_rewards.imagebind.pytorchvideo.data.video import Video
+
+
+class ClipSampling(Enum):
+    Random = 1
+
+
+class EpicKitchenForecasting(EpicKitchenDataset):
+    """
+    Action forecasting video data set for EpicKitchen-55 Dataset.
+    <https://epic-kitchens.github.io/2019/>
+
+    This dataset handles the loading, decoding, and clip sampling for the videos.
+    """
+
+    def __init__(
+        self,
+        video_info_file_path: str,
+        actions_file_path: str,
+        video_data_manifest_file_path: str,
+        clip_sampling: ClipSampling = ClipSampling.Random,
+        dataset_type: VideoDatasetType = VideoDatasetType.Frame,
+        seconds_per_clip: float = 2.0,
+        clip_time_stride: float = 10.0,
+        num_input_clips: int = 1,
+        frames_per_clip: Optional[int] = None,
+        num_forecast_actions: int = 1,
+        transform: Callable[[Dict[str, Any]], Any] = None,
+        multithreaded_io: bool = True,
+    ):
+        f"""
+        Args:
+            video_info_file_path (str):
+                Path or URI to manifest with basic metadata of each video.
+                File must be a csv (w/header) with columns:
+                {[f.name for f in dataclass_fields(VideoInfo)]}
+
+            actions_file_path (str):
+                Path or URI to manifest with action annotations for each video.
+                File must ber a csv (w/header) with columns:
+                {[f.name for f in dataclass_fields(ActionData)]}
+
+            video_data_manifest_file_path (str):
+                The path to a json file outlining the available video data for the
+                associated videos. File must be a csv (w/header) with columns either:
+
+                For Frame Videos:
+                {[f.name for f in dataclass_fields(VideoFrameInfo)]}
+
+                For Encoded Videos:
+                {[f.name for f in dataclass_fields(EncodedVideoInfo)]}
+
+                To generate this file from a directory of video frames, see helper
+                functions in Module: pytorchvideo.data.epic_kitchen.utils
+
+            clip_sampling (ClipSampling):
+                The type of sampling to perform to perform on the videos of the dataset.
+
+            dataset_type (VideoDatasetType): The dataformat in which dataset
+                video data is store (e.g. video frames, encoded video etc).
+
+            seconds_per_clip (float): The length of each sampled subclip in seconds.
+
+            clip_time_stride (float): The time difference in seconds between the start of
+                each input subclip.
+
+            num_input_clips (int): The number of subclips to be included in the input
+                video data.
+
+            frames_per_clip (Optional[int]): The number of frames per clip to sample.
+                If None, all frames in the clip will be included.
+
+            num_forecast_actions (int): The number of actions to be included in the
+                action vector.
+
+            transform (Callable[[Dict[str, Any]], Any]):
+                This callable is evaluated on the clip output before the clip is returned.
+                It can be used for user-defined preprocessing and augmentations to the clips.
+                The clip input is a dictionary with the following format:
+                    {{
+                        'video_id': <str>,
+                        'video': <video_tensor>,
+                        'audio': <audio_tensor>,
+                        'label': <List[ActionData]>,
+                        'start_time': <float>,
+                        'stop_time': <float>
+                    }}
+
+                If transform is None, the raw clip output in the above format is
+                    returned unmodified.
+
+            multithreaded_io (bool):
+                Boolean to control whether parllelizable io operations are performed across
+                multiple threads.
+        """
+        define_clip_structure_fn = (
+            EpicKitchenForecasting._define_clip_structure_generator(
+                clip_sampling,
+                seconds_per_clip,
+                clip_time_stride,
+                num_input_clips,
+                num_forecast_actions,
+            )
+        )
+        frame_filter = (
+            EpicKitchenForecasting._frame_filter_generator(
+                frames_per_clip, seconds_per_clip, clip_time_stride, num_input_clips
+            )
+            if frames_per_clip is not None
+            else None
+        )
+        transform = EpicKitchenForecasting._transform_generator(
+            transform, num_forecast_actions, frames_per_clip, num_input_clips
+        )
+
+        super().__init__(
+            video_info_file_path=video_info_file_path,
+            actions_file_path=actions_file_path,
+            video_data_manifest_file_path=video_data_manifest_file_path,
+            dataset_type=dataset_type,
+            transform=transform,
+            frame_filter=frame_filter,
+            clip_sampler=define_clip_structure_fn,
+            multithreaded_io=multithreaded_io,
+        )
+
+    @staticmethod
+    def _transform_generator(
+        transform: Callable[[Dict[str, Any]], Dict[str, Any]],
+        num_forecast_actions: int,
+        frames_per_clip: int,
+        num_input_clips: int,
+    ) -> Callable[[Dict[str, Any]], Dict[str, Any]]:
+        """
+        Args:
+            transform (Callable[[Dict[str, Any]], Dict[str, Any]]): A function that performs
+            any operation on a clip before it is returned in the default transform function.
+            num_forecast_actions: (int) The number of actions to be included in the
+                action vector.
+            frames_per_clip (int): The number of frames per clip to sample.
+            num_input_clips (int): The number of subclips to be included in the video data.
+
+        Returns:
+            A function that performs any operation on a clip and returns the transformed clip.
+        """
+
+        def transform_clip(clip: Dict[str, Any]) -> Dict[str, Any]:
+            assert all(
+                clip["actions"][i].start_time <= clip["actions"][i + 1].start_time
+                for i in range(len(clip["actions"]) - 1)
+            ), "Actions must be sorted"
+            next_k_actions: List[ActionData] = [
+                a for a in clip["actions"] if (a.start_time > clip["stop_time"])
+            ][:num_forecast_actions]
+            clip["actions"] = next_k_actions
+
+            assert clip["video"].size()[1] == num_input_clips * frames_per_clip
+            clip_video_tensor = torch.stack(
+                [
+                    clip["video"][
+                        :, (i * frames_per_clip) : ((i + 1) * frames_per_clip), :, :
+                    ]
+                    for i in range(num_input_clips)
+                ]
+            )
+            clip["video"] = clip_video_tensor
+
+            for key in clip:
+                if clip[key] is None:
+                    clip[key] = torch.tensor([])
+
+            if transform:
+                clip = transform(clip)
+
+            return clip
+
+        return transform_clip
+
+    @staticmethod
+    def _frame_filter_generator(
+        frames_per_clip: int,
+        seconds_per_clip: float,
+        clip_time_stride: float,
+        num_input_clips: int,
+    ) -> Callable[[List[int]], List[int]]:
+        """
+        Args:
+            frames_per_clip (int): The number of frames per clip to sample.
+            seconds_per_clip (float): The length of each sampled subclip in seconds.
+            clip_time_stride (float): The time difference in seconds between the start of
+                each input subclip.
+            num_input_clips (int): The number of subclips to be included in the video data.
+
+        Returns:
+            A function that takes in a list of frame indicies and outputs a subsampled list.
+        """
+        time_window_length = seconds_per_clip + (num_input_clips - 1) * clip_time_stride
+        desired_frames_per_second = frames_per_clip / seconds_per_clip
+
+        def frame_filter(frame_indices: List[int]) -> List[int]:
+            num_available_frames_for_all_clips = len(frame_indices)
+            available_frames_per_second = (
+                num_available_frames_for_all_clips / time_window_length
+            )
+            intra_clip_sampling_stride = int(
+                available_frames_per_second // desired_frames_per_second
+            )
+            selected_frames = set()
+            for i in range(num_input_clips):
+                clip_start_index = int(
+                    i * clip_time_stride * available_frames_per_second
+                )
+                for j in range(frames_per_clip):
+                    selected_frames.add(
+                        clip_start_index + j * intra_clip_sampling_stride
+                    )
+            return [x for i, x in enumerate(frame_indices) if i in selected_frames]
+
+        return frame_filter
+
+    @staticmethod
+    def _define_clip_structure_generator(
+        clip_sampling: str,
+        seconds_per_clip: float,
+        clip_time_stride: float,
+        num_input_clips: int,
+        num_forecast_actions: int,
+    ) -> Callable[[Dict[str, Video], Dict[str, List[ActionData]]], List[VideoClipInfo]]:
+        """
+        Args:
+            clip_sampling (ClipSampling):
+                The type of sampling to perform to perform on the videos of the dataset.
+            seconds_per_clip (float): The length of each sampled clip in seconds.
+            clip_time_stride: The time difference in seconds between the start of
+                each input subclip.
+            num_input_clips (int):  The number of subclips to be included in the video data.
+            num_forecast_actions (int): The number of actions to be included in the
+                action vector.
+
+        Returns:
+            A function that takes a dictionary of videos and outputs a list of sampled
+            clips.
+        """
+        # TODO(T77683480)
+        if not clip_sampling == ClipSampling.Random:
+            raise NotImplementedError(
+                f"Only {ClipSampling.Random} is implemented. "
+                f"{clip_sampling} not implemented."
+            )
+
+        time_window_length = seconds_per_clip + (num_input_clips - 1) * clip_time_stride
+
+        def define_clip_structure(
+            videos: Dict[str, Video], video_actions: Dict[str, List[ActionData]]
+        ) -> List[VideoClipInfo]:
+            candidate_sample_clips = []
+            for video_id, actions in video_actions.items():
+                for i, action in enumerate(actions[: (-1 * num_forecast_actions)]):
+                    # Only actions with num_forecast_actions after to predict
+                    # Confirm there are >= num_forecast_actions available
+                    # (it is possible for actions to overlap)
+                    number_valid_actions = 0
+                    for j in range(i + 1, len(actions)):
+                        if actions[j].start_time > action.stop_time:
+                            number_valid_actions += 1
+                        if number_valid_actions == num_forecast_actions:
+                            if (
+                                action.start_time - time_window_length >= 0
+                            ):  # Only add clips that have the full input video available
+                                candidate_sample_clips.append(
+                                    VideoClipInfo(
+                                        video_id,
+                                        action.stop_time - time_window_length,
+                                        action.stop_time,
+                                    )
+                                )
+                            break
+            return candidate_sample_clips
+
+        return define_clip_structure

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/frame_video.py

@@ -0,0 +1,258 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from __future__ import annotations
+
+import logging
+import math
+import os
+import re
+import time
+from typing import Callable, Dict, List, Optional
+
+import numpy as np
+import torch
+import torch.utils.data
+from iopath.common.file_io import g_pathmgr
+from ib_sync_rewards.imagebind.pytorchvideo.data.utils import optional_threaded_foreach
+
+from .utils import thwc_to_cthw
+from .video import Video
+
+
+try:
+    import cv2
+except ImportError:
+    _HAS_CV2 = False
+else:
+    _HAS_CV2 = True
+
+
+logger = logging.getLogger(__name__)
+
+
+class FrameVideo(Video):
+    """
+    FrameVideo is an abstractions for accessing clips based on their start and end
+    time for a video where each frame is stored as an image. PathManager is used for
+    frame image reading, allowing non-local uri's to be used.
+    """
+
+    def __init__(
+        self,
+        duration: float,
+        fps: float,
+        video_frame_to_path_fn: Callable[[int], str] = None,
+        video_frame_paths: List[str] = None,
+        multithreaded_io: bool = False,
+    ) -> None:
+        """
+        Args:
+            duration (float): the duration of the video in seconds.
+            fps (float): the target fps for the video. This is needed to link the frames
+                to a second timestamp in the video.
+            video_frame_to_path_fn (Callable[[int], str]): a function that maps from a frame
+                index integer to the file path where the frame is located.
+            video_frame_paths (List[str]): Dictionary of frame paths for each index of a video.
+            multithreaded_io (bool):  controls whether parllelizable io operations are
+                performed across multiple threads.
+        """
+        if not _HAS_CV2:
+            raise ImportError(
+                "opencv2 is required to use FrameVideo. Please "
+                "install with 'pip install opencv-python'"
+            )
+
+        self._duration = duration
+        self._fps = fps
+        self._multithreaded_io = multithreaded_io
+
+        assert (video_frame_to_path_fn is None) != (
+            video_frame_paths is None
+        ), "Only one of video_frame_to_path_fn or video_frame_paths can be provided"
+        self._video_frame_to_path_fn = video_frame_to_path_fn
+        self._video_frame_paths = video_frame_paths
+
+        # Set the pathname to the parent directory of the first frame.
+        self._name = os.path.basename(
+            os.path.dirname(self._video_frame_to_path(frame_index=0))
+        )
+
+    @classmethod
+    def from_directory(
+        cls,
+        path: str,
+        fps: float = 30.0,
+        multithreaded_io=False,
+        path_order_cache: Optional[Dict[str, List[str]]] = None,
+    ):
+        """
+        Args:
+            path (str): path to frame video directory.
+            fps (float): the target fps for the video. This is needed to link the frames
+                to a second timestamp in the video.
+            multithreaded_io (bool):  controls whether parllelizable io operations are
+                performed across multiple threads.
+            path_order_cache (dict): An optional mapping from directory-path to list
+                of frames in the directory in numerical order. Used for speedup by
+                caching the frame paths.
+        """
+        if path_order_cache is not None and path in path_order_cache:
+            return cls.from_frame_paths(path_order_cache[path], fps, multithreaded_io)
+
+        assert g_pathmgr.isdir(path), f"{path} is not a directory"
+        rel_frame_paths = g_pathmgr.ls(path)
+
+        def natural_keys(text):
+            return [int(c) if c.isdigit() else c for c in re.split("(\d+)", text)]
+
+        rel_frame_paths.sort(key=natural_keys)
+        frame_paths = [os.path.join(path, f) for f in rel_frame_paths]
+        if path_order_cache is not None:
+            path_order_cache[path] = frame_paths
+        return cls.from_frame_paths(frame_paths, fps, multithreaded_io)
+
+    @classmethod
+    def from_frame_paths(
+        cls,
+        video_frame_paths: List[str],
+        fps: float = 30.0,
+        multithreaded_io: bool = False,
+    ):
+        """
+        Args:
+            video_frame_paths (List[str]): a list of paths to each frames in the video.
+            fps (float): the target fps for the video. This is needed to link the frames
+                to a second timestamp in the video.
+            multithreaded_io (bool):  controls whether parllelizable io operations are
+                performed across multiple threads.
+        """
+        assert len(video_frame_paths) != 0, "video_frame_paths is empty"
+        return cls(
+            len(video_frame_paths) / fps,
+            fps,
+            video_frame_paths=video_frame_paths,
+            multithreaded_io=multithreaded_io,
+        )
+
+    @property
+    def name(self) -> float:
+        return self._name
+
+    @property
+    def duration(self) -> float:
+        """
+        Returns:
+            duration: the video's duration/end-time in seconds.
+        """
+        return self._duration
+
+    def _get_frame_index_for_time(self, time_sec: float) -> int:
+        return math.ceil(self._fps * time_sec)
+
+    def get_clip(
+        self,
+        start_sec: float,
+        end_sec: float,
+        frame_filter: Optional[Callable[[List[int]], List[int]]] = None,
+    ) -> Dict[str, Optional[torch.Tensor]]:
+        """
+        Retrieves frames from the stored video at the specified start and end times
+        in seconds (the video always starts at 0 seconds). Returned frames will be
+        in [start_sec, end_sec). Given that PathManager may
+        be fetching the frames from network storage, to handle transient errors, frame
+        reading is retried N times.  Note that as end_sec is exclusive, so you may need
+        to use `get_clip(start_sec, duration + EPS)` to get the last frame.
+
+        Args:
+            start_sec (float): the clip start time in seconds
+            end_sec (float): the clip end time in seconds
+            frame_filter (Optional[Callable[List[int], List[int]]]):
+                function to subsample frames in a clip before loading.
+                If None, no subsampling is peformed.
+        Returns:
+            clip_frames: A tensor of the clip's RGB frames with shape:
+                (channel, time, height, width). The frames are of type torch.float32 and
+                in the range [0 - 255]. Raises an exception if unable to load images.
+
+            clip_data:
+                "video": A tensor of the clip's RGB frames with shape:
+                (channel, time, height, width). The frames are of type torch.float32 and
+                in the range [0 - 255]. Raises an exception if unable to load images.
+
+                "frame_indices": A list of indices for each frame relative to all frames in the
+                video.
+
+            Returns None if no frames are found.
+        """
+        if start_sec < 0 or start_sec > self._duration:
+            logger.warning(
+                f"No frames found within {start_sec} and {end_sec} seconds. Video starts"
+                f"at time 0 and ends at {self._duration}."
+            )
+            return None
+
+        end_sec = min(end_sec, self._duration)
+
+        start_frame_index = self._get_frame_index_for_time(start_sec)
+        end_frame_index = min(
+            self._get_frame_index_for_time(end_sec), len(self._video_frame_paths)
+        )
+        frame_indices = list(range(start_frame_index, end_frame_index))
+        # Frame filter function to allow for subsampling before loading
+        if frame_filter:
+            frame_indices = frame_filter(frame_indices)
+
+        clip_paths = [self._video_frame_to_path(i) for i in frame_indices]
+        clip_frames = _load_images_with_retries(
+            clip_paths, multithreaded=self._multithreaded_io
+        )
+        clip_frames = thwc_to_cthw(clip_frames).to(torch.float32)
+        return {"video": clip_frames, "frame_indices": frame_indices, "audio": None}
+
+    def _video_frame_to_path(self, frame_index: int) -> str:
+        if self._video_frame_to_path_fn:
+            return self._video_frame_to_path_fn(frame_index)
+        elif self._video_frame_paths:
+            return self._video_frame_paths[frame_index]
+        else:
+            raise Exception(
+                "One of _video_frame_to_path_fn or _video_frame_paths must be set"
+            )
+
+
+def _load_images_with_retries(
+    image_paths: List[str], num_retries: int = 10, multithreaded: bool = True
+) -> torch.Tensor:
+    """
+    Loads the given image paths using PathManager, decodes them as RGB images and
+    returns them as a stacked tensors.
+    Args:
+        image_paths (List[str]): a list of paths to images.
+        num_retries (int): number of times to retry image reading to handle transient error.
+        multithreaded (bool): if images are fetched via multiple threads in parallel.
+    Returns:
+        A tensor of the clip's RGB frames with shape:
+        (time, height, width, channel). The frames are of type torch.uint8 and
+        in the range [0 - 255]. Raises an exception if unable to load images.
+    """
+    imgs = [None for i in image_paths]
+
+    def fetch_image(image_index: int, image_path: str) -> None:
+        for i in range(num_retries):
+            with g_pathmgr.open(image_path, "rb") as f:
+                img_str = np.frombuffer(f.read(), np.uint8)
+                img_bgr = cv2.imdecode(img_str, flags=cv2.IMREAD_COLOR)
+                img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+            if img_rgb is not None:
+                imgs[image_index] = img_rgb
+                return
+            else:
+                logging.warning(f"Reading attempt {i}/{num_retries} failed.")
+                time.sleep(1e-6)
+
+    optional_threaded_foreach(fetch_image, enumerate(image_paths), multithreaded)
+
+    if any((img is None for img in imgs)):
+        raise Exception("Failed to load images from {}".format(image_paths))
+
+    return torch.as_tensor(np.stack(imgs))

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/hmdb51.py

@@ -0,0 +1,231 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from __future__ import annotations
+
+import logging
+import os
+import pathlib
+from typing import Any, Callable, List, Optional, Tuple, Type, Union
+
+import torch
+import torch.utils.data
+from iopath.common.file_io import g_pathmgr
+
+from .clip_sampling import ClipSampler
+from .labeled_video_dataset import LabeledVideoDataset
+
+
+logger = logging.getLogger(__name__)
+
+
+class Hmdb51LabeledVideoPaths:
+    """
+    Pre-processor for Hmbd51 dataset mentioned here -
+        https://serre-lab.clps.brown.edu/resource/hmdb-a-large-human-motion-database/
+
+    This dataset consists of classwise folds with each class consisting of 3
+        folds (splits).
+
+    The videos directory is of the format,
+        video_dir_path/class_x/<somevideo_name>.avi
+        ...
+        video_dir_path/class_y/<somevideo_name>.avi
+
+    The splits/fold directory is of the format,
+        folds_dir_path/class_x_test_split_1.txt
+        folds_dir_path/class_x_test_split_2.txt
+        folds_dir_path/class_x_test_split_3.txt
+        ...
+        folds_dir_path/class_y_test_split_1.txt
+        folds_dir_path/class_y_test_split_2.txt
+        folds_dir_path/class_y_test_split_3.txt
+
+    And each text file in the splits directory class_x_test_split_<1 or 2 or 3>.txt
+        <a video as in video_dir_path/class_x> <0 or 1 or 2>
+        where 0,1,2 corresponds to unused, train split respectively.
+
+    Each video has name of format
+        <some_name>_<tag1>_<tag2>_<tag_3>_<tag4>_<tag5>_<some_id>.avi
+    For more details on tags -
+        https://serre-lab.clps.brown.edu/resource/hmdb-a-large-human-motion-database/
+    """
+
+    _allowed_splits = [1, 2, 3]
+    _split_type_dict = {"train": 1, "test": 2, "unused": 0}
+
+    @classmethod
+    def from_dir(
+        cls, data_path: str, split_id: int = 1, split_type: str = "train"
+    ) -> Hmdb51LabeledVideoPaths:
+        """
+        Factory function that creates Hmdb51LabeledVideoPaths object form a splits/folds
+        directory.
+
+        Args:
+            data_path (str): The path to the splits/folds directory of HMDB51.
+            split_id (int): Fold id to be loaded. Belongs to [1,2,3]
+            split_type (str): Split/Fold type to be loaded. It belongs to one of the
+                following,
+                - "train"
+                - "test"
+                - "unused" (This is a small set of videos that are neither
+                of part of test or train fold.)
+        """
+        data_path = pathlib.Path(data_path)
+        if not data_path.is_dir():
+            return RuntimeError(f"{data_path} not found or is not a directory.")
+        if not int(split_id) in cls._allowed_splits:
+            return RuntimeError(
+                f"{split_id} not found in allowed split id's {cls._allowed_splits}."
+            )
+        file_name_format = "_test_split" + str(int(split_id))
+        file_paths = sorted(
+            (
+                f
+                for f in data_path.iterdir()
+                if f.is_file() and f.suffix == ".txt" and file_name_format in f.stem
+            )
+        )
+        return cls.from_csvs(file_paths, split_type)
+
+    @classmethod
+    def from_csvs(
+        cls, file_paths: List[Union[pathlib.Path, str]], split_type: str = "train"
+    ) -> Hmdb51LabeledVideoPaths:
+        """
+        Factory function that creates Hmdb51LabeledVideoPaths object form a list of
+        split files of .txt type
+
+        Args:
+            file_paths (List[Union[pathlib.Path, str]]) : The path to the splits/folds
+                    directory of HMDB51.
+            split_type (str): Split/Fold type to be loaded.
+                - "train"
+                - "test"
+                - "unused"
+        """
+        video_paths_and_label = []
+        for file_path in file_paths:
+            file_path = pathlib.Path(file_path)
+            assert g_pathmgr.exists(file_path), f"{file_path} not found."
+            if not (file_path.suffix == ".txt" and "_test_split" in file_path.stem):
+                return RuntimeError(f"Ivalid file: {file_path}")
+
+            action_name = "_"
+            action_name = action_name.join((file_path.stem).split("_")[:-2])
+            with g_pathmgr.open(file_path, "r") as f:
+                for path_label in f.read().splitlines():
+                    line_split = path_label.rsplit(None, 1)
+
+                    if not int(line_split[1]) == cls._split_type_dict[split_type]:
+                        continue
+
+                    file_path = os.path.join(action_name, line_split[0])
+                    meta_tags = line_split[0].split("_")[-6:-1]
+                    video_paths_and_label.append(
+                        (file_path, {"label": action_name, "meta_tags": meta_tags})
+                    )
+
+        assert (
+            len(video_paths_and_label) > 0
+        ), f"Failed to load dataset from {file_path}."
+        return cls(video_paths_and_label)
+
+    def __init__(
+        self, paths_and_labels: List[Tuple[str, Optional[dict]]], path_prefix=""
+    ) -> None:
+        """
+        Args:
+            paths_and_labels [(str, int)]: a list of tuples containing the video
+                path and integer label.
+        """
+        self._paths_and_labels = paths_and_labels
+        self._path_prefix = path_prefix
+
+    def path_prefix(self, prefix):
+        self._path_prefix = prefix
+
+    path_prefix = property(None, path_prefix)
+
+    def __getitem__(self, index: int) -> Tuple[str, dict]:
+        """
+        Args:
+            index (int): the path and label index.
+
+        Returns:
+            The path and label tuple for the given index.
+        """
+        path, label = self._paths_and_labels[index]
+        return (os.path.join(self._path_prefix, path), label)
+
+    def __len__(self) -> int:
+        """
+        Returns:
+            The number of video paths and label pairs.
+        """
+        return len(self._paths_and_labels)
+
+
+def Hmdb51(
+    data_path: pathlib.Path,
+    clip_sampler: ClipSampler,
+    video_sampler: Type[torch.utils.data.Sampler] = torch.utils.data.RandomSampler,
+    transform: Optional[Callable[[dict], Any]] = None,
+    video_path_prefix: str = "",
+    split_id: int = 1,
+    split_type: str = "train",
+    decode_audio=True,
+    decoder: str = "pyav",
+) -> LabeledVideoDataset:
+    """
+    A helper function to create ``LabeledVideoDataset`` object for HMDB51 dataset
+
+    Args:
+        data_path (pathlib.Path): Path to the data. The path type defines how the data
+            should be read:
+
+            * For a file path, the file is read and each line is parsed into a
+              video path and label.
+            * For a directory, the directory structure defines the classes
+              (i.e. each subdirectory is a class).
+
+        clip_sampler (ClipSampler): Defines how clips should be sampled from each
+            video. See the clip sampling documentation for more information.
+
+        video_sampler (Type[torch.utils.data.Sampler]): Sampler for the internal
+            video container. This defines the order videos are decoded and,
+            if necessary, the distributed split.
+
+        transform (Callable): This callable is evaluated on the clip output before
+            the clip is returned. It can be used for user defined preprocessing and
+            augmentations to the clips. See the ``LabeledVideoDataset`` class for
+            clip output format.
+
+        video_path_prefix (str): Path to root directory with the videos that are
+            loaded in LabeledVideoDataset. All the video paths before loading
+            are prefixed with this path.
+
+        split_id (int): Fold id to be loaded. Options are 1, 2 or 3
+
+        split_type (str): Split/Fold type to be loaded. Options are ("train", "test" or
+            "unused")
+
+        decoder (str): Defines which backend should be used to decode videos.
+    """
+
+    torch._C._log_api_usage_once("PYTORCHVIDEO.dataset.Hmdb51")
+
+    labeled_video_paths = Hmdb51LabeledVideoPaths.from_dir(
+        data_path, split_id=split_id, split_type=split_type
+    )
+    labeled_video_paths.path_prefix = video_path_prefix
+    dataset = LabeledVideoDataset(
+        labeled_video_paths,
+        clip_sampler,
+        video_sampler,
+        transform,
+        decode_audio=decode_audio,
+        decoder=decoder,
+    )
+
+    return dataset

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/json_dataset.py

@@ -0,0 +1,254 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import json
+import logging
+import os
+from typing import Any, Callable, Dict, Optional, Type
+
+import torch
+from iopath.common.file_io import g_pathmgr
+from ib_sync_rewards.imagebind.pytorchvideo.data.clip_sampling import ClipInfo, ClipSampler
+from ib_sync_rewards.imagebind.pytorchvideo.data.labeled_video_dataset import LabeledVideoDataset
+
+
+logger = logging.getLogger(__name__)
+
+
+def video_only_dataset(
+    data_path: str,
+    clip_sampler: ClipSampler,
+    video_sampler: Type[torch.utils.data.Sampler] = torch.utils.data.RandomSampler,
+    transform: Optional[Callable[[Dict[str, Any]], Dict[str, Any]]] = None,
+    video_path_prefix: str = "",
+    decode_audio: bool = True,
+    decoder: str = "pyav",
+):
+    """
+    Builds a LabeledVideoDataset with no annotations from a json file with the following
+    format:
+
+        .. code-block:: text
+
+            {
+              "video_name1": {...}
+              "video_name2": {...}
+              ....
+              "video_nameN": {...}
+            }
+
+    Args:
+        labeled_video_paths (List[Tuple[str, Optional[dict]]]): List containing
+                video file paths and associated labels. If video paths are a folder
+                it's interpreted as a frame video, otherwise it must be an encoded
+                video.
+
+        clip_sampler (ClipSampler): Defines how clips should be sampled from each
+            video. See the clip sampling documentation for more information.
+
+        video_sampler (Type[torch.utils.data.Sampler]): Sampler for the internal
+            video container. This defines the order videos are decoded and,
+            if necessary, the distributed split.
+
+        transform (Callable): This callable is evaluated on the clip output before
+            the clip is returned. It can be used for user defined preprocessing and
+            augmentations on the clips. The clip output format is described in __next__().
+
+        decode_audio (bool): If True, also decode audio from video.
+
+        decoder (str): Defines what type of decoder used to decode a video. Not used for
+            frame videos.
+    """
+
+    torch._C._log_api_usage_once("PYTORCHVIDEO.dataset.json_dataset.video_only_dataset")
+
+    if g_pathmgr.isfile(data_path):
+        try:
+            with g_pathmgr.open(data_path, "r") as f:
+                annotations = json.load(f)
+        except Exception:
+            raise FileNotFoundError(f"{data_path} must be json for Ego4D dataset")
+
+        # LabeledVideoDataset requires the data to be list of tuples with format:
+        # (video_paths, annotation_dict), for no annotations we just pass in an empty dict.
+        video_paths = [
+            (os.path.join(video_path_prefix, x), {}) for x in annotations.keys()
+        ]
+    else:
+        raise FileNotFoundError(f"{data_path} not found.")
+
+    dataset = LabeledVideoDataset(
+        video_paths,
+        clip_sampler,
+        video_sampler,
+        transform,
+        decode_audio=decode_audio,
+        decoder=decoder,
+    )
+    return dataset
+
+
+def clip_recognition_dataset(
+    data_path: str,
+    clip_sampler: ClipSampler,
+    video_sampler: Type[torch.utils.data.Sampler] = torch.utils.data.RandomSampler,
+    transform: Optional[Callable[[Dict[str, Any]], Dict[str, Any]]] = None,
+    video_path_prefix: str = "",
+    decode_audio: bool = True,
+    decoder: str = "pyav",
+):
+    """
+    Builds a LabeledVideoDataset with noun, verb annotations from a json file with the following
+    format:
+
+        .. code-block:: text
+
+            {
+              "video_name1": {
+                  {
+                    "benchmarks": {
+                        "forecasting_hands_objects": [
+                            {
+                                "critical_frame_selection_parent_start_sec": <start_sec>
+                                "critical_frame_selection_parent_end_sec": <end_sec>
+                                {
+                                    "taxonomy: {
+                                        "noun": <label>,
+                                        "verb": <label>,
+                                    }
+                                }
+                            },
+                            {
+                                ...
+                            }
+                        ]
+                    }
+                  }
+              }
+              "video_name2": {...}
+              ....
+              "video_nameN": {...}
+            }
+
+    Args:
+        labeled_video_paths (List[Tuple[str, Optional[dict]]]): List containing
+                video file paths and associated labels. If video paths are a folder
+                it's interpreted as a frame video, otherwise it must be an encoded
+                video.
+
+        clip_sampler (ClipSampler): Defines how clips should be sampled from each
+            video. See the clip sampling documentation for more information.
+
+        video_sampler (Type[torch.utils.data.Sampler]): Sampler for the internal
+            video container. This defines the order videos are decoded and,
+            if necessary, the distributed split.
+
+        transform (Callable): This callable is evaluated on the clip output before
+            the clip is returned. It can be used for user defined preprocessing and
+            augmentations on the clips. The clip output format is described in __next__().
+
+        decode_audio (bool): If True, also decode audio from video.
+
+        decoder (str): Defines what type of decoder used to decode a video. Not used for
+            frame videos.
+    """
+    if g_pathmgr.isfile(data_path):
+        try:
+            with g_pathmgr.open(data_path, "r") as f:
+                annotations = json.load(f)
+        except Exception:
+            raise FileNotFoundError(f"{data_path} must be json for Ego4D dataset")
+
+        # LabeledVideoDataset requires the data to be list of tuples with format:
+        # (video_paths, annotation_dict), for no annotations we just pass in an empty dict.
+        untrimmed_clip_annotations = []
+        for video_name, child in annotations.items():
+            video_path = os.path.join(video_path_prefix, video_name)
+            for clip_annotation in child["benchmarks"]["forecasting_hands_objects"]:
+                clip_start = clip_annotation[
+                    "critical_frame_selection_parent_start_sec"
+                ]
+                clip_end = clip_annotation["critical_frame_selection_parent_end_sec"]
+                taxonomy = clip_annotation["taxonomy"]
+                noun_label = taxonomy["noun"]
+                verb_label = taxonomy["verb"]
+                verb_unsure = taxonomy["verb_unsure"]
+                noun_unsure = taxonomy["noun_unsure"]
+                if (
+                    noun_label is None
+                    or verb_label is None
+                    or verb_unsure
+                    or noun_unsure
+                ):
+                    continue
+
+                untrimmed_clip_annotations.append(
+                    (
+                        video_path,
+                        {
+                            "clip_start_sec": clip_start,
+                            "clip_end_sec": clip_end,
+                            "noun_label": noun_label,
+                            "verb_label": verb_label,
+                        },
+                    )
+                )
+    else:
+        raise FileNotFoundError(f"{data_path} not found.")
+
+    # Map noun and verb key words to unique index.
+    def map_labels_to_index(label_name):
+        labels = list({info[label_name] for _, info in untrimmed_clip_annotations})
+        label_to_idx = {label: i for i, label in enumerate(labels)}
+        for i in range(len(untrimmed_clip_annotations)):
+            label = untrimmed_clip_annotations[i][1][label_name]
+            untrimmed_clip_annotations[i][1][label_name] = label_to_idx[label]
+
+    map_labels_to_index("noun_label")
+    map_labels_to_index("verb_label")
+
+    dataset = LabeledVideoDataset(
+        untrimmed_clip_annotations,
+        UntrimmedClipSampler(clip_sampler),
+        video_sampler,
+        transform,
+        decode_audio=decode_audio,
+        decoder=decoder,
+    )
+    return dataset
+
+
+class UntrimmedClipSampler:
+    """
+    A wrapper for adapting untrimmed annotated clips from the json_dataset to the
+    standard `pytorchvideo.data.ClipSampler` expected format. Specifically, for each
+    clip it uses the provided `clip_sampler` to sample between "clip_start_sec" and
+    "clip_end_sec" from the json_dataset clip annotation.
+    """
+
+    def __init__(self, clip_sampler: ClipSampler) -> None:
+        """
+        Args:
+            clip_sampler (`pytorchvideo.data.ClipSampler`): Strategy used for sampling
+                between the untrimmed clip boundary.
+        """
+        self._trimmed_clip_sampler = clip_sampler
+
+    def __call__(
+        self, last_clip_time: float, video_duration: float, clip_info: Dict[str, Any]
+    ) -> ClipInfo:
+        clip_start_boundary = clip_info["clip_start_sec"]
+        clip_end_boundary = clip_info["clip_end_sec"]
+        duration = clip_start_boundary - clip_end_boundary
+
+        # Sample between 0 and duration of untrimmed clip, then add back start boundary.
+        clip_info = self._trimmed_clip_sampler(last_clip_time, duration, clip_info)
+        return ClipInfo(
+            clip_info.clip_start_sec + clip_start_boundary,
+            clip_info.clip_end_sec + clip_start_boundary,
+            clip_info.clip_index,
+            clip_info.aug_index,
+            clip_info.is_last_clip,
+        )
+
+    def reset(self) -> None:
+        pass

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/labeled_video_dataset.py

@@ -0,0 +1,304 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from __future__ import annotations
+
+import gc
+import logging
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type
+
+import torch.utils.data
+from ib_sync_rewards.imagebind.pytorchvideo.data.clip_sampling import ClipSampler
+from ib_sync_rewards.imagebind.pytorchvideo.data.video import VideoPathHandler
+
+from .labeled_video_paths import LabeledVideoPaths
+from .utils import MultiProcessSampler
+
+
+logger = logging.getLogger(__name__)
+
+
+class LabeledVideoDataset(torch.utils.data.IterableDataset):
+    """
+    LabeledVideoDataset handles the storage, loading, decoding and clip sampling for a
+    video dataset. It assumes each video is stored as either an encoded video
+    (e.g. mp4, avi) or a frame video (e.g. a folder of jpg, or png)
+    """
+
+    _MAX_CONSECUTIVE_FAILURES = 10
+
+    def __init__(
+        self,
+        labeled_video_paths: List[Tuple[str, Optional[dict]]],
+        clip_sampler: ClipSampler,
+        video_sampler: Type[torch.utils.data.Sampler] = torch.utils.data.RandomSampler,
+        transform: Optional[Callable[[dict], Any]] = None,
+        decode_audio: bool = True,
+        decode_video: bool = True,
+        decoder: str = "pyav",
+    ) -> None:
+        """
+        Args:
+            labeled_video_paths (List[Tuple[str, Optional[dict]]]): List containing
+                    video file paths and associated labels. If video paths are a folder
+                    it's interpreted as a frame video, otherwise it must be an encoded
+                    video.
+
+            clip_sampler (ClipSampler): Defines how clips should be sampled from each
+                video. See the clip sampling documentation for more information.
+
+            video_sampler (Type[torch.utils.data.Sampler]): Sampler for the internal
+                video container. This defines the order videos are decoded and,
+                if necessary, the distributed split.
+
+            transform (Callable): This callable is evaluated on the clip output before
+                the clip is returned. It can be used for user defined preprocessing and
+                augmentations on the clips. The clip output format is described in __next__().
+
+            decode_audio (bool): If True, decode audio from video.
+
+            decode_video (bool): If True, decode video frames from a video container.
+
+            decoder (str): Defines what type of decoder used to decode a video. Not used for
+                frame videos.
+        """
+        self._decode_audio = decode_audio
+        self._decode_video = decode_video
+        self._transform = transform
+        self._clip_sampler = clip_sampler
+        self._labeled_videos = labeled_video_paths
+        self._decoder = decoder
+
+        # If a RandomSampler is used we need to pass in a custom random generator that
+        # ensures all PyTorch multiprocess workers have the same random seed.
+        self._video_random_generator = None
+        if video_sampler == torch.utils.data.RandomSampler:
+            self._video_random_generator = torch.Generator()
+            self._video_sampler = video_sampler(
+                self._labeled_videos, generator=self._video_random_generator
+            )
+        else:
+            self._video_sampler = video_sampler(self._labeled_videos)
+
+        self._video_sampler_iter = None  # Initialized on first call to self.__next__()
+
+        # Depending on the clip sampler type, we may want to sample multiple clips
+        # from one video. In that case, we keep the store video, label and previous sampled
+        # clip time in these variables.
+        self._loaded_video_label = None
+        self._loaded_clip = None
+        self._last_clip_end_time = None
+        self.video_path_handler = VideoPathHandler()
+
+    @property
+    def video_sampler(self):
+        """
+        Returns:
+            The video sampler that defines video sample order. Note that you'll need to
+            use this property to set the epoch for a torch.utils.data.DistributedSampler.
+        """
+        return self._video_sampler
+
+    @property
+    def num_videos(self):
+        """
+        Returns:
+            Number of videos in dataset.
+        """
+        return len(self.video_sampler)
+
+    def __next__(self) -> dict:
+        """
+        Retrieves the next clip based on the clip sampling strategy and video sampler.
+
+        Returns:
+            A dictionary with the following format.
+
+            .. code-block:: text
+
+                {
+                    'video': <video_tensor>,
+                    'label': <index_label>,
+                    'video_label': <index_label>
+                    'video_index': <video_index>,
+                    'clip_index': <clip_index>,
+                    'aug_index': <aug_index>,
+                }
+        """
+        if not self._video_sampler_iter:
+            # Setup MultiProcessSampler here - after PyTorch DataLoader workers are spawned.
+            self._video_sampler_iter = iter(MultiProcessSampler(self._video_sampler))
+
+        for i_try in range(self._MAX_CONSECUTIVE_FAILURES):
+            # Reuse previously stored video if there are still clips to be sampled from
+            # the last loaded video.
+            if self._loaded_video_label:
+                video, info_dict, video_index = self._loaded_video_label
+            else:
+                video_index = next(self._video_sampler_iter)
+                try:
+                    video_path, info_dict = self._labeled_videos[video_index]
+                    video = self.video_path_handler.video_from_path(
+                        video_path,
+                        decode_audio=self._decode_audio,
+                        decode_video=self._decode_video,
+                        decoder=self._decoder,
+                    )
+                    self._loaded_video_label = (video, info_dict, video_index)
+                except Exception as e:
+                    logger.debug(
+                        "Failed to load video with error: {}; trial {}".format(
+                            e,
+                            i_try,
+                        )
+                    )
+                    logger.exception("Video load exception")
+                    continue
+
+            (
+                clip_start,
+                clip_end,
+                clip_index,
+                aug_index,
+                is_last_clip,
+            ) = self._clip_sampler(self._last_clip_end_time, video.duration, info_dict)
+
+            if isinstance(clip_start, list):  # multi-clip in each sample
+                # Only load the clips once and reuse previously stored clips if there are multiple
+                # views for augmentations to perform on the same clips.
+                if aug_index[0] == 0:
+                    self._loaded_clip = {}
+                    loaded_clip_list = []
+                    for i in range(len(clip_start)):
+                        clip_dict = video.get_clip(clip_start[i], clip_end[i])
+                        if clip_dict is None or clip_dict["video"] is None:
+                            self._loaded_clip = None
+                            break
+                        loaded_clip_list.append(clip_dict)
+
+                    if self._loaded_clip is not None:
+                        for key in loaded_clip_list[0].keys():
+                            self._loaded_clip[key] = [x[key] for x in loaded_clip_list]
+
+            else:  # single clip case
+                # Only load the clip once and reuse previously stored clip if there are multiple
+                # views for augmentations to perform on the same clip.
+                if aug_index == 0:
+                    self._loaded_clip = video.get_clip(clip_start, clip_end)
+
+            self._last_clip_end_time = clip_end
+
+            video_is_null = (
+                self._loaded_clip is None or self._loaded_clip["video"] is None
+            )
+            if (
+                is_last_clip[-1] if isinstance(is_last_clip, list) else is_last_clip
+            ) or video_is_null:
+                # Close the loaded encoded video and reset the last sampled clip time ready
+                # to sample a new video on the next iteration.
+                self._loaded_video_label[0].close()
+                self._loaded_video_label = None
+                self._last_clip_end_time = None
+                self._clip_sampler.reset()
+
+                # Force garbage collection to release video container immediately
+                # otherwise memory can spike.
+                gc.collect()
+
+                if video_is_null:
+                    logger.debug(
+                        "Failed to load clip {}; trial {}".format(video.name, i_try)
+                    )
+                    continue
+
+            frames = self._loaded_clip["video"]
+            audio_samples = self._loaded_clip["audio"]
+            sample_dict = {
+                "video": frames,
+                "video_name": video.name,
+                "video_index": video_index,
+                "clip_index": clip_index,
+                "aug_index": aug_index,
+                **info_dict,
+                **({"audio": audio_samples} if audio_samples is not None else {}),
+            }
+            if self._transform is not None:
+                sample_dict = self._transform(sample_dict)
+
+                # User can force dataset to continue by returning None in transform.
+                if sample_dict is None:
+                    continue
+
+            return sample_dict
+        else:
+            raise RuntimeError(
+                f"Failed to load video after {self._MAX_CONSECUTIVE_FAILURES} retries."
+            )
+
+    def __iter__(self):
+        self._video_sampler_iter = None  # Reset video sampler
+
+        # If we're in a PyTorch DataLoader multiprocessing context, we need to use the
+        # same seed for each worker's RandomSampler generator. The workers at each
+        # __iter__ call are created from the unique value: worker_info.seed - worker_info.id,
+        # which we can use for this seed.
+        worker_info = torch.utils.data.get_worker_info()
+        if self._video_random_generator is not None and worker_info is not None:
+            base_seed = worker_info.seed - worker_info.id
+            self._video_random_generator.manual_seed(base_seed)
+
+        return self
+
+
+def labeled_video_dataset(
+    data_path: str,
+    clip_sampler: ClipSampler,
+    video_sampler: Type[torch.utils.data.Sampler] = torch.utils.data.RandomSampler,
+    transform: Optional[Callable[[Dict[str, Any]], Dict[str, Any]]] = None,
+    video_path_prefix: str = "",
+    decode_audio: bool = True,
+    decoder: str = "pyav",
+) -> LabeledVideoDataset:
+    """
+    A helper function to create ``LabeledVideoDataset`` object for Ucf101 and Kinetics datasets.
+
+    Args:
+        data_path (str): Path to the data. The path type defines how the data
+            should be read:
+
+            * For a file path, the file is read and each line is parsed into a
+              video path and label.
+            * For a directory, the directory structure defines the classes
+              (i.e. each subdirectory is a class).
+
+        clip_sampler (ClipSampler): Defines how clips should be sampled from each
+                video. See the clip sampling documentation for more information.
+
+        video_sampler (Type[torch.utils.data.Sampler]): Sampler for the internal
+                video container. This defines the order videos are decoded and,
+                if necessary, the distributed split.
+
+        transform (Callable): This callable is evaluated on the clip output before
+                the clip is returned. It can be used for user defined preprocessing and
+                augmentations to the clips. See the ``LabeledVideoDataset`` class for clip
+                output format.
+
+        video_path_prefix (str): Path to root directory with the videos that are
+                loaded in ``LabeledVideoDataset``. All the video paths before loading
+                are prefixed with this path.
+
+        decode_audio (bool): If True, also decode audio from video.
+
+        decoder (str): Defines what type of decoder used to decode a video.
+
+    """
+    labeled_video_paths = LabeledVideoPaths.from_path(data_path)
+    labeled_video_paths.path_prefix = video_path_prefix
+    dataset = LabeledVideoDataset(
+        labeled_video_paths,
+        clip_sampler,
+        video_sampler,
+        transform,
+        decode_audio=decode_audio,
+        decoder=decoder,
+    )
+    return dataset

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/labeled_video_paths.py

@@ -0,0 +1,141 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from __future__ import annotations
+
+import os
+import pathlib
+from typing import List, Optional, Tuple
+
+from iopath.common.file_io import g_pathmgr
+from torchvision.datasets.folder import make_dataset
+
+
+class LabeledVideoPaths:
+    """
+    LabeledVideoPaths contains pairs of video path and integer index label.
+    """
+
+    @classmethod
+    def from_path(cls, data_path: str) -> LabeledVideoPaths:
+        """
+        Factory function that creates a LabeledVideoPaths object depending on the path
+        type.
+        - If it is a directory path it uses the LabeledVideoPaths.from_directory function.
+        - If it's a file it uses the LabeledVideoPaths.from_csv file.
+        Args:
+            file_path (str): The path to the file to be read.
+        """
+
+        if g_pathmgr.isfile(data_path):
+            return LabeledVideoPaths.from_csv(data_path)
+        elif g_pathmgr.isdir(data_path):
+            return LabeledVideoPaths.from_directory(data_path)
+        else:
+            raise FileNotFoundError(f"{data_path} not found.")
+
+    @classmethod
+    def from_csv(cls, file_path: str) -> LabeledVideoPaths:
+        """
+        Factory function that creates a LabeledVideoPaths object by reading a file with the
+        following format:
+            <path> <integer_label>
+            ...
+            <path> <integer_label>
+
+        Args:
+            file_path (str): The path to the file to be read.
+        """
+        assert g_pathmgr.exists(file_path), f"{file_path} not found."
+        video_paths_and_label = []
+        with g_pathmgr.open(file_path, "r") as f:
+            for path_label in f.read().splitlines():
+                line_split = path_label.rsplit(None, 1)
+
+                # The video path file may not contain labels (e.g. for a test split). We
+                # assume this is the case if only 1 path is found and set the label to
+                # -1 if so.
+                if len(line_split) == 1:
+                    file_path = line_split[0]
+                    label = -1
+                else:
+                    file_path, label = line_split
+
+                video_paths_and_label.append((file_path, int(label)))
+
+        assert (
+            len(video_paths_and_label) > 0
+        ), f"Failed to load dataset from {file_path}."
+        return cls(video_paths_and_label)
+
+    @classmethod
+    def from_directory(cls, dir_path: str) -> LabeledVideoPaths:
+        """
+        Factory function that creates a LabeledVideoPaths object by parsing the structure
+        of the given directory's subdirectories into the classification labels. It
+        expects the directory format to be the following:
+             dir_path/<class_name>/<video_name>.mp4
+
+        Classes are indexed from 0 to the number of classes, alphabetically.
+
+        E.g.
+            dir_path/class_x/xxx.ext
+            dir_path/class_x/xxy.ext
+            dir_path/class_x/xxz.ext
+            dir_path/class_y/123.ext
+            dir_path/class_y/nsdf3.ext
+            dir_path/class_y/asd932_.ext
+
+        Would produce two classes labeled 0 and 1 with 3 videos paths associated with each.
+
+        Args:
+            dir_path (str): Root directory to the video class directories .
+        """
+        assert g_pathmgr.exists(dir_path), f"{dir_path} not found."
+
+        # Find all classes based on directory names. These classes are then sorted and indexed
+        # from 0 to the number of classes.
+        classes = sorted(
+            (f.name for f in pathlib.Path(dir_path).iterdir() if f.is_dir())
+        )
+        class_to_idx = {classes[i]: i for i in range(len(classes))}
+        video_paths_and_label = make_dataset(
+            dir_path, class_to_idx, extensions=("mp4", "avi")
+        )
+        assert (
+            len(video_paths_and_label) > 0
+        ), f"Failed to load dataset from {dir_path}."
+        return cls(video_paths_and_label)
+
+    def __init__(
+        self, paths_and_labels: List[Tuple[str, Optional[int]]], path_prefix=""
+    ) -> None:
+        """
+        Args:
+            paths_and_labels [(str, int)]: a list of tuples containing the video
+                path and integer label.
+        """
+        self._paths_and_labels = paths_and_labels
+        self._path_prefix = path_prefix
+
+    def path_prefix(self, prefix):
+        self._path_prefix = prefix
+
+    path_prefix = property(None, path_prefix)
+
+    def __getitem__(self, index: int) -> Tuple[str, int]:
+        """
+        Args:
+            index (int): the path and label index.
+
+        Returns:
+            The path and label tuple for the given index.
+        """
+        path, label = self._paths_and_labels[index]
+        return (os.path.join(self._path_prefix, path), {"label": label})
+
+    def __len__(self) -> int:
+        """
+        Returns:
+            The number of video paths and label pairs.
+        """
+        return len(self._paths_and_labels)

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/ucf101.py

@@ -0,0 +1,70 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from typing import Any, Callable, Dict, Optional, Type
+
+import torch
+from ib_sync_rewards.imagebind.pytorchvideo.data.clip_sampling import ClipSampler
+
+from .labeled_video_dataset import labeled_video_dataset, LabeledVideoDataset
+
+
+"""
+    Action recognition video dataset for UCF101
+    <https://www.crcv.ucf.edu/data/UCF101.php>
+"""
+
+
+def Ucf101(
+    data_path: str,
+    clip_sampler: ClipSampler,
+    video_sampler: Type[torch.utils.data.Sampler] = torch.utils.data.RandomSampler,
+    transform: Optional[Callable[[Dict[str, Any]], Dict[str, Any]]] = None,
+    video_path_prefix: str = "",
+    decode_audio: bool = True,
+    decoder: str = "pyav",
+) -> LabeledVideoDataset:
+    """
+    A helper function to create ``LabeledVideoDataset`` object for the Ucf101 dataset.
+
+    Args:
+        data_path (str): Path to the data. The path type defines how the data
+            should be read:
+
+            * For a file path, the file is read and each line is parsed into a
+              video path and label.
+            * For a directory, the directory structure defines the classes
+              (i.e. each subdirectory is a class).
+
+        clip_sampler (ClipSampler): Defines how clips should be sampled from each
+                video. See the clip sampling documentation for more information.
+
+        video_sampler (Type[torch.utils.data.Sampler]): Sampler for the internal
+                video container. This defines the order videos are decoded and,
+                if necessary, the distributed split.
+
+        transform (Callable): This callable is evaluated on the clip output before
+                the clip is returned. It can be used for user defined preprocessing and
+                augmentations to the clips. See the ``LabeledVideoDataset`` class for clip
+                output format.
+
+        video_path_prefix (str): Path to root directory with the videos that are
+                loaded in ``LabeledVideoDataset``. All the video paths before loading
+                are prefixed with this path.
+
+        decode_audio (bool): If True, also decode audio from video.
+
+        decoder (str): Defines what type of decoder used to decode a video.
+
+    """
+
+    torch._C._log_api_usage_once("PYTORCHVIDEO.dataset.Ucf101")
+
+    return labeled_video_dataset(
+        data_path,
+        clip_sampler,
+        video_sampler,
+        transform,
+        video_path_prefix,
+        decode_audio,
+        decoder,
+    )

reward_models/ib_sync_rewards/imagebind/pytorchvideo/data/video.py

@@ -0,0 +1,100 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from abc import ABC, abstractmethod
+from typing import BinaryIO, Dict, Optional
+
+import torch
+from iopath.common.file_io import g_pathmgr
+
+
+class VideoPathHandler:
+    """
+    Utility class that handles all deciphering and caching of video paths for
+    encoded and frame videos.
+    """
+
+    def __init__(self) -> None:
+        # Pathmanager isn't guaranteed to be in correct order,
+        # sorting is expensive, so we cache paths in case of frame video and reuse.
+        self.path_order_cache = {}
+
+    def video_from_path(
+        self, filepath, decode_video=True, decode_audio=False, decoder="pyav", fps=30
+    ):
+        try:
+            is_file = g_pathmgr.isfile(filepath)
+            is_dir = g_pathmgr.isdir(filepath)
+        except NotImplementedError:
+            # Not all PathManager handlers support is{file,dir} functions, when this is the
+            # case, we default to assuming the path is a file.
+            is_file = True
+            is_dir = False
+
+        if is_file:
+            from pytorchvideo.data.encoded_video import EncodedVideo
+
+            return EncodedVideo.from_path(
+                filepath,
+                decode_video=decode_video,
+                decode_audio=decode_audio,
+                decoder=decoder,
+            )
+        elif is_dir:
+            from pytorchvideo.data.frame_video import FrameVideo
+
+            assert not decode_audio, "decode_audio must be False when using FrameVideo"
+            return FrameVideo.from_directory(
+                filepath, fps, path_order_cache=self.path_order_cache
+            )
+        else:
+            raise FileNotFoundError(f"{filepath} not found.")
+
+
+class Video(ABC):
+    """
+    Video provides an interface to access clips from a video container.
+    """
+
+    @abstractmethod
+    def __init__(
+        self,
+        file: BinaryIO,
+        video_name: Optional[str] = None,
+        decode_audio: bool = True,
+    ) -> None:
+        """
+        Args:
+            file (BinaryIO): a file-like object (e.g. io.BytesIO or io.StringIO) that
+                contains the encoded video.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def duration(self) -> float:
+        """
+        Returns:
+            duration of the video in seconds
+        """
+        pass
+
+    @abstractmethod
+    def get_clip(
+        self, start_sec: float, end_sec: float
+    ) -> Dict[str, Optional[torch.Tensor]]:
+        """
+        Retrieves frames from the internal video at the specified start and end times
+        in seconds (the video always starts at 0 seconds).
+
+        Args:
+            start_sec (float): the clip start time in seconds
+            end_sec (float): the clip end time in seconds
+        Returns:
+            video_data_dictonary: A dictionary mapping strings to tensor of the clip's
+                underlying data.
+
+        """
+        pass
+
+    def close(self):
+        pass

reward_models/ib_sync_rewards/imagebind/pytorchvideo/layers/accelerator/mobile_cpu/conv_helper.py

@@ -0,0 +1,556 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+"""
+This file contains helper classes for building conv3d efficient blocks.
+The helper classes are intended to be instantiated inside efficient block,
+not to be used by user to build network.
+"""
+
+from copy import deepcopy
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+
+
+class _Reshape(nn.Module):
+    """
+    Helper class to implement data reshape as a module.
+    Args:
+        reshape_size (tuple): size of data after reshape.
+    """
+
+    def __init__(
+        self,
+        reshape_size: Tuple,
+    ):
+        super().__init__()
+        self.reshape_size = reshape_size
+
+    def forward(self, x):
+        return torch.reshape(x, self.reshape_size)
+
+
+class _SkipConnectMul(nn.Module):
+    """
+    Helper class to implement skip multiplication.
+    Args:
+        layer (nn.Module): layer for skip multiplication. With input x, _SkipConnectMul
+            implements layer(x)*x.
+    """
+
+    def __init__(
+        self,
+        layer: nn.Module,
+    ):
+        super().__init__()
+        self.layer = layer
+        self.mul_func = nn.quantized.FloatFunctional()
+
+    def forward(self, x):
+        return self.mul_func.mul(x, self.layer(x))
+
+
+class _Conv3dTemporalKernel3Decomposed(nn.Module):
+    """
+    Helper class for decomposing conv3d with temporal kernel of 3 into equivalent conv2ds.
+    In conv3d with temporal kernel 3 and input I, for output temporal index of t (O[:,:,t,:,:]),
+    the conv can be expressed as:
+    O[:,:,t,:,:] = conv3d(I[:,:,t:t+3,:,:])
+                 = conv2d_0(I[:,:,t,:,:]) + conv2d_1(I[:,:,t+1,:,:]) + conv2d_2(I[:,:,t+2,:,:])
+    If bias is considered:
+    O[:,:,t,:,:] = conv3d_w_bias(I[:,:,t:t+3,:,:])
+                 = conv2d_0_wo_bias(I[:,:,t,:,:])
+                   + conv2d_1_w_bias(I[:,:,t+1,:,:]) + conv2d_2_wo_bias(I[:,:,t+2,:,:])
+    The input Conv3d also needs zero padding of size 1 in temporal dimension.
+    """
+
+    def __init__(
+        self,
+        conv3d_in: nn.Conv3d,
+        input_THW_tuple: Tuple,
+    ):
+        """
+        Args:
+            conv3d_in (nn.Module): input nn.Conv3d module to be converted
+                into equivalent conv2d.
+            input_THW_tuple (tuple): input THW size for conv3d_in during forward.
+        """
+        super().__init__()
+        assert conv3d_in.padding[0] == 1, (
+            "_Conv3dTemporalKernel3Eq only support temporal padding of 1, "
+            f"but got {conv3d_in.padding[0]}"
+        )
+        assert conv3d_in.padding_mode == "zeros", (
+            "_Conv3dTemporalKernel3Eq only support zero padding, "
+            f"but got {conv3d_in.padding_mode}"
+        )
+        self._input_THW_tuple = input_THW_tuple
+        padding_2d = conv3d_in.padding[1:]
+        in_channels = conv3d_in.in_channels
+        out_channels = conv3d_in.out_channels
+        kernel_size = conv3d_in.kernel_size[1:]
+        groups = conv3d_in.groups
+        stride_2d = conv3d_in.stride[1:]
+        # Create 3 conv2d to emulate conv3d.
+        if (
+            self._input_THW_tuple[0] > 1
+        ):  # Those two conv2d are needed only when temporal input > 1.
+            self._conv2d_3_3_0 = nn.Conv2d(
+                in_channels,
+                out_channels,
+                kernel_size=kernel_size,
+                padding=padding_2d,
+                stride=stride_2d,
+                groups=groups,
+                bias=False,
+            )
+            self._conv2d_3_3_2 = nn.Conv2d(
+                in_channels,
+                out_channels,
+                kernel_size=kernel_size,
+                padding=padding_2d,
+                stride=stride_2d,
+                groups=groups,
+                bias=False,
+            )
+        self._conv2d_3_3_1 = nn.Conv2d(
+            in_channels,
+            out_channels,
+            kernel_size=kernel_size,
+            padding=padding_2d,
+            stride=stride_2d,
+            groups=groups,
+            bias=(conv3d_in.bias is not None),
+        )
+
+        state_dict = conv3d_in.state_dict()
+        state_dict_1 = deepcopy(state_dict)
+        state_dict_1["weight"] = state_dict["weight"][:, :, 1]
+        self._conv2d_3_3_1.load_state_dict(state_dict_1)
+
+        if self._input_THW_tuple[0] > 1:
+            state_dict_0 = deepcopy(state_dict)
+            state_dict_0["weight"] = state_dict["weight"][:, :, 0]
+            if conv3d_in.bias is not None:
+                """
+                Don't need bias for other conv2d instances to avoid duplicated addition of bias.
+                """
+                state_dict_0.pop("bias")
+            self._conv2d_3_3_0.load_state_dict(state_dict_0)
+
+            state_dict_2 = deepcopy(state_dict)
+            state_dict_2["weight"] = state_dict["weight"][:, :, 2]
+            if conv3d_in.bias is not None:
+                state_dict_2.pop("bias")
+            self._conv2d_3_3_2.load_state_dict(state_dict_2)
+
+            self._add_funcs = nn.ModuleList(
+                [
+                    nn.quantized.FloatFunctional()
+                    for _ in range(2 * (self._input_THW_tuple[0] - 1))
+                ]
+            )
+            self._cat_func = nn.quantized.FloatFunctional()
+
+    def forward(self, x):
+        """
+        Use three conv2d to emulate conv3d.
+        This forward assumes zero padding of size 1 in temporal dimension.
+        """
+        if self._input_THW_tuple[0] > 1:
+            out_tensor_list = []
+            """
+            First output plane in temporal dimension,
+            conv2d_3_3_0 is skipped due to zero padding.
+            """
+            cur_tensor = (
+                self._add_funcs[0]
+                .add(self._conv2d_3_3_1(x[:, :, 0]), self._conv2d_3_3_2(x[:, :, 1]))
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            for idx in range(2, self._input_THW_tuple[0]):
+                cur_tensor = (
+                    self._add_funcs[2 * idx - 3]
+                    .add(
+                        self._add_funcs[2 * idx - 2].add(
+                            self._conv2d_3_3_0(x[:, :, idx - 2]),
+                            self._conv2d_3_3_1(x[:, :, idx - 1]),
+                        ),
+                        self._conv2d_3_3_2(x[:, :, idx]),
+                    )
+                    .unsqueeze(2)
+                )
+                out_tensor_list.append(cur_tensor)
+            """
+            Last output plane in temporal domain, conv2d_3_3_2 is skipped due to zero padding.
+            """
+            cur_tensor = (
+                self._add_funcs[-1]
+                .add(self._conv2d_3_3_0(x[:, :, -2]), self._conv2d_3_3_1(x[:, :, -1]))
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            return self._cat_func.cat(out_tensor_list, 2)
+        else:  # Degenerated to simple conv2d
+            return self._conv2d_3_3_1(x[:, :, 0]).unsqueeze(2)
+
+
+class _Conv3dTemporalKernel5Decomposed(nn.Module):
+    """
+    Helper class for decomposing conv3d with kernel size of (5, k, k) into equivalent conv2ds.
+    In such conv3d and input I, for output temporal index of t (O[:,:,t,:,:]), the conv
+    can be expressed as:
+    O[:,:,t,:,:] = conv3d(I[:,:,t:t+5,:,:])
+                 = conv2d_0(I[:,:,t,:,:]) + conv2d_1(I[:,:,t+1,:,:]) + conv2d_2(I[:,:,t+2,:,:])
+                   + conv2d_3(I[:,:,t+3,:,:]) + conv2d_4(I[:,:,t+4,:,:])
+    If bias is considered:
+    O[:,:,t,:,:] = conv3d_w_bias(I[:,:,t:t+3,:,:])
+                 = conv2d_0_wo_bias(I[:,:,t,:,:])
+                   + conv2d_1_wo_bias(I[:,:,t+1,:,:]) + conv2d_2_w_bias(I[:,:,t+2,:,:])
+                   + conv2d_3_wo_bias(I[:,:,t+1,:,:]) + conv2d_4_wo_bias(I[:,:,t+2,:,:])
+    The input Conv3d also needs zero padding of size 2 in temporal dimension at begin and end.
+    """
+
+    def __init__(
+        self,
+        conv3d_in: nn.Conv3d,
+        thw_shape: Tuple[int, int, int],
+    ):
+        """
+        Args:
+            conv3d_in (nn.Module): input nn.Conv3d module to be converted
+                into equivalent conv2d.
+            thw_shape (tuple): input THW size for conv3d_in during forward.
+        """
+        super().__init__()
+        assert conv3d_in.padding[0] == 2, (
+            "_Conv3dTemporalKernel5Eq only support temporal padding of 2, "
+            f"but got {conv3d_in.padding[0]}"
+        )
+        assert conv3d_in.padding_mode == "zeros", (
+            "_Conv3dTemporalKernel5Eq only support zero padding, "
+            f"but got {conv3d_in.padding_mode}"
+        )
+        self._thw_shape = thw_shape
+        padding_2d = conv3d_in.padding[1:]
+        in_channels = conv3d_in.in_channels
+        out_channels = conv3d_in.out_channels
+        kernel_size = conv3d_in.kernel_size[1:]
+        groups = conv3d_in.groups
+        stride_2d = conv3d_in.stride[1:]
+        # Create 3 conv2d to emulate conv3d.
+        t, h, w = self._thw_shape
+        args_dict = {
+            "in_channels": in_channels,
+            "out_channels": out_channels,
+            "kernel_size": kernel_size,
+            "padding": padding_2d,
+            "stride": stride_2d,
+            "groups": groups,
+        }
+
+        for iter_idx in range(5):
+            if iter_idx != 2:
+                if t > 1:  # Those four conv2d are needed only when temporal input > 1.
+                    self.add_module(
+                        f"_conv2d_{iter_idx}", nn.Conv2d(**args_dict, bias=False)
+                    )
+            else:  # _conv2d_2 is needed for all circumstances.
+                self.add_module(
+                    f"_conv2d_{iter_idx}",
+                    nn.Conv2d(**args_dict, bias=(conv3d_in.bias is not None)),
+                )
+
+        # State dict for _conv2d_2
+        original_state_dict = conv3d_in.state_dict()
+        state_dict_to_load = deepcopy(original_state_dict)
+        state_dict_to_load["weight"] = original_state_dict["weight"][:, :, 2]
+        self._conv2d_2.load_state_dict(state_dict_to_load)
+
+        if t > 1:
+            if conv3d_in.bias is not None:
+                # Don't need bias for other conv2d instances to avoid duplicated
+                # addition of bias.
+                state_dict_to_load.pop("bias")
+            # State dict for _conv2d_0, _conv2d_1, _conv2d_3, _conv2d_4
+            state_dict_to_load["weight"] = original_state_dict["weight"][:, :, 0]
+            self._conv2d_0.load_state_dict(state_dict_to_load)
+
+            state_dict_to_load["weight"] = original_state_dict["weight"][:, :, 1]
+            self._conv2d_1.load_state_dict(state_dict_to_load)
+
+            state_dict_to_load["weight"] = original_state_dict["weight"][:, :, 3]
+            self._conv2d_3.load_state_dict(state_dict_to_load)
+
+            state_dict_to_load["weight"] = original_state_dict["weight"][:, :, 4]
+            self._conv2d_4.load_state_dict(state_dict_to_load)
+            # Elementwise add are needed in forward function, use nn.quantized.FloatFunctional()
+            # for better quantization support. One convolution needs at most 4 elementwise adds
+            # without zero padding; for boundary planes fewer elementwise adds are needed.
+            # See forward() for more details.
+            self._add_funcs = nn.ModuleList(
+                [nn.quantized.FloatFunctional() for _ in range(4 * t - 6)]
+            )
+            self._cat_func = nn.quantized.FloatFunctional()
+
+    def forward(self, x):
+        """
+        Use three conv2d to emulate conv3d.
+        Args:
+           x (torch.Tensor): 5D tensor of (B, C, T, H, W)
+        """
+        t, h, w = self._thw_shape
+        out_tensor_list = []
+        if (
+            t == 1
+        ):  # Degenerated to simple conv2d, but make sure output still has T dimension
+            return self._conv2d_2(x[:, :, 0]).unsqueeze(2)
+        elif t == 2:
+            # out_tensor_list[0]: conv2d_1_1_0, conv2d_1_1_1 and conv2d_1_1_4 are
+            # applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[0]
+                .add(self._conv2d_2(x[:, :, 0]), self._conv2d_3(x[:, :, 1]))
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            # out_tensor_list[1]: conv2d_1_1_0, conv2d_1_1_3 and conv2d_1_1_4 are
+            # applied to zero padding.
+
+            cur_tensor = (
+                self._add_funcs[1]
+                .add(self._conv2d_1(x[:, :, 0]), self._conv2d_2(x[:, :, 1]))
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+        elif t == 3:
+            # out_tensor_list[0]: conv2d_1_1_0, conv2d_1_1_1 are applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[0]
+                .add(
+                    self._add_funcs[1].add(
+                        self._conv2d_2(x[:, :, 0]), self._conv2d_3(x[:, :, 1])
+                    ),
+                    self._conv2d_4(x[:, :, 2]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            # out_tensor_list[1]: conv2d_1_1_0, conv2d_1_1_4 are applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[2]
+                .add(
+                    self._add_funcs[3].add(
+                        self._conv2d_1(x[:, :, 0]), self._conv2d_2(x[:, :, 1])
+                    ),
+                    self._conv2d_3(x[:, :, 2]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            # out_tensor_list[2]: conv2d_1_1_3, conv2d_1_1_4 are applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[4]
+                .add(
+                    self._add_funcs[5].add(
+                        self._conv2d_0(x[:, :, 0]), self._conv2d_1(x[:, :, 1])
+                    ),
+                    self._conv2d_2(x[:, :, 2]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+        elif t == 4:
+            # out_tensor_list[0]: conv2d_1_1_0, conv2d_1_1_1 are applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[0]
+                .add(
+                    self._add_funcs[1].add(
+                        self._conv2d_2(x[:, :, 0]), self._conv2d_3(x[:, :, 1])
+                    ),
+                    self._conv2d_4(x[:, :, 2]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            # out_tensor_list[1]: conv2d_1_1_0 is applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[2]
+                .add(
+                    self._add_funcs[3].add(
+                        self._add_funcs[4].add(
+                            self._conv2d_1(x[:, :, 0]),
+                            self._conv2d_2(x[:, :, 1]),
+                        ),
+                        self._conv2d_3(x[:, :, 2]),
+                    ),
+                    self._conv2d_4(x[:, :, 3]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            # out_tensor_list[2]: conv2d_1_1_4 is applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[5]
+                .add(
+                    self._add_funcs[6].add(
+                        self._add_funcs[7].add(
+                            self._conv2d_0(x[:, :, 0]),
+                            self._conv2d_1(x[:, :, 1]),
+                        ),
+                        self._conv2d_2(x[:, :, 2]),
+                    ),
+                    self._conv2d_3(x[:, :, 3]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            # out_tensor_list[3]: conv2d_1_1_3, conv2d_1_1_4 are applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[8]
+                .add(
+                    self._add_funcs[9].add(
+                        self._conv2d_0(x[:, :, 1]), self._conv2d_1(x[:, :, 2])
+                    ),
+                    self._conv2d_2(x[:, :, 3]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+        else:  # t >= 5
+            # out_tensor_list[0]: conv2d_1_1_0, conv2d_1_1_1 are applied to zero padding.
+            add_func_idx_base = 0
+            cur_tensor = (
+                self._add_funcs[add_func_idx_base]
+                .add(
+                    self._add_funcs[add_func_idx_base + 1].add(
+                        self._conv2d_2(x[:, :, 0]), self._conv2d_3(x[:, :, 1])
+                    ),
+                    self._conv2d_4(x[:, :, 2]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            add_func_idx_base += 2
+            # out_tensor_list[1]: conv2d_1_1_0 is applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[add_func_idx_base]
+                .add(
+                    self._add_funcs[add_func_idx_base + 1].add(
+                        self._add_funcs[add_func_idx_base + 2].add(
+                            self._conv2d_1(x[:, :, 0]),
+                            self._conv2d_2(x[:, :, 1]),
+                        ),
+                        self._conv2d_3(x[:, :, 2]),
+                    ),
+                    self._conv2d_4(x[:, :, 3]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            add_func_idx_base += 3
+            # out_tensor_list[2:-2]: zero padding has no effect.
+            for idx in range(4, t):
+                cur_tensor = (
+                    self._add_funcs[add_func_idx_base]
+                    .add(
+                        self._add_funcs[add_func_idx_base + 1].add(
+                            self._add_funcs[add_func_idx_base + 2].add(
+                                self._add_funcs[add_func_idx_base + 3].add(
+                                    self._conv2d_0(x[:, :, idx - 4]),
+                                    self._conv2d_1(x[:, :, idx - 3]),
+                                ),
+                                self._conv2d_2(x[:, :, idx - 2]),
+                            ),
+                            self._conv2d_3(x[:, :, idx - 1]),
+                        ),
+                        self._conv2d_4(x[:, :, idx]),
+                    )
+                    .unsqueeze(2)
+                )
+                out_tensor_list.append(cur_tensor)
+                add_func_idx_base += 4
+            # out_tensor_list[-2]: conv2d_1_1_4 is applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[add_func_idx_base]
+                .add(
+                    self._add_funcs[add_func_idx_base + 1].add(
+                        self._add_funcs[add_func_idx_base + 2].add(
+                            self._conv2d_0(x[:, :, -4]),
+                            self._conv2d_1(x[:, :, -3]),
+                        ),
+                        self._conv2d_2(x[:, :, -2]),
+                    ),
+                    self._conv2d_3(x[:, :, -1]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+            add_func_idx_base += 3
+            # out_tensor_list[-1]: conv2d_1_1_3, conv2d_1_1_4 are applied to zero padding.
+            cur_tensor = (
+                self._add_funcs[add_func_idx_base]
+                .add(
+                    self._add_funcs[add_func_idx_base + 1].add(
+                        self._conv2d_0(x[:, :, -3]),
+                        self._conv2d_1(x[:, :, -2]),
+                    ),
+                    self._conv2d_2(x[:, :, -1]),
+                )
+                .unsqueeze(2)
+            )
+            out_tensor_list.append(cur_tensor)
+        return self._cat_func.cat(out_tensor_list, 2)
+
+
+class _Conv3dTemporalKernel1Decomposed(nn.Module):
+    """
+    Helper class for decomposing conv3d with temporal kernel of 1 into conv2d on
+    multiple temporal planes.
+    In conv3d with temporal kernel 1 and input I, for output temporal index of t (O[:,:,t,:,:]),
+    the conv can be expressed as:
+    O[:,:,t,:,:] = conv3d(I[:,:,t,:,:])
+                 = conv2d(I[:,:,t,:,:])
+    The full output can be obtained by concat O[:,:,t,:,:] for t in 0...T,
+    where T is the length of I in temporal dimension.
+    """
+
+    def __init__(
+        self,
+        conv3d_eq: nn.Conv3d,
+        input_THW_tuple: Tuple,
+    ):
+        """
+        Args:
+            conv3d_eq (nn.Module): input nn.Conv3d module to be converted
+                into equivalent conv2d.
+            input_THW_tuple (tuple): input THW size for conv3d_eq during forward.
+        """
+        super().__init__()
+        # create equivalent conv2d module
+        in_channels = conv3d_eq.in_channels
+        out_channels = conv3d_eq.out_channels
+        bias_flag = conv3d_eq.bias is not None
+        self.conv2d_eq = nn.Conv2d(
+            in_channels,
+            out_channels,
+            kernel_size=(conv3d_eq.kernel_size[1], conv3d_eq.kernel_size[2]),
+            stride=(conv3d_eq.stride[1], conv3d_eq.stride[2]),
+            groups=conv3d_eq.groups,
+            bias=bias_flag,
+            padding=(conv3d_eq.padding[1], conv3d_eq.padding[2]),
+            dilation=(conv3d_eq.dilation[1], conv3d_eq.dilation[2]),
+        )
+        state_dict = conv3d_eq.state_dict()
+        state_dict["weight"] = state_dict["weight"].squeeze(2)
+        self.conv2d_eq.load_state_dict(state_dict)
+        self.input_THW_tuple = input_THW_tuple
+
+    def forward(self, x):
+        out_tensor_list = []
+        for idx in range(self.input_THW_tuple[0]):
+            cur_tensor = self.conv2d_eq(x[:, :, idx]).unsqueeze(2)
+            out_tensor_list.append(cur_tensor)
+        return torch.cat(out_tensor_list, 2)

reward_models/ib_sync_rewards/imagebind/pytorchvideo/layers/accelerator/mobile_cpu/convolutions.py

@@ -0,0 +1,629 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+import logging
+from collections import OrderedDict
+from typing import Tuple
+
+import torch
+import torch.nn as nn
+from pytorchvideo.accelerator.efficient_blocks.efficient_block_base import (
+    EfficientBlockBase,
+)
+
+from .activation_functions import supported_act_functions
+from .conv_helper import (
+    _Conv3dTemporalKernel1Decomposed,
+    _Conv3dTemporalKernel3Decomposed,
+    _Conv3dTemporalKernel5Decomposed,
+    _Reshape,
+)
+
+
+TORCH_VERSION: Tuple[int, ...] = tuple(int(x) for x in torch.__version__.split(".")[:2])
+if TORCH_VERSION >= (1, 11):
+    from torch.ao.quantization import fuse_modules
+else:
+    from torch.quantization import fuse_modules
+
+
+class Conv3dPwBnAct(EfficientBlockBase):
+    """
+    Implements Conv3d + Bn + Activation for pointwise layers.
+    The conv layer has fixed kernel_size = (1,1,1),
+    groups = 1, padding = 0, stride = 1, dilation = 1.
+
+                          Input
+                            |
+                            ↓
+                        conv3d (1x1x1)
+                            ↓
+                        BatchNorm (optional)
+                            ↓
+                        Activation
+
+    Conv3dPwBnAct is in original form (for training) once instantiated. User can
+    call convert() method to convert it into deployable form for deployment.
+
+    convert_flag variable is to record whether the Conv3dPwBnAct instance
+    has been converted; Conv3dPwBnAct is in original form if convert_flag is false,
+    while it is in deployable form if convert_flag is true.
+
+    Current implementation of this layer in QNNPACK is very efficient.
+    Args:
+        in_channels (int): number of input channels for conv3d 1x1x1.
+        out_channels (int): number of output channels for conv3d 1x1x1.
+        bias (bool): if true, use bias for conv.
+        activation (str): applies selected activation from supported_act_functions.
+            See activation_functions.py for more info about supported activations.
+            Currently ReLU ('relu'), Swish ('swish'), Hardswish ('hswish'), Identity
+            ('identity') are supported.
+        use_bn (bool): if true, use batchnorm.
+        norm_eps (float): epsilon for batchnorm.
+        norm_momentum (float): momentum for batchnorm.
+
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        bias=False,
+        activation: str = "relu",
+        use_bn=True,
+        norm_eps: float = 1e-5,
+        norm_momentum: float = 0.1,
+    ):
+        super().__init__()
+        self._in_channels = in_channels
+        self._out_channels = out_channels
+        self.act = activation
+        kernel = OrderedDict()
+        kernel["conv"] = nn.Conv3d(in_channels, out_channels, kernel_size=1, bias=bias)
+        if use_bn:
+            kernel["bn"] = nn.BatchNorm3d(
+                out_channels, eps=norm_eps, momentum=norm_momentum
+            )
+        assert (
+            activation in supported_act_functions
+        ), f"Conv3dPwBnAct: {activation} is not in supported_act_functions."
+        kernel["act"] = supported_act_functions[activation]()
+        self.kernel = nn.Sequential(kernel)
+        self.convert_flag = False
+
+    def convert(
+        self,
+        input_blob_size: Tuple,
+        convert_for_quantize: bool = False,
+        native_conv3d_op_qnnpack: bool = False,
+        **kwargs,
+    ):
+        """
+        Converts the block into efficient form.
+        For fp32 operation, or quantized but with older version of QNNPACK w/o native int8
+        Conv3d support, this function converts Conv3d into equivalent Conv2d for Pytorch
+        Mobile deployment.
+        The Conv3d -> Conv2d conversion is done by first fuse conv3d with bn,
+        convert conv3d into equivalent conv2d, and optionally fuse conv2d with relu.
+        After conversion, the forwarding of this module becomes:
+        Input (5d tensor) --> reshape (4d tensor) --> conv2d (4d tensor)
+            --> reshape (5d tensor) --> output (5d tensor)
+
+        For quantized operation on new version of QNNPACK with native int8 Conv3d, this
+        function will only apply operator fusion.
+        Args:
+            input_blob_size (tuple): blob size at the input of Conv3dPwBnAct instance.
+            convert_for_quantize (bool): whether this module is intended to be quantized.
+            native_conv3d_op_qnnpack (bool): whether the QNNPACK version has native int8
+                Conv3d.
+            kwargs (any): any extra keyword arguments from upstream unused by convert().
+        """
+        assert (
+            self.convert_flag is False
+        ), "Conv3dPwBnAct: already converted, cannot be converted again"
+        self.kernel.eval()
+        # First fuse conv and bn if bn exists.
+        if hasattr(self.kernel, "bn"):
+            self.kernel = fuse_modules(self.kernel, ["conv", "bn"])
+        # If user intends to quantize the module and their QNNPACK comes with native int8 Conv3d,
+        # then we just need to do fusion.
+        if convert_for_quantize and native_conv3d_op_qnnpack:
+            if self.act == "relu":
+                self.kernel = fuse_modules(self.kernel, ["conv", "act.act"])
+            # Set new kernel in eval mode again
+            self.kernel.eval()
+        # Else, for fp32 operation or for int8 but with older version of QNNPACK w/o native int8 Conv3d,
+        # we need to unfold Conv3d into Conv2ds.
+        else:
+            batch_size = input_blob_size[0]
+            input_THW_tuple = input_blob_size[2:]
+            self._input_tensor_reshape_size = (
+                batch_size,
+                self._in_channels,  # C
+                input_THW_tuple[0] * input_THW_tuple[1],  # T*H
+                input_THW_tuple[2],  # W
+            )
+            self._output_tensor_size = (
+                batch_size,
+                self._out_channels,  # C
+                input_THW_tuple[0],  # T
+                input_THW_tuple[1],  # H
+                input_THW_tuple[2],  # W
+            )
+            conv2d_eq = nn.Conv2d(
+                self._in_channels,
+                self._out_channels,
+                kernel_size=1,
+                bias=(self.kernel.conv.bias is not None),
+            )
+            conv_state_dict = self.kernel.conv.state_dict()
+            conv_state_dict["weight"] = conv_state_dict["weight"].squeeze(2)
+            conv2d_eq.load_state_dict(conv_state_dict)
+            self.kernel.conv = conv2d_eq
+            # Convert activatiopn function
+            self.kernel.act.convert(input_blob_size, **kwargs)
+            # Fuse act with conv after conv3d -> conv2d if act is relu
+            if self.act == "relu":
+                self.kernel = fuse_modules(self.kernel, ["conv", "act.act"])
+            # Insert reshape layers before/after conv2d
+            self.kernel = nn.Sequential(
+                _Reshape(self._input_tensor_reshape_size),
+                self.kernel,
+                _Reshape(self._output_tensor_size),
+            )
+            # Set new kernel in eval mode again
+            self.kernel.eval()
+        self.convert_flag = True
+
+    def forward(self, x):
+        x = self.kernel(x)
+        return x
+
+
+class Conv3d3x3x3DwBnAct(EfficientBlockBase):
+    """
+    Implements Conv3d (3x3x3 dw) + (optional) Bn + Activation layers.
+    The conv layer has fixed kernel_size = (3,3,3), depthwise, zero padding size of
+    (1,1,1), temporal stride = 1, dilation = 1
+
+                      Input
+                        |
+                        ↓
+                    conv3d (3x3x3 dw)
+                        ↓
+                    BatchNorm (optional)
+                        ↓
+                    Activation
+
+    Current implementation of this layer in QNNPACK is reasonably efficient.
+
+    convert_flag variable is to record whether the Conv3d3x3x3DwBnAct instance
+    has been converted; Conv3d3x3x3DwBnAct is in original form if convert_flag is false,
+    while it is in deployable form if convert_flag is true.
+
+    Args:
+        in_channels (int): number of channels for conv3d 3x3x3 dw.
+        spatial_stride (tuple length of 2): spatial stride for conv.
+        bias (bool): if true, use bias for conv.
+        activation (str): applies selected activation from supported_act_functions.
+            See activation_functions.py for more info about supported activations.
+            Currently ReLU ('relu'), Swish ('swish'), Hardswish ('hswish'), Identity
+            ('identity') are supported.
+        use_bn (bool): if true, use batchnorm.
+        norm_eps (float): epsilon for batchnorm.
+        norm_momentum (float): momentum for batchnorm.
+
+    Current implementation of this layer in Pytorch Mobile is efficient.
+    Sidenote: QNNPACK has best support for dw with 3x3 spatial kernel.
+    For other spatial kernels like 7x7 dw, the efficiency may be lower.
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        spatial_stride: int = 1,
+        bias=False,
+        activation: str = "relu",
+        use_bn=True,
+        norm_eps: float = 1e-5,
+        norm_momentum: float = 0.1,
+    ):
+        super().__init__()
+        kernel = OrderedDict()
+        conv_stride = (1, spatial_stride, spatial_stride)
+        kernel["conv"] = nn.Conv3d(
+            in_channels,
+            in_channels,
+            kernel_size=(3, 3, 3),
+            stride=conv_stride,
+            groups=in_channels,
+            padding=1,
+            bias=bias,
+        )
+        if use_bn:
+            kernel["bn"] = nn.BatchNorm3d(
+                in_channels, eps=norm_eps, momentum=norm_momentum
+            )
+        assert (
+            activation in supported_act_functions
+        ), f"Conv3d3x3x3DwBnAct: {activation} is not in supported_act_functions."
+        kernel["act"] = supported_act_functions[activation]()
+        self.kernel = nn.Sequential(kernel)
+
+        self.convert_flag = False
+
+    def convert(
+        self,
+        input_blob_size: Tuple,
+        convert_for_quantize: bool = False,
+        native_conv3d_op_qnnpack: bool = False,
+        **kwargs,
+    ):
+        """
+        Converts the block into efficient form.
+        For fp32 operation, or quantized but with older version of QNNPACK w/o native int8
+        Conv3d support, this function converts Conv3d into equivalent Conv2d for Pytorch
+        Mobile deployment.
+        For quantized operation on new version of QNNPACK with native int8 Conv3d, this
+        function will only apply operator fusion.
+        Args:
+            input_blob_size (tuple): blob size at the input of Conv3d3x3x3DwBnAct
+                instance during forward.
+            convert_for_quantize (bool): whether this module is intended to be quantized.
+            native_conv3d_op_qnnpack (bool): whether the QNNPACK version has native int8
+                Conv3d.
+            kwargs (any): any keyword argument (unused).
+        """
+        assert (
+            self.convert_flag is False
+        ), "Conv3d3x3x3DwBnAct: already converted, cannot be converted twice."
+        self.kernel.eval()
+        # Fuse conv and bn if bn exists.
+        if hasattr(self.kernel, "bn"):
+            self.kernel = fuse_modules(self.kernel, ["conv", "bn"])
+        # Convert Conv3d into equivalent Conv2d if using fp32 operation (convert_for_quantize
+        # is False) or not using QNNPACK native conv3d (native_conv3d_op_qnnpack is False)
+        if (convert_for_quantize is False) or (native_conv3d_op_qnnpack is False):
+            self.kernel.conv = _Conv3dTemporalKernel3Decomposed(
+                self.kernel.conv, input_blob_size[2:]
+            )
+        # Convert activatiopn function
+        self.kernel.act.convert(input_blob_size, **kwargs)
+        """
+        Since conv3d is converted into multiple conv2d,
+        will not fuse conv with act to keep arithmetic equivalency.
+        """
+        self.convert_flag = True
+        # Set new kernel in eval mode again
+        self.kernel.eval()
+
+    def forward(self, x):
+        x = self.kernel(x)
+        return x
+
+
+class Conv3dTemporalKernel1BnAct(EfficientBlockBase):
+    """
+    Implements Conv3d + Bn + Activation where Conv3d has temporal kernel of 1.
+    The conv layer has padding[0] = 0, stride[0] = 1, dilation[0] = 1.
+
+                                  Input
+                                    |
+                                    ↓
+                                conv3d (1xkxk)
+                                    ↓
+                                BatchNorm (optional)
+                                    ↓
+                                Activation
+
+    Current implementation of this layer in QNNPACK is reasonably efficient
+    (not as efficient as Conv3dPwBnAct for 1x1x1 kernel).
+    Args:
+        in_channels (int): number of input channels for conv3d 1x1x1.
+        out_channels (int): number of output channels for conv3d 1x1x1.
+        bias (bool): if true, use bias for conv.
+        groups (int): number of groups for conv.
+        spstial_kernel (int): spatial kernel for conv3d.
+        spstial_stride (int): spatial stride for conv3d.
+        spatial_padding (int): spatial padding for conv3d.
+        spatial_dilation (int): spatial dilation for conv3d.
+        activation (str): applies selected activation from supported_act_functions.
+            See activation_functions.py for more info about supported activations.
+            Currently ReLU ('relu'), Swish ('swish'), Hardswish ('hswish'), Identity
+            ('identity') are supported.
+        use_bn (bool): if true, use batchnorm.
+        norm_eps (float): epsilon for batchnorm.
+        norm_momentum (float): momentum for batchnorm.
+
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        bias=False,
+        groups: int = 1,
+        spatial_kernel: int = 1,
+        spatial_stride: int = 1,
+        spatial_padding: int = 0,
+        spatial_dilation: int = 1,
+        activation: str = "relu",
+        use_bn=True,
+        norm_eps: float = 1e-5,
+        norm_momentum: float = 0.1,
+    ):
+        super().__init__()
+
+        kernel_size = (1, spatial_kernel, spatial_kernel)
+        stride = (1, spatial_stride, spatial_stride)
+        padding = (0, spatial_padding, spatial_padding)
+        dilation = (1, spatial_dilation, spatial_dilation)
+        kernel = OrderedDict()
+        kernel["conv"] = nn.Conv3d(
+            in_channels,
+            out_channels,
+            kernel_size=kernel_size,
+            padding=padding,
+            stride=stride,
+            dilation=dilation,
+            groups=groups,
+            bias=bias,
+        )
+        if use_bn:
+            kernel["bn"] = nn.BatchNorm3d(
+                out_channels, eps=norm_eps, momentum=norm_momentum
+            )
+        assert (
+            activation in supported_act_functions
+        ), f"Conv3dTemporalKernel1BnAct: {activation} is not in supported_act_functions."
+        kernel["act"] = supported_act_functions[activation]()
+        self.kernel = nn.Sequential(kernel)
+
+        self.convert_flag = False
+
+    def convert(
+        self,
+        input_blob_size: Tuple,
+        **kwargs,
+    ):
+        """
+        Converts Conv3d into equivalent Conv2d for QNNPACK deployment.
+        This conversion is done by first fuse conv3d with bn,
+        convert conv3d into equivalent conv2d,
+        and optionally fuse conv2d with relu.
+        Args:
+            input_blob_size (tuple): blob size at the input of
+                Conv3dTemporalKernel1BnAct instance during forward.
+            kwargs (any): any keyword argument (unused).
+        """
+        assert (
+            self.convert_flag is False
+        ), "Conv3dTemporalKernel1BnAct: already converted, cannot be converted again"
+        self.kernel.eval()
+        # First fuse conv and bn if bn exists.
+        if hasattr(self.kernel, "bn"):
+            self.kernel = fuse_modules(self.kernel, ["conv", "bn"])
+
+        self.kernel.conv = _Conv3dTemporalKernel1Decomposed(
+            self.kernel.conv, input_blob_size[2:]
+        )
+        # Convert activatiopn function
+        self.kernel.act.convert(input_blob_size, **kwargs)
+
+        self.convert_flag = True
+        # Set new kernel in eval mode again
+        self.kernel.eval()
+
+    def forward(self, x):
+        x = self.kernel(x)
+        return x
+
+
+class Conv3d3x1x1BnAct(EfficientBlockBase):
+    """
+    Implements Conv3d (3x1x1) + (optional) Bn + Activation for pointwise layers.
+    The conv layer has fixed kernel of (3, 1, 1), zero padding size of
+    (1, 0, 0), stride = (1, 1, 1), dilation = 1.
+
+                      Input
+                        |
+                        ↓
+                    conv3d (3x1x1)
+                        ↓
+                    BatchNorm (optional)
+                        ↓
+                    Activation
+
+    For regular convolution (i.e., groups=1), current implementation of this layer in
+    QNNPACK is reasonably efficient.
+    For depthwise convolution (i.e., groups=out_channels), current implementation of this
+    layer in QNNPACK is not efficient as Conv3d3x3x3DwBnRelu, as QNNPACK does not have
+    optimization for 1x1 depthwise convolution. The latencies of fp32 operation are similar
+    for Conv3d3x1x1BnAct and Conv3d3x3x3DwBnRelu, while with int8 operation Conv3d3x1x1BnAct
+    is 1.5X slower than Conv3d3x3x3DwBnRelu.
+
+    self.convert_flag property records whether the Conv3d3x1x1BnAct instance has been
+    converted; Conv3d3x1x1BnAct is in original form if convert_flag is false, while it
+    is in deployable form if convert_flag is true.
+
+    Args:
+        in_channels (int): number of input channels for conv3d 3x1x1.
+        out_channels (int): number of output channels for conv3d 3x1x1.
+        groups (int): number of groups for conv.
+        bias (bool): if true, use bias for conv.
+        activation (str): applies selected activation from supported_act_functions.
+            See activation_functions.py for more info about supported activations.
+            Currently ReLU ('relu'), Swish ('swish'), Hardswish ('hswish'), Identity
+            ('identity') are supported.
+        use_bn (bool): if true, use batchnorm.
+        norm_eps (float): epsilon for batchnorm.
+        norm_momentum (float): momentum for batchnorm.
+
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        groups: int = 1,
+        bias=False,
+        activation: str = "relu",
+        use_bn=True,
+        norm_eps=1e-5,
+        norm_momentum=0.1,
+    ):
+        super().__init__()
+        kernel = OrderedDict()
+        kernel["conv"] = nn.Conv3d(
+            in_channels,
+            out_channels,
+            kernel_size=(3, 1, 1),
+            groups=groups,
+            padding=(1, 0, 0),
+            bias=bias,
+        )
+
+        if groups == out_channels:
+            logging.warning(
+                (
+                    "Conv3d3x1x1BnAct has low efficiency for depthwise conv. "
+                    "Consider using Conv3d3x3x3DwBnRelu instead."
+                )
+            )
+
+        if use_bn:
+            kernel["bn"] = nn.BatchNorm3d(
+                out_channels, eps=norm_eps, momentum=norm_momentum
+            )
+        assert (
+            activation in supported_act_functions
+        ), f"Conv3d3x1x1BnAct: {activation} is not in supported_act_functions."
+        kernel["act"] = supported_act_functions[activation]()
+        self.kernel = nn.Sequential(kernel)
+        self.convert_flag = False
+
+    def convert(
+        self,
+        input_blob_size,
+        **kwargs,
+    ):
+        """
+        Converts Conv3d into equivalent Conv2d for Pytorch Mobile deployment
+
+        """
+        assert (
+            self.convert_flag is False
+        ), "Conv3d3x1x1BnAct: already converted, cannot be converted twice"
+        self.kernel.eval()
+        # Fuse conv and bn if bn exists.
+        if hasattr(self.kernel, "bn"):
+            self.kernel = fuse_modules(self.kernel, ["conv", "bn"])
+        self.kernel.conv = _Conv3dTemporalKernel3Decomposed(
+            self.kernel.conv, input_blob_size[2:]
+        )
+        # Convert activation function
+        self.kernel.act.convert(input_blob_size, **kwargs)
+        # Since conv3d is converted into multiple conv2d, will not fuse conv with relu
+        # to keep arithmetic equivalency.
+        self.convert_flag = True
+        self.kernel.eval()
+
+    def forward(self, x):
+        x = self.kernel(x)
+        return x
+
+
+class Conv3d5x1x1BnAct(EfficientBlockBase):
+    """
+    Implements Conv3d (5x1x1) + (optional) Bn + Activation for pointwise layers.
+    The conv layer has fixed kernel of (5, 1, 1), zero padding size of
+    (2, 0, 0), stride = (1, 1, 1), dilation = 1.
+
+                      Input
+                        |
+                        ↓
+                    conv3d (5x1x1)
+                        ↓
+                    BatchNorm (optional)
+                        ↓
+                    Activation
+
+    For regular convolution (i.e., groups=1), current implementation of this layer in
+    QNNPACK is reasonably efficient.
+
+    self.convert_flag property records whether the Conv3d5x1x1BnAct instance has been
+    converted; Conv3d5x1x1BnAct is in original form if convert_flag is false, while it
+    is in deployable form if convert_flag is true.
+
+    Args:
+        in_channels (int): number of input channels for conv3d 3x1x1.
+        out_channels (int): number of output channels for conv3d 3x1x1.
+        groups (int): number of groups for conv.
+        bias (bool): if true, use bias for conv.
+        activation (str): applies selected activation from supported_act_functions.
+            See activation_functions.py for more info about supported activations.
+            Currently ReLU ('relu'), Swish ('swish'), Hardswish ('hswish'), Identity
+            ('identity') are supported.
+        use_bn (bool): if true, use batchnorm.
+        norm_eps (float): epsilon for batchnorm.
+        norm_momentum (float): momentum for batchnorm.
+
+    """
+
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        groups: int = 1,
+        bias=False,
+        activation: str = "relu",
+        use_bn=True,
+        norm_eps=1e-5,
+        norm_momentum=0.1,
+    ):
+        super().__init__()
+        kernel = OrderedDict()
+        kernel["conv"] = nn.Conv3d(
+            in_channels,
+            out_channels,
+            kernel_size=(5, 1, 1),
+            groups=groups,
+            padding=(2, 0, 0),
+            bias=bias,
+        )
+
+        if use_bn:
+            kernel["bn"] = nn.BatchNorm3d(
+                out_channels, eps=norm_eps, momentum=norm_momentum
+            )
+        assert (
+            activation in supported_act_functions
+        ), f"Conv3d5x1x1BnAct: {activation} is not in supported_act_functions."
+        kernel["act"] = supported_act_functions[activation]()
+        self.kernel = nn.Sequential(kernel)
+        self.convert_flag = False
+
+    def convert(self, input_blob_size, **kwargs):
+        """
+        Converts Conv3d into equivalent Conv2d for Pytorch Mobile deployment
+
+        """
+        assert (
+            self.convert_flag is False
+        ), "Conv3d5x1x1BnAct: already converted, cannot be converted twice"
+        self.kernel.eval()
+        # Fuse conv and bn if bn exists.
+        if hasattr(self.kernel, "bn"):
+            self.kernel = fuse_modules(self.kernel, ["conv", "bn"])
+        self.kernel.conv = _Conv3dTemporalKernel5Decomposed(
+            self.kernel.conv, input_blob_size[2:]
+        )
+        # Convert activatiopn function
+        self.kernel.act.convert(input_blob_size, **kwargs)
+        # Since conv3d is converted into multiple conv2d, will not fuse conv with relu
+        # to keep arithmetic equivalency.
+        self.convert_flag = True
+        self.kernel.eval()
+
+    def forward(self, x):
+        x = self.kernel(x)
+        return x

reward_models/ib_sync_rewards/imagebind/pytorchvideo/layers/fusion.py

@@ -0,0 +1,149 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from typing import Callable, List
+
+import torch
+import torch.nn as nn
+
+
+"""
+Fusion layers are nn.Modules that take a list of Tensors (e.g. from a multi-stream
+architecture), and return a single fused Tensor. This file has several
+different types of fusion layers and a factory function "make_fusion_layer" to
+construct them.
+"""
+
+
+def make_fusion_layer(method: str, feature_dims: List[int]):
+    """
+    Args:
+        method (str): the fusion method to be constructed. Options:
+            - 'concat'
+            - 'temporal_concat'
+            - 'max'
+            - 'sum'
+            - 'prod'
+
+        feature_dims (List[int]): the first argument of all fusion layers. It holds a list
+            of required feature_dims for each tensor input (where the tensor inputs are of
+            shape (batch_size, seq_len, feature_dim)). The list order must corresponds to
+            the tensor order passed to forward(...).
+    """
+    if method == "concat":
+        return ConcatFusion(feature_dims)
+    elif method == "temporal_concat":
+        return TemporalConcatFusion(feature_dims)
+    elif method == "max":
+        return ReduceFusion(feature_dims, lambda x: torch.max(x, dim=0).values)
+    elif method == "sum":
+        return ReduceFusion(feature_dims, lambda x: torch.sum(x, dim=0))
+    elif method == "prod":
+        return ReduceFusion(feature_dims, lambda x: torch.prod(x, dim=0))
+    else:
+        raise NotImplementedError(f"Fusion {method} not available.")
+
+
+class ConcatFusion(nn.Module):
+    """
+    Concatenates all inputs by their last dimension. The resulting tensor last dim will be
+    the sum of the last dimension of all input tensors.
+    """
+
+    def __init__(self, feature_dims: List[int]):
+        super().__init__()
+        _verify_feature_dim(feature_dims)
+        self._output_dim = sum(feature_dims)
+
+    @property
+    def output_dim(self):
+        """
+        Last dimension size of forward(..) tensor output.
+        """
+        return self._output_dim
+
+    def forward(self, input_list: List[torch.Tensor]) -> torch.Tensor:
+        """
+        Args:
+            input_list (List[torch.Tensor]): a list of tensors of shape
+                (batch_size, seq_len, feature_dim).
+
+        Returns:
+            Tensor of shape (batch_size, seq_len, sum(feature_dims)) where sum(feature_dims)
+                is the sum of all input feature_dims.
+        """
+        return torch.cat(input_list, dim=-1)
+
+
+class TemporalConcatFusion(nn.Module):
+    """
+    Concatenates all inputs by their temporal dimension which is assumed to be dim=1.
+    """
+
+    def __init__(self, feature_dims: List[int]):
+        super().__init__()
+        _verify_feature_dim(feature_dims)
+
+        # All input dimensions must be the same
+        self._output_dim = max(feature_dims)
+        assert self._output_dim == min(feature_dims)
+
+    @property
+    def output_dim(self):
+        """
+        Last dimension size of forward(..) tensor output.
+        """
+        return self._output_dim
+
+    def forward(self, input_list: List[torch.Tensor]) -> torch.Tensor:
+        """
+        Args:
+            input_list (List[torch.Tensor]): a list of tensors of shape
+                (batch_size, seq_len, feature_dim)
+
+        Returns:
+            Tensor of shape (batch_size, sum(seq_len), feature_dim) where sum(seq_len) is
+                the sum of all input tensors.
+        """
+        return torch.cat(input_list, dim=1)
+
+
+class ReduceFusion(nn.Module):
+    """
+    Generic fusion method which takes a callable which takes the list of input tensors
+    and expects a single tensor to be used. This class can be used to implement fusion
+    methods like "sum", "max" and "prod".
+    """
+
+    def __init__(
+        self, feature_dims: List[int], reduce_fn: Callable[[torch.Tensor], torch.Tensor]
+    ):
+        super().__init__()
+        _verify_feature_dim(feature_dims)
+        self.reduce_fn = reduce_fn
+
+        # All input dimensions must be the same
+        self._output_dim = max(feature_dims)
+        assert self._output_dim == min(feature_dims)
+
+    @property
+    def output_dim(self):
+        """
+        Last dimension size of forward(..) tensor output.
+        """
+        return self._output_dim
+
+    def forward(self, input_list: List[torch.Tensor]) -> torch.Tensor:
+        """
+        Args:
+            input_list (List[torch.Tensor]): a list of tensors of shape
+                (batch_size, seq_len, feature_dim).
+
+        Returns:
+            Tensor of shape (batch_size, seq_len, feature_dim).
+        """
+        return self.reduce_fn(torch.stack(input_list))
+
+
+def _verify_feature_dim(feature_dims: List[int]):
+    assert isinstance(feature_dims, list)
+    assert all(x > 0 for x in feature_dims)

reward_models/ib_sync_rewards/imagebind/pytorchvideo/models/accelerator/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.

reward_models/ib_sync_rewards/imagebind/pytorchvideo/models/accelerator/mobile_cpu/__init__.py

@@ -0,0 +1 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.

reward_models/ib_sync_rewards/imagebind/pytorchvideo/models/csn.py

@@ -0,0 +1,191 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from typing import Callable, Tuple
+
+import torch
+import torch.nn as nn
+from pytorchvideo.models.head import create_res_basic_head
+from pytorchvideo.models.resnet import create_bottleneck_block, create_res_stage, Net
+from pytorchvideo.models.stem import create_res_basic_stem
+
+
+def create_csn(
+    *,
+    # Input clip configs.
+    input_channel: int = 3,
+    # Model configs.
+    model_depth: int = 50,
+    model_num_class: int = 400,
+    dropout_rate: float = 0,
+    # Normalization configs.
+    norm: Callable = nn.BatchNorm3d,
+    # Activation configs.
+    activation: Callable = nn.ReLU,
+    # Stem configs.
+    stem_dim_out: int = 64,
+    stem_conv_kernel_size: Tuple[int] = (3, 7, 7),
+    stem_conv_stride: Tuple[int] = (1, 2, 2),
+    stem_pool: Callable = None,
+    stem_pool_kernel_size: Tuple[int] = (1, 3, 3),
+    stem_pool_stride: Tuple[int] = (1, 2, 2),
+    # Stage configs.
+    stage_conv_a_kernel_size: Tuple[int] = (1, 1, 1),
+    stage_conv_b_kernel_size: Tuple[int] = (3, 3, 3),
+    stage_conv_b_width_per_group: int = 1,
+    stage_spatial_stride: Tuple[int] = (1, 2, 2, 2),
+    stage_temporal_stride: Tuple[int] = (1, 2, 2, 2),
+    bottleneck: Callable = create_bottleneck_block,
+    bottleneck_ratio: int = 4,
+    # Head configs.
+    head_pool: Callable = nn.AvgPool3d,
+    head_pool_kernel_size: Tuple[int] = (1, 7, 7),
+    head_output_size: Tuple[int] = (1, 1, 1),
+    head_activation: Callable = None,
+    head_output_with_global_average: bool = True,
+) -> nn.Module:
+    """
+    Build Channel-Separated Convolutional Networks (CSN):
+    Video classification with channel-separated convolutional networks.
+    Du Tran, Heng Wang, Lorenzo Torresani, Matt Feiszli. ICCV 2019.
+
+    CSN follows the ResNet style architecture including three parts: Stem,
+    Stages and Head. The three parts are assembled in the following order:
+
+    ::
+
+                                         Input
+                                           ↓
+                                         Stem
+                                           ↓
+                                         Stage 1
+                                           ↓
+                                           .
+                                           .
+                                           .
+                                           ↓
+                                         Stage N
+                                           ↓
+                                         Head
+
+    CSN uses depthwise convolution. To further reduce the computational cost, it uses
+    low resolution (112x112), short clips (4 frames), different striding and kernel
+    size, etc.
+
+    Args:
+
+        input_channel (int): number of channels for the input video clip.
+
+        model_depth (int): the depth of the resnet. Options include: 50, 101, 152.
+            model_num_class (int): the number of classes for the video dataset.
+            dropout_rate (float): dropout rate.
+
+        norm (callable): a callable that constructs normalization layer.
+
+        activation (callable): a callable that constructs activation layer.
+
+        stem_dim_out (int): output channel size to stem.
+        stem_conv_kernel_size (tuple): convolutional kernel size(s) of stem.
+        stem_conv_stride (tuple): convolutional stride size(s) of stem.
+        stem_pool (callable): a callable that constructs resnet head pooling layer.
+        stem_pool_kernel_size (tuple): pooling kernel size(s).
+        stem_pool_stride (tuple): pooling stride size(s).
+
+        stage_conv_a_kernel_size (tuple): convolutional kernel size(s) for conv_a.
+        stage_conv_b_kernel_size (tuple): convolutional kernel size(s) for conv_b.
+        stage_conv_b_width_per_group(int): the width of each group for conv_b. Set
+            it to 1 for depthwise convolution.
+        stage_spatial_stride (tuple): the spatial stride for each stage.
+        stage_temporal_stride (tuple): the temporal stride for each stage.
+        bottleneck (callable): a callable that constructs bottleneck block layer.
+            Examples include: create_bottleneck_block.
+        bottleneck_ratio (int): the ratio between inner and outer dimensions for
+            the bottleneck block.
+
+        head_pool (callable): a callable that constructs resnet head pooling layer.
+        head_pool_kernel_size (tuple): the pooling kernel size.
+        head_output_size (tuple): the size of output tensor for head.
+        head_activation (callable): a callable that constructs activation layer.
+        head_output_with_global_average (bool): if True, perform global averaging on
+            the head output.
+
+    Returns:
+        (nn.Module): the csn model.
+    """
+
+    torch._C._log_api_usage_once("PYTORCHVIDEO.model.create_csn")
+
+    # Number of blocks for different stages given the model depth.
+    _MODEL_STAGE_DEPTH = {50: (3, 4, 6, 3), 101: (3, 4, 23, 3), 152: (3, 8, 36, 3)}
+
+    # Given a model depth, get the number of blocks for each stage.
+    assert (
+        model_depth in _MODEL_STAGE_DEPTH.keys()
+    ), f"{model_depth} is not in {_MODEL_STAGE_DEPTH.keys()}"
+    stage_depths = _MODEL_STAGE_DEPTH[model_depth]
+
+    blocks = []
+    # Create stem for CSN.
+    stem = create_res_basic_stem(
+        in_channels=input_channel,
+        out_channels=stem_dim_out,
+        conv_kernel_size=stem_conv_kernel_size,
+        conv_stride=stem_conv_stride,
+        conv_padding=[size // 2 for size in stem_conv_kernel_size],
+        pool=stem_pool,
+        pool_kernel_size=stem_pool_kernel_size,
+        pool_stride=stem_pool_stride,
+        pool_padding=[size // 2 for size in stem_pool_kernel_size],
+        norm=norm,
+        activation=activation,
+    )
+    blocks.append(stem)
+
+    stage_dim_in = stem_dim_out
+    stage_dim_out = stage_dim_in * 4
+
+    # Create each stage for CSN.
+    for idx in range(len(stage_depths)):
+        stage_dim_inner = stage_dim_out // bottleneck_ratio
+        depth = stage_depths[idx]
+
+        stage_conv_b_stride = (
+            stage_temporal_stride[idx],
+            stage_spatial_stride[idx],
+            stage_spatial_stride[idx],
+        )
+
+        stage = create_res_stage(
+            depth=depth,
+            dim_in=stage_dim_in,
+            dim_inner=stage_dim_inner,
+            dim_out=stage_dim_out,
+            bottleneck=bottleneck,
+            conv_a_kernel_size=stage_conv_a_kernel_size,
+            conv_a_stride=(1, 1, 1),
+            conv_a_padding=[size // 2 for size in stage_conv_a_kernel_size],
+            conv_b_kernel_size=stage_conv_b_kernel_size,
+            conv_b_stride=stage_conv_b_stride,
+            conv_b_padding=[size // 2 for size in stage_conv_b_kernel_size],
+            conv_b_num_groups=(stage_dim_inner // stage_conv_b_width_per_group),
+            conv_b_dilation=(1, 1, 1),
+            norm=norm,
+            activation=activation,
+        )
+
+        blocks.append(stage)
+        stage_dim_in = stage_dim_out
+        stage_dim_out = stage_dim_out * 2
+
+    # Create head for CSN.
+    head = create_res_basic_head(
+        in_features=stage_dim_in,
+        out_features=model_num_class,
+        pool=head_pool,
+        output_size=head_output_size,
+        pool_kernel_size=head_pool_kernel_size,
+        dropout_rate=dropout_rate,
+        activation=head_activation,
+        output_with_global_average=head_output_with_global_average,
+    )
+    blocks.append(head)
+    return Net(blocks=nn.ModuleList(blocks))

reward_models/ib_sync_rewards/imagebind/pytorchvideo/models/hub/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from .csn import csn_r101
+from .efficient_x3d_mobile_cpu import efficient_x3d_s, efficient_x3d_xs
+from .r2plus1d import r2plus1d_r50
+from .resnet import c2d_r50, i3d_r50, slow_r50, slow_r50_detection
+from .slowfast import (
+    slowfast_16x8_r101_50_50,
+    slowfast_r101,
+    slowfast_r50,
+    slowfast_r50_detection,
+)
+from .vision_transformers import mvit_base_16, mvit_base_16x4, mvit_base_32x3
+from .x3d import x3d_l, x3d_m, x3d_s, x3d_xs

reward_models/ib_sync_rewards/imagebind/pytorchvideo/models/hub/csn.py

@@ -0,0 +1,58 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from typing import Any
+
+import torch.nn as nn
+from pytorchvideo.models.csn import create_csn
+from torch.hub import load_state_dict_from_url
+
+
+"""
+Channel-Separated Convolutional Network models for video recognition.
+"""
+
+root_dir = "https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics"
+checkpoint_paths = {
+    "csn_r101": f"{root_dir}/CSN_32x2_R101.pyth",
+}
+
+
+def csn_r101(
+    pretrained: bool = False, progress: bool = True, **kwargs: Any
+) -> nn.Module:
+    r"""
+    Channel-Separated Convolutional Networks (CSN) R101 model architecture [1]
+    with pretrained weights based on 32x2 setting on the Kinetics dataset.
+    Model with pretrained weights has top1 accuracy of 77.0 (trained on 16x8 GPUs).
+
+    [1] "Video classification with channel-separated convolutional networks"
+        Du Tran, Heng Wang, Lorenzo Torresani, Matt Feiszli. ICCV 2019.
+        https://arxiv.org/abs/1904.02811
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on the Kinetics dataset
+        progress (bool): If True, displays a progress bar of the download to stderr
+        kwargs: use these to modify any of the other model settings. All the
+            options are defined in pytorchvideo/models/resnet.py
+
+    NOTE: to use the pretrained model, do not modify the model configuration
+    via the kwargs. Only modify settings via kwargs to initialize a new model
+    without pretrained weights.
+    """
+    model = create_csn(
+        model_depth=101,
+        stem_pool=nn.MaxPool3d,
+        head_pool_kernel_size=(4, 7, 7),
+        **kwargs,
+    )
+
+    if pretrained:
+        path = checkpoint_paths["csn_r101"]
+        # All models are loaded onto CPU by default
+        checkpoint = load_state_dict_from_url(
+            path, progress=progress, map_location="cpu"
+        )
+        state_dict = checkpoint["model_state"]
+        model.load_state_dict(state_dict)
+
+    return model

reward_models/ib_sync_rewards/imagebind/pytorchvideo/models/hub/efficient_x3d_mobile_cpu.py

@@ -0,0 +1,83 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from typing import Any, Optional
+
+import torch.nn as nn
+from pytorchvideo.models.accelerator.mobile_cpu.efficient_x3d import create_x3d
+from torch.hub import load_state_dict_from_url
+
+
+_root_dir = "https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics"
+_checkpoint_paths = {
+    "efficient_x3d_xs": f"{_root_dir}/efficient_x3d_xs_original_form.pyth",
+    "efficient_x3d_s": f"{_root_dir}/efficient_x3d_s_original_form.pyth",
+}
+
+
+def _efficient_x3d(
+    pretrained: bool = False,
+    progress: bool = True,
+    checkpoint_path: Optional[str] = None,
+    # Model params
+    expansion: str = "XS",
+    **kwargs: Any,
+) -> nn.Module:
+    model = create_x3d(
+        expansion=expansion,
+        **kwargs,
+    )
+
+    if pretrained and checkpoint_path is not None:
+        # All models are loaded onto CPU by default
+        state_dict = load_state_dict_from_url(
+            checkpoint_path, progress=progress, map_location="cpu"
+        )
+        model.load_state_dict(state_dict)
+
+    return model
+
+
+def efficient_x3d_xs(pretrained: bool = False, progress: bool = True, **kwargs):
+    r"""
+    X3D-XS model architectures [1] with pretrained weights trained
+    on the Kinetics dataset with efficient implementation for mobile cpu.
+
+    [1] Christoph Feichtenhofer, "X3D: Expanding Architectures for
+    Efficient Video Recognition." https://arxiv.org/abs/2004.04730
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on Kinetcis-400 dataset
+        progress (bool): If True, displays a progress bar of the download to stderr
+        To modify any other model settings, specify them in the kwargs.
+        All the args are defined in pytorchvideo/models/x3d.py
+    """
+    return _efficient_x3d(
+        pretrained=pretrained,
+        progress=progress,
+        checkpoint_path=_checkpoint_paths["efficient_x3d_xs"],
+        expansion="XS",
+        **kwargs,
+    )
+
+
+def efficient_x3d_s(pretrained: bool = False, progress: bool = True, **kwargs):
+    r"""
+    X3D-S model architectures [1] with pretrained weights trained
+    on the Kinetics dataset with efficient implementation for mobile cpu.
+
+    [1] Christoph Feichtenhofer, "X3D: Expanding Architectures for
+    Efficient Video Recognition." https://arxiv.org/abs/2004.04730
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on Kinetcis-400 dataset
+        progress (bool): If True, displays a progress bar of the download to stderr
+        To modify any other model settings, specify them in the kwargs.
+        All the args are defined in pytorchvideo/models/x3d.py
+    """
+    return _efficient_x3d(
+        pretrained=pretrained,
+        progress=progress,
+        checkpoint_path=_checkpoint_paths["efficient_x3d_s"],
+        expansion="S",
+        **kwargs,
+    )

reward_models/ib_sync_rewards/imagebind/pytorchvideo/models/hub/r2plus1d.py

@@ -0,0 +1,54 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from typing import Any
+
+import torch.nn as nn
+from pytorchvideo.models.r2plus1d import create_r2plus1d
+from torch.hub import load_state_dict_from_url
+
+
+"""
+R(2+1)D style models for video recognition.
+"""
+
+root_dir = "https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo/kinetics"
+checkpoint_paths = {
+    "r2plus1d_r50": f"{root_dir}/R2PLUS1D_16x4_R50.pyth",
+}
+
+
+def r2plus1d_r50(
+    pretrained: bool = False, progress: bool = True, **kwargs: Any
+) -> nn.Module:
+    r"""
+
+    R(2+1)D model architecture from [1] with pretrained weights based on 16x4 setting
+    on the Kinetics dataset. Model with pretrained weights has top1 accuracy of 76.01.
+    (trained on 8*8 GPUs)
+
+    [1] "A closer look at spatiotemporal convolutions for action recognition"
+        Du Tran, Heng Wang, Lorenzo Torresani, Jamie Ray, Yann LeCun, Manohar Paluri. CVPR 2018.
+        https://arxiv.org/abs/1711.11248
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on the Kinetics dataset
+        progress (bool): If True, displays a progress bar of the download to stderr
+        kwargs: use these to modify any of the other model settings. All the
+            options are defined in pytorchvideo/models/resnet.py
+
+    NOTE: to use the pretrained model, do not modify the model configuration
+    via the kwargs. Only modify settings via kwargs to initialize a new model
+    without pretrained weights.
+    """
+    model = create_r2plus1d(dropout_rate=0.5, **kwargs)
+
+    if pretrained:
+        path = checkpoint_paths["r2plus1d_r50"]
+        # All models are loaded onto CPU by default
+        checkpoint = load_state_dict_from_url(
+            path, progress=progress, map_location="cpu"
+        )
+        state_dict = checkpoint["model_state"]
+        model.load_state_dict(state_dict)
+
+    return model

reward_models/ib_sync_rewards/imagebind/pytorchvideo/models/hub/resnet.py

@@ -0,0 +1,160 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+
+from typing import Any, Callable
+
+import torch.nn as nn
+from pytorchvideo.models.resnet import create_resnet, create_resnet_with_roi_head
+from torch.hub import load_state_dict_from_url
+
+
+"""
+ResNet style models for video recognition.
+"""
+
+root_dir = "https://dl.fbaipublicfiles.com/pytorchvideo/model_zoo"
+checkpoint_paths = {
+    "slow_r50": f"{root_dir}/kinetics/SLOW_8x8_R50.pyth",
+    "slow_r50_detection": f"{root_dir}/ava/SLOW_4x16_R50_DETECTION.pyth",
+    "c2d_r50": f"{root_dir}/kinetics/C2D_8x8_R50.pyth",
+    "i3d_r50": f"{root_dir}/kinetics/I3D_8x8_R50.pyth",
+}
+
+
+def _resnet(
+    pretrained: bool = False,
+    progress: bool = True,
+    checkpoint_path: str = "",
+    model_builder: Callable = create_resnet,
+    **kwargs: Any,
+) -> nn.Module:
+    model = model_builder(**kwargs)
+    if pretrained:
+        # All models are loaded onto CPU by default
+        checkpoint = load_state_dict_from_url(
+            checkpoint_path, progress=progress, map_location="cpu"
+        )
+        state_dict = checkpoint["model_state"]
+        model.load_state_dict(state_dict)
+    return model
+
+
+def slow_r50(
+    pretrained: bool = False, progress: bool = True, **kwargs: Any
+) -> nn.Module:
+    r"""
+    Slow R50 model architecture [1] with pretrained weights based on 8x8 setting
+    on the Kinetics dataset. Model with pretrained weights has top1 accuracy of 74.58.
+
+    [1] "SlowFast Networks for Video Recognition"
+        Christoph Feichtenhofer et al
+        https://arxiv.org/pdf/1812.03982.pdf
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on the Kinetics dataset
+        progress (bool): If True, displays a progress bar of the download to stderr
+        kwargs: use these to modify any of the other model settings. All the
+            options are defined in pytorchvideo/models/resnet.py
+
+    NOTE: to use the pretrained model, do not modify the model configuration
+    via the kwargs. Only modify settings via kwargs to initialize a new model
+    without pretrained weights.
+    """
+    return _resnet(
+        pretrained=pretrained,
+        progress=progress,
+        checkpoint_path=checkpoint_paths["slow_r50"],
+        stem_conv_kernel_size=(1, 7, 7),
+        head_pool_kernel_size=(8, 7, 7),
+        model_depth=50,
+        **kwargs,
+    )
+
+
+def slow_r50_detection(
+    pretrained: bool = False, progress: bool = True, **kwargs: Any
+) -> nn.Module:
+    r"""
+    Slow R50 model architecture [1] with pretrained weights based on 4x16 setting.
+    The model is initially trained on Kinetics dataset for classification and later
+    finetuned on AVA dataset for detection.
+
+    [1] Christoph Feichtenhofer et al, "SlowFast Networks for Video Recognition"
+        https://arxiv.org/pdf/1812.03982.pdf
+    """
+    return _resnet(
+        pretrained=pretrained,
+        progress=progress,
+        checkpoint_path=checkpoint_paths["slow_r50_detection"],
+        model_builder=create_resnet_with_roi_head,
+        **kwargs,
+    )
+
+
+def c2d_r50(
+    pretrained: bool = False, progress: bool = True, **kwargs: Any
+) -> nn.Module:
+    r"""
+    C2D R50 model architecture with pretrained weights based on 8x8 setting
+    on the Kinetics dataset. Model with pretrained weights has top1 accuracy of 71.46.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on the Kinetics dataset
+        progress (bool): If True, displays a progress bar of the download to stderr
+        kwargs: use these to modify any of the other model settings. All the
+            options are defined in pytorchvideo/models/resnet.py
+
+    NOTE: to use the pretrained model, do not modify the model configuration
+    via the kwargs. Only modify settings via kwargs to initialize a new model
+    without pretrained weights.
+    """
+    return _resnet(
+        pretrained=pretrained,
+        progress=progress,
+        checkpoint_path=checkpoint_paths["c2d_r50"],
+        stem_conv_kernel_size=(1, 7, 7),
+        stage1_pool=nn.MaxPool3d,
+        stage_conv_a_kernel_size=(
+            (1, 1, 1),
+            (1, 1, 1),
+            (1, 1, 1),
+            (1, 1, 1),
+        ),
+        **kwargs,
+    )
+
+
+def i3d_r50(
+    pretrained: bool = False, progress: bool = True, **kwargs: Any
+) -> nn.Module:
+    r"""
+    I3D R50 model architecture from [1] with pretrained weights based on 8x8 setting
+    on the Kinetics dataset. Model with pretrained weights has top1 accuracy of 73.27.
+
+    [1] "Quo Vadis, Action Recognition? A New Model and the Kinetics Dataset"
+        Joao Carreira, Andrew Zisserman
+        https://arxiv.org/abs/1705.07750
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on the Kinetics dataset
+        progress (bool): If True, displays a progress bar of the download to stderr
+        kwargs: use these to modify any of the other model settings. All the
+            options are defined in pytorchvideo/models/resnet.py
+
+    NOTE: to use the pretrained model, do not modify the model configuration
+    via the kwargs. Only modify settings via kwargs to initialize a new model
+    without pretrained weights.
+    """
+    return _resnet(
+        pretrained=pretrained,
+        progress=progress,
+        checkpoint_path=checkpoint_paths["i3d_r50"],
+        stem_conv_kernel_size=(5, 7, 7),
+        stage1_pool=nn.MaxPool3d,
+        stage_conv_a_kernel_size=(
+            (3, 1, 1),
+            [(3, 1, 1), (1, 1, 1)],
+            [(3, 1, 1), (1, 1, 1)],
+            [(1, 1, 1), (3, 1, 1)],
+        ),
+        **kwargs,
+    )