Upload folder using huggingface_hub

.gitignore

@@ -4,4 +4,5 @@ create_splits.py
 export_via_to_csv.py
 extract_jsonl_metadata.py
 test_wanfall_builder.py
-
+.claude
+test_framewise_complete.py

README.md

@@ -16,8 +16,7 @@ configs:
   - config_name: labels
     data_files:
       - labels/wanfall.csv
-    default: true
-    description: "Temporal segment labels for all videos. Load splits to get train/val/test paths."
+    description: "All temporal segment labels (19,228 segments) in a single split."
 
   - config_name: metadata
     data_files:
@@ -32,6 +31,7 @@ configs:
         path: "splits/random/val.csv"
       - split: test
         path: "splits/random/test.csv"
+    default: true
     description: "Random 80/10/10 train/val/test split (seed 42)"
 
   - config_name: cross_age
@@ -63,6 +63,9 @@ configs:
       - split: test
         path: "splits/cross_bmi/test.csv"
     description: "Cross-BMI evaluation: train on normal/underweight, val on overweight, test on obese"
+
+  - config_name: framewise
+    description: "Frame-wise labels (81 per video). Use framewise=True parameter with any split config instead."
 ---
 [![License: CC BY-NC 4.0](https://img.shields.io/badge/License-CC%20BY--NC%204.0-lightgrey.svg)](https://creativecommons.org/licenses/by-nc/4.0/)
 
@@ -91,11 +94,13 @@ WanFall is a large-scale synthetic dataset designed for activity recognition res
 - **Video duration**: 5.0625 seconds per clip
 - **Frame count**: 81 frames per video
 - **Frame rate**: 16 fps
-- **Split configurations**: 4 available configs
+- **Annotation formats**: Temporal segments (start/end times) OR frame-wise labels (81 per video)
+- **Split configurations**: 4 split configs + framewise support
   - `random`: 80/10/10 train/val/test split (seed 42) - 9,600/1,200/1,200 videos
   - `cross_age`: Cross-age evaluation - 4,000/2,000/6,000 videos
   - `cross_ethnicity`: Cross-ethnicity evaluation - 5,178/1,741/5,081 videos
   - `cross_bmi`: Cross-BMI evaluation - 6,066/2,962/2,972 videos
+  - `framewise=True`: Add frame-wise labels (81 per video) to any split
 - **Metadata fields**: 12 demographic and scene attributes per video
 
 ## Activity Categories
@@ -174,71 +179,267 @@ fall/fall_ch_002
 ...
 ```
 
-## Usage Example
+## Usage
+
+The WanFall dataset provides a flexible Python API through the HuggingFace `datasets` library with multiple configurations and loading modes.
+
+### Quick Start
+
+```python
+from datasets import load_dataset
+
+# Load with random 80/10/10 split (temporal segments, default)
+dataset = load_dataset("simplexsigil2/wanfall", "random")
+
+print(f"Train: {len(dataset['train'])} segments")
+print(f"Validation: {len(dataset['validation'])} segments")
+print(f"Test: {len(dataset['test'])} segments")
+
+# Access example
+example = dataset['train'][0]
+print(f"Video: {example['path']}")
+print(f"Activity: {example['label']} ({example['start']:.2f}s - {example['end']:.2f}s)")
+print(f"Age group: {example['age_group']}")
+```
+
+### Dataset Configurations
+
+WanFall provides **7 configurations** for different use cases:
+
+**Key Distinction: Segment-Level vs Video-Level**
+
+| Configuration | Sample Unit | Train Size | Has start/end? | Has frame_labels? |
+|--------------|-------------|------------|----------------|-------------------|
+| `random` | **Segment** | 15,344 segments | ✅ Yes | ❌ No |
+| `random` + `framewise=True` | **Video** | 9,600 videos | ❌ No | ✅ Yes (81 labels) |
+| `cross_age` | **Segment** | 6,267 segments | ✅ Yes | ❌ No |
+| `cross_age` + `framewise=True` | **Video** | 4,000 videos | ❌ No | ✅ Yes (81 labels) |
+| `labels` | **Segment** | 19,228 segments | ✅ Yes | ❌ No |
+| `framewise` | **Video** | 12,000 videos | ❌ No | ✅ Yes (81 labels) |
+
+#### 1. **Temporal Segments** (Default)
+
+Load temporal segment annotations where **each sample is a segment** with start/end times:
+
+```python
+# Default: random split with temporal segments
+dataset = load_dataset("simplexsigil2/wanfall")  # or "random"
+
+# Each example is a SEGMENT (not a video)
+example = dataset['train'][0]
+print(example['path'])      # "fall/fall_ch_001"
+print(example['label'])     # 1 (activity class ID)
+print(example['start'])     # 0.0 (start time in seconds)
+print(example['end'])       # 1.006 (end time in seconds)
+print(example['age_group']) # Demographic metadata
+
+# Dataset contains multiple segments per video
+print(f"Total segments in train: {len(dataset['train'])}")  # 15,344 segments
+print(f"Unique videos: {len(set([ex['path'] for ex in dataset['train']]))}") # 9,600 videos
+```
+
+**Key characteristics:**
+- **Sample = Temporal Segment** (one video can have multiple segments)
+- Each segment has `start` and `end` times
+- Train: 15,344 segments from 9,600 videos
+- Val: 1,927 segments from 1,200 videos
+- Test: 1,957 segments from 1,200 videos
+
+**Available split configs:**
+- `random` - 80/10/10 split (15,344/1,927/1,957 segments)
+- `cross_age` - Cross-age evaluation (6,267/3,762/9,199 segments)
+- `cross_ethnicity` - Cross-ethnicity evaluation (8,267/2,762/8,199 segments)
+- `cross_bmi` - Cross-BMI evaluation (9,675/4,701/4,852 segments)
+
+#### 2. **Frame-Wise Labels**
+
+Load dense frame-level labels where **each sample is a video** with 81 labels:
+
+```python
+# Standalone: all 12,000 videos with frame-wise labels
+dataset = load_dataset("simplexsigil2/wanfall", "framewise")
+
+# With splits: random split with frame-wise labels
+dataset = load_dataset("simplexsigil2/wanfall", "random", framewise=True)
+
+# Each example is a VIDEO (not a segment)
+example = dataset['train'][0]
+print(example['path'])         # "fall/fall_ch_001"
+print(example['frame_labels']) # [1, 1, 1, ..., 11, 11] (81 labels)
+print(len(example['frame_labels']))  # 81 frames
+print(example['age_group'])    # Demographic metadata included
+
+# Dataset contains one sample per video
+print(f"Total videos in train: {len(dataset['train'])}")  # 9,600 videos
+```
+
+**Key characteristics:**
+- **Sample = Video** (one sample per video, no segments)
+- Each video has 81 frame labels (no start/end times)
+- Train: 9,600 videos
+- Val: 1,200 videos
+- Test: 1,200 videos
+
+**Key features:**
+- **81 labels per video** (one per frame @ 16fps)
+- **Works with all split configs**: Add `framewise=True` to any split
+- **Efficient**: 348KB compressed archive, automatically cached
+- **Complete metadata**: All demographic attributes included
+
+#### 3. **Paths Only Mode**
+
+Load only video paths for custom video loading:
+
+```python
+# Minimal loading: only video paths
+dataset = load_dataset("simplexsigil2/wanfall", "random", paths_only=True)
+
+# Only contains paths
+example = dataset['train'][0]
+print(example)  # {'path': 'fall/fall_ch_001'}
+```
+
+#### 4. **All Segments** (No Splits)
+
+Load all 19,228 temporal segments without split partitions:
+
+```python
+dataset = load_dataset("simplexsigil2/wanfall", "labels")
+all_segments = dataset['train']  # Single split with all segments
+print(f"Total segments: {len(all_segments)}")  # 19,228 segments
+
+# Each sample is a segment (like config 1, but no train/val/test split)
+example = all_segments[0]
+print(f"Path: {example['path']}")
+print(f"Segment: {example['start']:.2f}s - {example['end']:.2f}s")
+print(f"Label: {example['label']}")
+```
+
+#### 5. **Video Metadata Only**
+
+Load only video-level metadata (12,000 videos):
+
+```python
+dataset = load_dataset("simplexsigil2/wanfall", "metadata")
+metadata = dataset['train']  # 12,000 videos
+print(f"Columns: {metadata.column_names}")
+# ['path', 'dataset', 'age_group', 'gender_presentation', ...]
+```
+
+### Complete Usage Examples
+
+#### Example 1: Training with Temporal Segments (Segment-Level)
+
+When using temporal segments, **each sample is a segment** with start/end times. Multiple segments can come from the same video.
 
 ```python
 from datasets import load_dataset
-import pandas as pd
-
-# Load the datasets
-print("Loading WanFall dataset...")
-
-# 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 the random 80/10/10 split
-random_split = load_dataset("simplexsigil2/wanfall", "random")
-
-# 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 (train, validation, test)
-for split_name, split_data in random_split.items():
-    # Convert to DataFrame
-    split_df = pd.DataFrame(split_data)
-
-    # Join with labels on 'path'
-    merged_df = pd.merge(split_df, labels_df, on="path", how="left")
-
-    # Print statistics
-    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
+
+# Load random split (segment-level samples)
+dataset = load_dataset("simplexsigil2/wanfall", "random")
+
+print(f"Training on {len(dataset['train'])} segments")  # 15,344 segments
+
+# Training loop - each iteration is ONE SEGMENT
+for example in dataset['train']:
+    video_path = example['path']
+    activity_label = example['label']  # 0-15
+    start_time = example['start']
+    end_time = example['end']
+
+    # Load only the frames for this segment
+    # frames = load_video_segment(video_path, start_time, end_time)
+    # model.train(frames, activity_label)
+
+# Note: The same video can appear multiple times with different segments
+# E.g., "fall/fall_ch_001" might have segments [0.0-1.0] and [1.0-5.0]
+```
+
+#### Example 2: Training with Frame-Wise Labels (Video-Level)
+
+When using frame-wise labels, **each sample is a video** with 81 frame labels. Each video appears only once.
+
+```python
+from datasets import load_dataset
+
+# Load random split with frame-wise labels (video-level samples)
+dataset = load_dataset("simplexsigil2/wanfall", "random", framewise=True)
+
+print(f"Training on {len(dataset['train'])} videos")  # 9,600 videos
+
+# Training loop - each iteration is ONE VIDEO
+for example in dataset['train']:
+    video_path = example['path']
+    frame_labels = example['frame_labels']  # 81 labels (one per frame)
+
+    # Load all frames from the video
+    # frames = load_video(video_path)  # Shape: (81, H, W, 3)
+    # model.train(frames, frame_labels)
+
+# Note: Each video appears exactly once with its 81 frame labels
+```
+
+#### Example 3: Cross-Demographic Evaluation
+
+```python
+from datasets import load_dataset
+
+# Train on young adults, test on elderly
+cross_age = load_dataset("simplexsigil2/wanfall", "cross_age", framewise=True)
+
+# Train
+for example in cross_age['train']:
+    age = cross_age['train'].features['age_group'].int2str(example['age_group'])
+    print(f"Training on {age}")  # "young_adults_18_34" or "middle_aged_35_64"
+
+# Test
+for example in cross_age['test']:
+    age = cross_age['test'].features['age_group'].int2str(example['age_group'])
+    print(f"Testing on {age}")  # "elderly_65_plus", "children_5_12", etc.
+```
+
+#### Example 4: Filtering by Demographics
+
+```python
+from datasets import load_dataset
+
+# Load all segments
+dataset = load_dataset("simplexsigil2/wanfall", "labels")
+segments = dataset['train']
+
+# Access label feature for conversion
+label_feature = segments.features['label']
+age_feature = segments.features['age_group']
+
+# Filter elderly fall segments
+elderly_falls = [
+    ex for ex in segments
+    if age_feature.int2str(ex['age_group']) == 'elderly_65_plus'
+    and ex['label'] == 1  # fall
 ]
-print(f"\nElderly fall segments: {len(elderly_falls)} ({elderly_falls['path'].nunique()} unique videos)")
+
+print(f"Found {len(elderly_falls)} elderly fall segments")
 ```
 
-### Label Mapping
+### Label Conversion
+
+Labels are stored as integers (0-15) but can be converted to strings:
 
 ```python
-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'
-}
+dataset = load_dataset("simplexsigil2/wanfall", "random")
+
+# Get label feature
+label_feature = dataset['train'].features['label']
+
+# Convert integer to string
+label_name = label_feature.int2str(1)  # "fall"
+
+# Convert string to integer
+label_id = label_feature.str2int("walk")  # 0
+
+# Access all label names
+all_labels = label_feature.names
+print(all_labels)  # ['walk', 'fall', 'fallen', ...]
 ```
 
 ### Cross-Demographic Evaluation Splits
@@ -263,28 +464,6 @@ Evaluates model performance across different body types:
 - **Validation** (2,962 videos): Overweight
 - **Test** (2,972 videos): Obese
 
-**Usage Example:**
-```python
-from datasets import load_dataset
-import pandas as pd
-
-# Load cross-age splits
-cross_age = load_dataset("simplexsigil2/wanfall", "cross_age")
-labels = load_dataset("simplexsigil2/wanfall", "labels")["train"]
-
-# Merge labels with splits
-labels_df = pd.DataFrame(labels)
-train_df = pd.DataFrame(cross_age["train"])
-train_labels = pd.merge(train_df, labels_df, on="path", how="left")
-
-print(f"Cross-age train: {len(train_labels)} segments")
-print(f"Age groups: {train_labels['age_group'].unique()}")
-
-# Similarly for cross_ethnicity and cross_bmi configs
-cross_ethnicity = load_dataset("simplexsigil2/wanfall", "cross_ethnicity")
-cross_bmi = load_dataset("simplexsigil2/wanfall", "cross_bmi")
-```
-
 ## Technical Properties
 
 ### Video Specifications

wanfall.py

@@ -9,7 +9,10 @@ robust activity recognition across diverse populations.
 
 import pandas as pd
 import datasets
-from datasets import BuilderConfig, GeneratorBasedBuilder, Features, Value, ClassLabel, SplitGenerator, Split
+from datasets import BuilderConfig, GeneratorBasedBuilder, Features, Value, ClassLabel, SplitGenerator, Split, Sequence
+import h5py
+import tarfile
+from pathlib import Path
 
 
 # Dataset metadata
@@ -81,15 +84,17 @@ class WanFallConfig(BuilderConfig):
     """BuilderConfig for WanFall dataset.
 
     Args:
-        split_type: Type of data to load ("labels", "metadata", or split name like "random")
+        split_type: Type of data to load ("labels", "metadata", "framewise", or split name like "random")
         paths_only: If True, only return video paths for split configs (no label merging)
+        framewise: If True, load frame-wise labels from HDF5 files (81 labels per video)
         **kwargs: Keyword arguments forwarded to super.
     """
 
-    def __init__(self, split_type="labels", paths_only=False, **kwargs):
+    def __init__(self, split_type="labels", paths_only=False, framewise=False, **kwargs):
         super().__init__(**kwargs)
         self.split_type = split_type
         self.paths_only = paths_only
+        self.framewise = framewise
 
 
 class WanFall(GeneratorBasedBuilder):
@@ -135,6 +140,13 @@ class WanFall(GeneratorBasedBuilder):
             description="Cross-BMI evaluation: train on normal/underweight, test on obese",
             split_type="cross_bmi",
         ),
+        WanFallConfig(
+            name="framewise",
+            version=VERSION,
+            description="Frame-wise labels for all videos (81 labels per video, one per frame)",
+            split_type="framewise",
+            framewise=True,
+        ),
     ]
 
     DEFAULT_CONFIG_NAME = "random"
@@ -145,6 +157,8 @@ class WanFall(GeneratorBasedBuilder):
         # Define features based on config type
         if self.config.split_type == "metadata":
             features = self._get_metadata_features()
+        elif self.config.framewise:
+            features = self._get_framewise_features()
         elif self.config.paths_only:
             features = self._get_paths_only_features()
         else:
@@ -222,9 +236,83 @@ class WanFall(GeneratorBasedBuilder):
             "path": Value("string"),
         })
 
+    def _get_framewise_features(self):
+        """Feature schema for frame-wise labels (81 labels per video)."""
+        return Features({
+            # Core identity
+            "path": Value("string"),
+            "dataset": Value("string"),
+
+            # Frame-wise labels (81 frames @ 16fps = 5.0625 seconds)
+            "frame_labels": Sequence(ClassLabel(num_classes=16, names=_ACTIVITY_LABELS), length=81),
+
+            # Demographic metadata (same as metadata config)
+            "age_group": ClassLabel(num_classes=6, names=_AGE_GROUPS),
+            "gender_presentation": ClassLabel(num_classes=2, names=_GENDERS),
+            "monk_skin_tone": ClassLabel(num_classes=10, names=_SKIN_TONES),
+            "race_ethnicity_omb": ClassLabel(num_classes=7, names=_ETHNICITIES),
+            "bmi_band": ClassLabel(num_classes=4, names=_BMI_BANDS),
+            "height_band": ClassLabel(num_classes=3, names=_HEIGHT_BANDS),
+
+            # Scene metadata
+            "environment_category": ClassLabel(num_classes=2, names=_ENVIRONMENTS),
+            "camera_shot": ClassLabel(num_classes=2, names=_CAMERA_SHOTS),
+            "speed": ClassLabel(num_classes=4, names=_SPEEDS),
+            "camera_elevation": ClassLabel(num_classes=4, names=_CAMERA_ELEVATIONS),
+            "camera_azimuth": ClassLabel(num_classes=4, names=_CAMERA_AZIMUTHS),
+            "camera_distance": ClassLabel(num_classes=2, names=_CAMERA_DISTANCES),
+        })
+
     def _split_generators(self, dl_manager):
         """Define data splits and their source files."""
 
+        # Handle framewise config - needs to download and extract HDF5 files
+        if self.config.framewise:
+            # Download the frame-wise labels archive
+            archive_path = dl_manager.download_and_extract("data_files/frame_wise_labels.tar.zst")
+
+            # If split_type is "framewise", return all videos in one split
+            if self.config.split_type == "framewise":
+                return [
+                    SplitGenerator(
+                        name=Split.TRAIN,
+                        gen_kwargs={
+                            "hdf5_dir": archive_path,
+                            "metadata_path": "videos/metadata.csv",
+                            "split_file": None,
+                        },
+                    ),
+                ]
+            # Otherwise, use split files (random, cross_age, etc.)
+            else:
+                split_dir = f"splits/{self.config.split_type}"
+                return [
+                    SplitGenerator(
+                        name=Split.TRAIN,
+                        gen_kwargs={
+                            "hdf5_dir": archive_path,
+                            "metadata_path": "videos/metadata.csv",
+                            "split_file": f"{split_dir}/train.csv",
+                        },
+                    ),
+                    SplitGenerator(
+                        name=Split.VALIDATION,
+                        gen_kwargs={
+                            "hdf5_dir": archive_path,
+                            "metadata_path": "videos/metadata.csv",
+                            "split_file": f"{split_dir}/val.csv",
+                        },
+                    ),
+                    SplitGenerator(
+                        name=Split.TEST,
+                        gen_kwargs={
+                            "hdf5_dir": archive_path,
+                            "metadata_path": "videos/metadata.csv",
+                            "split_file": f"{split_dir}/test.csv",
+                        },
+                    ),
+                ]
+
         # Handle different config types
         if self.config.split_type == "labels":
             # Labels config: single split with all temporal segments
@@ -289,8 +377,8 @@ class WanFall(GeneratorBasedBuilder):
             ]
 
     def _generate_examples(self, filepath=None, split_file=None, labels_path=None,
-                          split_name=None, split_dir=None):
-        """Generate examples from CSV files.
+                          split_name=None, split_dir=None, hdf5_dir=None, metadata_path=None):
+        """Generate examples from CSV files or HDF5 files.
 
         Args:
             filepath: Direct path to CSV file (for labels/metadata configs)
@@ -298,8 +386,137 @@ class WanFall(GeneratorBasedBuilder):
             labels_path: Path to labels file for merging (for split configs with full data)
             split_name: Name of the split being generated
             split_dir: Directory containing split files
+            hdf5_dir: Directory containing extracted HDF5 files (for framewise config)
+            metadata_path: Path to metadata CSV (for framewise config)
         """
 
+        # Case 0: Frame-wise labels from HDF5 files
+        if hdf5_dir is not None:
+            # Load metadata
+            metadata_df = pd.read_csv(metadata_path)
+
+            # If split_file is provided, load the video paths for this split
+            valid_paths = None
+            if split_file is not None:
+                split_df = pd.read_csv(split_file)
+                valid_paths = set(split_df['path'].tolist())
+
+            # hdf5_dir might be a tar file (if zst extraction only decompressed to tar)
+            # Check if it's a tar file and handle appropriately
+            hdf5_path = Path(hdf5_dir)
+
+            if hdf5_path.is_file() and (hdf5_path.suffix == '.tar' or tarfile.is_tarfile(str(hdf5_path))):
+                # It's a tar file - iterate through it directly
+                idx = 0
+                with tarfile.open(hdf5_path, 'r') as tar:
+                    for member in tar.getmembers():
+                        if not member.name.endswith('.h5'):
+                            continue
+
+                        # Extract path from tar member name
+                        # e.g., "./lie_down/lie_down_yo_076.h5" or "lie_down/lie_down_yo_076.h5"
+                        video_path = member.name.lstrip('./').replace('.h5', '')
+
+                        # Skip if not in this split
+                        if valid_paths is not None and video_path not in valid_paths:
+                            continue
+
+                        try:
+                            # Extract H5 file to memory
+                            h5_file = tar.extractfile(member)
+                            if h5_file is None:
+                                continue
+
+                            # h5py can't read from file-like object directly, need temp file
+                            import tempfile
+                            with tempfile.NamedTemporaryFile(suffix='.h5', delete=True) as tmp:
+                                tmp.write(h5_file.read())
+                                tmp.flush()
+
+                                with h5py.File(tmp.name, 'r') as f:
+                                    frame_labels = f['label_indices'][:].tolist()
+
+                            # Get metadata for this video
+                            video_metadata = metadata_df[metadata_df['path'] == video_path]
+
+                            if len(video_metadata) == 0:
+                                continue
+
+                            video_meta = video_metadata.iloc[0]
+
+                            # Create example
+                            example = {
+                                "path": video_path,
+                                "dataset": "wanfall",
+                                "frame_labels": frame_labels,
+                            }
+
+                            # Add metadata fields
+                            metadata_fields = [
+                                "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"
+                            ]
+                            for field in metadata_fields:
+                                if field in video_meta and pd.notna(video_meta[field]):
+                                    example[field] = str(video_meta[field])
+
+                            yield idx, example
+                            idx += 1
+
+                        except Exception as e:
+                            print(f"Warning: Failed to process {member.name}: {e}")
+                            continue
+            else:
+                # It's a directory - glob for H5 files
+                hdf5_files = sorted(hdf5_path.glob("**/*.h5"))
+
+                idx = 0
+                for h5_file in hdf5_files:
+                    relative_path = h5_file.relative_to(hdf5_path)
+                    video_path = str(relative_path.with_suffix(''))
+
+                    # Skip if not in this split
+                    if valid_paths is not None and video_path not in valid_paths:
+                        continue
+
+                    try:
+                        with h5py.File(h5_file, 'r') as f:
+                            frame_labels = f['label_indices'][:].tolist()
+
+                        video_metadata = metadata_df[metadata_df['path'] == video_path]
+
+                        if len(video_metadata) == 0:
+                            continue
+
+                        video_meta = video_metadata.iloc[0]
+
+                        example = {
+                            "path": video_path,
+                            "dataset": "wanfall",
+                            "frame_labels": frame_labels,
+                        }
+
+                        metadata_fields = [
+                            "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"
+                        ]
+                        for field in metadata_fields:
+                            if field in video_meta and pd.notna(video_meta[field]):
+                                example[field] = str(video_meta[field])
+
+                        yield idx, example
+                        idx += 1
+
+                    except Exception as e:
+                        print(f"Warning: Failed to process {h5_file}: {e}")
+                        continue
+
+            return
+
         # Case 1: Direct file loading (labels or metadata config)
         if filepath is not None:
             df = pd.read_csv(filepath)