xView Datensatz#
Das xView-Dataset ist einer der größten öffentlich verfügbaren Satellitenbild-Benchmarks für die object detection und bietet über 1 Million Objektinstanzen in 60 Klassen, die mit bounding boxes in mehr als 1.400 km² 0,3 m WorldView-3-Bildmaterial annotiert sind. Es wurde für die DIUx xView 2018 Challenge von der U.S. National Geospatial-Intelligence Agency (NGA) veröffentlicht und erfordert einen manuellen Download von etwa 20,7 GB.
Das Dataset wurde entwickelt, um vier computer vision-Grenzbereiche voranzutreiben:
- Verringerung der Mindestauflösung für die Erkennung.
- Verbesserung der Lerneffizienz.
- Ermöglichung der Entdeckung weiterer Objektklassen.
- Verbesserung der Erkennung feingranularer Klassen.
Aufbauend auf Benchmarks wie COCO zielt xView auf Luftbilder ab, bei denen Objekte viel kleiner und dichter gepackt sind als auf Fotos aus der Bodenperspektive.
Das xView-Dataset wird nicht automatisch heruntergeladen. Registriere dich auf der Website der DIUx xView 2018 Challenge, um train_images.zip (~15 GB), train_labels.zip und val_images.zip (~5 GB) herunterzuladen, und entpacke sie dann unter datasets/xView/, sodass es Folgendes enthält:
datasets/xView/
├── train_images/ # 847 TIF satellite images
├── val_images/ # 282 TIF images (no public labels)
└── xView_train.geojson # bounding-box annotationsBeim ersten Trainingsdurchlauf konvertiert Ultralytics die GeoJSON-Annotationen automatisch in das YOLO-Format und teilt die annotierten Bilder grob im Verhältnis 90/10 in Trainings- und Validierungssets auf – eine manuelle Konvertierung ist nicht erforderlich.
Hauptfunktionen#
- Fein granulierte Klassen: 60 Objektklassen, die Flugzeuge, Fahrzeuge, Eisenbahnmaterial, Wasserfahrzeuge, Baumaschinen und Gebäude umfassen – viele davon klein, selten und visuell ähnlich.
- Hohe Auflösung: 0,3 m Bodenauflösung (Ground Sample Distance), erfasst von WorldView-3-Satelliten.
- Dichte Annotation: über 1 Million Objektinstanzen auf mehr als 1.400 km² Bildmaterial, alle mit horizontalen Bounding Boxes markiert.
- Automatische Konvertierung: Das Ultralytics-Download-Skript konvertiert die ursprünglichen GeoJSON-Labels in das YOLO-Format und generiert beim ersten Gebrauch den Trainings-/Validierungs-Split.
Datensatzstruktur#
xView-Bilder sind große Satellitenszenen im TIF-Format, und nur die 847 Trainingsbilder werden mit öffentlichen Labels ausgeliefert – der Validierungssatz der Challenge mit 282 Bildern hat keine. Die Ultralytics xView.yaml-Konfiguration teilt die annotierten Bilder daher beim ersten Gebrauch automatisch auf:
| Split | Bilder | Beschreibung |
|---|---|---|
| Trainieren | ~90 % von 847 | Annotierte Bilder, die in autosplit_train.txt aufgeführt sind und beim ersten Durchlauf generiert werden |
| Validation | ~10 % von 847 | Annotierte Bilder, die in autosplit_val.txt aufgeführt sind und zur evaluation verwendet werden |
Die 60 Klassen decken feingranulare Kategorien wie Fixed-wing Aircraft, Cargo Plane, Small Car, Bus, Locomotive, Maritime Vessel, Excavator, Building, Aircraft Hangar und Storage Tank ab; die vollständige Liste befindet sich unten im Dataset YAML. Während der Konvertierung werden die ursprünglichen Challenge-Klassen-IDs (11–94) auf fortlaufende Indizes von 0 bis 59 abgebildet.
Anwendungen#
Die feingranularen Klassen von xView und der hochauflösende Luftbild-Blickwinkel machen es zu einem Standard-Benchmark für das Training und die Evaluierung von deep learning-Modellen in der remote sensing. Zu den häufigen Anwendungsfällen gehören:
- Militärische Aufklärung und Verteidigung
- Stadtplanung und -entwicklung
- Umweltüberwachung
- Katastrophenhilfe und -bewertung
- Infrastruktur-Kartierung und -Management
Weitere Benchmarks für Luftbilder findest du im drohnenfokussierten VisDrone dataset oder im Dataset für orientierte Boxen DOTA-v2 dataset.
Datensatz-YAML#
Die Datei xView.yaml definiert die Dataset-Konfiguration – die Pfade des Datasets, die 60 Klassennamen und das Download-Skript, das die GeoJSON-Annotationen konvertiert und den Autosplit generiert. Sie wird im Ultralytics-Repository unter https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/xView.yaml gepflegt.
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
# DIUx xView 2018 Challenge dataset https://challenge.xviewdataset.org by U.S. National Geospatial-Intelligence Agency (NGA)
# -------- Download and extract data manually to `datasets/xView` before running the train command. --------
# Documentation: https://docs.ultralytics.com/datasets/detect/xview
# Example usage: yolo train data=xView.yaml
# parent
# ├── ultralytics
# └── datasets
# └── xView ← downloads here (20.7 GB)
# Train/val/test sets as 1) dir: path/to/imgs, 2) file: path/to/imgs.txt, or 3) list: [path/to/imgs1, path/to/imgs2, ..]
path: xView # dataset root dir
train: images/autosplit_train.txt # train images (relative to 'path') 90% of 847 train images
val: images/autosplit_val.txt # val images (relative to 'path') 10% of 847 train images
# Classes
names:
0: Fixed-wing Aircraft
1: Small Aircraft
2: Cargo Plane
3: Helicopter
4: Passenger Vehicle
5: Small Car
6: Bus
7: Pickup Truck
8: Utility Truck
9: Truck
10: Cargo Truck
11: Truck w/Box
12: Truck Tractor
13: Trailer
14: Truck w/Flatbed
15: Truck w/Liquid
16: Crane Truck
17: Railway Vehicle
18: Passenger Car
19: Cargo Car
20: Flat Car
21: Tank car
22: Locomotive
23: Maritime Vessel
24: Motorboat
25: Sailboat
26: Tugboat
27: Barge
28: Fishing Vessel
29: Ferry
30: Yacht
31: Container Ship
32: Oil Tanker
33: Engineering Vehicle
34: Tower crane
35: Container Crane
36: Reach Stacker
37: Straddle Carrier
38: Mobile Crane
39: Dump Truck
40: Haul Truck
41: Scraper/Tractor
42: Front loader/Bulldozer
43: Excavator
44: Cement Mixer
45: Ground Grader
46: Hut/Tent
47: Shed
48: Building
49: Aircraft Hangar
50: Damaged Building
51: Facility
52: Construction Site
53: Vehicle Lot
54: Helipad
55: Storage Tank
56: Shipping container lot
57: Shipping Container
58: Pylon
59: Tower
# Download script/URL (optional) ---------------------------------------------------------------------------------------
download: |
import json
from pathlib import Path
import shutil
import numpy as np
from PIL import Image
from ultralytics.utils import TQDM
from ultralytics.data.split import autosplit
from ultralytics.utils.ops import xyxy2xywhn
def convert_labels(fname=Path("xView/xView_train.geojson")):
"""Convert xView GeoJSON labels to YOLO format (classes 0-59) and save them as text files."""
path = fname.parent
with open(fname, encoding="utf-8") as f:
print(f"Loading {fname}...")
data = json.load(f)
# Make dirs
labels = path / "labels" / "train"
shutil.rmtree(labels, ignore_errors=True)
labels.mkdir(parents=True, exist_ok=True)
# xView classes 11-94 to 0-59
xview_class2index = [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, -1, 3, -1, 4, 5, 6, 7, 8, -1, 9, 10, 11,
12, 13, 14, 15, -1, -1, 16, 17, 18, 19, 20, 21, 22, -1, 23, 24, 25, -1, 26, 27, -1, 28, -1,
29, 30, 31, 32, 33, 34, 35, 36, 37, -1, 38, 39, 40, 41, 42, 43, 44, 45, -1, -1, -1, -1, 46,
47, 48, 49, -1, 50, 51, -1, 52, -1, -1, -1, 53, 54, -1, 55, -1, -1, 56, -1, 57, -1, 58, 59]
shapes = {}
for feature in TQDM(data["features"], desc=f"Converting {fname}"):
p = feature["properties"]
if p["bounds_imcoords"]:
image_id = p["image_id"]
image_file = path / "train_images" / image_id
if image_file.exists(): # 1395.tif missing
try:
box = np.array([int(num) for num in p["bounds_imcoords"].split(",")])
assert box.shape[0] == 4, f"incorrect box shape {box.shape[0]}"
cls = p["type_id"]
cls = xview_class2index[int(cls)] # xView class to 0-59
assert 59 >= cls >= 0, f"incorrect class index {cls}"
# Write YOLO label
if image_id not in shapes:
shapes[image_id] = Image.open(image_file).size
box = xyxy2xywhn(box[None].astype(float), w=shapes[image_id][0], h=shapes[image_id][1], clip=True)
with open((labels / image_id).with_suffix(".txt"), "a", encoding="utf-8") as f:
f.write(f"{cls} {' '.join(f'{x:.6f}' for x in box[0])}\n") # write label.txt
except Exception as e:
print(f"WARNING: skipping one label for {image_file}: {e}")
# Download manually from https://challenge.xviewdataset.org
dir = Path(yaml["path"]) # dataset root dir
# urls = [
# "https://d307kc0mrhucc3.cloudfront.net/train_labels.zip", # train labels
# "https://d307kc0mrhucc3.cloudfront.net/train_images.zip", # 15G, 847 train images
# "https://d307kc0mrhucc3.cloudfront.net/val_images.zip", # 5G, 282 val images (no labels)
# ]
# download(urls, dir=dir)
# Convert labels
convert_labels(dir / "xView_train.geojson")
# Move images
images = Path(dir / "images")
images.mkdir(parents=True, exist_ok=True)
Path(dir / "train_images").rename(dir / "images" / "train")
Path(dir / "val_images").rename(dir / "images" / "val")
# Split
autosplit(dir / "images" / "train")Verwendung#
Für das Training wird erwartet, dass der oben beschriebene manuelle Download unter datasets/xView/ entpackt wird; die Annotationskonvertierung und die Aufteilung in Train/Val erfolgen dann automatisch.
Um ein Modell für 100 epochs mit einer Bildgröße von 640 auf dem xView-Dataset zu trainieren, kannst du die folgenden Code-Snippets verwenden. Eine vollständige Liste der verfügbaren Argumente findest du auf der Training-Seite des Modells.
from ultralytics import YOLO
# Load a model
model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training)
# Train the model
results = model.train(data="xView.yaml", epochs=100, imgsz=640)Um zusätzliche Satellitenbilder zu annotieren und xView-Trainingsläufe in deinem Browser zu verwalten, verwende die Ultralytics Platform.
Beispieldaten und Annotationen#
Das Beispiel unten zeigt eine typische xView-Szene: hochauflösende Luftbilder, in denen kleine Objekte wie Fahrzeuge und Gebäude mit bounding boxes annotiert sind, was veranschaulicht, warum die object detection in Satellitenbildern eine feingranulare Lokalisierung erfordert.

Zitate und Danksagungen#
Wenn du den xView-Datensatz in deiner Forschungs- oder Entwicklungsarbeit verwendest, zitiere bitte das folgende Papier:
@misc{lam2018xview,
title={xView: Objects in Context in Overhead Imagery},
author={Darius Lam and Richard Kuzma and Kevin McGee and Samuel Dooley and Michael Laielli and Matthew Klaric and Yaroslav Bulatov and Brendan McCord},
year={2018},
eprint={1802.07856},
archivePrefix={arXiv},
primaryClass={cs.CV}
}Wir möchten der Defense Innovation Unit (DIU) und den Erstellern des xView-Datasets für ihren wertvollen Beitrag zur Computer-Vision-Forschungsgemeinschaft danken. Weitere Informationen findest du auf der xView dataset website.
FAQ#
Das xView-Dataset ist ein Satellitenbild-Benchmark, der für die DIUx xView 2018 Challenge von der U.S. National Geospatial-Intelligence Agency veröffentlicht wurde, und bietet über 1 Million Objektinstanzen in 60 feingranularen Klassen in 0,3 m WorldView-3-Bildmaterial. Es unterstützt die Forschung zur Erkennung kleiner, seltenster und feingranularer Objekte in Luftbildern, die weitaus schwierigere Ziele darstellen als solche auf Fotos aus der Bodenperspektive.
xView erfordert einen manuellen Download: Registriere dich auf der Website der DIUx xView 2018 Challenge, lade
train_images.zip(~15 GB),train_labels.zipundval_images.zip(~5 GB) herunter – insgesamt etwa 20,7 GB – und entpacke sie unterdatasets/xView/entsprechend dem Layout, das in der Warnung oben auf dieser Seite gezeigt wird. Beim ersten Trainingslauf konvertiert Ultralytics die GeoJSON-Annotationen automatisch in das YOLO-Format und erstellt die Aufteilung in Training/Validierung.xView enthält 847 annotierte Trainingsbilder und 282 Validierungsbilder ohne öffentliche Labels, die alle von WorldView-3-Satelliten mit einer Auflösung von 0,3 m aufgenommen wurden. Die Annotationen umfassen über 1 Million Objektinstanzen in 60 Klassen. Da nur die Trainings-Labels öffentlich sind, teilt die Ultralytics
xView.yaml-Konfiguration die 847 annotierten Bilder im Verhältnis von etwa 90/10 in Trainings- und Validierungssätze auf; siehe Dataset Structure für Details.Trainiere ein YOLO26n-Modell auf xView für 100 Epochen bei einer Bildgröße von 640:
Trainingsbeispielfrom ultralytics import YOLO # Load a model model = YOLO("yolo26n.pt") # load a pretrained model (recommended for training) # Train the model results = model.train(data="xView.yaml", epochs=100, imgsz=640)Detaillierte Argumente und Einstellungen findest du auf der Training-Seite des Modells.
Zitiere das Paper „xView: Objects in Context in Overhead Imagery“ (Lam et al., arXiv:1802.07856, 2018); der vollständige BibTeX-Eintrag befindet sich im Abschnitt Citations and Acknowledgments oben.



