Dataset TT100K
Il Tsinghua-Tencent 100K (TT100K) è un dataset benchmark su larga scala per segnali stradali, creato da 100.000 panorami di Tencent Street View. Questo dataset è specificamente progettato per il detect e la classificazione dei segnali stradali in condizioni reali, fornendo a ricercatori e sviluppatori una risorsa completa per la costruzione di sistemi robusti di riconoscimento dei segnali stradali.
Il dataset contiene 100.000 immagini con oltre 30.000 istanze di segnali stradali distribuite in 221 diverse categorie. Queste immagini catturano ampie variazioni di illuminazione, condizioni meteorologiche, angoli di visione e distanze, rendendolo ideale per l'addestramento di modelli che devono funzionare in modo affidabile in diversi scenari del mondo reale.
Questo dataset è particolarmente prezioso per:
- Sistemi di guida autonoma
- Sistemi avanzati di assistenza alla guida (ADAS)
- Applicazioni di monitoraggio del traffico
- Pianificazione urbana e analisi del traffico
- Ricerca sulla visione artificiale in condizioni reali
Caratteristiche principali
Il dataset TT100K offre diversi vantaggi chiave:
- Scala: 100.000 immagini ad alta risoluzione (2048×2048 pixel)
- Diversità: 221 categorie di segnali stradali che coprono i segnali stradali cinesi
- Condizioni reali: Ampie variazioni di condizioni meteorologiche, illuminazione e angoli di visione
- Annotazioni dettagliate: Ogni segnale include etichetta di classe, bounding box e maschera di pixel
- Copertura completa: Include segnali di divieto, di pericolo, di obbligo e di informazione
- Suddivisione Train/Test: Suddivisioni predefinite per una valutazione coerente
Struttura del set di dati
Il dataset TT100K è suddiviso in tre sottoinsiemi:
- Set di Addestramento: La collezione principale di immagini di scene di traffico utilizzate per addestrare i modelli a detect e classify diversi tipi di segnali stradali.
- Set di Validazione: Un sottoinsieme utilizzato durante lo sviluppo del modello per monitorare le prestazioni e ottimizzare gli iperparametri.
- Set di Test: Una collezione di immagini riservate utilizzate per valutare la capacità del modello finale di detect e classify segnali stradali in scenari reali.
Il dataset TT100K include 221 categorie di segnali stradali organizzate in diversi gruppi principali:
Segnali di Limite di Velocità (pl, pm)
- pl_: Limiti di velocità di divieto (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
- pm_: Limiti di velocità minimi (pm5, pm10, pm20, pm30, pm40, pm50, pm55)
Segnali di Divieto (p, pn, pr_)
- p1-p28: Segnali di divieto generali (divieto di accesso, divieto di sosta, divieto di fermata, ecc.)
- pn/pne: Segnali di divieto di accesso e divieto di sosta
- pr: Vari segnali di restrizione (pr10, pr20, pr30, pr40, pr50, ecc.)
Segnali di Pericolo (w_)
- w1-w66: Segnali di pericolo per vari rischi stradali, condizioni e situazioni
- Include attraversamenti pedonali, curve strette, strade scivolose, animali, lavori in corso, ecc.
Segnali di Limite di Altezza/Larghezza (ph, pb)
- ph_: Segnali di limite di altezza (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5, ecc.)
- pb_: Segnali di limite di larghezza
Segnali di Informazione (i, il, io, ip)
- i1-i15: Segnali informativi generali
- il_: Informazioni sul limite di velocità (il60, il80, il100, il110)
- io: Altri segnali informativi
- ip: Targhe informative
YAML del set di dati
Un file YAML (Yet Another Markup Language) viene utilizzato per definire la configurazione del dataset. Contiene informazioni sui percorsi, le classi e altre informazioni pertinenti del dataset. Per il dataset TT100K, il TT100K.yaml file include funzionalità di download e conversione automatici.
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)
Utilizzo
Per addestrare un modello YOLO26 sul dataset TT100K per 100 epoche con una dimensione dell'immagine di 640, è possibile utilizzare i seguenti snippet di codice. Il dataset verrà scaricato e convertito automaticamente nel formato YOLO al primo utilizzo.
Esempio di addestramento
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
Immagini di esempio e annotazioni
Ecco alcuni esempi tipici dal dataset TT100K:
- Ambienti urbani: Scene stradali con molteplici segnali stradali a varie distanze
- Scene autostradali: Segnali stradali ad alta velocità, inclusi limiti di velocità e indicatori di direzione
- Intersezioni complesse: Segnali multipli in prossimità ravvicinata con orientamenti variabili
- Condizioni impegnative: Segnali in diverse condizioni di illuminazione (giorno/notte), meteorologiche (pioggia/nebbia) e angoli di visualizzazione
Il dataset include:
- Segnali ravvicinati: Segnali grandi e chiaramente visibili che occupano un'area significativa dell'immagine
- Segnali distanti: Segnali piccoli che richiedono capacità di detect a grana fine
- Segnali parzialmente occlusi: Segnali parzialmente bloccati da veicoli, alberi o altri oggetti
- Segnali multipli per immagine: Immagini contenenti diversi tipi di segnali
Citazioni e ringraziamenti
Se si utilizza il dataset TT100K nel proprio lavoro di ricerca o sviluppo, si prega di citare il seguente articolo:
@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}
}
Desideriamo ringraziare la collaborazione tra l'Università di Tsinghua e Tencent per aver creato e mantenuto questa preziosa risorsa per le comunità di visione artificiale e guida autonoma. Per maggiori informazioni sul dataset TT100K, visitare il sito web ufficiale del dataset.
FAQ
A cosa serve il dataset TT100K?
Il dataset Tsinghua-Tencent 100K (TT100K) è specificamente progettato per il detect e la classificazione dei segnali stradali in condizioni reali. È utilizzato principalmente per:
- Addestramento di sistemi di percezione per la guida autonoma
- Sviluppo di Sistemi Avanzati di Assistenza alla Guida (ADAS)
- Ricerca nel detect robusto di oggetti in condizioni variabili
- Benchmarking di algoritmi di riconoscimento dei segnali stradali
- Test delle prestazioni del modello su oggetti piccoli in immagini grandi
Con 100.000 diverse immagini di street view e 221 categorie di segnali stradali, fornisce un banco di prova completo per il detect di segnali stradali nel mondo reale.
Quante categorie di segnali stradali ci sono in TT100K?
Il dataset TT100K contiene 221 diverse categorie di segnali stradali, tra cui:
- Limiti di velocità: da pl5 a pl120 (limiti di divieto) e da pm5 a pm55 (velocità minime)
- Segnali di divieto: oltre 28 tipi di divieto generale (p1-p28) più restrizioni (pr*, pn, pne)
- Segnali di pericolo: oltre 60 categorie di pericolo (w1-w66)
- Limiti di altezza/larghezza: serie ph e pb per restrizioni fisiche
- Segnali informativi: i1-i15, il*, io, ip per orientamento e informazioni
Questa copertura completa include la maggior parte dei segnali stradali presenti nelle reti stradali cinesi.
Come posso addestrare un modello YOLO26n utilizzando il dataset TT100K?
Per addestrare un modello YOLO26n sul dataset TT100K per 100 epoche con una dimensione dell'immagine di 640, utilizzare l'esempio seguente.
Esempio di addestramento
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
Per configurazioni di training dettagliate, consultare la documentazione relativa al Training.
Cosa rende TT100K impegnativo rispetto ad altri dataset?
TT100K presenta diverse sfide uniche:
- Variazione di scala: I segnali vanno da molto piccoli (segnali autostradali distanti) a grandi (segnali urbani ravvicinati)
- Condizioni reali: Variazioni estreme di illuminazione, condizioni meteorologiche e angoli di visione
- Alta risoluzione: Immagini da 2048×2048 pixel richiedono una notevole potenza di elaborazione
- Squilibrio di classe: Alcuni tipi di segnali sono molto più comuni di altri
- Scene dense: Più segnali possono apparire in una singola immagine
- Occlusione parziale: I segnali possono essere parzialmente bloccati da veicoli, vegetazione o strutture
Queste sfide rendono TT100K un benchmark prezioso per lo sviluppo di algoritmi di detect robusti.
Come gestisco le grandi dimensioni delle immagini in TT100K?
Il dataset TT100K utilizza immagini di 2048×2048 pixel, che possono essere ad alta intensità di risorse. Ecco le strategie raccomandate:
Per l'addestramento:
# 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
Raccomandazioni:
- Iniziare con
imgsz=640per esperimenti iniziali - Usa
imgsz=1280se si dispone di memoria GPU sufficiente (24GB+) - Considerare strategie di tiling per segnali molto piccoli
- Utilizzare l'accumulo di gradiente per simulare dimensioni di batch maggiori
