YOLO Vision 2026:

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:

  1. Verringerung der Mindestauflösung für die Erkennung.
  2. Verbesserung der Lerneffizienz.
  3. Ermöglichung der Entdeckung weiterer Objektklassen.
  4. 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.

Manueller Download erforderlich

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 annotations

Beim 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:

SplitBilderBeschreibung
Trainieren~90 % von 847Annotierte Bilder, die in autosplit_train.txt aufgeführt sind und beim ersten Durchlauf generiert werden
Validation~10 % von 847Annotierte 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/cfg/datasets/xView.yaml
# 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#

20,7 GB manueller Download

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.

Trainingsbeispiel
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.

xView dataset overhead satellite imagery with object detection

Zitate und Danksagungen#

Wenn du den xView-Datensatz in deiner Forschungs- oder Entwicklungsarbeit verwendest, zitiere bitte das folgende Papier:

Zitat
@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.zip und val_images.zip (~5 GB) herunter – insgesamt etwa 20,7 GB – und entpacke sie unter datasets/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:

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

    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.

Kommentare