Link to this sectionxView Datensatz#

Das xView-Dataset ist einer der größten öffentlich verfügbaren Benchmarks für Satellitenbilder im Bereich der Objekterkennung und bietet über 1 Million Objektinstanzen in 60 Klassen, die mit Bounding Boxes in mehr als 1.400 km² WorldView-3-Bildmaterial mit einer Auflösung von 0,3 m 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 Fronten der Computer Vision 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 Overhead-Aufnahmen ab, bei denen Objekte weitaus kleiner und dichter gepackt sind als auf Fotos vom Boden aus.

datasets/xView/
├── train_images/          # 847 TIF satellite images
├── val_images/            # 282 TIF images (no public labels)
└── xView_train.geojson    # bounding-box annotations

Link to this sectionHauptfunktionen#

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

Link to this sectionDatensatzstruktur#

xView-Bilder sind große Satellitenszenen im TIF-Format, und nur die 847 Trainingsbilder werden mit öffentlichen Labels ausgeliefert – das Challenge-Validierungsset mit 282 Bildern enthält keine. Die Ultralytics xView.yaml-Konfiguration teilt die annotierten Bilder daher beim ersten Gebrauch automatisch auf:

Die 60 Klassen decken fein granulierte Kategorien wie Starrflügelflugzeuge, Frachtflugzeuge, Kleinwagen, Busse, Lokomotiven, Wasserfahrzeuge, Bagger, Gebäude, Flugzeughangars und Lagertanks ab; die vollständige Liste befindet sich weiter unten im Dataset YAML. Während der Konvertierung werden die ursprünglichen Challenge-Klassen-IDs (11–94) auf fortlaufende Indizes von 0–59 umgemappt.

Link to this sectionAnwendungen#

Die fein granulierten Klassen und der hochauflösende Overhead-Blickwinkel von xView machen es zu einem Standard-Benchmark für das Training und die Evaluierung von Deep Learning-Modellen in der Fernerkundung. Häufige Anwendungen umfassen:

• Militärische Aufklärung und Verteidigung
• Stadtplanung und -entwicklung
• Umweltüberwachung
• Katastrophenhilfe und -bewertung
• Infrastruktur-Kartierung und -Management

Für weitere Benchmarks mit Overhead-Bildern siehe das drohnenfokussierte VisDrone-Dataset oder das DOTA-v2-Dataset für orientierte Bounding Boxes.

Link to this sectionDatensatz-YAML#

Die xView.yaml-Datei definiert die Dataset-Konfiguration – die Dataset-Pfade, 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")

Link to this sectionVerwendung#

Um ein Modell auf dem xView-Datensatz für 100 Epochen mit einer Bildgröße von 640 zu trainieren, kannst du die folgenden Code-Snippets verwenden. Eine umfassende Liste der verfügbaren Argumente findest du auf der Modell-Training-Seite.

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-Trainingsdurchläufe in deinem Browser zu verwalten, nutze die Ultralytics Platform.

Link to this sectionBeispieldaten und Annotationen#

Das Beispiel unten zeigt eine typische xView-Szene: hochauflösende Overhead-Aufnahmen, in denen kleine Objekte wie Fahrzeuge und Gebäude mit Bounding Boxes annotiert sind, was verdeutlicht, warum die Objekterkennung bei Satellitenbildern eine präzise Lokalisierung erfordert.

Link to this sectionZitate 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.

Link to this sectionFAQ#

Link to this sectionWas ist der xView-Datensatz und welchen Nutzen hat er für die Computer-Vision-Forschung?#

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 über 1 Million Objektinstanzen in 60 fein granulierten Klassen auf WorldView-3-Bildern mit 0,3 m Auflösung bereitstellt. Es unterstützt die Forschung zur Erkennung von kleinen, seltenen und fein granulierten Objekten aus der Vogelperspektive, die deutlich schwierigere Ziele darstellen als in Fotos vom Boden aus.

Link to this sectionWie kann ich das xView-Dataset herunterladen und einrichten?#

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 diese unter datasets/xView/ gemäß dem Layout, das in der Warnung am Anfang dieser Seite gezeigt wird. Beim ersten Trainingsdurchlauf konvertiert Ultralytics die GeoJSON-Annotationen automatisch in das YOLO-Format und erstellt den Trainings-/Validierungs-Split.

Link to this sectionWie viele Bilder und Klassen hat xView?#

xView enthält 847 annotierte Trainingsbilder und 282 Validierungsbilder ohne öffentliche Labels, alle von WorldView-3-Satelliten mit 0,3 m Auflösung aufgenommen. Die Annotationen umfassen über 1 Million Objektinstanzen in 60 Klassen. Da nur die Trainingslabels öffentlich sind, teilt die Ultralytics xView.yaml-Konfiguration die 847 annotierten Bilder grob im Verhältnis 90/10 in Trainings- und Validierungssets auf; siehe Dataset Structure für Details.

Link to this sectionWie trainiere ich ein YOLO26-Modell auf dem xView-Dataset?#

Trainiere ein YOLO26n-Modell auf xView für 100 Epochen bei einer Bildgröße von 640:

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)

Für detaillierte Argumente und Einstellungen siehe die Modell-Training-Seite.

Link to this sectionWie zitiere ich den xView-Datensatz in meiner Forschung?#

Zitiere das Paper "xView: Objects in Context in Overhead Imagery" (Lam et al., arXiv:1802.07856, 2018); der vollständige BibTeX-Eintrag befindet sich oben im Abschnitt Citations and Acknowledgments.