Set di dati TT100K
Il Tsinghua-Tencent 100K (TT100K) è un dataset di riferimento su larga scala relativo alla segnaletica stradale, creato a partire da 100.000 panoramiche di Tencent Street View. Questo dataset è stato progettato specificamente per il rilevamento e la classificazione della segnaletica stradale in condizioni reali, fornendo a ricercatori e sviluppatori una risorsa completa per la creazione di sistemi affidabili di riconoscimento della segnaletica stradale.
Il set di dati contiene 100.000 immagini con oltre 30.000 esempi di segnali stradali in 221 categorie diverse. Queste immagini catturano grandi variazioni di illuminamento, condizioni meteorologiche, angoli di visione e distanze, rendendole ideali per l'addestramento di modelli che devono funzionare in modo affidabile in diversi scenari reali.
Questo set di dati è particolarmente prezioso per:
- Sistemi di guida autonoma
- Sistemi avanzati di assistenza alla guida (ADAS)
- Applicazioni per il monitoraggio del traffico
- Pianificazione urbana e analisi del traffico
- Ricerca sulla visione artificiale in condizioni reali
Caratteristiche principali
Il set di dati 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: grandi variazioni di condizioni meteorologiche, illuminazione e angoli di visione
- Annotazioni dettagliate: ogni segno include etichetta di classe, riquadro di delimitazione e maschera pixel.
- Copertura completa: include segnali di divieto, di avvertimento, di obbligo e informativi.
- Divisione tra addestramento e test: divisioni predefinite per una valutazione coerente
Struttura del set di dati
Il set di dati TT100K è suddiviso in tre sottoinsiemi:
- Set di addestramento: raccolta primaria di immagini di scene di traffico utilizzata per addestrare i modelli al riconoscimento e alla classificazione dei 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 raccolta di immagini utilizzata per valutare la capacità del modello finale di detect classify i segnali classify in scenari reali.
Il set di dati TT100K comprende 221 categorie di segnali stradali organizzate in diversi gruppi principali:
Segnaletica di limite di velocità (pl, pm)
- pl_: Limiti di velocità proibitivi (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
- pm_: Limiti di velocità minimi (pm5, pm10, pm20, pm30, pm40, pm50, pm55)
Segni 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 di sosta
- pr: Vari segnali di restrizione (pr10, pr20, pr30, pr40, pr50, ecc.)
Segnali di avvertimento (w_)
- w1-w66: Segnali di pericolo relativi a vari pericoli, condizioni e situazioni stradali
- Comprende attraversamenti pedonali, curve strette, strade scivolose, animali, lavori in corso, ecc.
Segnaletica 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
Segni informativi (i, il, io, ip)
- i1-i15: Segnaletica informativa generale
- il_: Informazioni sui limiti di velocità (il60, il80, il100, il110)
- io: Altri cartelli informativi
- ip: Targhette informative
YAML del set di dati
Un file YAML (Yet Another Markup Language) viene utilizzato per definire la configurazione del set di dati. Contiene informazioni sui percorsi, sulle classi e altre informazioni rilevanti relative al set di dati. Per il set di dati TT100K, il TT100K.yaml Il file include funzionalità di download e conversione automatici.
ultralytics.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 YOLO11 sul set di dati TT100K per 100 epoche con immagini di dimensioni pari a 640, è possibile utilizzare i seguenti frammenti di codice. Il set di dati verrà scaricato automaticamente e convertito nel YOLO al primo utilizzo.
Esempio di addestramento
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.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=yolo11n.pt epochs=100 imgsz=640
Immagini di esempio e annotazioni
Ecco alcuni esempi tipici tratti dal set di dati TT100K:
- Ambienti urbani: scene stradali con più segnali stradali a varie distanze
- Scene autostradali: segnali stradali relativi alla velocità, compresi i limiti di velocità e gli indicatori di direzione
- Intersezioni complesse: più segnali in stretta vicinanza con orientamenti diversi
- Condizioni difficili: segnaletica in condizioni di illuminazione diverse (giorno/notte), condizioni meteorologiche (pioggia/nebbia) e angoli di visione diversi
Il set di dati include:
- Segni ravvicinati: segni grandi e chiaramente visibili che occupano una parte significativa dell'area dell'immagine.
- Segni distanti: piccoli segni che richiedono capacità di rilevamento molto precise
- Segni parzialmente occlusi: Segni parzialmente ostruiti da veicoli, alberi o altri oggetti
- Più segni per immagine: immagini contenenti diversi tipi di segni
Citazioni e ringraziamenti
Se utilizzi il set di dati TT100K nella tua attività di ricerca o sviluppo, ti preghiamo 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 l'Università Tsinghua e Tencent per la collaborazione nella creazione e nella manutenzione di questa preziosa risorsa per le comunità che si occupano di visione artificiale e guida autonoma. Per ulteriori informazioni sul dataset TT100K, visitate il sito web ufficiale del dataset.
FAQ
A cosa serve il set di dati TT100K?
Il set di dati Tsinghua-Tencent 100K (TT100K) è stato progettato specificamente per il rilevamento e la classificazione dei segnali stradali in condizioni reali. Viene utilizzato principalmente per:
- Formazione sui sistemi di percezione della guida autonoma
- Sviluppo di sistemi avanzati di assistenza alla guida (ADAS)
- Ricerca sul rilevamento affidabile di oggetti in condizioni variabili
- Benchmarking degli algoritmi di riconoscimento dei segnali stradali
- Testare le prestazioni del modello su piccoli oggetti in immagini di grandi dimensioni
Con 100.000 immagini diverse di Street View e 221 categorie di segnali stradali, offre un banco di prova completo per il rilevamento dei segnali stradali nel mondo reale.
Quante categorie di segnali stradali ci sono in TT100K?
Il set di dati 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)
- Segni di divieto: oltre 28 tipi di divieti generali (p1-p28) più restrizioni (pr*, pn, pne)
- Segnali di avvertimento: oltre 60 categorie di avvertimento (w1-w66)
- Limiti di altezza/larghezza: serie ph e pb per restrizioni fisiche
- Segnaletica informativa: i1-i15, il*, io, ip per indicazioni e informazioni
Questa copertura completa include la maggior parte dei segnali stradali presenti nella rete stradale cinese.
Come posso addestrare un modello YOLO11n utilizzando il set di dati TT100K?
Per addestrare un modello YOLO11n sul set di dati TT100K per 100 epoche con immagini di dimensioni pari a 640, utilizzare l'esempio riportato di seguito.
Esempio di addestramento
from ultralytics import YOLO
# Load a model
model = YOLO("yolo11n.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=yolo11n.pt epochs=100 imgsz=640
Per configurazioni di training dettagliate, consultare la documentazione relativa al Training.
Cosa rende TT100K più impegnativo rispetto ad altri set di dati?
TT100K presenta diverse sfide uniche:
- Variazione di scala: i cartelli vanno da quelli molto piccoli (cartelli autostradali distanti) a quelli grandi (cartelli urbani ravvicinati).
- Condizioni reali: variazioni estreme di illuminazione, condizioni meteorologiche e angoli di visione
- Alta risoluzione: le immagini da 2048×2048 pixel richiedono una notevole potenza di elaborazione.
- Squilibrio di classe: alcuni tipi di segni sono molto più comuni di altri
- Scene dense: in una singola immagine possono comparire più segni
- Occlusione parziale: i segnali possono essere parzialmente oscurati da veicoli, vegetazione o strutture.
Queste sfide rendono TT100K un prezioso punto di riferimento per lo sviluppo di algoritmi di rilevamento robusti.
Come gestisco le immagini di grandi dimensioni in TT100K?
Il set di dati TT100K utilizza immagini da 2048×2048 pixel, che possono richiedere molte risorse. Ecco alcune strategie consigliate:
Per la formazione:
# 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:
- Inizia con
imgsz=640per gli esperimenti iniziali - Usa
imgsz=1280se disponi di GPU sufficiente (24 GB+) - Considerare strategie di affiancamento per segni molto piccoli
- Utilizza l'accumulo graduale per simulare lotti di dimensioni maggiori
