Cityscapes-Datensatz#

Der Cityscapes-Datensatz 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 in 19 Klassen. Er gehört zu den am häufigsten verwendeten Datensätzen für die Forschung zum autonomen Fahren und zum Verständnis urbaner Szenen mit Ultralytics YOLO-Modellen.

Wichtige Funktionen#

• Die detaillierten Cityscapes-Annotationen umfassen 2.975 Trainingsbilder und 500 Validierungsbilder in 19 Klassen. Das Archiv enthält außerdem 1.525 Testbilder, deren veröffentlichten Masken jedoch nur das eigene Fahrzeug und den Bildrand kennzeichnen – echte Klassenannotationen werden zurückgehalten, und offizielle Ergebnisse auf dem Testsatz erfordern die Übermittlung von Vorhersagen an den Cityscapes-Auswertungsserver.
• Der Datensatz umfasst 19 Auswertungsklassen aus den Kategorien flach, Mensch, Fahrzeug, Bauwerk, Objekt, Natur und Himmel.
• Cityscapes stellt standardisierte Auswertungsmetriken wie die mittlere Schnittmenge über Vereinigungsmenge (mIoU) für die semantische Segmentierung bereit und ermöglicht dadurch einen effektiven Vergleich der Modellleistung.
• Bevor du den manuellen Download von ~11 GB startest, solltest du deine Trainingspipeline anhand der 8 Bilder umfassenden Cityscapes8-Teilmenge testen.

Datensatzstruktur#

Die Ultralytics-Konfiguration erwartet nach der Vorbereitung die folgende Struktur:

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

Die semantischen Masken sind einkanalige PNG-Dateien. Die ursprünglichen Cityscapes-Label-IDs werden über den Abschnitt label_mapping den standardmäßigen 19 Trainings-IDs zugeordnet. Ignorierte oder ungültige Labels werden 255 zugeordnet, sodass sie aus Training und Auswertung ausgeschlossen werden.

Anwendungen#

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

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

Dataset-YAML#

Eine YAML-Datei für den Datensatz definiert die Cityscapes-Pfade, Klassen, das Maskenverzeichnis und die Zuordnung der Labels. 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

# Load a model
model = YOLO("yolo26n-sem.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="cityscapes.yaml", epochs=100, imgsz=1024)

Zitate, Lizenz und Danksagungen#

Cityscapes wird unter einer benutzerdefinierten, nicht kommerziellen Lizenz veröffentlicht – der Datensatz ist für akademische Forschung und Auswertung kostenlos, für die kommerzielle Nutzung, Lizenzierung oder Weiterverteilung der Daten ist jedoch eine gesonderte Genehmigung des Cityscapes-Teams erforderlich.

Wenn du den Cityscapes-Datensatz in deiner Forschungs- 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 für die Erstellung und Pflege dieser wertvollen Ressource für die Fachgemeinschaften des autonomen Fahrens und der Computer Vision danken. Weitere Informationen zum Cityscapes-Datensatz und seinen Erstellern findest du auf der Website des Cityscapes-Datensatzes.

FAQ#