xView-Datensatz#
Der xView-Datensatz ist einer der größten öffentlich verfügbaren Benchmarks für Satellitenbilder zur Objekterkennung. Er umfasst mehr als 1 Million Objektinstanzen aus 60 Klassen, die mit Begrenzungsrahmen in über 1.400 km² WorldView-3-Bildmaterial mit einer Auflösung von 0,3 m annotiert wurden. Er wurde für die DIUx xView 2018 Challenge von der Nationalen US-Agentur für Geospatial-Intelligence (NGA) veröffentlicht und erfordert einen manuellen Download von etwa 20,7 GB.
Der Datensatz wurde entwickelt, um vier Bereiche der Computer Vision voranzubringen:
- Die für die Erkennung erforderliche Mindestauflösung reduzieren.
- Die Lerneffizienz verbessern.
- Die Erkennung weiterer Objektklassen ermöglichen.
- Die Erkennung fein abgestufter Klassen verbessern.
Aufbauend auf Benchmarks wie COCO konzentriert sich xView auf Aufnahmen aus der Vogelperspektive, in denen Objekte deutlich kleiner und dichter angeordnet sind als auf Aufnahmen vom Boden.
Der xView-Datensatz 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 anschließend unter datasets/xView/, sodass dieser Ordner 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 Trainingslauf konvertiert Ultralytics die GeoJSON-Annotationen in das YOLO-Format und teilt die annotierten Bilder automatisch ungefähr im Verhältnis 90/10 in Trainings- und Validierungsdatensätze auf – eine manuelle Konvertierung ist nicht erforderlich.
Wichtige Funktionen#
- Fein abgestufte Klassen: 60 Objektklassen aus den Bereichen Luftfahrzeuge, Fahrzeuge, Schienenfahrzeuge, Schiffe, Baumaschinen und Gebäude – viele davon klein, selten und visuell ähnlich.
- Hohe Auflösung: Bodenauflösung von 0,3 m, erfasst von WorldView-3-Satelliten.
- Dichte Annotationen: mehr als 1 Million Objektinstanzen in über 1.400 km² Bildmaterial, alle mit horizontalen Begrenzungsrahmen annotiert.
- Automatische Konvertierung: Das Ultralytics-Downloadskript konvertiert die ursprünglichen GeoJSON-Labels in das YOLO-Format und erzeugt bei der ersten Verwendung die Aufteilung in Trainings- und Validierungsdaten.
Datensatzstruktur#
xView-Bilder sind große Satellitenszenen im TIF-Format, und nur die 847 Trainingsbilder werden mit öffentlich verfügbaren Labels ausgeliefert – für den 282 Bilder umfassenden Validierungsdatensatz der Challenge gibt es keine. Die Ultralytics-Konfiguration xView.yaml teilt die annotierten Bilder daher bei der ersten Verwendung automatisch auf:
| Aufteilung | Bilder | Beschreibung |
|---|---|---|
| Trainieren | ~90 % von 847 | In autosplit_train.txt aufgeführte annotierte Bilder, die beim ersten Lauf erzeugt werden |
| Validierung | ~10 % von 847 | In autosplit_val.txt aufgeführte annotierte Bilder, die zur Evaluierung verwendet werden |
Die 60 Klassen umfassen fein abgestufte Kategorien wie Starrflügler, Frachtflugzeug, Kleinwagen, Bus, Lokomotive, Schiff, Bagger, Gebäude, Flugzeughangar und Lagertank. Die vollständige Liste findest du unten in der Dataset-YAML-Datei. Während der Konvertierung werden die ursprünglichen Klassen-IDs der Challenge (11–94) auf fortlaufende Indizes von 0–59 abgebildet.
Anwendungen#
Die fein abgestuften Klassen und die hochauflösende Perspektive aus der Vogelansicht machen xView zu einem Standardbenchmark für das Training und die Evaluierung von Deep-Learning-Modellen in der Fernerkundung. Häufige Anwendungsbereiche sind:
- Aufklärung im Militär- und Verteidigungsbereich
- Stadtplanung und Stadtentwicklung
- Umweltüberwachung
- Katastrophenhilfe und Schadensbewertung
- Kartierung und Verwaltung von Infrastruktur
Weitere Benchmarks für Aufnahmen aus der Vogelperspektive findest du im drohnenorientierten VisDrone-Datensatz oder im DOTA-v2-Datensatz mit orientierten Begrenzungsrahmen.
Dataset-YAML#
Die Datei xView.yaml definiert die Datensatzkonfiguration – die Pfade zum Datensatz, die 60 Klassennamen und das Downloadskript, das die GeoJSON-Annotationen konvertiert und die automatische Aufteilung erzeugt. 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 muss der oben beschriebene manuelle Download unter datasets/xView/ entpackt werden. Die Konvertierung der Annotationen und die Aufteilung in Trainings- und Validierungsdaten werden anschließend automatisch ausgeführt.
Um ein Modell 100 Epochen lang mit einer Bildgröße von 640 auf dem xView-Datensatz zu trainieren, kannst du die folgenden Codebeispiele verwenden. Eine vollständige Liste der verfügbaren Argumente findest du auf der Seite Training 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 folgende Beispiel zeigt eine typische xView-Szene: hochauflösende Aufnahmen aus der Vogelperspektive, in denen kleine Objekte wie Fahrzeuge und Gebäude mit Begrenzungsrahmen annotiert sind. Es veranschaulicht, warum die Objekterkennung in Satellitenbildern eine fein abgestufte Lokalisierung erfordert.
Zitate und Danksagungen#
Wenn du den xView-Datensatz für deine Forschungs- oder Entwicklungsarbeit verwendest, zitiere bitte die folgende Veröffentlichung:
@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 die Defense Innovation Unit (DIU) und den Erstellern des xView-Datensatzes für ihren wertvollen Beitrag zur Forschungscommunity im Bereich Computer Vision danken. Weitere Informationen findest du auf der Website des xView-Datensatzes.
FAQ#
Der xView-Datensatz ist ein Benchmark für Satellitenbilder, der für die DIUx xView 2018 Challenge von der Nationalen US-Agentur für Geospatial-Intelligence veröffentlicht wurde. Er umfasst mehr als 1 Million Objektinstanzen aus 60 fein abgestuften Klassen in WorldView-3-Bildmaterial mit einer Auflösung von 0,3 m. Er unterstützt die Forschung zur Erkennung kleiner, seltener und fein abgestufter Objekte aus der Vogelperspektive, die deutlich schwieriger zu erkennen sind als Objekte auf Aufnahmen vom Boden.
Für xView ist ein manueller Download erforderlich: 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 gemäß der im Warnhinweis oben auf dieser Seite gezeigten Struktur unterdatasets/xView/. Beim ersten Trainingslauf konvertiert Ultralytics die GeoJSON-Annotationen automatisch in das YOLO-Format und erstellt die Aufteilung in Trainings- und Validierungsdaten.xView enthält 847 annotierte Trainingsbilder und 282 Validierungsbilder ohne öffentlich verfügbare Labels. Alle wurden von WorldView-3-Satelliten mit einer Auflösung von 0,3 m aufgenommen. Die Annotationen umfassen mehr als 1 Million Objektinstanzen aus 60 Klassen. Da nur die Trainingslabels öffentlich verfügbar sind, teilt die Ultralytics-Konfiguration
xView.yamldie 847 annotierten Bilder ungefähr im Verhältnis 90/10 in Trainings- und Validierungsdatensätze auf. Weitere Informationen findest du unter Dataset-Struktur.Trainiere ein YOLO26n-Modell 100 Epochen lang mit einer Bildgröße von 640 auf xView:
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)Ausführliche Argumente und Einstellungen findest du auf der Seite Training des Modells.
Zitiere die Veröffentlichung „xView: Objects in Context in Overhead Imagery“ (Lam et al., arXiv:1802.07856, 2018). Den vollständigen BibTeX-Eintrag findest du oben im Abschnitt Zitate und Danksagungen.