TT100K-Datensatz
Der Tsinghua-Tencent 100K (TT100K) ist ein umfangreicher Benchmark-Datensatz für Verkehrszeichen, der aus 100.000 Tencent Street View-Panoramabildern erstellt wurde. Dieser Datensatz wurde speziell für die Erkennung und Klassifizierung von Verkehrszeichen unter realen Bedingungen entwickelt und bietet Forschern und Entwicklern eine umfassende Ressource für die Erstellung robuster Systeme zur Erkennung von Verkehrszeichen.
Der Datensatz enthält 100.000 Bilder mit über 30.000 Verkehrszeicheninstanzen aus 221 verschiedenen Kategorien. Diese Bilder zeigen große Unterschiede in Bezug auf Beleuchtungsstärke, Wetterbedingungen, Blickwinkel und Entfernungen und eignen sich daher ideal für das Training von Modellen, die in verschiedenen realen Szenarien zuverlässig funktionieren müssen.
Dieser Datensatz ist besonders wertvoll für:
- Autonome Fahrsysteme
- Fortschrittliche Fahrerassistenzsysteme (ADAS)
- Verkehrsüberwachungsanwendungen
- Stadtplanung und Verkehrsanalyse
- Computer Vision-Forschung unter realen Bedingungen
Hauptmerkmale
Der TT100K-Datensatz bietet mehrere wesentliche Vorteile:
- Maßstab: 100.000 hochauflösende Bilder (2048 × 2048 Pixel)
- Vielfalt: 221 Kategorien von Verkehrszeichen, die chinesische Verkehrszeichen abdecken
- Reale Bedingungen: Große Schwankungen bei Wetter, Beleuchtung und Blickwinkeln
- Umfangreiche Anmerkungen: Jedes Zeichen enthält eine Klassenbezeichnung, einen Begrenzungsrahmen und eine Pixelmaske.
- Umfassende Abdeckung: Umfasst Verbots-, Warn-, Gebots- und Hinweisschilder
- Train/Test-Aufteilung: Vordefinierte Aufteilungen für eine konsistente Bewertung
Dataset-Struktur
Der Datensatz TT100K ist in drei Teilmengen unterteilt:
- Trainingssatz: Die primäre Sammlung von Bildern aus Verkehrssituationen, die zum Trainieren von Modellen zur Erkennung und Klassifizierung verschiedener Arten von Verkehrszeichen verwendet wird.
- Validierungssatz: Eine Teilmenge, die während der Modellentwicklung verwendet wird, um die Leistung zu überwachen und Hyperparameter anzupassen.
- Testset: Eine zurückbehaltene Sammlung von Bildern, die verwendet wird, um die Fähigkeit des endgültigen Modells zur detect classify in realen Szenarien zu bewerten.
Der Datensatz TT100K umfasst 221 Verkehrszeichenkategorien, die in mehrere Hauptgruppen unterteilt sind:
Geschwindigkeitsbegrenzungsschilder (pl, pm)
- pl_: Geschwindigkeitsbegrenzungen (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
- pm_: Mindestgeschwindigkeitsbegrenzungen (pm5, pm10, pm20, pm30, pm40, pm50, pm55)
Verbotszeichen (p, pn, pr_)
- S. 1–28: Allgemeine Verbotszeichen (Durchfahrt verboten, Parkverbot, Halteverbot usw.)
- pn/pne: Durchfahrts- und Parkverbotsschilder
- pr: Verschiedene Beschränkungsschilder (pr10, pr20, pr30, pr40, pr50 usw.)
Warnzeichen (w_)
- w1-w66: Warnzeichen für verschiedene Gefahren, Zustände und Situationen im Straßenverkehr
- Dazu gehören Fußgängerüberwege, scharfe Kurven, rutschige Straßen, Tiere, Baustellen usw.
Höhen-/Breitenbegrenzungsschilder (ph, pb)
- ph_: Höhenbegrenzungsschilder (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5 usw.)
- pb_: Schilder zur Begrenzung der Breite
Informative Zeichen (i, il, io, ip)
- i1-i15: Allgemeine Hinweisschilder
- il_: Informationen zur Geschwindigkeitsbegrenzung (il60, il80, il100, il110)
- io: Weitere informative Schilder
- ip: Typenschilder
Datensatz-YAML
Eine YAML-Datei (Yet Another Markup Language) wird verwendet, um die Konfiguration des Datensatzes zu definieren. Sie enthält Informationen über die Pfade, Klassen und andere relevante Informationen des Datensatzes. Für den TT100K-Datensatz ist die TT100K.yaml Die Datei enthält Funktionen zum automatischen Herunterladen und Konvertieren.
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)
Nutzung
Um ein YOLO11 auf dem TT100K-Datensatz für 100 Epochen mit einer Bildgröße von 640 zu trainieren, können Sie die folgenden Codeausschnitte verwenden. Der Datensatz wird bei der ersten Verwendung automatisch heruntergeladen und in YOLO konvertiert.
Trainingsbeispiel
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
sample_images und Anmerkungen
Hier sind typische Beispiele aus dem TT100K-Datensatz:
- Städtische Umgebungen: Straßenszenen mit mehreren Verkehrszeichen in unterschiedlichen Entfernungen
- Autobahn-Szenen: Verkehrszeichen für hohe Geschwindigkeiten, einschließlich Geschwindigkeitsbegrenzungen und Richtungsanzeigen
- Komplexe Kreuzungen: Mehrere Schilder in unmittelbarer Nähe mit unterschiedlichen Ausrichtungen
- Herausfordernde Bedingungen: Schilder unter verschiedenen Lichtverhältnissen (Tag/Nacht), Wetterbedingungen (Regen/Nebel) und Blickwinkeln
Der Datensatz umfasst:
- Nahaufnahmen von Schildern: Große, gut sichtbare Schilder, die einen bedeutenden Teil des Bildes einnehmen.
- Entfernte Zeichen: Kleine Zeichen, die eine fein abgestufte Erkennungsfähigkeit erfordern
- Teilweise verdeckte Schilder: Schilder, die teilweise durch Fahrzeuge, Bäume oder andere Objekte verdeckt sind.
- Mehrere Schilder pro Bild: Bilder, die mehrere verschiedene Schildtypen enthalten
Zitate und Danksagungen
Wenn Sie den TT100K-Datensatz in Ihrer Forschungs- oder Entwicklungsarbeit verwenden, zitieren Sie bitte die folgende Veröffentlichung:
@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}
}
Wir möchten der Tsinghua-Universität und Tencent für die Zusammenarbeit bei der Erstellung und Pflege dieser wertvollen Ressource für die Bereiche Computer Vision und autonomes Fahren danken. Weitere Informationen zum TT100K-Datensatz finden Sie auf der offiziellen Website des Datensatzes.
FAQ
Wofür wird der TT100K-Datensatz verwendet?
Der Datensatz Tsinghua-Tencent 100K (TT100K) wurde speziell für die Erkennung und Klassifizierung von Verkehrszeichen unter realen Bedingungen entwickelt. Er wird in erster Linie für folgende Zwecke verwendet:
- Training autonomer Fahrwahrnehmungssysteme
- Entwicklung fortschrittlicher Fahrerassistenzsysteme (ADAS)
- Forschung zur robusten Objekterkennung unter wechselnden Bedingungen
- Benchmarking von Algorithmen zur Erkennung von Verkehrszeichen
- Testen der Modellleistung bei kleinen Objekten in großen Bildern
Mit 100.000 vielfältigen Straßenansichten und 221 Kategorien von Verkehrszeichen bietet es eine umfassende Testumgebung für die Erkennung von Verkehrszeichen in der realen Welt.
Wie viele Verkehrszeichentypen gibt es in TT100K?
Der Datensatz TT100K enthält 221 verschiedene Verkehrszeichenkategorien, darunter:
- Geschwindigkeitsbegrenzungen: pl5 bis pl120 (Verbotsbegrenzungen) und pm5 bis pm55 (Mindestgeschwindigkeiten)
- Verbotszeichen: 28+ allgemeine Verbotsarten (p1-p28) plus Einschränkungen (pr*, pn, pne)
- Warnzeichen: Über 60 Warnkategorien (w1-w66)
- Höhen-/Breitenbeschränkungen: Serien ph und pb für physische Einschränkungen
- Informationsschilder: i1-i15, il*, io, ip zur Orientierung und Information
Diese umfassende Abdeckung umfasst die meisten Verkehrszeichen, die im chinesischen Straßennetz zu finden sind.
Wie kann ich ein YOLO11n-Modell mit dem TT100K-Datensatz trainieren?
Um ein YOLO11n-Modell auf dem TT100K-Datensatz für 100 Epochen mit einer Bildgröße von 640 zu trainieren, verwenden Sie das folgende Beispiel.
Trainingsbeispiel
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
Detaillierte Trainingskonfigurationen finden Sie in der Trainingsdokumentation.
Was macht TT100K im Vergleich zu anderen Datensätzen so anspruchsvoll?
TT100K stellt mehrere einzigartige Herausforderungen dar:
- Größenunterschiede: Die Schilder reichen von sehr klein (entfernte Autobahnschilder) bis groß (Nahaufnahmen von Stadtschildern).
- Reale Bedingungen: Extreme Schwankungen bei Beleuchtung, Wetter und Blickwinkeln
- Hohe Auflösung: Bilder mit einer Auflösung von 2048×2048 Pixeln erfordern eine erhebliche Rechenleistung.
- Klassenungleichgewicht: Einige Zeichentypen kommen viel häufiger vor als andere.
- Dichte Szenen: In einem einzigen Bild können mehrere Zeichen erscheinen.
- Teilweise Verdeckung: Die Zeichen können teilweise durch Fahrzeuge, Vegetation oder Bauwerke verdeckt sein.
Diese Herausforderungen machen TT100K zu einem wertvollen Maßstab für die Entwicklung robuster Erkennungsalgorithmen.
Wie gehe ich mit den großen Bildgrößen in TT100K um?
Der TT100K-Datensatz verwendet Bilder mit einer Auflösung von 2048×2048 Pixeln, was sehr ressourcenintensiv sein kann. Hier sind einige empfohlene Strategien:
Für Schulungen:
# 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
Empfehlungen:
- Beginnen Sie mit
imgsz=640für erste Experimente - Verwenden Sie
imgsz=1280wenn Sie über ausreichend GPU (24 GB+) verfügen - Überlegen Sie sich Strategien für die Anordnung sehr kleiner Schilder.
- Verwenden Sie Gradientenakkumulation, um größere Chargengrößen zu simulieren.
