weikaih/ego4d-random-views-20k

Ego4D Random Views Dataset

This dataset contains 20,000 random view frames sampled from the Ego4D dataset using a high-performance multi-process generation system.

Dataset Overview

• Total Images: 20,000 high-quality frames
• Image Format: PNG (1024×1024 resolution)
• Source: Ego4D v2 dataset (52,665+ video files)
• Sampling Method: Multi-process random sampling with maximum diversity
• Generation Time: 797.57 seconds (~13 minutes)
• Generation Speed: 25.08 frames/second
• Success Rate: 100.0%

Key Features

🎬 Maximum Diversity: Sampled from 50,000+ different Ego4D videos
🚀 High Performance: Generated using 128 parallel workers
📊 Complete Metadata: Full metadata for each frame including video source, timestamp, etc.
🎯 High Quality: 1024×1024 resolution PNG images
💾 Efficient Storage: Stored in parquet format for fast loading
🔍 Rich Context: Each frame includes video UID, timestamp, and source information

Dataset Schema

Each sample contains:

Field	Type	Description
image	Image	The frame image (1024×1024 PNG)
frame_id	string	Unique frame identifier
video_uid	string	Original Ego4D video UID
video_filename	string	Source video filename
video_path	string	Full path to source video
frame_idx	int32	Frame index in original video
total_frames	int32	Total frames in source video
timestamp_sec	float32	Timestamp in video (seconds)
fps	float32	Video frame rate
worker_id	int32	Generation worker ID
generated_at	string	Generation timestamp
image_width	int32	Image width (1024)
image_height	int32	Image height (1024)
original_shape_*	int32	Original video frame dimensions

Usage

Quick Start

from datasets import load_dataset

# Load the dataset
dataset = load_dataset("weikaih/ego4d-random-views-20k")

# Get a sample
sample = dataset['train'][0]
image = sample['image']  # PIL Image
print(f"Video: {sample['video_filename']}")
print(f"Timestamp: {sample['timestamp_sec']:.2f}s")

Exploring the Data

import matplotlib.pyplot as plt

# Display a sample image
sample = dataset['train'][42]
plt.figure(figsize=(10, 6))

plt.subplot(1, 2, 1)
plt.imshow(sample['image'])
plt.title(f"Frame from {sample['video_uid'][:8]}...")
plt.axis('off')

plt.subplot(1, 2, 2)
plt.text(0.1, 0.8, f"Video: {sample['video_filename'][:30]}...")
plt.text(0.1, 0.7, f"Timestamp: {sample['timestamp_sec']:.2f}s")
plt.text(0.1, 0.6, f"Frame: {sample['frame_idx']}/{sample['total_frames']}")
plt.text(0.1, 0.5, f"FPS: {sample['fps']}")
plt.axis('off')
plt.show()

PyTorch Integration

import torch
from torch.utils.data import DataLoader
from torchvision import transforms

# Define transforms
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                       std=[0.229, 0.224, 0.225])
])

# Custom dataset class
class Ego4DDataset(torch.utils.data.Dataset):
    def __init__(self, hf_dataset, transform=None):
        self.dataset = hf_dataset
        self.transform = transform
    
    def __len__(self):
        return len(self.dataset)
    
    def __getitem__(self, idx):
        sample = self.dataset[idx]
        image = sample['image']
        
        if self.transform:
            image = self.transform(image)
        
        return image, sample

# Create dataset and dataloader
pytorch_dataset = Ego4DDataset(dataset['train'], transform=transform)
dataloader = DataLoader(pytorch_dataset, batch_size=32, shuffle=True)

# Training loop example
for batch_idx, (images, metadata) in enumerate(dataloader):
    # Your training code here
    print(f"Batch {batch_idx}: {images.shape}")
    if batch_idx >= 2:  # Just show first few batches
        break

Data Analysis

import pandas as pd
from collections import Counter

# Convert to pandas for analysis
data = []
for sample in dataset['train']:
    data.append({
        'video_uid': sample['video_uid'],
        'timestamp_sec': sample['timestamp_sec'],
        'fps': sample['fps'],
        'total_frames': sample['total_frames'],
        'worker_id': sample['worker_id']
    })

df = pd.DataFrame(data)

# Basic statistics
print(f"Unique videos: {df['video_uid'].nunique()}")
print(f"Average FPS: {df['fps'].mean():.2f}")
print(f"Timestamp range: {df['timestamp_sec'].min():.2f}s - {df['timestamp_sec'].max():.2f}s")

# Video distribution
video_counts = Counter(df['video_uid'])
print(f"Samples per video - Min: {min(video_counts.values())}, Max: {max(video_counts.values())}")

Applications

This dataset is suitable for:

• Egocentric vision research: First-person view understanding
• Activity recognition: Daily activity classification
• Object detection: Objects in natural settings
• Scene understanding: Indoor/outdoor scene analysis
• Transfer learning: Pre-training for egocentric tasks
• Multi-modal learning: Combining with video metadata
• Temporal analysis: Using timestamp information

Generation Statistics

• Target Frames: 20,000
• Generated Frames: 20,000
• Success Rate: 100.0%
• Generation Time: 13.3 minutes
• Workers Used: 128
• Processing Speed: 25.08 frames/second
• Source Videos: 52,665+ Ego4D video files
• Diversity: Maximum diversity through distributed sampling

Technical Details

Sampling Strategy

• Random Selection: Both video and frame positions randomly sampled
• Worker Distribution: Videos distributed across 128 workers for diversity
• Quality Control: Automatic validation and error recovery
• Metadata Preservation: Complete provenance tracking

Data Quality

• Image Quality: All frames validated during generation
• Resolution: Consistent 1024×1024 PNG format
• Color Space: RGB color space
• Compression: PNG lossless compression
• Metadata Completeness: 100% metadata coverage

Citation

If you use this dataset, please cite the original Ego4D paper:

@inproceedings{grauman2022ego4d,
  title={Ego4d: Around the world in 3,000 hours of egocentric video},
  author={Grauman, Kristen and Westbury, Andrew and Byrnes, Eugene and others},
  booktitle={Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition},
  pages={18211--18230},
  year={2022}
}

License

This dataset follows the same license terms as the original Ego4D dataset. Please refer to the Ego4D license for usage terms.

Dataset Creation

This dataset was generated using a high-performance multi-process sampling system designed for maximum diversity and efficiency. The generation process:

1. Video Indexing: Scanned 52,665+ Ego4D video files
2. Distributed Sampling: Used 128 parallel workers for maximum diversity
3. Quality Assurance: Validated each frame during generation
4. Metadata Collection: Captured complete provenance information
5. Efficient Upload: Used HuggingFace datasets library with parquet format

For more details on the generation process, see the technical documentation.