Meet YOLO26: next-gen vision AI.

Link to this sectionJeu 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 de panneaux de signalisation dans des conditions réelles, offrant aux chercheurs et développeurs une ressource complète pour créer des systèmes robustes de reconnaissance de signalisation.

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 annotées. 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 toutes les 221 catégories annotées, dont beaucoup sont très éparses. Ces images capturent d'importantes variations d'éclairement, 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 du monde réel.

Ce jeu de données est particulièrement précieux 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

Link to this sectionFonctionnalité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 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 des panneaux d'interdiction, d'avertissement, d'obligation et d'information
  • Répartition Entraînement/Test : Séparations prédéfinies pour une évaluation cohérente

Link to this sectionStructure 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 routières utilisée pour entraîner les modèles à détecter et classer 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 classer 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 (par ex., pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_ : Limitations de vitesse minimales (par ex., pm5, pm10, pm20, pm30, pm40, pm50, pm55)

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

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

Panneaux d'avertissement (w_)

  1. w1-w67 : Panneaux d'avertissement pour divers dangers routiers, conditions et situations
  2. Inclut les passages piétons, virages serrés, chaussées glissantes, animaux, travaux, etc.

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

  1. ph_ : Panneaux de limitation de hauteur (par ex., ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5)
  2. pb/pw_ : Panneaux de limitation de largeur

Panneaux d'information (i, il, io, ip)**

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

Link to this sectionYAML 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 données pertinentes. Pour le jeu de données TT100K, le fichier TT100K.yaml inclut une fonctionnalité de téléchargement et de conversion automatique.

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

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

Link to this sectionUtilisation#

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)

Link to this sectionExemples d'images et 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 routiers à grande vitesse incluant des limitations de vitesse et des indicateurs de direction
  3. Intersections complexes : Panneaux multiples à proximité immédiate avec des orientations variables
  4. Conditions difficiles : Panneaux sous différents éclairages (jour/nuit), météo (pluie/brouillard) et angles de vue

Le jeu de données inclut :

  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 obstrué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

Link to this sectionCitations 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 précieuse ressource 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.

Link to this sectionFAQ#

Link to this sectionÀ 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 de panneaux de signalisation dans des conditions réelles. Il est principalement utilisé pour :

  1. L'entraînement de systèmes de perception pour la conduite autonome
  2. Le développement de systèmes avancés d'aide à la conduite (ADAS)
  3. La recherche en détection d'objets robuste dans des conditions variables
  4. L'évaluation comparative des algorithmes de reconnaissance de signalisation
  5. Le test des performances de modèles sur de petits objets dans de grandes images

Avec 100 000 images de rue diversifiées et 221 catégories de panneaux, il offre un banc d'essai complet pour la détection de signalisation réelle.

Link to this sectionCombien de catégories de panneaux de signalisation y a-t-il dans TT100K ?#

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

  1. Limitations de vitesse : pl* limitations d'interdiction et pm* vitesses minimales (par ex., pl40, pl120, pm30, pm55)
  2. Panneaux d'interdiction : 29 types d'interdiction générale (p1-p29) plus des restrictions (pr*, pn, pne)
  3. Panneaux d'avertissement : plus de 60 catégories d'avertissement (w1-w67)
  4. Limitations de hauteur/largeur : séries ph* hauteur et pw* largeur pour les restrictions physiques
  5. Panneaux d'information : 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.

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

Link to this sectionQu'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 d'éclairage, de météo et d'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 développer des algorithmes de détection robustes.

Link to this sectionComment 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 tuilage pour les très petits panneaux
  • Utilise l'accumulation de gradients pour simuler des tailles de batch plus grandes
Contributeurs
GLglenn-jocher4RAraimbekovm1PRPrashantDixit01

Commentaires