Upload README.md with huggingface_hub

README.md

@@ -229,6 +229,346 @@ for video_path in train_df['path'][:5]:
               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