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 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 la construction de systèmes robustes de reconnaissance de panneaux 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 différentes. Ces images capturent de grandes variations d'éclairement, de conditions météorologiques, d'angles de vue et de distances, ce qui le rend idéal pour l'entraînement de modèles qui doivent fonctionner de manière fiable dans divers scénarios du monde réel.
Ce jeu de données est particulièrement précieux pour :
- Systèmes de conduite autonome
- Systèmes avancés d'aide à la conduite (ADAS)
- Applications de surveillance du trafic
- Urbanisme et analyse du trafic
- Recherche en vision par ordinateur dans des conditions réelles
Principales caractéristiques
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 comprend une étiquette de classe, une boîte englobante et un masque de pixels
- Couverture complète : Inclut les panneaux d'interdiction, d'avertissement, d'obligation et d'information
- Séparation Entraînement/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 :
- Jeu d'entraînement : La collection principale d'images de scènes de trafic utilisée pour entraîner les modèles à detect et classify différents types de panneaux de signalisation.
- Jeu de validation : Un sous-ensemble utilisé pendant le développement du modèle pour surveiller les performances et ajuster les hyperparamètres.
- Jeu de test : Une collection d'images réservée utilisée pour évaluer la capacité du modèle final à detect et classify les panneaux de signalisation dans des scénarios réels.
Le jeu de données TT100K comprend 221 catégories de panneaux de signalisation organisées en plusieurs groupes majeurs :
Panneaux de limitation de vitesse (pl, pm)
- pl_ : Limitations de vitesse d'interdiction (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
- pm_ : Limitations de vitesse minimales (pm5, pm10, pm20, pm30, pm40, pm50, pm55)
Panneaux d'interdiction (p, pn, pr_)
- p1-p28 : Panneaux d'interdiction généraux (sens interdit, stationnement interdit, arrêt interdit, etc.)
- pn/pne : Panneaux sens interdit et stationnement interdit
- pr : Divers panneaux de restriction (pr10, pr20, pr30, pr40, pr50, etc.)
Panneaux d'avertissement (w_)
- w1-w66: Panneaux d'avertissement pour divers dangers routiers, conditions et situations
- Comprend les passages piétons, les virages serrés, les routes glissantes, les animaux, les chantiers, etc.
Panneaux de limitation de hauteur/largeur (ph, pb)
- ph_: Panneaux de limitation de hauteur (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5, etc.)
- pb_: Panneaux de limitation de largeur
Panneaux d'information (i, il, io, ip)
- i1-i15: Panneaux d'information généraux
- il_: Informations sur les limitations de vitesse (il60, il80, il100, il110)
- io: Autres panneaux d'information
- ip: Panneaux d'information complémentaires
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 d'accès, les classes et d'autres informations pertinentes du jeu de données. Pour le jeu de données TT100K, le TT100K.yaml fichier inclut des fonctionnalités 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 l'ensemble de données TT100K pendant 100 époques avec une taille d'image de 640, vous pouvez utiliser les extraits de code suivants. L'ensemble 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)
# Start training from a pretrained *.pt model
# Dataset will auto-download and convert on first run
yolo detect train data=TT100K.yaml model=yolo26n.pt epochs=100 imgsz=640
Images et annotations d'exemple
Voici des exemples typiques du jeu de données TT100K :
- Environnements urbains: Scènes de rue avec plusieurs panneaux de signalisation à différentes distances
- Scènes d'autoroute: Panneaux routiers à grande vitesse, y compris les limitations de vitesse et les indicateurs de direction
- Intersections complexes: Plusieurs panneaux à proximité immédiate avec des orientations variables
- Conditions difficiles: Panneaux dans différentes conditions d'éclairage (jour/nuit), météorologiques (pluie/brouillard) et angles de vue
Le jeu de données comprend :
- Panneaux en gros plan: Grands panneaux clairement visibles occupant une zone d'image significative
- Panneaux éloignés: Petits panneaux nécessitant des capacités de détection à grain fin
- Panneaux partiellement occlus: Panneaux partiellement bloqués par des véhicules, des arbres ou d'autres objets
- Plusieurs panneaux par image: Images contenant plusieurs types de panneaux différents
Citations et remerciements
Si vous utilisez le jeu de données TT100K dans vos travaux de recherche ou de développement, veuillez citer l'article suivant :
@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 à saluer la collaboration entre l'Université de Tsinghua et Tencent pour 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, visitez le site web 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 :
- L'entraînement des systèmes de perception pour la conduite autonome
- Le développement de Systèmes Avancés d'Aide à la Conduite (ADAS)
- La recherche en détection d'objets robuste dans des conditions variables
- L'évaluation comparative des algorithmes de reconnaissance des panneaux de signalisation
- Le test de la performance des modèles sur de petits objets dans de grandes images
Avec 100 000 images de vue de rue diverses et 221 catégories de panneaux de signalisation, il offre un banc d'essai complet pour la détection de 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 :
- Limitations de vitesse : pl5 à pl120 (limites d'interdiction) et pm5 à pm55 (vitesses minimales)
- Panneaux d'interdiction : plus de 28 types d'interdiction générale (p1-p28) plus des restrictions (pr*, pn, pne)
- Panneaux d'avertissement : plus de 60 catégories d'avertissement (w1-w66)
- Limitations de hauteur/largeur : séries ph et pb pour les restrictions physiques
- Panneaux d'information : i1-i15, il*, io, ip pour l'orientation et l'information
Cette couverture exhaustive inclut la plupart des panneaux de signalisation présents sur les réseaux routiers chinois.
Comment puis-je entraîner un modèle YOLO26n en utilisant l'ensemble de données TT100K ?
Pour entraîner un modèle YOLO26n sur l'ensemble de données TT100K pendant 100 époques avec une taille d'image de 640, utilisez 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)
# Start training from a pretrained *.pt model
yolo detect train data=TT100K.yaml model=yolo26n.pt epochs=100 imgsz=640
Pour les configurations d'entraînement détaillées, consultez 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 :
- Variation d'échelle : Les panneaux vont de très petits (panneaux d'autoroute éloignés) à grands (panneaux urbains en gros plan)
- Conditions réelles : Variations extrêmes d'éclairage, météorologiques et d'angles de vue
- Haute résolution : Les images de 2048×2048 pixels nécessitent une puissance de traitement significative
- Déséquilibre des classes : Certains types de panneaux sont beaucoup plus courants que d'autres
- Scènes denses : Plusieurs panneaux peuvent apparaître dans une seule image
- Occlusion partielle : Les panneaux peuvent être partiellement masqués par des véhicules, de la végétation ou des structures
Ces défis font de TT100K un banc d'essai précieux pour le développement d'algorithmes de detect 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 :
- Commencez par
imgsz=640pour les expériences initiales - Utilisez
imgsz=1280si vous disposez de suffisamment de mémoire GPU (24 Go et plus) - Envisagez des stratégies de tuilage pour les très petits panneaux
- Utilisez l'accumulation de gradients pour simuler des tailles de lot plus importantes
