GeoEvidence-6K

GeoEvidence-6K is a remote-sensing visual question answering dataset with annotated evidence regions and four complementary processed image views. This release provides 6,750 question–answer samples: 6,000 single-choice and 750 multiple-choice questions, with English questions and A–D options.

The images are packaged as independent, view-specific ZIP shards. Original large images, training checkpoints, and internal validation reports are not included. See SCHEMA.md for the complete annotation specification.

1. Image views

View	Metadata field	Contents
plain	plain_file_name	Full image without an evidence box
global	global_file_name	Full image with a red box marking the evidence region
contextual	contextual_file_name	Expanded local crop with a red box marking the evidence region
evidence	evidence_file_name	Tight crop of the evidence region

Each view contains 6,150 image files (24,600 files across the four views). Multiple questions may share an image; the image count is therefore smaller than the QA count. Always resolve images through the metadata fields, rather than matching image filenames or archive positions across views.

The released plain, global, and contextual images are 2048 × 2048 pixels. The evidence crops have a longest side of 2048 pixels and may be rectangular. Exact per-sample dimensions are recorded as [width, height] in view_sizes. The existing processed images are preserved without re-encoding.

2. Repository layout

GeoEvidence-6K/
├── README.md
├── SCHEMA.md
├── train/
│   └── metadata.jsonl
└── archives/
    ├── plain-00000.zip
    ├── plain-00001.zip
    ├── ...
    ├── global-00000.zip
    ├── ...
    ├── contextual-00000.zip
    ├── ...
    └── evidence-00000.zip
        ...

The full package uses 41 ZIP shards, with a target of approximately 1 GiB per shard. Each ZIP is independently readable: do not concatenate the shards. Download every numbered shard for each view you need.

ZIP entries already contain the train/<view>/... prefix. Extract at the dataset root, not inside train/. After extraction:

GeoEvidence-6K/train/
├── metadata.jsonl
├── plain/<source>/<filename>.jpg
├── global/<source>/<filename>.jpg
├── contextual/<source>/<filename>.jpg
└── evidence/<source>/<filename>.jpg

All image paths in the metadata are relative to train/. The provider subdirectories and filenames must be retained during extraction.

The image payload is approximately 39.53 GiB. ZIP_STORED preserves the already encoded image bytes; it reduces the number of uploaded files, not the image payload size. Allow approximately 80 GiB to keep both all ZIPs and all extracted images, plus filesystem/cache overhead.

3. Download and extract

Install the lightweight dependencies:

pip install -U huggingface_hub pillow

If access requires authentication, run hf auth login with an account that has access to the dataset. Never put access tokens into shared scripts.

from pathlib import Path
import zipfile
from huggingface_hub import snapshot_download

root = Path(snapshot_download(
    repo_id="ronniejiangC/GeoEvidence-6K",
    repo_type="dataset",
    local_dir="GeoEvidence-6K",
    allow_patterns=["README.md", "SCHEMA.md", "train/metadata.jsonl", "archives/*.zip"],
))

for archive_path in sorted((root / "archives").glob("*.zip")):
    print("Extracting", archive_path.name)
    with zipfile.ZipFile(archive_path) as archive:
        archive.extractall(root)  # Entries already begin with train/.

To download only selected views, replace "archives/*.zip" with, for example, "archives/global-*.zip" and "archives/evidence-*.zip". Keep the metadata: it describes all four views, so paths for views you did not download will not exist locally. Reusing the same local_dir lets the Hub client reuse downloads. For reproducible experiments, pass a fixed repository commit as revision.

4. Read annotations and open images

import json
from pathlib import Path
from PIL import Image

root = Path("GeoEvidence-6K")
with (root / "train/metadata.jsonl").open(encoding="utf-8") as handle:
    samples = [json.loads(line) for line in handle if line.strip()]

sample = samples[0]
print(sample["sample_id"])
print(sample["question"])
print(sample["choices"])
print("Ground truth:", sample["answer_labels"])

views = {}
for view in ("plain", "global", "contextual", "evidence"):
    path = root / "train" / sample[f"{view}_file_name"]
    with Image.open(path) as image:
        views[view] = image.convert("RGB")
    print(view, views[view].size)

Skip undownloaded views when using a partial download. The ZIP layout is a download-and-extract release, not a Parquet or WebDataset release. Loading JSONL alone does not automatically decode the four image-path fields.

Main annotation fields

Field	Meaning
sample_id	Stable QA identifier
question	Question text, separated from options and appended instructions
choices	Ordered list of {"label": "A", "text": "..."} objects
question_type	single_choice or multiple_choice
answer_labels	List of correct option labels in canonical option order
answer_raw	Unchanged source answer string
answer_instruction	Required single- or multiple-choice output format
visual_instruction	Source visual hint, such as focusing on a red box
plain_file_name, global_file_name, contextual_file_name, evidence_file_name	Image paths relative to train/
view_sizes	Dimensions for plain, global, contextual, and evidence
source, source_image_id, source_image_name	Source provenance; the original large image is not distributed
original_size, bbox_original	Original image dimensions and evidence box in original-image coordinates
source_row_index	Zero-based source annotation row index

bbox_original is [x0, y0, x1, y1] in original-image pixels, not in the resized or cropped view. The right/bottom endpoints are exclusive. Do not draw these coordinates directly on a released 2048-pixel view without an appropriate coordinate transform. Contextual-crop coordinate transforms are not supplied.

5. Construct a question prompt

Preserve the option order and use the per-sample answer instruction. A minimal text prompt for a boxed global image can be constructed as follows:

def build_question(sample, view="global"):
    question = sample["question"]
    # The source visual hint is appropriate for the boxed full-image view.
    # Do not blindly reuse a red-box hint with unmarked plain/evidence images.
    if view == "global" and sample.get("visual_instruction"):
        question += " " + sample["visual_instruction"]
    options = "\n".join(f"{item['label']}. {item['text']}" for item in sample["choices"])
    return question + "\n\n" + options + "\n\n" + sample["answer_instruction"]

prompt = build_question(sample, view="global")
print(prompt)

Pass the image(s) and this text through your model's multimodal processor or chat template. Image placeholders are model-specific and are not inserted by this function. Ground-truth answers must not be included in the model prompt. For multiple views or crops, adapt spatial/red-box instructions to what is actually visible. The same question may be harder to localize without a box.

For single-choice questions, answer_labels contains one label, such as ["B"]. For multiple-choice questions, it may contain several labels, such as ["A", "B", "C"]; follow answer_instruction (comma-separated letters). If scoring multiple-choice predictions with exact set accuracy, parse the answer into valid labels and compare its set to set(sample["answer_labels"]). Do not treat different label orders as different answers. Invalid labels or malformed responses should be handled explicitly by the evaluation protocol.

6. Completeness checks

After downloading and extracting all four views:

assert len(samples) == 6750
assert len({row["sample_id"] for row in samples}) == len(samples)
assert sum(row["question_type"] == "single_choice" for row in samples) == 6000
assert sum(row["question_type"] == "multiple_choice" for row in samples) == 750

for view in ("plain", "global", "contextual", "evidence"):
    paths = {row[f"{view}_file_name"] for row in samples}
    assert len(paths) == 6150, (view, len(paths))
    missing = [name for name in paths if not (root / "train" / name).is_file()]
    assert not missing, (view, missing[:5])
print("All QA records and referenced image files are present.")

These checks verify counts and file presence, not image semantics or benchmark independence. A ZIP CRC check (zipfile.ZipFile(path).testzip()) additionally detects archive corruption.

7. Scope, provenance, and limitations

• The source labels in the annotations are GeoNRW, Beeldmateriaal, swissimage, and France. They identify provenance and are not license grants.
• train/ contains the released annotations; no validation/test split is provided. Multiple QA samples can share a source image. When constructing new splits, group by source_image_id rather than randomly splitting QA rows. This grouping alone does not prove absence of geographic overlap.
• This package does not itself establish independence from external benchmarks. Internal validation and overlap-audit reports are not distributed here.
• Existing contextual views are included as-is. Their exact expansion geometry has not been certified against every released image; do not infer a fixed 2× expansion or contextual-window coordinates from the directory name.
• Original large images are omitted. source_image_name, original_size, and bbox_original are retained only as provenance and annotation information.
• No dataset-wide redistribution license is asserted by this packaging step. Confirm the applicable imagery and annotation rights before redistribution or downstream use; repository availability does not override source rights.

For field-level definitions and identifier construction, see SCHEMA.md.