Jeu de données Cityscapes

Le jeu de données Cityscapes est un benchmark de segmentation sémantique à grande échelle axé sur les scènes de rues urbaines capturées dans 50 villes européennes. Il fournit des annotations au niveau du pixel de haute qualité et est l'un des jeux de données les plus utilisés pour la recherche sur la conduite autonome et la compréhension des scènes urbaines avec les modèles Ultralytics YOLO.

Fonctionnalités clés

Les annotations fines de Cityscapes incluent 2 975 images d'entraînement, 500 images de validation et 1 525 images de test.
Le jeu de données couvre 19 classes d'évaluation englobant les catégories route, véhicule, humain, construction, objet, nature et ciel.
Cityscapes fournit des métriques d'évaluation standardisées comme l'Intersection sur Union moyenne (mIoU) pour la segmentation sémantique, permettant une comparaison efficace des performances des modèles.

Structure du jeu de données

La configuration Ultralytics attend la structure suivante après préparation :

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

Les masques sémantiques sont des fichiers PNG monocanaux. Les IDs de label originaux de Cityscapes sont mappés vers les 19 IDs d'entraînement standards via la section label_mapping, et les labels ignorés ou vides sont mappés sur 255 afin qu'ils soient exclus de l'entraînement et de l'évaluation. Télécharge les archives officielles leftImg8bit et gtFine depuis le site web de Cityscapes et extrais-les à la racine du jeu de données ; le bloc de préparation dans cityscapes.yaml organise ensuite les images et les masques selon cette structure.

Applications

Cityscapes est largement utilisé pour entraîner et évaluer des modèles de deep learning en segmentation sémantique, particulièrement pour la conduite autonome, les systèmes avancés d'assistance au conducteur (ADAS) et la robotique urbaine.

Ses images haute résolution et ses annotations détaillées le rendent également précieux pour la recherche sur l'analyse de scène en temps réel, la compréhension des voies et des obstacles, et toute tâche nécessitant une compréhension dense au niveau du pixel d'environnements urbains complexes.

YAML du jeu de données

Un fichier YAML de jeu de données définit les chemins, les classes, le répertoire des masques et le mappage des labels de Cityscapes. Le fichier cityscapes.yaml est maintenu à l'adresse https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/cityscapes.yaml.

ultralytics/cfg/datasets/cityscapes.yaml

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

Utilisation

Pour entraîner un modèle YOLO26n-sem sur le jeu de données Cityscapes pendant 100 époques avec une taille d'image de 1024, tu peux utiliser les extraits de code suivants. Pour une liste complète des arguments disponibles, consulte la page Entraînement du modèle.

Exemple d'entraînement

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)

Citations et remerciements

Si tu utilises le jeu de données Cityscapes dans tes travaux de recherche ou de développement, merci de citer l'article suivant :

Citation

@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}
}

Nous tenons à remercier l'équipe de Cityscapes pour la création et la maintenance de cette ressource précieuse pour les communautés de la conduite autonome et de la vision par ordinateur. Pour plus d'informations sur le jeu de données Cityscapes et ses créateurs, visite le site web du jeu de données Cityscapes.

FAQ

Qu'est-ce que le jeu de données Cityscapes et pourquoi est-il important pour la vision par ordinateur ?

Le jeu de données Cityscapes est un benchmark de segmentation sémantique à grande échelle axé sur les scènes de rues urbaines capturées dans 50 villes européennes. Il contient 5 000 images annotées finement à travers 19 classes d'évaluation, ce qui en fait une ressource fondamentale pour la recherche sur la conduite autonome et la compréhension des scènes urbaines. Ses images haute résolution, ses annotations denses et sa métrique standardisée d'Intersection sur Union moyenne (mIoU) le rendent idéal pour évaluer des modèles de prédiction dense.

Comment puis-je entraîner un modèle YOLO en utilisant le jeu de données Cityscapes ?

Pour entraîner un modèle YOLO26n-sem sur le jeu de données Cityscapes pendant 100 époques avec une taille d'image de 1024, tu peux utiliser les extraits de code suivants. Pour une liste détaillée des arguments disponibles, consulte la page Entraînement du modèle.

Exemple d'entraînement

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)

Comment le jeu de données Cityscapes est-il structuré ?

Après préparation, le jeu de données est organisé en répertoires images/{train,val,test}/ et masks/{train,val,test}/, chaque image étant associée à un masque PNG monocanal. Le fichier YAML d'Ultralytics apparie chaque image à son masque via le champ masks_dir: masks et utilise label_mapping pour convertir les IDs de label originaux de Cityscapes en 19 IDs d'entraînement continus standards, en mappant les labels ignorés et vides sur 255.

Dois-je télécharger Cityscapes manuellement ?

Oui. Cityscapes nécessite d'accepter les termes du jeu de données sur le site officiel. Télécharge et extrais leftImg8bit et gtFine dans la racine du jeu de données cityscapes avant d'utiliser le bloc de préparation dans cityscapes.yaml pour créer la structure images/ et masks/ attendue.

Pourquoi Cityscapes utilise-t-il `label_mapping` ?

Les masques sources de Cityscapes stockent des IDs de label originaux qui diffèrent des 19 IDs d'entraînement utilisés pour l'évaluation. La section label_mapping convertit les labels valides en IDs de classe continus de 0 à 18, et assigne 255 aux labels ignorés et vides afin qu'ils soient exclus de la perte et des métriques pendant l'entraînement et la validation.

Contributors

LALaughing-q¹

Created il y a 1 heureUpdated il y a 1 heure