Modifier la page sur GitHub (EN)

Jeu de données TT100K

Le Tsinghua-Tencent 100K (TT100K) est un jeu de données de référence à grande échelle pour les panneaux de signalisation, créé à partir de 100 000 panoramas de Tencent Street View. Ce jeu de données est spécifiquement conçu pour la détection et la classification des panneaux de signalisation dans des conditions réelles, offrant aux chercheurs et aux développeurs une ressource complète pour créer des systèmes de reconnaissance de panneaux de signalisation robustes.

Le jeu de données contient 100 000 images avec plus de 30 000 instances de panneaux de signalisation réparties dans 221 catégories d'annotation. L'article original applique un seuil de 100 instances par classe pour l'apprentissage supervisé, ce qui donne un sous-ensemble couramment utilisé de 45 classes ; cependant, la configuration du jeu de données Ultralytics fournie conserve les 221 catégories annotées, dont beaucoup sont très rares. Ces images capturent de grandes variations d'éclairage, de conditions météorologiques, d'angles de vue et de distances, ce qui le rend idéal pour entraîner des modèles devant fonctionner de manière fiable dans divers scénarios réels.

Ce jeu de données est particulièrement utile pour :

  • Les systèmes de conduite autonome
  • Les systèmes avancés d'aide à la conduite (ADAS)
  • Les applications de surveillance du trafic
  • L'urbanisme et l'analyse du trafic
  • La recherche en vision par ordinateur dans des conditions réelles

Fonctionnalités clés

Le jeu de données TT100K offre plusieurs avantages clés :

  • Échelle : 100 000 images haute résolution (2048×2048 pixels)
  • Diversité : 221 catégories de panneaux de signalisation couvrant les panneaux de signalisation chinois
  • Conditions réelles : Grandes variations de météo, d'éclairage et d'angles de vue
  • Annotations riches : Chaque panneau inclut une étiquette de classe, une boîte englobante et un masque de pixel
  • Couverture complète : Inclut les panneaux d'interdiction, d'avertissement, d'obligation et d'information
  • Répartition Train/Test : Séparations prédéfinies pour une évaluation cohérente

Structure du jeu de données

Le jeu de données TT100K est divisé en trois sous-ensembles :

  1. Ensemble d'entraînement : La collection principale d'images de scènes de circulation utilisée pour entraîner des modèles à détecter et classifier différents types de panneaux de signalisation.
  2. Ensemble de validation : Un sous-ensemble utilisé pendant le développement du modèle pour surveiller les performances et ajuster les hyperparamètres.
  3. Ensemble de test : Une collection d'images mise de côté pour évaluer la capacité du modèle final à détecter et classifier les panneaux de signalisation dans des scénarios réels.

Le jeu de données TT100K inclut 221 catégories de panneaux de signalisation organisées en plusieurs groupes principaux :

Panneaux de limitation de vitesse (pl, pm)**

  1. pl_ : Limitations de vitesse prohibitives (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_ : Limitations de vitesse minimales (pm5, pm10, pm20, pm30, pm40, pm50, pm55)

Panneaux d'interdiction (p, pn, pr_)**

  1. p1-p28 : Panneaux d'interdiction généraux (accès interdit, stationnement interdit, arrêt interdit, etc.)
  2. pn/pne : Panneaux d'accès interdit et de stationnement interdit
  3. pr : Divers panneaux de restriction (pr10, pr20, pr30, pr40, pr50, etc.)

Panneaux d'avertissement (w_)

  1. w1-w66 : Panneaux d'avertissement pour divers dangers, conditions et situations routières
  2. Inclut les passages piétons, les virages serrés, les routes glissantes, les animaux, les travaux, etc.

Panneaux de limitation de hauteur/largeur (ph, pb)**

  1. ph_ : Panneaux de limitation de hauteur (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5, etc.)
  2. pb_ : Panneaux de limitation de largeur

Panneaux informatifs (i, il, io, ip)**

  1. i1-i15 : Panneaux informatifs généraux
  2. il_ : Informations sur la limitation de vitesse (il60, il80, il100, il110)
  3. io : Autres panneaux informatifs
  4. ip : Plaques d'information

YAML du jeu de données

Un fichier YAML (Yet Another Markup Language) est utilisé pour définir la configuration du jeu de données. Il contient des informations sur les chemins du jeu de données, les classes et d'autres informations pertinentes. Pour le jeu de données TT100K, le fichier TT100K.yaml inclut une fonctionnalité de téléchargement et de conversion automatiques.

ultralytics/cfg/datasets/TT100K.yaml
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# Tsinghua-Tencent 100K (TT100K) dataset https://cg.cs.tsinghua.edu.cn/traffic-sign/ by Tsinghua University
# Documentation: https://cg.cs.tsinghua.edu.cn/traffic-sign/tutorial.html
# Paper: Traffic-Sign Detection and Classification in the Wild (CVPR 2016)
# License: CC BY-NC 2.0 license for non-commercial use only
# Example usage: yolo train data=TT100K.yaml
# parent
# ├── ultralytics
# └── datasets
#     └── TT100K ← downloads here (~18 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: TT100K # dataset root dir
train: images/train # train images (relative to 'path') 6105 images
val: images/val # val images (relative to 'path') 7641 images (original 'other' split)
test: images/test # test images (relative to 'path') 3071 images

# Classes (221 traffic sign categories, 45 with sufficient training instances)
names:
  0: pl5
  1: pl10
  2: pl15
  3: pl20
  4: pl25
  5: pl30
  6: pl40
  7: pl50
  8: pl60
  9: pl70
  10: pl80
  11: pl90
  12: pl100
  13: pl110
  14: pl120
  15: pm5
  16: pm10
  17: pm13
  18: pm15
  19: pm20
  20: pm25
  21: pm30
  22: pm35
  23: pm40
  24: pm46
  25: pm50
  26: pm55
  27: pm8
  28: pn
  29: pne
  30: ph4
  31: ph4.5
  32: ph5
  33: ps
  34: pg
  35: ph1.5
  36: ph2
  37: ph2.1
  38: ph2.2
  39: ph2.4
  40: ph2.5
  41: ph2.8
  42: ph2.9
  43: ph3
  44: ph3.2
  45: ph3.5
  46: ph3.8
  47: ph4.2
  48: ph4.3
  49: ph4.8
  50: ph5.3
  51: ph5.5
  52: pb
  53: pr10
  54: pr100
  55: pr20
  56: pr30
  57: pr40
  58: pr45
  59: pr50
  60: pr60
  61: pr70
  62: pr80
  63: pr90
  64: p1
  65: p2
  66: p3
  67: p4
  68: p5
  69: p6
  70: p7
  71: p8
  72: p9
  73: p10
  74: p11
  75: p12
  76: p13
  77: p14
  78: p15
  79: p16
  80: p17
  81: p18
  82: p19
  83: p20
  84: p21
  85: p22
  86: p23
  87: p24
  88: p25
  89: p26
  90: p27
  91: p28
  92: pa8
  93: pa10
  94: pa12
  95: pa13
  96: pa14
  97: pb5
  98: pc
  99: pg
  100: ph1
  101: ph1.3
  102: ph1.5
  103: ph2
  104: ph3
  105: ph4
  106: ph5
  107: pi
  108: pl0
  109: pl4
  110: pl5
  111: pl8
  112: pl10
  113: pl15
  114: pl20
  115: pl25
  116: pl30
  117: pl35
  118: pl40
  119: pl50
  120: pl60
  121: pl65
  122: pl70
  123: pl80
  124: pl90
  125: pl100
  126: pl110
  127: pl120
  128: pm2
  129: pm8
  130: pm10
  131: pm13
  132: pm15
  133: pm20
  134: pm25
  135: pm30
  136: pm35
  137: pm40
  138: pm46
  139: pm50
  140: pm55
  141: pn
  142: pne
  143: po
  144: pr10
  145: pr100
  146: pr20
  147: pr30
  148: pr40
  149: pr45
  150: pr50
  151: pr60
  152: pr70
  153: pr80
  154: ps
  155: w1
  156: w2
  157: w3
  158: w5
  159: w8
  160: w10
  161: w12
  162: w13
  163: w16
  164: w18
  165: w20
  166: w21
  167: w22
  168: w24
  169: w28
  170: w30
  171: w31
  172: w32
  173: w34
  174: w35
  175: w37
  176: w38
  177: w41
  178: w42
  179: w43
  180: w44
  181: w45
  182: w46
  183: w47
  184: w48
  185: w49
  186: w50
  187: w51
  188: w52
  189: w53
  190: w54
  191: w55
  192: w56
  193: w57
  194: w58
  195: w59
  196: w60
  197: w62
  198: w63
  199: w66
  200: i1
  201: i2
  202: i3
  203: i4
  204: i5
  205: i6
  206: i7
  207: i8
  208: i9
  209: i10
  210: i11
  211: i12
  212: i13
  213: i14
  214: i15
  215: il60
  216: il80
  217: il100
  218: il110
  219: io
  220: ip

# Download script/URL (optional) ---------------------------------------------------------------------------------------
download: |
  import json
  import shutil
  from pathlib import Path

  from PIL import Image

  from ultralytics.utils import TQDM
  from ultralytics.utils.downloads import download

  def tt100k2yolo(dir):
      """Convert TT100K annotations to YOLO format with images/{split} and labels/{split} structure."""
      data_dir = dir / "data"
      anno_file = data_dir / "annotations.json"

      print("Loading annotations...")
      with open(anno_file, encoding="utf-8") as f:
          data = json.load(f)

      # Build class name to index mapping from yaml
      names = yaml["names"]
      class_to_idx = {v: k for k, v in names.items()}

      # Create directories
      for split in ["train", "val", "test"]:
          (dir / "images" / split).mkdir(parents=True, exist_ok=True)
          (dir / "labels" / split).mkdir(parents=True, exist_ok=True)

      print("Converting annotations to YOLO format...")
      skipped = 0
      for img_id, img_data in TQDM(data["imgs"].items(), desc="Processing"):
          img_path_str = img_data["path"]
          if "train" in img_path_str:
              split = "train"
          elif "test" in img_path_str:
              split = "test"
          else:
              split = "val"

          # Source and destination paths
          src_img = data_dir / img_path_str
          if not src_img.exists():
              continue

          dst_img = dir / "images" / split / src_img.name

          # Get image dimensions
          try:
              with Image.open(src_img) as img:
                  img_width, img_height = img.size
          except Exception as e:
              print(f"Error reading {src_img}: {e}")
              continue

          # Copy image to destination
          shutil.copy2(src_img, dst_img)

          # Convert annotations
          label_file = dir / "labels" / split / f"{src_img.stem}.txt"
          lines = []

          for obj in img_data.get("objects", []):
              category = obj["category"]
              if category not in class_to_idx:
                  skipped += 1
                  continue

              bbox = obj["bbox"]
              xmin, ymin = bbox["xmin"], bbox["ymin"]
              xmax, ymax = bbox["xmax"], bbox["ymax"]

              # Convert to YOLO format (normalized center coordinates and dimensions)
              x_center = ((xmin + xmax) / 2.0) / img_width
              y_center = ((ymin + ymax) / 2.0) / img_height
              width = (xmax - xmin) / img_width
              height = (ymax - ymin) / img_height

              # Clip to valid range
              x_center = max(0, min(1, x_center))
              y_center = max(0, min(1, y_center))
              width = max(0, min(1, width))
              height = max(0, min(1, height))

              cls_idx = class_to_idx[category]
              lines.append(f"{cls_idx} {x_center:.6f} {y_center:.6f} {width:.6f} {height:.6f}\n")

          # Write label file
          if lines:
              label_file.write_text("".join(lines), encoding="utf-8")

      if skipped:
          print(f"Skipped {skipped} annotations with unknown categories")
      print("Conversion complete!")

  # Download
  dir = Path(yaml["path"])  # dataset root dir
  urls = ["https://cg.cs.tsinghua.edu.cn/traffic-sign/data_model_code/data.zip"]
  download(urls, dir=dir, curl=True, threads=1)

  # Convert
  tt100k2yolo(dir)

Utilisation

Pour entraîner un modèle YOLO26 sur le jeu de données TT100K pendant 100 epochs avec une taille d'image de 640, tu peux utiliser les extraits de code suivants. Le jeu de données sera automatiquement téléchargé et converti au format YOLO lors de la première utilisation.

Exemple d'entraînement
from ultralytics import YOLO

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

# Train the model - dataset will auto-download on first run
results = model.train(data="TT100K.yaml", epochs=100, imgsz=640)

Exemples d'images et d'annotations

Voici des exemples typiques du jeu de données TT100K :

  1. Environnements urbains : Scènes de rue avec plusieurs panneaux de signalisation à diverses distances
  2. Scènes d'autoroute : Panneaux de signalisation à haute vitesse incluant des limitations de vitesse et des indicateurs de direction
  3. Intersections complexes : Plusieurs panneaux à proximité immédiate avec des orientations variées
  4. Conditions difficiles : Panneaux sous différents éclairages (jour/nuit), météos (pluie/brouillard) et angles de vue

Le jeu de données comprend :

  1. Panneaux en gros plan : Grands panneaux clairement visibles occupant une zone importante de l'image
  2. Panneaux distants : Petits panneaux nécessitant des capacités de détection fine
  3. Panneaux partiellement occultés : Panneaux partiellement bloqués par des véhicules, des arbres ou d'autres objets
  4. Plusieurs panneaux par image : Images contenant plusieurs types de panneaux différents

Citations et remerciements

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

Citation
@InProceedings{Zhu_2016_CVPR,
    author = {Zhu, Zhe and Liang, Dun and Zhang, Songhai and Huang, Xiaolei and Li, Baoli and Hu, Shimin},
    title = {Traffic-Sign Detection and Classification in the Wild},
    booktitle = {The IEEE Conference on Computer Vision and Pattern Recognition (CVPR)},
    month = {June},
    year = {2016}
}

Nous tenons à remercier l'Université Tsinghua et Tencent pour leur collaboration dans la création et la maintenance de cette ressource précieuse pour les communautés de la vision par ordinateur et de la conduite autonome. Pour plus d'informations sur le jeu de données TT100K, visite le site officiel du jeu de données.

FAQ

À quoi sert le jeu de données TT100K ?

Le jeu de données Tsinghua-Tencent 100K (TT100K) est spécifiquement conçu pour la détection et la classification des panneaux de signalisation dans des conditions réelles. Il est principalement utilisé pour :

  1. Entraîner des systèmes de perception pour la conduite autonome
  2. Développer des systèmes avancés d'aide à la conduite (ADAS)
  3. La recherche sur la détection d'objets robuste dans des conditions variées
  4. L'évaluation comparative des algorithmes de reconnaissance de panneaux de signalisation
  5. Tester les performances des modèles sur de petits objets dans de grandes images

Avec 100 000 images de scènes de rue variées et 221 catégories de panneaux de signalisation, il fournit un banc d'essai complet pour la détection des panneaux de signalisation en conditions réelles.

Combien de catégories de panneaux de signalisation y a-t-il dans TT100K ?

Le jeu de données TT100K contient 221 catégories différentes de panneaux de signalisation, notamment :

  1. Limitations de vitesse : pl5 à pl120 (limitations prohibitives) et pm5 à pm55 (vitesses minimales)
  2. Panneaux d'interdiction : 28+ types d'interdiction généraux (p1-p28) plus des restrictions (pr*, pn, pne)
  3. Panneaux d'avertissement : 60+ catégories d'avertissement (w1-w66)
  4. Limitations de hauteur/largeur : séries ph* et pb* pour les restrictions physiques
  5. Panneaux informatifs : i1-i15, il*, io, ip pour le guidage et l'information

Cette couverture complète inclut la plupart des panneaux de signalisation trouvés sur les réseaux routiers chinois.

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

Pour entraîner un modèle YOLO26n sur le jeu de données TT100K pendant 100 epochs avec une taille d'image de 640, utilise l'exemple ci-dessous.

Exemple d'entraînement
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="TT100K.yaml", epochs=100, imgsz=640)

Pour des configurations d'entraînement détaillées, consulte la documentation Entraînement.

Qu'est-ce qui rend TT100K difficile par rapport à d'autres jeux de données ?

TT100K présente plusieurs défis uniques :

  1. Variation d'échelle : Les panneaux vont de très petits (panneaux d'autoroute distants) à grands (panneaux urbains en gros plan)
  2. Conditions réelles : Variations extrêmes de l'éclairage, de la météo et des angles de vue
  3. Haute résolution : Les images de 2048×2048 pixels nécessitent une puissance de traitement importante
  4. Déséquilibre des classes : Certains types de panneaux sont beaucoup plus courants que d'autres
  5. Scènes denses : Plusieurs panneaux peuvent apparaître dans une seule image
  6. Occlusion partielle : Les panneaux peuvent être partiellement bloqués par des véhicules, de la végétation ou des structures

Ces défis font de TT100K une référence précieuse pour le développement d'algorithmes de détection robustes.

Comment gérer les grandes tailles d'image dans TT100K ?

Le jeu de données TT100K utilise des images de 2048×2048 pixels, ce qui peut être gourmand en ressources. Voici les stratégies recommandées :

Pour l'entraînement :

# Option 1: Resize to standard YOLO size
model.train(data="TT100K.yaml", imgsz=640, batch=16)

# Option 2: Use larger size for better small object detection
model.train(data="TT100K.yaml", imgsz=1280, batch=4)

# Option 3: Multi-scale training
model.train(data="TT100K.yaml", imgsz=640, scale=0.5)  # trains at varying scales

Recommandations :

  • Commence avec imgsz=640 pour les expériences initiales
  • Utilise imgsz=1280 si tu disposes de suffisamment de mémoire GPU (24 Go+)
  • Envisage des stratégies de pavage pour les très petits panneaux
  • Utilise l'accumulation de gradients pour simuler de plus grandes tailles de batch
Contributors
Modifier la page sur GitHub (EN)
GLglenn-jocher2RAraimbekovm1PRPrashantDixit01

Commentaires