docs/en/datasets/detect/tt100k.md
The Tsinghua-Tencent 100K (TT100K) dataset is a traffic-sign benchmark for object detection, created by Zhu et al. for the CVPR 2016 paper Traffic-Sign Detection and Classification in the Wild. The Ultralytics TT100K configuration provides 16,817 images (6,105 train / 7,641 val / 3,071 test) across 221 traffic-sign categories, with the source benchmark reporting over 30,000 sign instances. The "100K" in the name refers to the roughly 100,000 Tencent Street View images the benchmark was created from — not the number of images you download and train on. Because the original paper keeps only categories with at least 100 training instances, a commonly used 45-class subset exists, but the Ultralytics configuration retains all 221 annotated categories (many of them sparse).
The high-resolution street-view imagery captures large variations in illumination, weather, viewing angle, and distance, making TT100K a demanding benchmark for small-object detection in real-world driving scenes.
The Ultralytics TT100K configuration is split into three subsets, all sharing the same 221 categories:
| Split | Images | Description |
|---|---|---|
| Train | 6,105 | Labeled traffic-scene images used to train the detector |
| Validation | 7,641 | The dataset's original "other" split, used for evaluation |
| Test | 3,071 | Held-out images for final evaluation of the trained model |
The 221 categories are organized into several major groups:
pl* (e.g., pl5–pl120) and minimum speeds pm* (e.g., pm5–pm55).p1–p29, no-entry/no-parking pn/pne, and restrictions pr* (pr10–pr100).w1–w67 for road hazards such as crossings, sharp turns, slippery roads, and construction.ph* (e.g., ph2–ph5.5) and width limits pb/pw*.i1–i15, speed-limit info il* (il50–il110), other io, and information plates ip.TT100K is widely used for building and benchmarking traffic-sign recognition in real-world conditions. Common applications include:
The TT100K.yaml file defines the dataset configuration — the dataset paths, class names, and the automatic download-and-convert script. It is maintained in the Ultralytics repository at https://github.com/ultralytics/ultralytics/blob/main/ultralytics/cfg/datasets/TT100K.yaml.
!!! example "ultralytics/cfg/datasets/TT100K.yaml"
```yaml
--8<-- "ultralytics/cfg/datasets/TT100K.yaml"
```
!!! warning "~18 GB download"
TT100K downloads automatically the first time you train and requires about 18 GB of free disk space. On first use the download script fetches the original data and converts the annotations to YOLO format, which can take several minutes.
To train a YOLO26n model on the TT100K dataset for 100 epochs with an image size of 640, you can use the following code snippets. For a comprehensive list of available arguments, refer to the model Training page.
!!! example "Train Example"
=== "Python"
```python
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)
```
=== "CLI"
```bash
# 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
```
To label additional traffic-sign images and manage TT100K training runs in your browser, use Ultralytics Platform.
TT100K images are 2048×2048 street scenes in which traffic signs often occupy only a small fraction of the frame. A single image can contain multiple signs at different scales and distances, some partially occluded by vehicles, vegetation, or structures, and captured under day/night and clear/rainy conditions. This mix of small objects and challenging conditions is what makes the dataset a strong test of detector robustness.
If you use the TT100K dataset in your research or development work, please cite the following paper:
!!! quote ""
=== "BibTeX"
```bibtex
@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.
The Tsinghua-Tencent 100K (TT100K) dataset is used for traffic-sign detection and classification in real-world conditions. Its 221 categories and high-resolution street-view imagery make it a common benchmark for autonomous-driving perception, advanced driver-assistance systems (ADAS), and small-object detection research.
The Ultralytics TT100K configuration contains 16,817 images: 6,105 for training, 7,641 for validation (the dataset's original "other" split), and 3,071 for testing. See the Dataset Structure section for the full breakdown.
The "100K" refers to the roughly 100,000 Tencent Street View images the original benchmark was created from. The Ultralytics detection configuration provides 16,817 of those images with YOLO-format labels; the name reflects the source collection, not the training-set size.
TT100K defines 221 categories spanning speed-limit, prohibitory, warning, height/width-limit, and informative signs. The original paper keeps only the 45 categories with at least 100 training instances, but the Ultralytics configuration retains all 221. See Dataset Structure for the group breakdown.
TT100K is about 18 GB and downloads automatically the first time you train with data="TT100K.yaml" — no manual download is required. The script also converts the original annotations to YOLO format on first run.
Train a YOLO26n model on TT100K for 100 epochs at an image size of 640:
!!! example "Train Example"
=== "Python"
```python
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)
```
=== "CLI"
```bash
# Start training from a pretrained *.pt model
yolo detect train data=TT100K.yaml model=yolo26n.pt epochs=100 imgsz=640
```
For detailed configurations, see the Training page and model training tips.
Start with imgsz=640 for initial experiments, then raise to imgsz=1280 (with a smaller batch) if you have enough GPU memory, since the higher resolution helps recover small, distant signs:
model.train(data="TT100K.yaml", imgsz=1280, batch=4) # higher resolution for small signs
You can also tune data augmentation and consider tiling strategies for very small objects. See Tips for Model Training for more.