Upload folder using huggingface_hub

README.md

@@ -1,3 +1,234 @@
----
-license: cc-by-4.0
----
+# DISBench: DeepImageSearch Benchmark
+
+DISBench is the first benchmark for context-aware image retrieval over visual histories. It contains 122 queries across 57 users and 109,467 photos, requiring multi-step reasoning over corpus-level context.
+
+## Download
+
+```bash
+# Option 1: Hugging Face
+huggingface-cli download xxx/DISBench --local-dir .
+
+# Option 2: Download images from YFCC100M
+python download_images.py --photo-ids-path photo_ids --images-path images
+```
+
+## File Structure
+
+```
+DISBench/
+├── queries.jsonl              # 122 annotated queries
+├── metadata/
+│   └── {user_id}.jsonl        # Photo metadata per user
+├── images/
+│   └── {user_id}/
+│       └── {photo_id}.jpg     # Photo files
+├── photo_ids/
+│   └── {user_id}.txt          # Photo IDs and hashes per user
+├── evaluate.py                # Evaluation script
+└── download_images.py         # Image download script
+```
+
+## Data Format
+
+### queries.jsonl
+
+Each line is a JSON object representing one query:
+
+```json
+{
+    "query_id": "q001",
+    "user_id": "12345678",
+    "query": "Find photos from the musical performance identified by the blue and white event logo on site, where only the lead singer appears on stage.",
+    "answer": ["98765432", "98765433", "98765434"],
+    "event_type": "intra-event"
+}
+```
+
+| Field | Type | Description |
+|:------|:-----|:------------|
+| `query_id` | string | Unique query identifier |
+| `user_id` | string | User whose photo collection to search |
+| `query` | string | Natural language query (text-only) |
+| `answer` | list[string] | Ground-truth target photo IDs |
+| `event_type` | string | `"intra-event"` or `"inter-event"` |
+
+### metadata/{user_id}.jsonl
+
+Each line is a JSON object representing one photo's metadata:
+
+```json
+{
+    "photo_id": "98765432",
+    "metadata": {
+        "taken_time": "2012-08-03 14:32:10",
+        "longitude": -1.8808,
+        "latitude": 50.7192,
+        "accuracy": 16.0,
+        "address": "Bournemouth, Dorset, England",
+        "capturedevice": "Canon EOS 550D"
+    }
+}
+```
+
+| Field | Type | Description |
+|:------|:-----|:------------|
+| `photo_id` | string | Unique photo identifier |
+| `metadata.taken_time` | string | Capture time in `YY-MM-DD HH:MM:SS` format |
+| `metadata.longitude` | float | GPS longitude. **Missing if unavailable.** |
+| `metadata.latitude` | float | GPS latitude. **Missing if unavailable.** |
+| `metadata.accuracy` | float | GPS accuracy level. **Missing if unavailable.** |
+| `metadata.address` | string | Reverse-geocoded address. **Missing if unavailable.** |
+| `metadata.capturedevice` | string | Camera/device name. **Missing if unavailable.** |
+
+> **Note:** Optional fields (`longitude`, `latitude`, `accuracy`, `address`, `capturedevice`) are omitted entirely when unavailable — they will not appear as keys in the JSON object.
+
+### images/{user_id}/{photo_id}.jpg
+
+Photo files organized by user. Each user's collection contains approximately 2,000 photos accumulated chronologically from their photosets.
+
+### photo_ids/{user_id}.txt
+
+Each line represents one photo ID and its hash on aws storage in the format `{photo_id}\t{hash}`:
+```
+1205732595	c45044fd7b5c9450b2a11adc6b42d
+```
+
+| Field | Type | Description |
+|:------|:-----|:------------|
+| `photo_id` | string | Unique photo identifier |
+| `hash` | string | Hashed value of the photo on aws storage |
+
+## Evaluation
+
+### Agent Evaluation
+
+For agent systems that predict a set of photo IDs per query:
+
+```bash
+python evaluate.py \
+    --mode agent \
+    --dataset_path . \
+    --prediction_path /path/to/predictions.jsonl \
+    --output_dir /path/to/run_id_dir/
+```
+
+**Prediction format** — a JSONL file where each line is:
+
+```json
+{
+    "query_id": "q001",
+    "prediction": ["98765432", "98765433"]
+}
+```
+
+**Output files:**
+
+`eval_samples.jsonl` — per-query results:
+
+```json
+{
+    "query_id": "q001",
+    "user_id": "12345678",
+    "query": "Find photos from the musical performance...",
+    "answer": ["98765432", "98765433", "98765434"],
+    "prediction": ["98765432", "98765433"],
+    "tp": 2, "fp": 0, "fn": 1,
+    "em": 0,
+    "iou": 0.667,
+    "precision": 1.0,
+    "recall": 0.667,
+    "f1": 0.8
+}
+```
+
+`eval_summary.json` — aggregated results:
+
+```json
+{
+    "n_samples": {
+        "total": 122,
+        "inter_event": 65,
+        "intra_event": 57
+    },
+    "aggregation": {
+        "total": {
+            "macro": { "em": 0.271, "iou": 0.45, "precision": 0.55, "recall": 0.52, "f1": 0.513 },
+            "micro": { "tp": 230, "fp": 45, "fn": 60, "iou": 0.42, "precision": 0.836, "recall": 0.793, "f1": 0.814 }
+        },
+        "inter_event": { "macro": { "..." : "..." }, "micro": { "..." : "..." } },
+        "intra_event": { "macro": { "..." : "..." }, "micro": { "..." : "..." } }
+    },
+    "set_size": {
+        "avg_answer_size": { "total": 3.76, "inter_event": 3.52, "intra_event": 4.04 },
+        "avg_pred_size": { "total": 3.10, "inter_event": 2.80, "intra_event": 3.44 }
+    },
+    "notes": {
+        "empty_pred_count": { "total": 5, "inter_event": 3, "intra_event": 2 }
+    }
+}
+```
+
+### Retriever Baseline Evaluation
+
+For embedding-based retrieval that returns a ranked list:
+
+```bash
+python evaluate.py \
+    --mode retriever \
+    --dataset_path . \
+    --prediction_path /path/to/predictions.jsonl \
+    --output_dir /path/to/retriever_dir/
+```
+
+**Prediction format** — a JSONL file where each line is:
+
+```json
+{
+    "query_id": "q001",
+    "prediction": ["photo_rank1", "photo_rank2", "photo_rank3", "..."]
+}
+```
+
+> Predictions should be ordered by descending relevance score.
+
+**Output files:**
+
+`eval_samples.jsonl` — per-query results with MAP@k, Recall@k, NDCG@k for k ∈ {1, 3, 5, 10}.
+
+`eval_summary.json` — aggregated metrics:
+
+```json
+{
+    "n_samples": 122,
+    "aggregation": {
+        "MAP@1": 0.123, "MAP@3": 0.105, "MAP@5": 0.120, "MAP@10": 0.133,
+        "Recall@1": 0.054, "Recall@3": 0.116, "Recall@5": 0.170, "Recall@10": 0.250,
+        "NDCG@1": 0.123, "NDCG@3": 0.133, "NDCG@5": 0.157, "NDCG@10": 0.188
+    },
+    "notes": {
+        "incomplete_pred_count": 0
+    }
+}
+```
+
+## Dataset Statistics
+
+| Statistic | Value |
+|:----------|:------|
+| Total Queries | 122 |
+| Intra-Event Queries | 57 (46.7%) |
+| Inter-Event Queries | 65 (53.3%) |
+| Total Users | 57 |
+| Total Photos | 109,467 |
+| Avg. Targets per Query | 3.76 |
+| Avg. History Span | 3.4 years |
+| Query Retention Rate | 6.1% (122 / 2,000 candidates) |
+| Inter-Annotator IoU | 0.91 |
+
+## Data Source
+
+DISBench is constructed from [YFCC100M](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/), which preserves a hierarchical structure of users → photosets → photos. All images are publicly shared under Creative Commons licenses. Photoset boundaries are used during construction but are **not** provided to models during evaluation.
+
+## License
+
+The DISBench dataset follows the Creative Commons licensing terms of the underlying YFCC100M data. Please refer to individual image licenses for specific usage terms.

download_images.py

@@ -0,0 +1,316 @@
+"""
+fetch photos of selected users from yfcc.
+
+arguments:
+    --dataset-path: path to the DISBench dataset
+    --max-workers: maximum number of worker threads for downloading
+    --clear: if set, the downloaded status will be cleared and you can start downloading from scratch.
+
+input:
+    - DISBench/photo_ids/<uid>.txt
+        - each line: {photo_id}\t{hash} or {photo_id}\t{hash}\t{status}
+
+output:
+    - DISBench/images/<uid>/{photo_id}.jpg
+    - DISBench/photo_ids/<uid>.txt
+        - each line: {photo_id}\t{hash}\t{status}
+
+description:
+    - read the photo ids file, and get the photo ids, hashes, and statuses.
+    - if clear is set, clear the status, save the file.
+    - for each photo, if the status is:
+        - "valid": skip this.
+        - "success": try to load this file, if the file is valid, set the status to "valid". else, set the status to "error".
+        - "error" or None: try to download this photo again.
+    - download photos from s3.
+        - url: https://multimedia-commons.s3-us-west-2.amazonaws.com/data/images/<first 3 chars in hash>/<next 3 chars in hash>/<hash>.jpg. for example, if the hash is 00024a73d1a4c32fb29732d56a2, the url is https://multimedia-commons.s3-us-west-2.amazonaws.com/data/images/000/24a/00024a73d1a4c32fb29732d56a2.jpg.
+        - save the photo to the photos folder.
+        - download with multithreading, workers set to 16 in main(). 
+        - if download is successful, set the status to "success". else, set the status to "error".
+        - save the status to the photo ids file for each user.
+"""
+import argparse
+import os
+import time
+import requests
+from pathlib import Path
+from tqdm import tqdm
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from PIL import Image
+
+
+def construct_s3_url(hash_value):
+    """Construct S3 URL from hash value"""
+    # Get first 3 chars and next 3 chars
+    first_3 = hash_value[:3]
+    next_3 = hash_value[3:6]
+    return f"https://multimedia-commons.s3-us-west-2.amazonaws.com/data/images/{first_3}/{next_3}/{hash_value}.jpg"
+
+
+def validate_image_file(image_path):
+    """Validate if an image file exists and can be loaded"""
+    if not image_path.exists():
+        return False
+    try:
+        with Image.open(image_path) as img:
+            img.load()
+        return True
+    except Exception:
+        return False
+
+
+def download_photo(photo_id, hash_value, output_path, uid):
+    """Download a single photo from S3 with retry logic"""
+    max_retries = 4
+    last_error = None
+    
+    for attempt in range(max_retries):
+        try:
+            url = construct_s3_url(hash_value)
+            response = requests.get(url, timeout=30, stream=True)
+            response.raise_for_status()
+            
+            # Save the photo
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            with open(output_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            
+            return photo_id, "success", None
+        except Exception as e:
+            last_error = e
+            # Retry for other errors
+            if attempt < max_retries - 1:
+                time.sleep(1)  # Brief delay before retry
+                continue
+            return photo_id, "error", str(e)
+    
+    # If we exhausted all retries, return the last error
+    return photo_id, "error", str(last_error) if last_error else "Unknown error after retries"
+
+
+def process_photo_ids_file(photo_ids_file, photos_base_dir, uid):
+    """Process a single photo_ids file and return tasks and photo records"""
+    photos_dir = photos_base_dir / uid
+    photos_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Read all photo records
+    photo_records = []  # List of (photo_id, hash, status)
+    tasks = []  # List of (photo_id, hash, output_path) for photos to download
+    has_updates = False  # Track if any status was updated
+    
+    with open(photo_ids_file, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            
+            parts = line.split('\t')
+            if len(parts) < 2:
+                continue
+            
+            photo_id = parts[0].strip()
+            hash_value = parts[1].strip()
+            status = parts[2].strip() if len(parts) >= 3 else None
+            
+            if not photo_id or not hash_value:
+                continue
+            
+            output_path = photos_dir / f"{photo_id}.jpg"
+            
+            # Store the record
+            photo_records.append({
+                'photo_id': photo_id,
+                'hash': hash_value,
+                'status': status,
+                'output_path': output_path
+            })
+            
+            # Process based on status according to description:
+            # - "valid": skip this
+            if status == "valid":
+                continue
+            
+            # - "success": try to load this file, if valid set to "valid", else set to "error"
+            if status == "success":
+                if validate_image_file(output_path):
+                    photo_records[-1]['status'] = "valid"
+                    has_updates = True
+                else:
+                    photo_records[-1]['status'] = "error"
+                    has_updates = True
+                    # Need to download again
+                    tasks.append((photo_id, hash_value, output_path))
+                continue
+            
+            # - "error" or None: try to download this photo again
+            if status == "error" or status is None:
+                tasks.append((photo_id, hash_value, output_path))
+    
+    return tasks, photo_records, has_updates
+
+
+def save_photo_ids_file(photo_ids_file, photo_records):
+    """Save updated photo records back to the photo_ids file"""
+    with open(photo_ids_file, 'w', encoding='utf-8') as f:
+        for record in photo_records:
+            photo_id = record['photo_id']
+            hash_value = record['hash']
+            status = record['status']
+            
+            # Always write status if it exists
+            if status:
+                f.write(f"{photo_id}\t{hash_value}\t{status}\n")
+            else:
+                f.write(f"{photo_id}\t{hash_value}\n")
+
+
+def download_photos_for_uid(uid, photo_ids_file, photos_base_dir, max_workers):
+    """Download all photos for a single user ID"""
+    tasks, photo_records, has_updates = process_photo_ids_file(photo_ids_file, photos_base_dir, uid)
+    
+    # Create a mapping from photo_id to record for easy updates
+    photo_id_to_record = {record['photo_id']: record for record in photo_records}
+    
+    # Count initial statistics
+    valid_count = sum(1 for r in photo_records if r['status'] == "valid")
+    skipped_count = sum(1 for r in photo_records if r['status'] and r['status'] != "error")
+    
+    if not tasks:
+        print(f"{uid}: No photos to download ({skipped_count} already processed, {valid_count} valid)")
+        # Save the file if statuses were updated
+        if has_updates:
+            save_photo_ids_file(photo_ids_file, photo_records)
+        return
+    
+    print(f"Processing {uid}: {len(tasks)} photos to download ({skipped_count} skipped, {valid_count} valid)")
+    
+    success_count = 0
+    error_count = 0
+    
+    with ThreadPoolExecutor(max_workers=max_workers) as executor:
+        futures = {
+            executor.submit(download_photo, photo_id, hash_value, output_path, uid): (photo_id, hash_value)
+            for photo_id, hash_value, output_path in tasks
+        }
+        
+        for future in tqdm(as_completed(futures), total=len(futures), desc=f"Downloading {uid}"):
+            photo_id, hash_value = futures[future]
+            try:
+                result_photo_id, status, error = future.result()
+                
+                # Update the record with the download status
+                if result_photo_id in photo_id_to_record:
+                    photo_id_to_record[result_photo_id]['status'] = status
+                    has_updates = True
+                
+                if status == "success":
+                    success_count += 1
+                elif status == "error":
+                    error_count += 1
+                    if error:
+                        print(f"\nError downloading {result_photo_id}: {error}")
+                
+                # Sleep for 2 seconds every 50 requests
+                if (success_count + error_count) % 50 == 0:
+                    time.sleep(2)
+                    
+            except Exception as e:
+                error_count += 1
+                print(f"\nException for {photo_id}: {e}")
+    
+    # Save updated photo_ids file with download statuses only if there were updates
+    if has_updates:
+        save_photo_ids_file(photo_ids_file, photo_records)
+    
+    print(f"Completed {uid}: {success_count} downloaded, {error_count} errors, {skipped_count} skipped, {valid_count} valid")
+
+
+def clear_statuses(photo_ids_file):
+    """Clear all statuses from photo_ids file and save"""
+    photo_records = []
+    
+    # Read all photo records
+    with open(photo_ids_file, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            
+            parts = line.split('\t')
+            
+            photo_id = parts[0].strip()
+            hash_value = parts[1].strip()
+            
+            # Clear status (set to None)
+            photo_records.append({
+                'photo_id': photo_id,
+                'hash': hash_value,
+                'status': None
+            })
+    
+    # Save with cleared statuses
+    save_photo_ids_file(photo_ids_file, photo_records)
+    return
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Fetch photos of selected users from YFCC")
+    parser.add_argument(
+        "--photo-ids-path",
+        type=str,
+        default="photo_ids",
+        help="Path to the DISBench dataset"
+    )
+    parser.add_argument(
+        "--images-path",
+        type=str,
+        default="images",
+        help="Path to the images directory"
+    )
+    parser.add_argument(
+        "--max-workers",
+        type=int,
+        default=16,
+        help="Maximum number of worker threads for downloading"
+    )
+    parser.add_argument(
+        "--clear",
+        action="store_true",
+        help="Clear the downloaded status and exit"
+    )
+    
+    args = parser.parse_args()
+    
+    photo_ids_path = Path(args.photo_ids_path)
+    images_path = Path(args.images_path)
+    max_workers = args.max_workers
+    
+    # Get all photo_ids files
+    photo_ids_files = sorted([f for f in photo_ids_path.glob("*.txt")])
+    
+    if not photo_ids_files:
+        print(f"No photo_ids files found in {photo_ids_path}")
+        return
+    
+    # If clear is set, clear statuses and exit
+    if args.clear:
+        print(f"Clearing statuses for {len(photo_ids_files)} photo_ids files...")
+        for photo_ids_file in photo_ids_files:
+            uid = photo_ids_file.stem
+            print(f"Clearing statuses for {uid}...")
+            clear_statuses(photo_ids_file)
+        print("All statuses cleared!")
+        return
+    
+    print(f"Found {len(photo_ids_files)} photo_ids files to process")
+    
+    # Process each user's photo_ids file
+    for photo_ids_file in photo_ids_files:
+        uid = photo_ids_file.stem  # Get filename without extension
+        download_photos_for_uid(uid, photo_ids_file, images_path, max_workers)
+    
+    print("All downloads completed!")
+    return
+
+
+if __name__ == '__main__':
+    main()

images.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:648d788d398bb15393c1262cb4971d13cd0fbf489738ae2c43a825a05e9765d0
+size 14434611540