Upload folder using huggingface_hub

.gitignore

@@ -1,3 +1,5 @@
-export_via_to_csv.py
-create_splits.py
 CLAUDE.md
+create_demographic_plots.py
+create_splits.py
+export_via_to_csv.py
+extract_jsonl_metadata.py

README.md

@@ -19,6 +19,11 @@ configs:
     default: true
     description: "Temporal segment labels for all videos. Load splits to get train/val/test paths."
 
+  - config_name: metadata
+    data_files:
+      - videos/metadata.csv
+    description: "Video level metadata."
+
   - config_name: random
     data_files:
       - split: train
@@ -35,6 +40,8 @@ configs:
 
 This repository contains temporal segment annotations for WanFall, a synthetic activity recognition dataset focused on fall detection and related activities of daily living.
 
+**This dataset is currently under development and subject to change!**
+
 ## Overview
 
 WanFall is a large-scale synthetic dataset designed for activity recognition research, with emphasis on fall detection and posture transitions. The dataset features computer-generated videos of human actors performing various activities in controlled virtual environments.
@@ -50,7 +57,7 @@ WanFall is a large-scale synthetic dataset designed for activity recognition res
 
 - **Total videos**: 12,000
 - **Total temporal segments**: 19,228
-- **Annotation format**: Temporal segmentation (start/end timestamps)
+- **Annotation format**: Temporal segmentation (start/end timestamps) with rich metadata
 - **Video duration**: 5.0625 seconds per clip
 - **Frame count**: 81 frames per video
 - **Frame rate**: 16 fps
@@ -58,6 +65,7 @@ WanFall is a large-scale synthetic dataset designed for activity recognition res
   - Train: 9,600 videos
   - Validation: 1,200 videos
   - Test: 1,200 videos
+- **Metadata fields**: 12 demographic and scene attributes per video
 
 ## Activity Categories
 
@@ -81,35 +89,39 @@ The dataset includes **16 activity classes** organized into dynamic actions and
 - **14. crawl** - Crawling movement on hands and knees
 - **15. jump** - Jumping action
 
-## Structure
-
-The repository is organized as follows:
-
-- `labels/` - CSV files containing temporal segment annotations
-  - `wanfall.csv` - All temporal segments for the dataset
-  - `label2id.csv` - Mapping of activity names to integer IDs
-- `splits/` - Train/validation/test split definitions
-  - `train.csv` - Training set video paths (80%)
-  - `val.csv` - Validation set video paths (10%)
-  - `test.csv` - Test set video paths (10%)
-
 ### Label Format
 
-The `labels/wanfall.csv` file follows this format:
+The `labels/wanfall.csv` file contains temporal segments with rich metadata:
 
-```
-path,label,start,end,subject,cam,dataset
+```csv
+path,label,start,end,subject,cam,dataset,age_group,gender_presentation,monk_skin_tone,race_ethnicity_omb,bmi_band,height_band,environment_category,camera_shot,speed,camera_elevation,camera_azimuth,camera_distance
 ```
 
-Where:
+**Core Fields:**
 - `path`: Relative path to the video (without .mp4 extension, e.g., "fall/fall_ch_001")
-- `label`: Class ID (0-15) corresponding to one of the 16 activity classes
+- `label`: Activity class ID (0-15)
 - `start`: Start time of the segment in seconds
 - `end`: End time of the segment in seconds
-- `subject`: Subject ID (`-1` for synthetic data without subject tracking)
-- `cam`: Camera view ID (`-1` for single view/no camera variation)
+- `subject`: Subject ID (`-1` for synthetic data)
+- `cam`: Camera view ID (`-1` for single view)
 - `dataset`: Dataset name (`wanfall`)
 
+**Demographic Metadata:**
+- `age_group`: One of 6 age categories (toddlers_1_4, children_5_12, teenagers_13_17, young_adults_18_34, middle_aged_35_64, elderly_65_plus)
+- `gender_presentation`: Visual gender presentation (male, female)
+- `monk_skin_tone`: Monk Skin Tone scale (mst1-mst10, representing diverse skin tones)
+- `race_ethnicity_omb`: OMB ethnicity categories (white, black, asian, hispanic_latino, aian, nhpi, mena)
+- `bmi_band`: Body type (underweight, normal, overweight, obese)
+- `height_band`: Height category (short, avg, tall)
+
+**Scene Metadata:**
+- `environment_category`: Scene location (indoor, outdoor)
+- `camera_shot`: Shot composition (static_wide, static_medium_wide)
+- `speed`: Frame rate (24fps_rt, 25fps_rt, 30fps_rt, std_rt)
+- `camera_elevation`: Camera height (eye, low, high, top)
+- `camera_azimuth`: Camera angle (front, rear, left, right)
+- `camera_distance`: Camera distance (medium, far)
+
 ### Split Format
 
 Split files in the `splits/` directory list the video paths included in each partition:
@@ -121,9 +133,7 @@ fall/fall_ch_002
 ...
 ```
 
-## Usage Examples
-
-### Load Default Split
+## Usage Example
 
 ```python
 from datasets import load_dataset
@@ -132,18 +142,23 @@ import pandas as pd
 # Load the datasets
 print("Loading WanFall dataset...")
 
-# Load labels (all temporal segments) - default config
-labels = load_dataset("YOUR_USERNAME/wanfall")["train"]
+# Note: All segment labels are in the "train" split when loaded from the labels config,
+# but we join them with the actual train/val/test splits afterwards.
+labels = load_dataset("simplexsigil2/wanfall", "labels")["train"]
 
-# Load random train/val/test splits
-random_split = load_dataset("YOUR_USERNAME/wanfall", "random")
+# Load the random 80/10/10 split
+random_split = load_dataset("simplexsigil2/wanfall", "random")
 
-# Convert to pandas DataFrames
+# Load video metadata (optional, for demographic filtering)
+video_metadata = pd.read_csv("videos/metadata.csv")
+print(f"Video metadata shape: {video_metadata.shape}")
+
+# Convert labels to DataFrame
 labels_df = pd.DataFrame(labels)
 print(f"Labels dataframe shape: {labels_df.shape}")
 print(f"Total temporal segments: {len(labels_df)}")
 
-# Process each split
+# Process each split (train, validation, test)
 for split_name, split_data in random_split.items():
     # Convert to DataFrame
     split_df = pd.DataFrame(split_data)
@@ -152,419 +167,39 @@ for split_name, split_data in random_split.items():
     merged_df = pd.merge(split_df, labels_df, on="path", how="left")
 
     # Print statistics
-    print(f"\n{split_name} split:")
-    print(f"  Videos: {len(split_df)}")
-    print(f"  Temporal segments: {len(merged_df)}")
-    print(f"  Unique labels: {merged_df['label'].nunique()}")
+    print(f"\n{split_name} split: {len(split_df)} videos, {len(merged_df)} temporal segments")
+
+    # Print examples
+    if not merged_df.empty:
+        print(f"\n  {split_name.upper()} EXAMPLES:")
+        random_samples = merged_df.sample(min(3, len(merged_df)))
+        for i, (_, row) in enumerate(random_samples.iterrows()):
+            print(f"  Example {i+1}:")
+            print(f"    Path: {row['path']}")
+            print(f"    Label: {row['label']} (segment {row['start']:.2f}s - {row['end']:.2f}s)")
+            print(f"    Age: {row['age_group']}, Gender: {row['gender_presentation']}")
+            print(f"    Ethnicity: {row['race_ethnicity_omb']}, Environment: {row['environment_category']}")
+            print()
+
+# Example: Filter by demographics
+elderly_falls = labels_df[
+    (labels_df['age_group'] == 'elderly_65_plus') &
+    (labels_df['label'] == 1)  # fall = label 1
+]
+print(f"\nElderly fall segments: {len(elderly_falls)} ({elderly_falls['path'].nunique()} unique videos)")
 ```
 
-### Analyze Label Distribution
+### Label Mapping
 
 ```python
-from datasets import load_dataset
-import pandas as pd
-
-# Load labels (default config)
-labels = load_dataset("YOUR_USERNAME/wanfall")["train"]
-labels_df = pd.DataFrame(labels)
-
-# Load label names
-label_map = {
+LABEL_MAP = {
     0: 'walk', 1: 'fall', 2: 'fallen', 3: 'sit_down',
     4: 'sitting', 5: 'lie_down', 6: 'lying', 7: 'stand_up',
     8: 'standing', 9: 'other', 10: 'kneel_down', 11: 'kneeling',
     12: 'squat_down', 13: 'squatting', 14: 'crawl', 15: 'jump'
 }
-
-# Add label names
-labels_df['label_name'] = labels_df['label'].map(label_map)
-
-# Segment-level distribution
-print("Temporal Segment Distribution:")
-segment_counts = labels_df['label_name'].value_counts().sort_index()
-for label_name, count in segment_counts.items():
-    print(f"  {label_name:15s}: {count:5d} segments")
-
-# Video-level distribution (primary activity from path)
-labels_df['primary_activity'] = labels_df['path'].str.split('/').str[0]
-print("\nVideo Distribution by Primary Activity:")
-video_counts = labels_df['primary_activity'].value_counts()
-for activity, count in video_counts.items():
-    print(f"  {activity:15s}: {count:5d} segments")
-```
-
-### Iterate Over Split
-
-```python
-from datasets import load_dataset
-import pandas as pd
-
-# Load data
-labels = load_dataset("YOUR_USERNAME/wanfall")["train"]  # default config
-labels_df = pd.DataFrame(labels)
-
-splits = load_dataset("YOUR_USERNAME/wanfall", "random")
-train_df = pd.DataFrame(splits["train"])
-
-# Merge to get train labels
-train_labels = pd.merge(train_df, labels_df, on="path", how="left")
-
-print(f"Training set: {len(train_labels)} temporal segments")
-
-# Iterate over videos
-for video_path in train_df['path'][:5]:
-    # Get all segments for this video
-    video_segments = train_labels[train_labels['path'] == video_path]
-
-    print(f"\n{video_path}:")
-    print(f"  Segments: {len(video_segments)}")
-
-    for _, seg in video_segments.iterrows():
-        duration = seg['end'] - seg['start']
-        print(f"    {seg['start']:.3f}s - {seg['end']:.3f}s ({duration:.3f}s): "
-              f"label {seg['label']}")
-```
-
-### PyTorch Dataset Integration
-
-```python
-from datasets import load_dataset
-import pandas as pd
-import torch
-from torch.utils.data import Dataset, DataLoader
-from pathlib import Path
-import cv2
-import numpy as np
-
-
-class WanFallDataset(Dataset):
-    """
-    PyTorch Dataset for WanFall activity recognition.
-
-    This dataset provides both temporal segments and video paths for loading.
-    """
-
-    def __init__(
-        self,
-        split='train',
-        video_root=None,
-        transform=None,
-        target_transform=None,
-        return_segments=True,
-        fps=16,
-        num_frames=81
-    ):
-        """
-        Args:
-            split: One of 'train', 'validation', 'test'
-            video_root: Root directory containing video files (e.g., /path/to/wanfall/videos)
-            transform: Optional transform to apply to video frames
-            target_transform: Optional transform to apply to labels
-            return_segments: If True, returns all temporal segments. If False, returns one sample per video.
-            fps: Frame rate of videos (default: 16)
-            num_frames: Number of frames per video (default: 81)
-        """
-        super().__init__()
-
-        # Load labels (all temporal segments)
-        labels_ds = load_dataset("simplexsigil2/wanfall")
-        self.labels_df = pd.DataFrame(labels_ds["train"])
-
-        # Load split
-        split_ds = load_dataset("simplexsigil2/wanfall", "random")
-        split_df = pd.DataFrame(split_ds[split])
-
-        # Merge to get labeled segments for this split
-        self.data = pd.merge(split_df, self.labels_df, on="path", how="left")
-
-        # If not returning segments, keep only one row per video
-        if not return_segments:
-            self.data = self.data.groupby('path').first().reset_index()
-
-        self.video_root = Path(video_root) if video_root else None
-        self.transform = transform
-        self.target_transform = target_transform
-        self.return_segments = return_segments
-        self.fps = fps
-        self.num_frames = num_frames
-
-    def __len__(self):
-        return len(self.data)
-
-    def __getitem__(self, idx):
-        row = self.data.iloc[idx]
-
-        # Get video path
-        video_path = row['path']
-        if self.video_root is not None:
-            video_path = self.video_root / f"{video_path}.mp4"
-
-        # Load video frames (if video_root is provided)
-        frames = None
-        if self.video_root is not None and Path(video_path).exists():
-            frames = self._load_video(video_path)
-            if self.transform is not None:
-                frames = self.transform(frames)
-
-        # Get label information
-        label = int(row['label'])
-        start_time = float(row['start'])
-        end_time = float(row['end'])
-
-        # Convert timestamps to frame indices
-        start_frame = int(start_time * self.fps)
-        end_frame = int(end_time * self.fps)
-
-        if self.target_transform is not None:
-            label = self.target_transform(label)
-
-        # Return data
-        sample = {
-            'video_path': row['path'],
-            'label': label,
-            'start_time': start_time,
-            'end_time': end_time,
-            'start_frame': start_frame,
-            'end_frame': end_frame,
-        }
-
-        if frames is not None:
-            sample['frames'] = frames
-
-        return sample
-
-    def _load_video(self, video_path):
-        """Load video frames using OpenCV."""
-        cap = cv2.VideoCapture(str(video_path))
-        frames = []
-
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            # Convert BGR to RGB
-            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            frames.append(frame)
-
-        cap.release()
-
-        # Convert to numpy array (T, H, W, C)
-        frames = np.array(frames)
-
-        return frames
-
-
-# Example usage
-def get_dataloaders(video_root, batch_size=32, num_workers=4):
-    """Create PyTorch DataLoaders for train/val/test splits."""
-
-    # Optional: Define transforms
-    from torchvision import transforms
-
-    transform = transforms.Compose([
-        transforms.Lambda(lambda x: torch.from_numpy(x).float()),
-        transforms.Lambda(lambda x: x.permute(0, 3, 1, 2)),  # (T, H, W, C) -> (T, C, H, W)
-        transforms.Lambda(lambda x: x / 255.0),  # Normalize to [0, 1]
-    ])
-
-    # Create datasets
-    train_dataset = WanFallDataset(
-        split='train',
-        video_root=video_root,
-        transform=transform,
-        return_segments=True
-    )
-
-    val_dataset = WanFallDataset(
-        split='validation',
-        video_root=video_root,
-        transform=transform,
-        return_segments=True
-    )
-
-    test_dataset = WanFallDataset(
-        split='test',
-        video_root=video_root,
-        transform=transform,
-        return_segments=True
-    )
-
-    # Create dataloaders
-    train_loader = DataLoader(
-        train_dataset,
-        batch_size=batch_size,
-        shuffle=True,
-        num_workers=num_workers,
-        pin_memory=True
-    )
-
-    val_loader = DataLoader(
-        val_dataset,
-        batch_size=batch_size,
-        shuffle=False,
-        num_workers=num_workers,
-        pin_memory=True
-    )
-
-    test_loader = DataLoader(
-        test_dataset,
-        batch_size=batch_size,
-        shuffle=False,
-        num_workers=num_workers,
-        pin_memory=True
-    )
-
-    return train_loader, val_loader, test_loader
-
-
-# Example training loop snippet
-if __name__ == "__main__":
-    video_root = Path("/path/to/wanfall/videos")
-
-    train_loader, val_loader, test_loader = get_dataloaders(
-        video_root=video_root,
-        batch_size=16,
-        num_workers=4
-    )
-
-    print(f"Train batches: {len(train_loader)}")
-    print(f"Val batches: {len(val_loader)}")
-    print(f"Test batches: {len(test_loader)}")
-
-    # Inspect first batch
-    for batch in train_loader:
-        print("\nBatch keys:", batch.keys())
-        if 'frames' in batch:
-            print(f"Frames shape: {batch['frames'].shape}")
-        print(f"Labels shape: {batch['label'].shape}")
-        print(f"Label range: [{batch['label'].min()}, {batch['label'].max()}]")
-        break
-```
-
-### Converting Temporal Segments to Frame-Level Labels
-
-If you need frame-level labels for dense prediction tasks:
-
-```python
-import numpy as np
-
-
-def temporal_segments_to_frames(segments_df, fps=16, num_frames=81):
-    """
-    Convert temporal segments to frame-level labels.
-
-    Args:
-        segments_df: DataFrame with 'start', 'end', 'label' columns for one video
-        fps: Frame rate (default: 16)
-        num_frames: Number of frames per video (default: 81)
-
-    Returns:
-        Array of shape (num_frames,) with label for each frame
-    """
-    # Initialize with -1 (unlabeled)
-    frame_labels = np.full(num_frames, -1, dtype=np.int32)
-
-    # Sort segments by start time
-    segments_df = segments_df.sort_values('start')
-
-    for _, seg in segments_df.iterrows():
-        start_frame = int(seg['start'] * fps)
-        end_frame = min(int(seg['end'] * fps), num_frames - 1)
-
-        # Assign label to frames
-        frame_labels[start_frame:end_frame + 1] = seg['label']
-
-    return frame_labels
-
-
-# Example usage with PyTorch Dataset
-class WanFallFrameLevelDataset(Dataset):
-    """PyTorch Dataset with frame-level labels."""
-
-    def __init__(self, split='train', video_root=None, transform=None):
-        super().__init__()
-
-        # Load labels and split
-        labels_ds = load_dataset("simplexsigil2/wanfall")
-        self.labels_df = pd.DataFrame(labels_ds["train"])
-
-        split_ds = load_dataset("simplexsigil2/wanfall", "random")
-        split_df = pd.DataFrame(split_ds[split])
-
-        # Get unique videos in this split
-        self.video_paths = split_df['path'].tolist()
-        self.video_root = Path(video_root) if video_root else None
-        self.transform = transform
-
-    def __len__(self):
-        return len(self.video_paths)
-
-    def __getitem__(self, idx):
-        video_path = self.video_paths[idx]
-
-        # Load video frames
-        frames = None
-        if self.video_root is not None:
-            full_path = self.video_root / f"{video_path}.mp4"
-            if full_path.exists():
-                frames = self._load_video(full_path)
-                if self.transform is not None:
-                    frames = self.transform(frames)
-
-        # Get all segments for this video and convert to frame labels
-        video_segments = self.labels_df[self.labels_df['path'] == video_path]
-        frame_labels = temporal_segments_to_frames(video_segments)
-
-        return {
-            'video_path': video_path,
-            'frames': frames,
-            'labels': torch.from_numpy(frame_labels),  # Shape: (81,)
-        }
-
-    def _load_video(self, video_path):
-        """Load video frames."""
-        cap = cv2.VideoCapture(str(video_path))
-        frames = []
-        while True:
-            ret, frame = cap.read()
-            if not ret:
-                break
-            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-            frames.append(frame)
-        cap.release()
-        return np.array(frames)
 ```
 
-### Best Practices
-
-**1. Temporal Segment vs Frame-Level:**
-- Use temporal segments directly for action localization and detection tasks
-- Convert temporal segments to frame-level labels for dense prediction tasks (see example above)
-- The dataset provides temporal segments; use the conversion function for frame-level labels
-
-**2. Handling Multiple Segments per Video:**
-- Set `return_segments=True` to get all temporal segments (one sample per segment)
-- Set `return_segments=False` to get one sample per video (useful for video-level classification)
-
-**3. Data Loading:**
-- Videos are stored separately and not included in this HuggingFace dataset
-- Provide `video_root` path where videos are stored with structure: `{video_root}/{path}.mp4`
-- Example: `{video_root}/fall/fall_ch_001.mp4`
-
-**4. Memory Efficiency:**
-- Load videos on-demand in `__getitem__` rather than pre-loading
-- Use `num_workers > 0` in DataLoader for parallel loading
-- Consider using video decoding libraries like `decord` or `torchvision.io` for faster loading
-
-**5. Temporal Sampling:**
-- For long videos or limited memory, sample frames instead of loading all 81 frames
-- Use uniform sampling, random sampling, or segment-focused sampling based on task
-
-**6. Label Handling:**
-- Labels are integers 0-15 for the 16 activity classes
-- `-1` indicates unlabeled frames (when converting to frame-level labels)
-- Consider class balancing or weighted sampling for imbalanced classes
-
 ## Technical Properties
 
 ### Video Specifications
@@ -601,31 +236,26 @@ Videos often contain natural sequences of activities:
 
 Not all transitions include static states (e.g., a person might stand_up immediately after falling without a `fallen` state).
 
-## Future Extensions
+## Demographic Diversity
 
-This dataset is designed to support additional metadata and splits:
-- **Demographics**: Age groups, ethnicity (to be added)
-- **Cross-demographic splits**: Train on one demographic, test on another
-- **Scenario variations**: Different environments, lighting, occlusions
+The dataset includes rich demographic and scene metadata for every video, enabling bias analysis and cross-demographic evaluation.
+However, while age and gender and ethnicity are quite reliable with consistent generation, the attributes were merely provided with the generation prompts and due to model biases, the resulting videos can deviate.
 
-## Citation
+### Overview
 
-If you use WanFall in your research, please cite:
+![Demographic Overview](figures/demographic_overview.png)
 
-```bibtex
-@misc{wanfall2025,
-  title={WanFall: A Synthetic Activity Recognition Dataset},
-  author={TODO},
-  year={2025},
-}
-```
 
-## License
+### Scene Variations
 
-The annotations and split definitions in this repository are released under [Creative Commons Attribution-NonCommercial 4.0 International License](https://creativecommons.org/licenses/by-nc/4.0/).
+Beyond demographic diversity, the dataset includes:
+- **Environment**: Indoor and outdoor settings
+- **Camera Angles**: Multiple elevations (eye, low, high, top), azimuths (front, rear, left, right), and distances
+- **Camera Shots**: Static wide and medium-wide compositions
+- **Frame Rates**: Various speeds (24fps, 25fps, 30fps, standard real-time)
 
-The video data is synthetic and must be obtained separately from the original source.
+## License
 
-## Contact
+The annotations and split definitions in this repository are released under [Creative Commons Attribution-NonCommercial 4.0 International License](https://creativecommons.org/licenses/by-nc/4.0/).
 
-For questions about the dataset, please contact [TODO].
+The video data is synthetic and must be obtained separately from the original source, more information in the future.