Link to this sectionTT100K Dataset#
The Tsinghua-Tencent 100K (TT100K) is a large-scale traffic sign benchmark dataset created from 100,000 Tencent Street View panoramas. This dataset is specifically designed for traffic sign detection and classification in real-world conditions, providing researchers and developers with a comprehensive resource for building robust traffic sign recognition systems.
The dataset contains 100,000 images with over 30,000 traffic sign instances across 221 annotation categories. The original paper applies a 100-instance threshold per class for supervised training, yielding a commonly used 45-class subset; however, the provided Ultralytics dataset configuration retains all 221 annotated categories, many of which are very sparse. These images capture large variations in illuminance, weather conditions, viewing angles, and distances, making it ideal for training models that need to perform reliably in diverse real-world scenarios.
This dataset is particularly valuable for:
- Autonomous driving systems
- Advanced driver assistance systems (ADAS)
- Traffic monitoring applications
- Urban planning and traffic analysis
- Computer vision research in real-world conditions
Link to this sectionKey Features#
The TT100K dataset provides several key advantages:
- Scale: 100,000 high-resolution images (2048×2048 pixels)
- Diversity: 221 traffic sign categories covering Chinese traffic signs
- Real-world conditions: Large variations in weather, illumination, and viewing angles
- Rich annotations: Each sign includes class label, bounding box, and pixel mask
- Comprehensive coverage: Includes prohibitory, warning, mandatory, and informative signs
- Train/Test split: Pre-defined splits for consistent evaluation
Link to this sectionDataset Structure#
The TT100K dataset is split into three subsets:
- Training Set: The primary collection of traffic-scene images used to train models for detecting and classifying different types of traffic signs.
- Validation Set: A subset used during model development to monitor performance and tune hyperparameters.
- Test Set: A held-out collection of images used to evaluate the final model's ability to detect and classify traffic signs in real-world scenarios.
The TT100K dataset includes 221 traffic sign categories organized into several major groups:
Speed Limit Signs (pl, pm)**
- pl_: Prohibitory speed limits (e.g., pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
- pm_: Minimum speed limits (e.g., pm5, pm10, pm20, pm30, pm40, pm50, pm55)
Prohibitory Signs (p, pn, pr_)**
- p1-p29: General prohibitory signs (no entry, no parking, no stopping, etc.)
- pn/pne: No entry and no parking signs
- pr: Various restriction signs (e.g., pr10, pr20, pr30, pr40, pr50)
Warning Signs (w_)
- w1-w67: Warning signs for various road hazards, conditions, and situations
- Includes pedestrian crossings, sharp turns, slippery roads, animals, construction, etc.
Height/Width Limit Signs (ph, pb, pw*)**
- ph_: Height limit signs (e.g., ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5)
- pb/pw_: Width limit signs
Informative Signs (i, il, io, ip)**
- i1-i15: General informative signs
- il_: Speed limit information (il50, il60, il70, il80, il90, il100, il110)
- io: Other informative signs
- ip: Information plates
Link to this sectionDataset YAML#
A YAML (Yet Another Markup Language) file is used to define the dataset configuration. It contains information about the dataset's paths, classes, and other relevant information. For the TT100K dataset, the TT100K.yaml file includes automatic download and conversion functionality.
# 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 sectionUsage#
To train a YOLO26 model on the TT100K dataset for 100 epochs with an image size of 640, you can use the following code snippets. The dataset will be automatically downloaded and converted to YOLO format on first use.
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)Link to this sectionSample Images and Annotations#
Here are typical examples from the TT100K dataset:
- Urban environments: Street scenes with multiple traffic signs at various distances
- Highway scenes: High-speed road signs including speed limits and direction indicators
- Complex intersections: Multiple signs in close proximity with varying orientations
- Challenging conditions: Signs under different lighting (day/night), weather (rain/fog), and viewing angles
The dataset includes:
- Close-up signs: Large, clearly visible signs occupying significant image area
- Distant signs: Small signs requiring fine-grained detection capabilities
- Partially occluded signs: Signs partially blocked by vehicles, trees, or other objects
- Multiple signs per image: Images containing several different sign types
Link to this sectionCitations and Acknowledgments#
If you use the TT100K dataset in your research or development work, please cite the following paper:
@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}
}We would like to acknowledge the Tsinghua University and Tencent collaboration for creating and maintaining this valuable resource for the computer vision and autonomous driving communities. For more information about the TT100K dataset, visit the official dataset website.
Link to this sectionFAQ#
Link to this sectionWhat is the TT100K dataset used for?#
The Tsinghua-Tencent 100K (TT100K) dataset is specifically designed for traffic sign detection and classification in real-world conditions. It's primarily used for:
- Training autonomous driving perception systems
- Developing Advanced Driver Assistance Systems (ADAS)
- Research in robust object detection under varying conditions
- Benchmarking traffic sign recognition algorithms
- Testing model performance on small objects in large images
With 100,000 diverse street view images and 221 traffic sign categories, it provides a comprehensive testbed for real-world traffic sign detection.
Link to this sectionHow many traffic sign categories are in TT100K?#
The TT100K dataset contains 221 different traffic sign categories, including:
- Speed limits: pl* prohibitory limits and pm* minimum speeds (e.g., pl40, pl120, pm30, pm55)
- Prohibitory signs: 29 general prohibition types (p1-p29) plus restrictions (pr*, pn, pne)
- Warning signs: 60+ warning categories (w1-w67)
- Height/width limits: ph* height and pw* width series for physical restrictions
- Informative signs: i1-i15, il*, io, ip for guidance and information
This comprehensive coverage includes most traffic signs found in Chinese road networks.
Link to this sectionHow can I train a YOLO26n model using the TT100K dataset?#
To train a YOLO26n model on the TT100K dataset for 100 epochs with an image size of 640, use the example below.
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)For detailed training configurations, refer to the Training documentation.
Link to this sectionWhat makes TT100K challenging compared to other datasets?#
TT100K presents several unique challenges:
- Scale variation: Signs range from very small (distant highway signs) to large (close-up urban signs)
- Real-world conditions: Extreme variations in lighting, weather, and viewing angles
- High resolution: 2048×2048 pixel images require significant processing power
- Class imbalance: Some sign types are much more common than others
- Dense scenes: Multiple signs may appear in a single image
- Partial occlusion: Signs may be partially blocked by vehicles, vegetation, or structures
These challenges make TT100K a valuable benchmark for developing robust detection algorithms.
Link to this sectionHow do I handle the large image sizes in TT100K?#
The TT100K dataset uses 2048×2048 pixel images, which can be resource-intensive. Here are recommended strategies:
For Training:
# 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 scalesRecommendations:
- Start with
imgsz=640for initial experiments - Use
imgsz=1280if you have sufficient GPU memory (24GB+) - Consider tiling strategies for very small signs
- Use gradient accumulation to simulate larger batch sizes