Cityscapes-Datensatz#

Der Datensatz Cityscapes ist ein groß angelegter Benchmark für die semantische Segmentierung urbaner Straßenszenen aus 50 europäischen Städten. Er umfasst 2.975 detailliert annotierte Trainingsbilder und 500 Validierungsbilder mit 19 Klassen. Er zählt zu den am häufigsten verwendeten Datensätzen für die Forschung zum autonomen Fahren und zum Verständnis urbaner Szenen mit Modellen von Ultralytics YOLO.

Wichtige Funktionen#

• Die detaillierten Annotationen von Cityscapes umfassen 2.975 Trainingsbilder und 500 Validierungsbilder mit 19 Klassen. Das Archiv enthält außerdem 1.525 Testbilder, doch deren veröffentlichte Masken kennzeichnen nur das Ego-Fahrzeug und den Bildrand — Annotationen für die tatsächlichen Klassen werden zurückgehalten. Für offizielle Ergebnisse auf dem Testsatz müssen Vorhersagen beim Cityscapes-Evaluierungsserver eingereicht werden.
• Der Datensatz umfasst 19 Evaluierungsklassen aus den Kategorien flach, Mensch, Fahrzeug, Bauwerk, Objekt, Natur und Himmel.
• Cityscapes stellt standardisierte Evaluierungsmetriken wie Mean Intersection over Union (mIoU) für die semantische Segmentierung bereit und ermöglicht so einen aussagekräftigen Vergleich der Modellleistung.
• Bevor du mit dem manuellen Download von ~11 GB beginnst, prüfe deine Trainingspipeline zunächst anhand der Teilmenge Cityscapes8 mit 8 Bildern.

Datensatzstruktur#

Nach der Vorbereitung erwartet die Ultralytics-Konfiguration folgende Verzeichnisstruktur:

cityscapes/
├── images/
│   ├── train/
│   ├── val/
│   └── test/
└── masks/
    ├── train/
    ├── val/
    └── test/

Die semantischen Masken sind einkanalige PNG-Dateien. Der Abschnitt label_mapping ordnet die ursprünglichen Cityscapes-Label-IDs den standardmäßigen 19 Trainings-IDs zu. Ignorierte oder ungültige Labels werden 255 zugeordnet, damit sie beim Training und bei der Evaluierung ausgeschlossen werden.

Anwendungsfälle#

Cityscapes wird häufig zum Trainieren und Evaluieren von Deep-Learning-Modellen für die semantische Segmentierung verwendet, insbesondere für autonomes Fahren, fortgeschrittene Fahrerassistenzsysteme (ADAS) und urbane Robotik.

Die hochauflösenden Bilder und detaillierten Annotationen machen den Datensatz außerdem wertvoll für die Forschung zur Szenenanalyse in Echtzeit, zum Verständnis von Fahrspuren und Hindernissen sowie für alle Aufgaben, die ein dichtes pixelgenaues Verständnis komplexer urbaner Umgebungen erfordern. Vortrainierte YOLO26-Modelle für semantische Segmentierung erreichen auf dem Cityscapes-Validierungssatz bis zu 83,6 mIoU — die vollständige Benchmark-Tabelle findest du auf der Seite zu Modellen für semantische Segmentierung. Mit der Ultralytics Platform kannst du Cityscapes-Daten während des gesamten Modellierungsprozesses organisieren, visualisieren und verwalten.

YAML-Datei des Datensatzes#

Eine YAML-Datei für den Datensatz definiert die Cityscapes-Pfade, Klassen, das Maskenverzeichnis und die Label-Zuordnung. Die Datei cityscapes.yaml wird unter https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/cityscapes.yaml gepflegt.

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# Cityscapes semantic segmentation dataset (19 classes)
# Documentation: https://docs.ultralytics.com/datasets/semantic/cityscapes
# Example usage: yolo semantic train data=cityscapes.yaml model=yolo26n-sem.pt
# parent
# ├── ultralytics
# └── datasets
#     └── cityscapes ← downloads here (11 GB)
#         └── images
#         └── masks

# Dataset root directory
path: cityscapes # dataset root dir
train: images/train # train images (relative to 'path') 2975 images
val: images/val # val images (relative to 'path') 500 images
test: images/test # test images (relative to 'path') 1525 images

masks_dir: masks # semantic mask directory

# Cityscapes 19-class labels
names:
  0: road
  1: sidewalk
  2: building
  3: wall
  4: fence
  5: pole
  6: traffic light
  7: traffic sign
  8: vegetation
  9: terrain
  10: sky
  11: person
  12: rider
  13: car
  14: truck
  15: bus
  16: train
  17: motorcycle
  18: bicycle

# Map source label IDs to train IDs; ignore_label is converted to 255.
label_mapping:
  -1: ignore_label
  0: ignore_label
  1: ignore_label
  2: ignore_label
  3: ignore_label
  4: ignore_label
  5: ignore_label
  6: ignore_label
  7: 0
  8: 1
  9: ignore_label
  10: ignore_label
  11: 2
  12: 3
  13: 4
  14: ignore_label
  15: ignore_label
  16: ignore_label
  17: 5
  18: ignore_label
  19: 6
  20: 7
  21: 8
  22: 9
  23: 10
  24: 11
  25: 12
  26: 13
  27: 14
  28: 15
  29: ignore_label
  30: ignore_label
  31: 16
  32: 17
  33: 18

# Preparation script (requires manual Cityscapes download)
download: |
  from pathlib import Path
  from shutil import copy2

  cityscapes_dir = Path(yaml["path"])  # dataset root dir
  # Download and extract the official Cityscapes leftImg8bit and gtFine archives into cityscapes_dir first.
  leftimg8bit_dir = cityscapes_dir / "leftImg8bit"
  gtfine_dir = cityscapes_dir / "gtFine"

  for split in ("train", "val", "test"):
      print(f"Processing {split} set")
      src_image_dir = leftimg8bit_dir / split
      dst_image_dir = cityscapes_dir / "images" / split
      dst_mask_dir = cityscapes_dir / "masks" / split
      dst_image_dir.mkdir(parents=True, exist_ok=True)
      dst_mask_dir.mkdir(parents=True, exist_ok=True)

      image_paths = sorted(src_image_dir.rglob("*_leftImg8bit.png"))
      for image_path in image_paths:
          relative_path = image_path.relative_to(src_image_dir)
          mask_path = gtfine_dir / split / relative_path.parent / image_path.name.replace(
              "_leftImg8bit.png", "_gtFine_labelIds.png"
          )
          if not mask_path.exists():
              raise FileNotFoundError(f"Mask not found for {image_path}: {mask_path}")

          image_name = image_path.name.replace("_leftImg8bit", "")
          mask_name = mask_path.name.replace("_gtFine_labelIds", "")
          copy2(image_path, dst_image_dir / image_name)
          copy2(mask_path, dst_mask_dir / mask_name)

Verwendung#

Um ein YOLO26n-sem-Modell 100 Epochen lang mit einer Bildgröße von 1024 auf dem Cityscapes-Datensatz zu trainieren, kannst du die folgenden Codebeispiele verwenden. Eine vollständige Liste der verfügbaren Argumente findest du auf der Seite zum Training des Modells.

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-sem.pt")  # ein vortrainiertes Modell laden (für das Training empfohlen)

# Das Modell trainieren
results = model.train(data="cityscapes.yaml", epochs=100, imgsz=1024)

Zitate, Lizenz und Danksagungen#

Cityscapes wird unter einer speziellen nichtkommerziellen Lizenz veröffentlicht — die Nutzung für akademische Forschung und Evaluierung ist kostenlos, doch für die kommerzielle Nutzung, Lizenzierung oder Weiterverbreitung der Daten ist eine gesonderte Genehmigung des Cityscapes-Teams erforderlich.

Wenn du den Cityscapes-Datensatz für deine Forschung oder Entwicklungsarbeit verwendest, zitiere bitte die folgende Veröffentlichung:

@inproceedings{Cordts2016Cityscapes,
  title={The Cityscapes Dataset for Semantic Urban Scene Understanding},
  author={Cordts, Marius and Omran, Mohamed and Ramos, Sebastian and Rehfeld, Timo and Enzweiler, Markus and Benenson, Rodrigo and Franke, Uwe and Roth, Stefan and Schiele, Bernt},
  booktitle={Proc. of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
  year={2016}
}

Wir möchten dem Cityscapes-Team dafür danken, dass es diese wertvolle Ressource für die Fachgemeinschaften rund um autonomes Fahren und Computer Vision erstellt und gepflegt hat. Weitere Informationen zum Cityscapes-Datensatz und seinen Urhebern findest du auf der Cityscapes-Datensatz-Website.

Häufig gestellte Fragen#