Create load_viddiff_dataset.py

load_viddiff_dataset.py

@@ -0,0 +1,368 @@
+import ipdb
+import pdb
+import os
+import numpy as np
+import json
+import re
+from PIL import Image
+from pathlib import Path
+from datasets import load_dataset
+import decord
+from tqdm import tqdm
+import logging
+import hashlib
+
+
+def load_viddiff_dataset(splits=["easy"], subset_mode="0", cache_dir=None, test_new=False):
+    """
+    splits in ['easy', 'medium', 'hard']
+    """
+    if not test_new:    
+        dataset = load_dataset("viddiff/VidDiffBench_2", cache_dir=cache_dir)
+        dataset = dataset['test']
+        valid_splits = set(dataset['split'])
+    else: 
+        dataset = load_dataset("viddiff/VidDiffBench_2", cache_dir=cache_dir)
+        dataset = dataset['test']
+        dataset = dataset.map(lambda example: example.update({'split': example['domain']}) or example)
+        valid_splits = set(dataset['split'])
+
+    def _filter_splits(example):
+        return example["split"] in splits
+
+    dataset = dataset.filter(_filter_splits)
+    if len(dataset) == 0:
+        raise ValueError(
+            f"Dataset empty for splits {splits}. Valid splits {valid_splits}")
+
+    def _map_elements_to_json(example):
+        example["videos"] = json.loads(example["videos"])
+        example["differences_annotated"] = json.loads(
+            example["differences_annotated"])
+        example["differences_gt"] = json.loads(example["differences_gt"])
+        return example
+
+    dataset = dataset.map(_map_elements_to_json)
+    # dataset = dataset.map(_clean_annotations)
+    dataset = apply_subset_mode(dataset, subset_mode)
+
+    dataset = _get_difficulty_splits(dataset)
+
+    return dataset
+
+
+def _get_difficulty_splits(dataset):
+    with open("data/lookup_action_to_split.json", "r") as fp:
+        lookup_action_to_split = json.load(fp)
+
+    def add_split_difficulty(example):
+        example['split_difficulty'] = lookup_action_to_split[example['action']]
+        return example
+
+    dataset = dataset.map(add_split_difficulty)
+    return dataset
+
+
+def load_all_videos(dataset,
+                    cache=True,
+                    cache_dir="cache/cache_data",
+                    overwrite_cache=False,
+                    test_samevideo=0,
+                    test_flipvids=0,
+                    do_tqdm=True):
+    """ 
+    Return a 2-element tuple. Each element is a list of length len(datset). 
+    First list is video A for each datapoint as a dict with elements 
+        path: original path to video 
+        fps: frames per second 
+        video: numpy array of the video shape (nframes,H,W,3)
+    Second list is the same but for video B. 
+
+    Args:
+        cache_dir (str): Directory to store cached video data. Defaults to "cache/cache_data"
+    """
+
+    all_videos = ([], [])
+    # make iterator, with or without tqdm based on `do_tqdm`
+    if do_tqdm:
+        it = tqdm(dataset)
+    else:
+        it = dataset
+
+    # load each video
+    for row in it:
+        videos = get_video_data(row['videos'],
+                              cache=cache,
+                              cache_dir=cache_dir,
+                              overwrite_cache=overwrite_cache)
+
+        video0, video1 = videos[0], videos[1]
+
+        if test_flipvids:
+            video0, video1 = video1, video0
+
+        if not test_samevideo:
+            all_videos[0].append(video0)
+            all_videos[1].append(video1)
+        else:
+            all_videos[0].append(video1)
+            all_videos[1].append(video1)
+
+    return all_videos
+
+
+def _clean_annotations(example):
+    # Not all differences in the taxonomy may have a label available, so filter them.
+
+    differences_gt_labeled = {
+        k: v
+        for k, v in example['differences_gt'].items() if v is not None
+    }
+    differences_annotated = {
+        k: v
+        for k, v in example['differences_annotated'].items()
+        if k in differences_gt_labeled.keys()
+    }
+
+    # Directly assign to the example without deepcopy
+    example['differences_gt'] = differences_gt_labeled
+    example['differences_annotated'] = differences_annotated
+
+    return example
+
+
+def get_video_data(videos: dict, cache=True, cache_dir="cache/cache_data", overwrite_cache=False):
+    """
+    Pass in the videos dictionary from the dataset, like dataset[idx]['videos'].
+    Load the 2 videos represented as numpy arrays. 
+    By default, cache the arrays ... so the second time through, the dataset 
+    loading will be faster. 
+
+    returns: video0, video1
+    """
+    video_dicts = []
+
+    for i in [0, 1]:
+        path = videos[i]['path']
+        assert Path(path).exists(
+        ), f"Video not downloaded [{path}]\nCheck dataset README about downloading videos"
+        frames_trim = slice(*videos[i]['frames_trim'])
+
+        video_dict = videos[i].copy()
+
+        if cache:
+            dir_cache = Path(cache_dir)
+            dir_cache.mkdir(exist_ok=True, parents=True)
+            hash_key = get_hash_key(path + str(frames_trim))
+            memmap_filename = dir_cache / f"memmap_{hash_key}.npy"
+
+            # if not in the cache, and not overwriting, then get OG video
+            if os.path.exists(memmap_filename) and not overwrite_cache:
+                video_info = np.load(f"{memmap_filename}.info.npy",
+                                     allow_pickle=True).item()
+                video = np.memmap(memmap_filename,
+                                  dtype=video_info['dtype'],
+                                  mode='r',
+                                  shape=video_info['shape'])
+                video_dict['video'] = video
+                video_dict['fps'] = video_dict['fps_original'] # since we don't downsample here
+                video_dicts.append(video_dict)
+                continue
+
+        is_dir = Path(path).is_dir()
+        if is_dir:
+            video = _load_video_from_directory_of_images(
+                path, frames_trim=frames_trim)
+
+        else:
+            assert Path(path).suffix in (".mp4", ".mov")
+            video, fps = _load_video(path, frames_trim=frames_trim)
+            assert fps == videos[i]['fps_original']
+
+        if cache:
+            np.save(f"{memmap_filename}.info.npy", {
+                'shape': video.shape,
+                'dtype': video.dtype
+            })
+            memmap = np.memmap(memmap_filename,
+                               dtype=video.dtype,
+                               mode='w+',
+                               shape=video.shape)
+            memmap[:] = video[:]
+            memmap.flush()
+            video = memmap
+
+        video_dict['video'] = video
+        video_dict['fps'] = video_dict['fps_original']
+        video_dicts.append(video_dict)
+
+    return video_dicts
+
+
+def _load_video(f, return_fps=True, frames_trim: slice = None) -> np.ndarray:
+    """ 
+    mp4 video to frames numpy array shape (N,H,W,3).
+    Do not use for long videos
+    frames_trim: (s,e) is start and end int frames to include (warning, the range
+    is inclusive, unlike in list indexing.)
+    """
+    vid = decord.VideoReader(str(f))
+    fps = vid.get_avg_fps()
+
+    if len(vid) > 50000:
+        raise ValueError(
+            "Video probably has too many frames to convert to a numpy")
+
+    if frames_trim is None:
+        frames_trim = slice(0, None, None)
+    video_np = vid[frames_trim].asnumpy()
+
+    if not return_fps:
+        return video_np
+    else:
+        assert fps > 0
+        return video_np, fps
+
+
+def _load_video_from_directory_of_images(
+    path_dir: str,
+    frames_trim: slice = None,
+    downsample_time: int = None,
+) -> np.ndarray:
+    """
+
+    `path_dir` is a directory path with images that, when arranged in alphabetical
+    order, make a video. 
+    This function returns the a numpy array shape (N,H,W,3)  where N is the 
+    number of frames. 
+    """
+    files = sorted(os.listdir(path_dir))
+
+    if frames_trim is not None:
+        files = files[frames_trim]
+
+    if downsample_time is not None:
+        files = files[::downsample_time]
+
+    files = [f"{path_dir}/{f}" for f in files]
+    images = [Image.open(f) for f in files]
+
+    video_array = np.stack(images)
+
+    return video_array
+
+
+def _subsample_video(video: np.ndarray,
+                     fps_original: int,
+                     fps_target: int,
+                     fps_warning: bool = True):
+    """ 
+    video: video as numby array (nframes, h, w, 3)
+    fps_original: original fps of the video 
+    fps_target: target fps to downscale to
+    fps_warning: if True, then log warnings to logger if the target fps is 
+        higher than original fps, or if the target fps isn't possible because 
+        it isn't divisible by the original fps. 
+    """
+    subsample_time = fps_original / fps_target
+
+    if subsample_time < 1 and fps_warning:
+        logging.warning(f"Trying to subsample frames to fps {fps_target}, which "\
+            "is higher than the fps of the original video which is "\
+            "{video['fps']}. The video fps won't be changed for {video['path']}. "\
+            f"\nSupress this warning by setting config fps_warning=False")
+        return video, fps_original, 1
+
+    subsample_time_int = int(subsample_time)
+    fps_new = int(fps_original / subsample_time_int)
+    if fps_new != fps_target and fps_warning:
+        logging.warning(f"Config lmm.fps='{fps_target}' but the original fps is {fps_original} " \
+            f"so we downscale to fps {fps_new} instead. " \
+            f"\nSupress this warning by setting config fps_warning=False")
+
+    video = video[::subsample_time_int]
+
+    return video, fps_new, subsample_time_int
+
+def downsample_videos(dataset, videos, args_fps_inference, fps_warning=True):
+    """To fix some hacky - oOnly called by viddiff_method.run_viddiff.py """
+    for i in range(len(dataset)):
+        row = dataset[i]
+        domain = row['domain']
+        fps_inference = args_fps_inference[domain]
+        video0, video1 = videos[0][i], videos[1][i]
+        for video in (video0, video1):
+            video['video'], fps_new, subsample_time_int = _subsample_video(
+                video['video'], video['fps_original'], fps_inference, fps_warning)
+            video['fps'] = fps_new
+    
+    return videos 
+
+
+def apply_subset_mode(dataset, subset_mode):
+    """ 
+    For example if subset_mode is "3_per_action" then just get the first 3 rows
+    for each unique action. 
+    Useful for working with subsets. 
+    """
+    match = re.match(r"(\d+)_per_action", subset_mode)
+    if match:
+        instances_per_action = int(match.group(1))
+        action_counts = {}
+        subset_indices = []
+
+        for idx, example in enumerate(dataset):
+            action = example['action']
+            if action not in action_counts:
+                action_counts[action] = 0
+
+            if action_counts[action] < instances_per_action:
+                subset_indices.append(idx)
+                action_counts[action] += 1
+
+        return dataset.select(subset_indices)
+    else:
+        return dataset
+
+
+def get_hash_key(key: str) -> str:
+    return hashlib.sha256(key.encode()).hexdigest()
+
+
+def dataset_metrics(dataset):
+    import pandas as pd
+    df = pd.DataFrame(dataset)
+    print("Number of actions ")
+    print(df.groupby(['split'])['action'].nunique())
+    print("Total actions", df['action'].nunique())
+
+    print("Samples by category")
+    print(df.groupby(["split"])['split'].count())
+    print("Total ", len(df))
+    print()
+
+    diffs = []
+    for row in dataset:
+        diff = {
+            k: v
+            for k, v in row['differences_gt'].items() if v is not None
+        }
+        diffs.append(diff)
+    cnts = [len(d) for d in diffs]
+    df['variation_cnts'] = cnts
+    print("Variation counts by category")
+    print(df.groupby(['split'])['variation_cnts'].sum())
+    print("total ", df['variation_cnts'].sum())
+
+
+    print()
+
+
+if __name__ == "__main__":
+    # these are the 3 data loading commands
+    splits = ['ballsports', 'fitness', 'diving', 'music', 'surgery']
+    dataset = load_viddiff_dataset(splits=splits)
+    metrics = dataset_metrics(dataset)
+
+    videos = load_all_videos(dataset)
+    n_differences = lvd.get_n_differences(dataset, "data/n_differences.json")