update

README.md

@@ -70,7 +70,7 @@ configs:
 ---
 
 <h1 align='center' style="text-align:center; font-weight:bold; font-size:2.0em;letter-spacing:2.0px;">
-    LV-Haystack: Temporal Search in Long-Form Video Understanding</h1>    
+    LV-Haystack: Temporal Search for Long-Form Video Understanding</h1>    
 
 
 <p align='center' style="text-align:center;font-size:1.25em;">
@@ -87,7 +87,8 @@ configs:
 <a href="https://jiajunwu.com/" target="_blank">Jiajun Wu<sup>1</sup></a>,&nbsp;
 <a href="https://limanling.github.io/" target="_blank">Manling Li<sup>2</sup></a><br/>
 &nbsp;Stanford University<sup>1</sup>, Northwestern University<sup>2</sup>, Carnegie Mellon University<sup>3</sup><br/>
-<em>Conference on AI Research, 2025</em><br/>
+<!-- <em>Conference on AI Research, 2025</em> -->
+<br/>
 <a href="https://examplewebsite.com" title="Website" target="_blank" rel="nofollow" style="text-decoration: none;">🌎Website</a> |
 <a href="https://examplecode.com" title="Dataset" target="_blank" rel="nofollow" style="text-decoration: none;">🧑‍💻Code</a> |
 <a href="https://arxiv.org/examplepaper" title="aXiv" target="_blank" rel="nofollow" style="text-decoration: none;">📄arXiv</a> |
@@ -100,18 +101,14 @@ configs:
   Dataset is part of the <a href="">T* project</a></p>
 
 <p align=center>
-NOTE: Does Manling need Stanford Affiliation? <br>
-NOTE: Fill in website url etc
-</p>
 
+</p>
 
 
-## News
 
-- **1/1/2025: Thrilled to announce T\* and LV-Haystack!**
 
 
-## Dataset Sample
+#### Dataset Sample
 
 ```python
 {
@@ -119,7 +116,7 @@ NOTE: Fill in website url etc
     'question_id': 10,
     'question': 'What nail did I pull out?',
     'answer': 'E',
-    'frame_indexes': [5036, 5232],
+    'frame_indexes': [5036, 5232], # the keyframe indexes
     'choices': {
         'A': 'The nail from the front wheel fender',
         'B': 'The nail from the motorcycle battery compartment',
@@ -128,22 +125,25 @@ NOTE: Fill in website url etc
         'E': 'The nail on the right side of the motorcycle exhaust pipe'
     },
     'video_metadata': {
-        'CLIP-reference-interval': [180.0, 240.0],  # Time interval of the video clip
+        'CLIP-reference-interval': [180.0, 240.0],  # Time interval of the video that is considered to be important in CLIP. This is originally from the Ego4D dataset, used here for annotators to quickly locate in the video.
         'frame_count': 14155,  # Total number of frames in the video
         'frame_rate': 30.0,  # Frame rate of the video
         'duration': 471.8333435058594,  # Duration of the video in seconds
         'resolution': '454x256',  # Original resolution of the video
         'frame_dimensions': None,  # Frame dimensions (if available)
-        'codec': 'N/A',  # Codec used for the video (not available here)
-        'bitrate': 0,  # Bitrate of the video
+        'codec': 'N/A',  # Codec used for the video (if available)
+        'bitrate': 0,  # Bitrate of the video (if available)
         'frame_dimensions_resized': [340, 256],  # Resized frame dimensions
         'resolution_resized': '340x256',  # Resized resolution
         'video_id': 'b6ae365a-dd70-42c4-90d6-e0351778d991'  # Unique video identifier
     }
 }
 ```
+#### Dataset exploration
 
-## Usage
+add hyperlink to demo
+
+#### Dataset Usage
 
 ```python
 from datasets import load_dataset
@@ -163,79 +163,61 @@ print(dataset)
 })
 ```
 
+#### Dataset Statistics Summary
 
+| **Metric**                    | **Total**    | **Train**   | **Test**    |
+|--------------------------------|--------------|-------------|-------------|
+| **Video Statistics**           |              |             |             |
+| Total Videos                   | **988**      | **744**     | **244**     |
+| Total Video Duration (hr)      | 423.3        | 322.2       | 101.0       |
+| Avg. Video Duration (min)      | 25.7         | 26.0        | 24.8        |
+| **Clip Statistics**            |              |             |             |
+| Total Video Clips              | **1,324**    | **996**     | **328**     |
+| Total Video Clip Duration (hr) | 180.4        | 135.3       | 45.0        |
+| Avg. Video Clip Duration (sec) | 8.2          | 8.2         | 8.2         |
+| **Frame Statistics**           |              |             |             |
+| Total Frames (k)               | **45,700**       | **34,800**      | **10,900**      |
+| Avg. Frames per Video (k)      | 46.3         | 46.8        | 44.7        |
+| Ratio of Keyframe / Frame (‰)  | 0.62         | 0.59        | 0.71        |
+| **QA Statistics**              |              |             |             |
+| Total QA Pairs                 | **15,092**   | **11,218**  | **3,874**   |
+| Avg. QA Pair per Video         | 15.3         | 15.1        | 15.9        |
+| Avg. QA Pair per Clip          | 11.4         | 11.3        | 11.8        |
+| Avg. Keyframes per Question    | 1.88         | 1.84        | 2.01        |
 
 
-## Abstract
-
-[[ABSTRACT]]
+#### Download Videos
 
-## [[TITLE]] Statistics
+Assume your video is in ./videos/
 
-<img src="[[STATISTICS_IMAGE_LINK]]" alt="image description" width="850" height="200">
+#### Evaluation scripts
 
+Please refer to ./eval.py (add hyperlink).
 
 
-## Dataset Organization
-
-The dataset is organized to facilitate easy access to all resources. Below is the structure:
-```
-[[DATASET_ORGANIZATION_STRUCTURE]]
-```
-
-### Description of Key Components
-```[[KEY_COMPONENT_PATH]]```: This directory contains resources in [[FORMAT]] format. Each file includes metadata and other details:
-
-- ```[[DATA_FILE_1]]```:
-  - [[DESCRIPTION_1]].
 
-- ```[[DATA_FILE_2]]```:
-  - [[DESCRIPTION_2]].
 
-- ```[[DATA_FILE_3]]```:
-  - [[DESCRIPTION_3]].
 
-### Annotation Format
-Each entry includes metadata in the following format:
 
-```
-{
-    "[[FIELD_1]]": {
-        "[[METADATA_FIELD_1]]": {
-            "[[DETAIL_1]]": [[DETAIL_TYPE_1]],
-            "[[DETAIL_2]]": [[DETAIL_TYPE_2]],
-        },
-        "[[BENCHMARK_FIELD]]": [
-            {
-                "[[QUESTION_FIELD]]": [[QUESTION_TYPE]],
-                "[[TASK_FIELD]]": [[TASK_TYPE]],
-                "[[LABEL_FIELD]]": [[LABEL_TYPE]],
-                "[[TIMESTAMP_FIELD]]": [[TIMESTAMP_TYPE]],
-                "[[MCQ_FIELD]]": "[[MCQ_OPTIONS]]",
-                "[[ANSWER_FIELD_1]]": [[ANSWER_TYPE_1]],
-                "[[ANSWER_FIELD_2]]": [[ANSWER_TYPE_2]],
-                "[[ANSWER_FIELD_3]]": [[ANSWER_TYPE_3]],
-                "[[ANSWER_FIELD_4]]": [[ANSWER_TYPE_4]],
-                "[[ANSWER_FIELD_5]]": [[ANSWER_TYPE_5]]
-            },
-            // Next question
-        ]
-    },
-    // Next entry
-}
-```
 
-## Limitations
-[[LIMITATIONS]]
 
-## Contact
-- [[CONTACT_1]]
-- [[CONTACT_2]]
-- [[CONTACT_3]]
+#### Contact
+- Jinhui Ye: [email protected]
+- Zihan Wang: [email protected]
+- Haosen Sun: [email protected]
+- Keshigeyan Chandrasegaran: [email protected]
+- Manling Li: [email protected]
 
-## Citation
+#### Citation
 
 ```bibtex
-[[BIBTEX]]
+@misc{tstar,
+      title={Re-thinking Temporal Search for Long-Form Video Understanding}, 
+      author={Jinhui Ye and Zihan Wang and Haosen Sun and Keshigeyan Chandrasegaran and Zane Durante and Cristobal Eyzaguirre and Yonatan Bisk and Juan Carlos Niebles and Ehsan Adeli and Li Fei-Fei and Jiajun Wu and Manling Li},
+      year={2025},
+      eprint={2501.TODO},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG}
+}
 ```
-
+Website template borrowed from [HourVideo](https://huggingface.co/datasets/HourVideo/HourVideo).

eval.py

@@ -0,0 +1,197 @@
+import torch
+import torch.nn.functional as F
+import numpy as np
+from typing import List, Tuple, Union, Protocol, Callable
+from abc import ABC, abstractmethod
+
+
+class ElementSimilarity(Protocol):
+    """Protocol for computing similarity between two elements"""
+    def __call__(self, x: any, y: any) -> float:
+        ...
+
+
+class SetSimilarity:
+    """Calculate similarity metrics between two sets based on element-wise similarity"""
+    
+    def __init__(self, element_similarity: ElementSimilarity):
+        self.element_similarity = element_similarity
+    
+    def compute_similarity_matrix(self, pred_set: List, gt_set: List) -> np.ndarray:
+        """Compute pairwise similarity matrix between elements of two sets"""
+        return np.array([
+            [self.element_similarity(pred, gt) for gt in gt_set]
+            for pred in pred_set
+        ])
+    
+    def __call__(self, pred_set: List, gt_set: List) -> Tuple[float, float, float]:
+        """Compute precision, recall, and F1 between two sets"""
+        if not pred_set or not gt_set:
+            return 0.0, 0.0, 0.0
+            
+        # Compute similarity matrix
+        sim_matrix = self.compute_similarity_matrix(pred_set, gt_set)
+        # For each prediction, get its highest similarity with any ground truth
+        pred_max_sim = np.max(sim_matrix, axis=1)
+        precision = np.mean(pred_max_sim)
+        
+        # Count how many predictions match with ground truths
+        match_threshold = 1  # Could be parameterized
+        total_matches = np.sum(pred_max_sim >= match_threshold)
+        
+        # Apply penalty if there are more matches than ground truths
+        if total_matches > len(gt_set):
+            precision *= len(gt_set) / total_matches
+        
+        # For each ground truth, get its highest similarity with any prediction
+        recall = np.mean(np.max(sim_matrix, axis=0))
+        
+        # Compute F1
+        f1 = 2 * precision * recall / (precision + recall) if precision + recall > 0 else 0.0
+        
+        return precision, recall, f1
+
+
+class TimestampSimilarity:
+    """Compute similarity between two timestamps"""
+    
+    def __init__(self, threshold: float = 5.0):
+        self.threshold = threshold
+    
+    def __call__(self, t1: float, t2: float) -> float:
+        """Return 1 if timestamps are within threshold, 0 otherwise"""
+        return float(abs(t1 - t2) <= self.threshold)
+
+
+class SSIMSimilarity:
+    """Compute SSIM similarity between two images. 
+    Assumes input images are in range [0, 255]."""
+    
+    def __init__(self, window_size: int = 11):
+        self.window_size = window_size
+        self._window_cache = {}
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        # Parameters for images in [0, 255] range
+        self.C1 = (0.01 * 255) ** 2
+        self.C2 = (0.03 * 255) ** 2
+    
+    def _create_window(self, channel: int) -> torch.Tensor:
+        """Create a 2D Gaussian window"""
+        kernel_1d = self._gaussian_kernel()
+        window_2d = kernel_1d.unsqueeze(1) @ kernel_1d.unsqueeze(0)
+        return window_2d.expand(channel, 1, self.window_size, self.window_size)
+    
+    def _gaussian_kernel(self, sigma: float = 1.5) -> torch.Tensor:
+        """Generate 1D Gaussian kernel"""
+        coords = torch.arange(self.window_size, dtype=torch.float32)
+        coords = coords - (self.window_size - 1) / 2
+        kernel = torch.exp(-(coords ** 2) / (2 * sigma ** 2))
+        return kernel / kernel.sum()
+    
+    def __call__(self, img1: torch.Tensor, img2: torch.Tensor) -> float:
+        """Compute SSIM between two images in range [0, 255]"""
+        if img1.shape != img2.shape:
+            raise ValueError("Images must have the same shape")
+            
+        # Move images to device
+        img1 = img1.to(self.device)
+        img2 = img2.to(self.device)
+        
+        if img1.dim() == 3:
+            img1 = img1.unsqueeze(0)
+            img2 = img2.unsqueeze(0)
+            
+        channel = img1.size(1)
+        if channel not in self._window_cache:
+            self._window_cache[channel] = self._create_window(channel).to(self.device)
+        window = self._window_cache[channel]
+        
+        # Compute means
+        mu1 = F.conv2d(img1, window, padding=self.window_size//2, groups=channel)
+        mu2 = F.conv2d(img2, window, padding=self.window_size//2, groups=channel)
+        mu1_sq, mu2_sq = mu1 ** 2, mu2 ** 2
+        mu1_mu2 = mu1 * mu2
+        
+        # Compute variances and covariance
+        sigma1_sq = F.conv2d(img1 ** 2, window, padding=self.window_size//2, groups=channel) - mu1_sq
+        sigma2_sq = F.conv2d(img2 ** 2, window, padding=self.window_size//2, groups=channel) - mu2_sq
+        sigma12 = F.conv2d(img1 * img2, window, padding=self.window_size//2, groups=channel) - mu1_mu2
+        
+        # Compute SSIM
+        ssim = ((2 * mu1_mu2 + self.C1) * (2 * sigma12 + self.C2)) / \
+               ((mu1_sq + mu2_sq + self.C1) * (sigma1_sq + sigma2_sq + self.C2))
+        
+        # Return mean SSIM
+        return float(ssim.mean())
+
+
+class BatchEvaluator:
+    """Evaluate similarity metrics for a batch of set pairs"""
+    
+    def __init__(self, set_similarity: SetSimilarity):
+        self.set_similarity = set_similarity
+    
+    def __call__(self, pred_sets: List[List], gt_sets: List[List]) -> Tuple[float, float, float]:
+        """Compute average precision, recall, and F1 across all set pairs"""
+        if len(pred_sets) != len(gt_sets):
+            raise ValueError("Number of predicted and ground truth sets must match")
+            
+        metrics = [
+            self.set_similarity(pred_set, gt_set)
+            for pred_set, gt_set in zip(pred_sets, gt_sets)
+        ]
+        
+        avg_precision = np.mean([p for p, _, _ in metrics])
+        avg_recall = np.mean([r for _, r, _ in metrics])
+        avg_f1 = np.mean([f for _, _, f in metrics])
+        
+        return avg_precision, avg_recall, avg_f1
+
+
+# Example usage
+def main():
+    # Example 1: Timestamp similarity
+    timestamp_sim = TimestampSimilarity(threshold=5.0)
+    set_sim = SetSimilarity(timestamp_sim)
+    
+    # Example where we have multiple predictions matching the same ground truth
+    gt_set = [10.0, 20.0]  # Two ground truth timestamps
+    pred_set = [9.0, 9.5, 10.2, 10.8, 19.8]  # Multiple predictions near first GT
+    
+    p, r, f1 = set_sim(pred_set, gt_set)
+    print(f"Timestamp Metrics with penalty:")
+    print(f"P: {p:.3f}, R: {r:.3f}, F1: {f1:.3f}")
+    
+    # Test batch evaluation
+    batch_eval = BatchEvaluator(set_sim)
+    pred_sets = [
+        [9.0, 9.5, 10.2, 19.8],  # Multiple predictions for first GT
+        [15.0, 25.0, 25.2]  # Multiple predictions for second GT
+    ]
+    gt_sets = [
+        [10.0, 20.0],
+        [15.0, 25.0]
+    ]
+    p, r, f1 = batch_eval(pred_sets, gt_sets)
+    print(f"\nBatch Metrics:")
+    print(f"P: {p:.3f}, R: {r:.3f}, F1: {f1:.3f}")
+    
+    
+    
+    # Example 2: Image similarity
+    ssim_sim = SSIMSimilarity()
+    set_sim_images = SetSimilarity(ssim_sim)
+    batch_eval_images = BatchEvaluator(set_sim_images)
+    
+    # Sample image data (assuming torch tensors of shape [C, H, W])
+    img1 = (torch.randn(3, 64, 64) * 255).to(torch.uint8).float()
+    img2 = (torch.randn(3, 64, 64) * 255).to(torch.uint8).float()
+    pred_sets = [[img1, img2]]
+    gt_sets = [[img2]]
+    
+    p, r, f1 = batch_eval_images(pred_sets, gt_sets)
+    print(f"Image Metrics - P: {p:.3f}, R: {r:.3f}, F1: {f1:.3f}")
+
+
+if __name__ == "__main__":
+    main()