Add IBCBench queries, metadata, and dataset card

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,178 @@
+---
+pretty_name: IBCBench
+language:
+- en
+license: other
+task_categories:
+- other
+tags:
+- image-retrieval
+- multi-image-retrieval
+- multimodal-agents
+- image-bundle-composition
+- visual-history
+- yfcc100m
+configs:
+- config_name: default
+  data_files:
+  - split: test
+    path: queries.jsonl
+---
+
+# IBCBench: Image Bundle Composition Benchmark
+
+IBCBench is the benchmark introduced in **Weaving Visual Narratives: Agentic Image Bundle Composition Beyond Atomic Visual Matching**, accepted to the **EMNLP 2026 Main Conference**.
+
+[**GitHub**](https://github.com/LaVieEnRose365/Image-Bundle-Composition)
+
+## Overview
+
+Image Bundle Composition (IBC) shifts image retrieval from independently ranking images to dynamically composing a compact, cohesive bundle whose images jointly satisfy relational, temporal, spatial, or narrative constraints. The target bundles are not predefined in the image pool, so systems must reason over non-decomposable bundle-level relevance in a combinatorial search space.
+
+IBCBench contains **667 human-verified queries** evaluated against a pool of **109,467 images from 57 users**. Each ground-truth bundle contains 3--5 images. The benchmark was built using a semi-automated candidate mining and verification pipeline followed by expert human review.
+
+## Dataset Statistics
+
+| Statistic | Value |
+|:--|--:|
+| Queries | 667 |
+| Images | 109,467 |
+| Users | 57 |
+| Bundle size: 3 images | 162 (24.3%) |
+| Bundle size: 4 images | 215 (32.2%) |
+| Bundle size: 5 images | 290 (43.5%) |
+| Same-location dynamics | 52.5% |
+| Cross-location structures | 47.5% |
+
+## Download
+
+Download the complete benchmark from the Hugging Face Hub:
+
+```bash
+hf download CyberDancer/IBCBench --repo-type dataset --local-dir IBCBench
+```
+
+Then extract the image pool:
+
+```bash
+unzip IBCBench/images.zip -d IBCBench
+```
+
+Alternatively, the included `download_images.py` script can reconstruct the image pool from `photo_ids/`:
+
+```bash
+python IBCBench/download_images.py \
+  --photo-ids-path IBCBench/photo_ids \
+  --images-path IBCBench/images
+```
+
+## File Structure
+
+```text
+IBCBench/
+├── queries.jsonl              # 667 IBC queries and ground-truth bundles
+├── metadata/
+│   └── {user_id}.jsonl        # Photo metadata for each user
+├── photo_ids/
+│   └── {user_id}.txt          # Photo IDs and storage hashes for each user
+├── images.zip                # images/{user_id}/{photo_id}.jpg
+└── download_images.py        # Alternative image downloader
+```
+
+## Query Format
+
+Each line in `queries.jsonl` is one query and its ground-truth image bundle:
+
+```json
+{
+  "query_id": "10287726@N02_s18_w0_n3",
+  "query": "Find a bundle documenting the same spectator's Olympic viewing experience: ...",
+  "image_ids": ["7797992908", "7797994344", "7797998284"]
+}
+```
+
+| Field | Type | Description |
+|:--|:--|:--|
+| `query_id` | string | Unique query identifier. Its prefix is the YFCC user ID. |
+| `query` | string | Natural-language bundle query in English. |
+| `image_ids` | list[string] | Ground-truth set of 3--5 YFCC photo IDs. |
+
+## Photo Metadata Format
+
+Each line in `metadata/{user_id}.jsonl` describes one image:
+
+```json
+{
+  "photo_id": "4517621778",
+  "metadata": {
+    "taken_time": "2010-04-10 13:52:57",
+    "longitude": -1.239802,
+    "latitude": 51.754123,
+    "accuracy": 16.0,
+    "address": "...",
+    "capturedevice": "Panasonic DMC-TZ5"
+  }
+}
+```
+
+The location, address, accuracy, and capture-device fields are optional and may be absent. Album identifiers are intentionally excluded from the benchmark.
+
+Each non-empty line in `photo_ids/{user_id}.txt` has the following tab-separated form:
+
+```text
+{photo_id}\t{storage_hash}
+```
+
+## Shared Image Pool and Attribution
+
+IBCBench uses the same image pool, metadata, and photo-ID mapping as [DISBench](https://huggingface.co/datasets/RUC-NLPIR/DISBench), which is derived from the public [YFCC100M](https://multimediacommons.wordpress.com/yfcc100m-core-dataset/) collection. IBCBench contributes a separate set of 667 queries and ground-truth bundles for the Image Bundle Composition task.
+
+Please also cite DISBench and YFCC100M when using the shared image pool.
+
+## Ethical Considerations
+
+The source images were publicly distributed under Creative Commons licenses. IBCBench is intended for research on multimodal retrieval and relational reasoning, particularly user-centric organization of personal photo collections. It is not intended for unauthorized surveillance, identity profiling, or analysis of private third-party collections.
+
+Although the source media is public, the benchmark includes spatiotemporal metadata. Users should handle this information responsibly and follow the terms attached to each original image.
+
+## License
+
+The IBCBench query annotations and BundleWeaver project are released under the [Apache License 2.0](https://github.com/LaVieEnRose365/Image-Bundle-Composition/blob/main/LICENSE). The images retain the individual Creative Commons licenses attached to the corresponding YFCC100M records; downstream users are responsible for checking and following those terms. The included DISBench-derived helper and shared files retain their upstream terms.
+
+## Citation
+
+```bibtex
+@inproceedings{shan2026weaving,
+  title     = {Weaving Visual Narratives: Agentic Image Bundle Composition Beyond Atomic Visual Matching},
+  author    = {Shan, Rong and Xu, Tianyi and Zheng, Congmin and Chen, Wenteng and Zhu, Jiachen and Wu, Junjie and Zeng, Dun and Wang, Teng and Liu, Weiwen and Zhang, Changwang and Zhang, Weinan and Wang, Jun and Lin, Jianghao},
+  booktitle = {Proceedings of the 2026 Conference on Empirical Methods in Natural Language Processing},
+  year      = {2026}
+}
+```
+
+DISBench:
+
+```bibtex
+@misc{deng2026deepimagesearch,
+  title         = {DeepImageSearch: Benchmarking Multimodal Agents for Context-Aware Image Retrieval in Visual Histories},
+  author        = {Deng, Chenlong and Deng, Mengjie and Wu, Junjie and Zeng, Dun and Wang, Teng and Xie, Qingsong and Huang, Jiadeng and Ma, Shengjie and Zhang, Changwang and Wang, Zhaoxiang and Wang, Jun and Zhu, Yutao and Dou, Zhicheng},
+  year          = {2026},
+  eprint        = {2602.10809},
+  archivePrefix = {arXiv},
+  primaryClass  = {cs.CV}
+}
+```
+
+YFCC100M:
+
+```bibtex
+@article{thomee2016yfcc100m,
+  title   = {YFCC100M: The New Data in Multimedia Research},
+  author  = {Thomee, Bart and Shamma, David A. and Friedland, Gerald and Elizalde, Benjamin and Ni, Karl and Poland, Douglas and Borth, Damian and Li, Li-Jia},
+  journal = {Communications of the ACM},
+  volume  = {59},
+  number  = {2},
+  pages   = {64--73},
+  year    = {2016}
+}
+```

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()