ego4d dataset download

.gitignore

@@ -1,5 +1,5 @@
 lvos/frames/
 ego4d/frames/
-lvos/lvos_temp/
-lvos/lvos_train/
-lvos/train
+
+*.pyc
+__pycache__/

README.md

@@ -26,10 +26,15 @@ bash lvos/install_lvos.sh
 
 3. Next, install the Ego4D portion of the dataset. Note that you have need access to obtain access to Ego4D data. License requests can take a few hours to a few days, and can be obtained here:  https://ego4d-data.org/docs/start-here/
 
+Make sure that you have the ego4d CLI installed by running:
 ```
-bash ego4d/install_ego4d.sh
+pip install ego4d
 ```
 
+```
+bash ego4d/install_ego4d.sh
+```
+## loading data:
 We provide a dataloader script: 
 ```
 python check_dataloader.py

check_dataloader.py

@@ -2,44 +2,38 @@ import os
 
 from dataloaders.mosedataloader import MoseTrackDataLoader
 from dataloaders.lvosdataloader import LVOSTrackDataLoader
-
-# from dataloaders.ego4ddataloader import Ego4DTrackDataLoader
+from dataloaders.egoloader import Ego4DTrackDataLoader
 
 data_root = "/data/ilona/datasets/itto_release/itto"
 
-for dataset_type in ["mose", "lvos"]:
+for dataset_type in ["ego4d", "mose", "lvos"]:
+    annotation_dir = os.path.join(data_root, dataset_type, "annotations")
+    video_id_list = os.listdir(os.path.join(data_root, dataset_type, "frames"))
+    video_dir = os.path.join(data_root, dataset_type, "frames")
+
     if dataset_type == "mose":
         print("checking MOSE dataset portion")
-        video_id_list = os.listdir(
-            os.path.join(data_root, dataset_type, "frames")
-        )
         loader = MoseTrackDataLoader(
             video_ids=video_id_list,
-            annotation_dir=os.path.join(data_root, dataset_type, "annotations"),
-            video_dir=os.path.join(data_root, dataset_type, "frames"),
+            annotation_dir=annotation_dir,
+            video_dir=video_dir,
             device="cpu",
         )
     elif dataset_type == "lvos":
         print("checking LVOS dataset portion")
-        video_id_list = os.listdir(
-            os.path.join(data_root, dataset_type, "frames")
-        )
         loader = LVOSTrackDataLoader(
             video_ids=video_id_list,
-            annotation_dir=os.path.join(data_root, dataset_type, "annotations"),
-            video_dir=os.path.join(data_root, dataset_type, "frames"),
+            annotation_dir=annotation_dir,
+            video_dir=video_dir,
             device="cpu",
         )
 
     elif dataset_type == "ego4d":
         print("checking EGO4D dataset portion")
-        video_id_list = os.listdir(
-            "/data/ilona/code/tracking-benchmark-dataset/model_eval_scripts/tool_annotations/ego4d_tool_annotations/"
-        )
         loader = Ego4DTrackDataLoader(
             video_ids=video_id_list,
-            annotation_dir="/data/ilona/code/tracking-benchmark-dataset/model_eval_scripts/video_tool_annots/ego4d_npz/",
-            video_dir="/data/ilona/datasets/ego4d/ego4d_chosen_videos/",
+            annotation_dir=annotation_dir,
+            video_dir=video_dir,
             device="cpu",
         )
 

dataloaders/egoloader.py

@@ -0,0 +1,137 @@
+from .mosedataloader import MoseTrackDataLoader, load_mose_video
+import os
+import torch
+import numpy as np
+from typing import List
+from PIL import Image
+import sys
+import pdb
+
+
+class Ego4DTrackDataLoader(MoseTrackDataLoader):
+    def __init__(
+        self,
+        video_ids: List[str],
+        annotation_dir: str,
+        video_dir: str,
+        device: str = "cuda:0",
+    ):
+        super().__init__(video_ids, annotation_dir, video_dir, device)
+
+    def _create_queries(
+        self, tracks: torch.Tensor, gt_vis: torch.Tensor
+    ) -> torch.Tensor:
+        B, N, T, _ = tracks.shape
+
+        # Find the first frame where visibility is True
+        first_visible_mask = gt_vis.bool()
+
+        query_frames = torch.zeros((B, N), dtype=torch.long, device=self.device)
+
+        for b in range(B):
+            for n in range(N):
+                visible_indices = torch.nonzero(
+                    first_visible_mask[b, n], as_tuple=False
+                )
+                if visible_indices.numel() > 0:
+                    query_frames[b, n] = visible_indices[0].item()
+                else:
+                    query_frames[b, n] = 0  # fallback
+
+        query_coords = tracks[
+            torch.arange(B)[:, None], torch.arange(N)[None, :], query_frames
+        ]
+
+        return torch.stack(
+            [
+                query_frames.float(),
+                query_coords[:, :, 0],
+                query_coords[:, :, 1],
+            ],
+            dim=2,
+        )
+
+    def get(self, video_id: str):
+        if video_id not in self.videos:
+            grad_file = os.path.join(
+                self.annotation_dir, f"{video_id}/{video_id}_gradient.npy"
+            )
+            rand_file = os.path.join(
+                self.annotation_dir, f"{video_id}/{video_id}_random.npy"
+            )
+            bcknd_file = os.path.join(
+                self.annotation_dir, f"{video_id}/{video_id}_background.npy"
+            )
+
+            use_bcknd, use_rand, use_grad = True, True, True
+            if os.path.exists(bcknd_file):
+                bcknd_annots = self._load_annotations(bcknd_file)  # N1, T, 4
+                _, T, _ = bcknd_annots.shape
+            else:
+                use_bcknd = False
+                print(f"no background file for {video_id} found !!")
+
+            if os.path.exists(rand_file):
+                rand_annots = self._load_annotations(rand_file)  # N2, T, 4
+                _, T, _ = rand_annots.shape
+            else:
+                print(f"no random queries file for {video_id} found !!")
+                use_rand = False
+
+            if os.path.exists(grad_file):
+                grad_annots = self._load_annotations(grad_file)  # N3, T, 4
+                _, T, _ = grad_annots.shape
+            else:
+                use_grad = False
+
+            # creates empty tensors if those files aren't used
+            if not use_bcknd:
+                bcknd_annots = torch.empty((0, T, 4), dtype=torch.float32)
+            if not use_rand:
+                rand_annots = torch.empty((0, T, 4), dtype=torch.float32)
+            if not use_grad:
+                grad_annots = torch.empty((0, T, 4), dtype=torch.float32)
+
+            grad_tracks = grad_annots[:, :, :2].unsqueeze(0)
+            rand_tracks = rand_annots[:, :, :2].unsqueeze(0)
+            bcknd_tracks = bcknd_annots[:, :, :2].unsqueeze(0)
+
+            grad_vis = grad_annots[:, :, 2].unsqueeze(0).to(self.device)
+            rand_vis = rand_annots[:, :, 2].unsqueeze(0).to(self.device)
+            bcknd_vis = bcknd_annots[:, :, 2].unsqueeze(0).to(self.device)
+
+            gt_tracks = torch.cat(
+                [grad_tracks, rand_tracks, bcknd_tracks],
+                dim=1,
+            )  # 1, (N1+N2+N3), T, 2
+            gt_vis = torch.cat(
+                [grad_vis, rand_vis, bcknd_vis],
+                dim=1,
+            )  # 1, (N1+N2+N3), T, 1
+            queries = self._create_queries(
+                gt_tracks, gt_vis
+            )  # 1, (N1+N2+N3), 3
+
+            video_folder = os.path.join(self.video_dir, video_id)
+            video_tensor = load_mose_video(video_folder)  # keep on CPU
+
+            self.grad_tracks[video_id] = grad_tracks
+            self.rand_tracks[video_id] = rand_tracks
+            self.bcknd_tracks[video_id] = bcknd_tracks
+            self.gt_tracks[video_id] = gt_tracks
+
+            self.grad_vis[video_id] = grad_vis
+            self.rand_vis[video_id] = rand_vis
+            self.bcknd_vis[video_id] = bcknd_vis
+            self.gt_vis[video_id] = gt_vis
+
+            self.queries[video_id] = queries
+            self.videos[video_id] = video_tensor
+
+        return {
+            "video_id": video_id,
+            "video": self.videos[video_id],
+            "gt_tracks": self.gt_tracks[video_id],
+            "gt_vis": self.gt_vis[video_id],
+            "queries": self.queries[video_id],
+        }

dataloaders/lvosdataloader.py

@@ -1,4 +1,3 @@
-# from .mosedataloader import MoseTrackDataLoader, load_mose_video
 from .mosedataloader import MoseTrackDataLoader, load_mose_video
 import os
 import torch
@@ -8,60 +7,16 @@ from PIL import Image
 import sys
 import pdb
 
-import torch
-from typing import List
-from .mosedataloader import MoseTrackDataLoader
-
 
 class LVOSTrackDataLoader(MoseTrackDataLoader):
-
     def __init__(
         self,
         video_ids: List[str],
         annotation_dir: str,
         video_dir: str,
         device: str = "cuda:0",
-        load_video: bool = True,
     ):
-        # Forward load_video flag to base class
-        super().__init__(
-            video_ids, annotation_dir, video_dir, device, load_video
-        )
-
-        # Initialize caches for get()
-        self.videos = {}
-        self.gt_tracks = {}
-        self.gt_vis = {}
-        self.queries = {}
-        self.grad_tracks = {}
-        self.rand_tracks = {}
-        self.bcknd_tracks = {}
-        self.grad_vis = {}
-        self.rand_vis = {}
-        self.bcknd_vis = {}
-
-        self.load_video = load_video
-
-    def _load_annotations(self, path: str) -> torch.Tensor:
-        """
-        Load a .npy annotation and return a Tensor of shape [N, T, 4]:
-          - [:,:,:2] = (x,y) track coords
-          - [:,:,2]  = visibility mask (0/1)
-          - [:,:,3]  = zeros (unused)
-        """
-        a = np.load(path)
-        if a.ndim == 3 and a.shape[-1] >= 4:
-            arr = a[..., :4]
-        elif a.ndim == 3 and a.shape[-1] == 2:
-            tracks = a.astype(np.float32)
-            vis = np.ones(tracks.shape[:2], dtype=np.float32)[..., None]
-            zeros = np.zeros(tracks.shape[:2] + (1,), dtype=np.float32)
-            arr = np.concatenate([tracks, vis, zeros], axis=2)
-        else:
-            raise ValueError(
-                f"[Ego4DLoader] Unexpected annotation shape {a.shape}"
-            )
-        return torch.from_numpy(arr).to(self.device)
+        super().__init__(video_ids, annotation_dir, video_dir, device)
 
     def _create_queries(
         self, tracks: torch.Tensor, gt_vis: torch.Tensor
@@ -97,100 +52,69 @@ class LVOSTrackDataLoader(MoseTrackDataLoader):
         )
 
     def get(self, video_id: str):
-        """
-        Returns dict with:
-          - video_id: str
-          - video:    Tensor [T,3,H,W] or None
-          - gt_tracks: Tensor [1, N, T, 2]
-          - gt_vis:    Tensor [1, N, T]
-          - queries:   Tensor [1, N, 3]
-        Caches results to avoid reloading on subsequent calls.
-        """
         if video_id not in self.videos:
-            # Paths for each query type
             grad_file = os.path.join(
-                self.annotation_dir, video_id, f"{video_id}_gradient.npy"
+                self.annotation_dir, f"{video_id}/{video_id}_gradient.npy"
             )
             rand_file = os.path.join(
-                self.annotation_dir, video_id, f"{video_id}_random.npy"
+                self.annotation_dir, f"{video_id}/{video_id}_random.npy"
             )
             bcknd_file = os.path.join(
-                self.annotation_dir, video_id, f"{video_id}_background.npy"
+                self.annotation_dir, f"{video_id}/{video_id}_background.npy"
             )
 
-            # Load any existing annotation arrays and record their length T
-            Ts, data = [], {}
-            for key, path in [
-                ("grad", grad_file),
-                ("rand", rand_file),
-                ("bcknd", bcknd_file),
-            ]:
-                if os.path.exists(path):
-                    arr = self._load_annotations(path)  # [N, T, 4]
-                    Ts.append(arr.shape[1])
-                    data[key] = arr
-                else:
-                    data[key] = None
+            use_bcknd, use_rand, use_grad = True, True, True
+            if os.path.exists(bcknd_file):
+                bcknd_annots = self._load_annotations(bcknd_file)  # N1, T, 4
+                _, T, _ = bcknd_annots.shape
+            else:
+                use_bcknd = False
+                print(f"no background file for {video_id} found !!")
+
+            if os.path.exists(rand_file):
+                rand_annots = self._load_annotations(rand_file)  # N2, T, 4
+                _, T, _ = rand_annots.shape
+            else:
+                print(f"no random queries file for {video_id} found !!")
+                use_rand = False
+
+            if os.path.exists(grad_file):
+                grad_annots = self._load_annotations(grad_file)  # N3, T, 4
+                _, T, _ = grad_annots.shape
+            else:
+                use_grad = False
+
+            # creates empty tensors if those files aren't used
+            if not use_bcknd:
+                bcknd_annots = torch.empty((0, T, 4), dtype=torch.float32)
+            if not use_rand:
+                rand_annots = torch.empty((0, T, 4), dtype=torch.float32)
+            if not use_grad:
+                grad_annots = torch.empty((0, T, 4), dtype=torch.float32)
+
+            grad_tracks = grad_annots[:, :, :2].unsqueeze(0)
+            rand_tracks = rand_annots[:, :, :2].unsqueeze(0)
+            bcknd_tracks = bcknd_annots[:, :, :2].unsqueeze(0)
+
+            grad_vis = grad_annots[:, :, 2].unsqueeze(0).to(self.device)
+            rand_vis = rand_annots[:, :, 2].unsqueeze(0).to(self.device)
+            bcknd_vis = bcknd_annots[:, :, 2].unsqueeze(0).to(self.device)
 
-            if not Ts:
-                raise FileNotFoundError(
-                    f"No annotation files found for {video_id}"
-                )
-            T = Ts[0]  # assume consistent length
-
-            # Prepare placeholders for missing types
-            grad_annots = (
-                data["grad"]
-                if data["grad"] is not None
-                else torch.empty(
-                    (0, T, 4), dtype=torch.float32, device=self.device
-                )
-            )
-            rand_annots = (
-                data["rand"]
-                if data["rand"] is not None
-                else torch.empty(
-                    (0, T, 4), dtype=torch.float32, device=self.device
-                )
-            )
-            bcknd_annots = (
-                data["bcknd"]
-                if data["bcknd"] is not None
-                else torch.empty(
-                    (0, T, 4), dtype=torch.float32, device=self.device
-                )
-            )
-
-            # Split coords vs. vis
-            grad_tracks = grad_annots[..., :2].unsqueeze(0)  # [1, N1, T, 2]
-            rand_tracks = rand_annots[..., :2].unsqueeze(0)  # [1, N2, T, 2]
-            bcknd_tracks = bcknd_annots[..., :2].unsqueeze(0)  # [1, N3, T, 2]
-
-            grad_vis = grad_annots[..., 2].unsqueeze(0)  # [1, N1, T]
-            rand_vis = rand_annots[..., 2].unsqueeze(0)  # [1, N2, T]
-            bcknd_vis = bcknd_annots[..., 2].unsqueeze(0)  # [1, N3, T]
-
-            # Concatenate all queries
             gt_tracks = torch.cat(
-                [grad_tracks, rand_tracks, bcknd_tracks], dim=1
-            )  # [1, N, T, 2]
+                [grad_tracks, rand_tracks, bcknd_tracks],
+                dim=1,
+            )  # 1, (N1+N2+N3), T, 2
             gt_vis = torch.cat(
-                [grad_vis, rand_vis, bcknd_vis], dim=1
-            )  # [1, N, T]
-
+                [grad_vis, rand_vis, bcknd_vis],
+                dim=1,
+            )  # 1, (N1+N2+N3), T, 1
             queries = self._create_queries(
                 gt_tracks, gt_vis
             )  # 1, (N1+N2+N3), 3
 
-            # Load video frames if requested
-            video_tensor = None
-            if self.load_video:
-                vid_folder = os.path.join(self.video_dir, video_id)
-                video_tensor = load_mose_video(vid_folder).to(
-                    self.device
-                )  # [T,3,H,W]
+            video_folder = os.path.join(self.video_dir, video_id)
+            video_tensor = load_mose_video(video_folder)  # keep on CPU
 
-            # Cache for future calls
             self.grad_tracks[video_id] = grad_tracks
             self.rand_tracks[video_id] = rand_tracks
             self.bcknd_tracks[video_id] = bcknd_tracks

dataloaders/mosedataloader.py

@@ -1,24 +1,37 @@
-#!/usr/bin/env python3
-"""
-MoseTrackDataLoader — loads GT, visibility, queries for MOSE; skip video if desired.
-"""
 import os
 import torch
 import numpy as np
 from typing import List
 from PIL import Image
+import sys
 
+# sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+# from utils import load_mose_video
 
-def load_mose_video(folder: str) -> torch.Tensor:
-    files = sorted(
-        f for f in os.listdir(folder) if f.lower().endswith((".png", ".jpg"))
-    )
-    imgs = []
-    for fn in files:
-        im = Image.open(os.path.join(folder, fn)).convert("RGB")
-        arr = np.array(im).transpose(2, 0, 1).astype(np.float32)
-        imgs.append(arr)
-    return torch.from_numpy(np.stack(imgs, 0))
+
+# eek redundant... TODO(ilona) figure out importing of from utils here
+def load_mose_video(video_folder):
+    files = [f for f in os.listdir(video_folder) if f.endswith(".jpg")]
+    files = sorted(files, key=lambda x: int(os.path.splitext(x)[0]))
+
+    frames = []  # list to collect each image tensor
+
+    # print(files)
+    for filename in files:
+        filepath = os.path.join(video_folder, filename)
+        # Open image and ensure it's in RGB mode
+        img = Image.open(filepath).convert("RGB")
+        # Convert the image to a NumPy array of shape (H, W, 3)
+        img_np = np.array(img)
+        # Convert to (3, H, W) by reordering the axes
+        img_np = np.transpose(img_np, (2, 0, 1))
+        frames.append(img_np)
+
+    video_np = np.stack(frames, axis=0)
+    video_tensor = torch.from_numpy(video_np).float()
+
+    # [T, 3, H, W]
+    return video_tensor
 
 
 class MoseTrackDataLoader:
@@ -28,13 +41,29 @@ class MoseTrackDataLoader:
         annotation_dir: str,
         video_dir: str,
         device: str = "cuda:0",
-        load_video: bool = True,
     ):
         self.video_ids = video_ids
         self.annotation_dir = annotation_dir
         self.video_dir = video_dir
         self.device = torch.device(device)
-        self.load_video = load_video
+
+        self.grad_tracks = {}
+        self.rand_tracks = {}
+        self.bcknd_tracks = {}
+        self.gt_tracks = {}
+
+        self.grad_vis = {}
+        self.rand_vis = {}
+        self.bcknd_vis = {}
+        self.gt_vis = {}
+
+        self.queries = {}
+        self.videos = {}
+
+    def _load_annotations(self, file_path: str) -> torch.Tensor:
+        return torch.tensor(
+            np.load(file_path), dtype=torch.float32
+        )  # [N, T, 4]
 
     def _create_queries(self, tracks: torch.Tensor) -> torch.Tensor:
         B, N, T, _ = tracks.shape
@@ -46,49 +75,81 @@ class MoseTrackDataLoader:
         )
 
     def get(self, video_id: str):
-        types = ["gradient", "random", "background"]
-        tracks_list, vis_list = [], []
-        for t in types:
-            path = os.path.join(
-                self.annotation_dir, video_id, f"{video_id}_{t}.npy"
+        
+        if video_id not in self.videos:
+            # Load annotations
+            grad_file = os.path.join(
+                self.annotation_dir, f"{video_id}/{video_id}_gradient.npy"
+            )
+            rand_file = os.path.join(
+                self.annotation_dir, f"{video_id}/{video_id}_random.npy"
             )
-            if not os.path.exists(path):
-                continue
-            arr = np.load(path)
-            if arr.ndim == 3 and arr.shape[-1] >= 4:
-                tr = arr[..., :2].astype(np.float32)
-                vi = arr[..., 2].astype(bool)
+            bcknd_file = os.path.join(
+                self.annotation_dir, f"{video_id}/{video_id}_background.npy"
+            )
+
+            grad_annots = self._load_annotations(grad_file)
+            rand_annots = self._load_annotations(rand_file)
+            if os.path.exists(bcknd_file):
+                bcknd_annots = self._load_annotations(bcknd_file)  # N1, T, 4
             else:
-                tr = arr.astype(np.float32)
-                vi = np.ones(arr.shape[:2], bool)
-
-            # now tr: [N, T, 2], vi: [N, T]
-            tr_ten = (
-                torch.from_numpy(tr).to(self.device).unsqueeze(0)
-            )  # [1, N, T, 2]
-            vi_ten = (
-                torch.from_numpy(vi).to(self.device).unsqueeze(0)
-            )  # [1, N, T]
-            tracks_list.append(tr_ten)
-            vis_list.append(vi_ten)
-
-        # concatenate along track-dimension
-        gt_tracks = torch.cat(tracks_list, dim=1)  # [1, sum_N, T, 2]
-        gt_vis = torch.cat(vis_list, dim=1)  # [1, sum_N, T]
-
-        # queries: [1, sum_N, 3]
-        queries = self._create_queries(gt_tracks)
-
-        # optionally load video frames
-        video_tensor = None
-        if self.load_video:
-            folder = os.path.join(self.video_dir, video_id)
-            video_tensor = load_mose_video(folder).to(self.device)  # [T,3,H,W]
+                _, T, _ = grad_annots.shape
+                bcknd_annots = torch.empty((0, T, 4), dtype=torch.float32)
+
+            grad_tracks = grad_annots[:, :, :2].unsqueeze(0)
+            rand_tracks = rand_annots[:, :, :2].unsqueeze(0)
+            bcknd_tracks = bcknd_annots[:, :, :2].unsqueeze(0)
+
+            grad_vis = grad_annots[:, :, 2].unsqueeze(0)
+            rand_vis = rand_annots[:, :, 2].unsqueeze(0)
+            bcknd_vis = bcknd_annots[:, :, 2].unsqueeze(0)
+
+            gt_tracks = torch.cat(
+                [grad_tracks, rand_tracks, bcknd_tracks], dim=1
+            )
+            gt_vis = torch.cat([grad_vis, rand_vis, bcknd_vis], dim=1)
+            queries = self._create_queries(gt_tracks)
+
+            video_folder = os.path.join(self.video_dir, video_id)
+            video_tensor = load_mose_video(video_folder)
+
+            # Store in memory if needed
+            self.grad_tracks[video_id] = grad_tracks
+            self.rand_tracks[video_id] = rand_tracks
+            self.bcknd_tracks[video_id] = bcknd_tracks
+            self.gt_tracks[video_id] = gt_tracks
+
+            self.grad_vis[video_id] = grad_vis
+            self.rand_vis[video_id] = rand_vis
+            self.bcknd_vis[video_id] = bcknd_vis
+            self.gt_vis[video_id] = gt_vis
+
+            self.queries[video_id] = queries
+            self.videos[video_id] = video_tensor
 
         return {
             "video_id": video_id,
-            "video": video_tensor,
-            "gt_tracks": gt_tracks,
-            "gt_vis": gt_vis,
-            "queries": queries,
+            "video": self.videos[video_id],
+            "gt_tracks": self.gt_tracks[video_id],
+            "gt_vis": self.gt_vis[video_id],
+            "queries": self.queries[video_id],
         }
+
+
+# debugging
+if __name__ == "__main__":
+
+    video_id_list = os.listdir(f"video_tool_annots/mose_npz")
+    video_id_list = list(set(v.split("_")[0] for v in video_id_list))
+
+    loader = MoseTrackDataLoader(
+        video_ids=video_id_list,
+        annotation_dir=f"video_tool_annots/mose_npz",
+        video_dir="/data/ilona/datasets/mose/mose_train/JPEGImages",
+        device="cpu",
+    )
+
+    data = loader.get("03e5f069")
+    print(data["video"].shape)  # [T, 3, H, W]
+    print(data["gt_tracks"].shape)  # [1, N, T, 2]
+    print(data["queries"].shape)  # [1, N, 3]

ego4d/install_ego4d.sh

@@ -0,0 +1,30 @@
+################## ilona command line history ##################
+ 
+conda create -n ego4d-py312 python=3.12.7 -y
+
+conda activate ego4d-py312
+
+python -m pip install --upgrade pip setuptools wheel
+
+pip install ego4d
+pip install torch torchvision
+pip install av
+
+cd ego4d
+
+# TODO: this part doesn't work at the moment
+ego4d \
+  --datasets full_scale \
+  --video_uid_file video_uids.txt \
+  --aws_profile_name ego4d \
+  --output_directory ego4d_full_videos/ \
+  -y
+
+# loads the metadata
+python process_ego4d_videos.py
+
+rm -rf ego4d_full_videos
+
+
+################################################################
+

ego4d/process_ego4d_videos.py

@@ -33,7 +33,7 @@ for json_file in json_list:
 
     # save paths
     video_path = f"ego4d_videos/v2/full_scale/{video_id}.mp4"
-    save_dir = f"ego4d_chosen_videos/{video_name}"
+    save_dir = f"frames/{video_name}"
 
     print("\n PROCESSING VIDEO ", video_name)
 
@@ -56,13 +56,13 @@ for json_file in json_list:
 
     print(f"Saved {len(cropped_vid)} frames to {save_dir}")
 
-    # TODO(ilona) - remove this later
-    # checks that current dataset aligns with the files that we have !! 
+    # # TODO(ilona) - remove this later
+    # # checks that current dataset aligns with the files that we have !! 
     # for frame_number in [f"{i:06d}" for i in range(0, num_output_frames)]:
     #     paths = [
-    #         # f"/data/ilona/datasets/ego4d/ego4d_chosen_videos/{video_name}/rgb_frames/{frame_number}.jpg",
     #         f"/data/ilona/datasets/ego4d/ego4d_chosen_videos/{video_name}/rgb_frames/{frame_number}.jpg",
-    #         f"/data/ilona/datasets/itto_release/itto/ego4d/ego4d_chosen_videos/{video_name}/{frame_number}.jpg",
+    #         # f"/data/ilona/datasets/go4d/frames/{video_name}/rgb_frames/{frame_number}.jpg",
+    #         f"/data/ilona/datasets/itto_release/itto/ego4d/frames/{video_name}/{frame_number}.jpg",
     #     ]
 
     #     # Load images

ego4d/video_uids.txt

@@ -1,3 +1,4 @@
+f42ae9c2-d43e-45af-8adb-02d0b16b2ef7
 c6047868-51a3-4bb8-b833-5453c1fa563c
 d40be91b-85bb-4c47-ac18-52c4d044e3fc
 3ae87694-c71b-4564-9aea-8d65ba9cc19d
@@ -18,7 +19,6 @@ be462bcf-13ad-446a-8dfb-248cb2e3417a
 426eb9d9-d4cf-4acc-9efb-979f61a5be91
 fa6386e1-82ba-4c67-b217-e11640546582
 366b71ad-3f35-4704-b6ef-e793c7e73ac6
-f42ae9c2-d43e-45af-8adb-02d0b16b2ef7
 04046863-98c0-42a8-90f9-4191013cc252
 127392a3-036a-4af6-9db9-ca00141229db
 4675859e-620c-493a-b1e7-27c347074783