Link to this sectionJeu de données TT100K#
Le jeu de données Tsinghua-Tencent 100K (TT100K) est une référence de panneaux de signalisation pour la détection d'objets, créée par Zhu et al. pour l'article de la CVPR 2016 Traffic-Sign Detection and Classification in the Wild. La configuration Ultralytics TT100K fournit 16 817 images (6 105 pour l'entraînement / 7 641 pour la validation / 3 071 pour le test) réparties sur 221 catégories de panneaux de signalisation, la référence source faisant état de plus de 30 000 instances de panneaux. Le « 100K » dans le nom fait référence aux quelque 100 000 images Tencent Street View à partir desquelles la référence a été créée — et non au nombre d'images que tu télécharges et sur lesquelles tu t'entraînes. Comme l'article original ne conserve que les catégories comptant au moins 100 instances d'entraînement, il existe un sous-ensemble couramment utilisé de 45 classes, mais la configuration Ultralytics conserve les 221 catégories annotées (dont beaucoup sont rares).
Les images haute résolution street-view capturent de grandes variations d'éclairage, de météo, d'angle de vue et de distance, faisant de TT100K une référence exigeante pour la détection de petits objets dans des scènes de conduite réelles.
Link to this sectionFonctionnalités clés#
- Détection multi-classes : 221 catégories de panneaux de signalisation couvrant les limitations de vitesse chinoises, les interdictions, les avertissements, les limites de hauteur/largeur et les panneaux informatifs.
- Haute résolution : images de 2048×2048 pixels, les panneaux allant donc de gros plans à de minuscules marqueurs distants qui sollicitent la détection fine.
- Conditions réelles : Grandes variations de météo, d'éclairage, d'angle de vue et d'occlusion.
- Annotations de boîte englobante : Chaque panneau est étiqueté avec une classe et une bounding box au format YOLO après conversion automatique.
- Divisions prédéfinies : Divisions fixes pour l'entraînement / la validation / le test (6 105 / 7 641 / 3 071 images) pour une évaluation cohérente.
Link to this sectionStructure du jeu de données#
La configuration Ultralytics TT100K est divisée en trois sous-ensembles, partageant tous les mêmes 221 catégories :
| Split | Images | Description |
|---|---|---|
| Entraîner (Train) | 6 105 | Images de scènes de circulation étiquetées utilisées pour entraîner le détecteur |
| Validation | 7 641 | La division originale « autre » du jeu de données, utilisée pour l'évaluation |
| Test | 3 071 | Images mises de côté pour l'évaluation finale du modèle entraîné |
Les 221 catégories sont organisées en plusieurs groupes principaux :
- Panneaux de limitation de vitesse — limites prohibitives
pl*(par ex., pl5–pl120) et vitesses minimalespm*(par ex., pm5–pm55). - Panneaux d'interdiction — interdictions générales
p1–p29, interdictions d'entrée/stationnementpn/pneet restrictionspr*(pr10–pr100). - Panneaux d'avertissement —
w1–w67pour les dangers routiers tels que les passages piétons, les virages serrés, les routes glissantes et les travaux. - Panneaux de limite de hauteur/largeur — limites de hauteur
ph*(par ex., ph2–ph5.5) et limites de largeurpb/pw*. - Panneaux informatifs — informations générales
i1–i15, informations sur la limitation de vitesseil*(il50–il110), autresioet panneaux d'informationip.
Link to this sectionApplications#
TT100K est largement utilisé pour construire et comparer la reconnaissance des panneaux de signalisation dans des conditions réelles. Les applications courantes incluent :
- Systèmes de perception pour la conduite autonome
- Systèmes avancés d'aide à la conduite (ADAS)
- Surveillance du trafic et analyse des infrastructures routières
- Aménagement urbain et études de flux de circulation
- Recherche en vision par ordinateur sur les petits objets dans les images haute résolution
Link to this sectionYAML du jeu de données#
Le fichier TT100K.yaml définit la configuration du jeu de données — les chemins des données, les noms des classes et le script de téléchargement et de conversion automatique. Il est maintenu dans le dépôt Ultralytics à l'adresse https://github.com/ultralytics/ultralytics/blob/main/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#
TT100K se télécharge automatiquement lors de ton premier entraînement et nécessite environ 18 Go d'espace disque libre. Lors de la première utilisation, le script de téléchargement récupère les données originales et convertit les annotations au format YOLO, ce qui peut prendre plusieurs minutes.
Pour entraîner un modèle YOLO26n sur le jeu de données TT100K pendant 100 époques avec une taille d'image de 640, tu peux utiliser les extraits de code suivants. Pour une liste complète des arguments disponibles, consulte la page Entraînement du modèle.
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)Pour étiqueter des images de panneaux de signalisation supplémentaires et gérer tes exécutions d'entraînement TT100K dans ton navigateur, utilise Ultralytics Platform.
Link to this sectionExemples de données et d'annotations#
Les images TT100K sont des scènes de rue en 2048×2048 où les panneaux de signalisation n'occupent souvent qu'une petite fraction de l'image. Une seule image peut contenir plusieurs panneaux à des échelles et distances différentes, certains étant partiellement masqués par des véhicules, de la végétation ou des structures, et capturés dans des conditions de jour/nuit et par temps clair/pluvieux. Ce mélange de petits objets et de conditions difficiles est ce qui fait de ce jeu de données un test solide de la robustesse du détecteur.
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 :
@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 utilisé pour la détection et la classification des panneaux de signalisation dans des conditions réelles. Ses 221 catégories et son imagerie haute résolution de type street-view en font une référence courante pour la perception en conduite autonome, les systèmes avancés d'aide à la conduite (ADAS) et la recherche sur la détection de petits objets.
Link to this sectionCombien d'images y a-t-il dans le jeu de données TT100K ?#
La configuration Ultralytics TT100K contient 16 817 images : 6 105 pour l'entraînement, 7 641 pour la validation (la division « autre » originale du jeu de données) et 3 071 pour le test. Consulte la section Structure du jeu de données pour le détail complet.
Link to this sectionPourquoi l'appelle-t-on 100K s'il n'y a qu'environ 16 800 images ?#
Le « 100K » fait référence aux quelque 100 000 images Tencent Street View à partir desquelles la référence originale a été créée. La configuration de détection Ultralytics fournit 16 817 de ces images avec des étiquettes au format YOLO ; le nom reflète la collection source, pas la taille du jeu d'entraînement.
Link to this sectionCombien de catégories de panneaux de signalisation y a-t-il dans TT100K ?#
TT100K définit 221 catégories couvrant les panneaux de limitation de vitesse, d'interdiction, d'avertissement, de limite de hauteur/largeur et informatifs. L'article original ne conserve que les 45 catégories ayant au moins 100 instances d'entraînement, mais la configuration Ultralytics en conserve les 221. Voir Structure du jeu de données pour la répartition par groupe.
Link to this sectionQuelle est la taille du téléchargement du jeu de données TT100K ?#
TT100K pèse environ 18 Go et se télécharge automatiquement la première fois que tu t'entraînes avec data="TT100K.yaml" — aucun téléchargement manuel n'est requis. Le script convertit également les annotations originales au format YOLO lors de la première exécution.
Link to this sectionComment entraîner un modèle YOLO26 sur le jeu de données TT100K ?#
Entraîne un modèle YOLO26n sur TT100K pour 100 époques avec une taille d'image de 640 :
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étaillées, consulte la page Entraînement et les conseils pour l'entraînement des modèles.
Link to this sectionComment gérer les grandes images 2048×2048 dans TT100K ?#
Commence avec imgsz=640 pour les premières expériences, puis passe à imgsz=1280 (avec un batch plus petit) si tu as assez de mémoire GPU, car la résolution supérieure aide à récupérer les petits panneaux distants :
model.train(data="TT100K.yaml", imgsz=1280, batch=4) # higher resolution for small signsTu peux également ajuster l'augmentation des données et envisager des stratégies de tuilage (tiling) pour les très petits objets. Voir Conseils pour l'entraînement des modèles pour en savoir plus.