Conjunto de Dados TT100K
O Tsinghua-Tencent 100K (TT100K) é um conjunto de dados de benchmark de sinais de trânsito em larga escala criado a partir de 100.000 panoramas do Tencent Street View. Este conjunto de dados é especificamente projetado para detecção e classificação de sinais de trânsito em condições do mundo real, fornecendo a pesquisadores e desenvolvedores um recurso abrangente para a construção de sistemas robustos de reconhecimento de sinais de trânsito.
O conjunto de dados contém 100 000 imagens com mais de 30 000 instâncias de sinais de trânsito distribuídas por 221 categorias de anotação. O artigo original aplica um limiar de 100 instâncias por classe para o treino supervisionado, resultando num subconjunto de 45 classes comumente utilizado; no entanto, a configuração Ultralytics fornecida mantém todas as 221 categorias anotadas, muitas das quais são muito escassas. Estas imagens capturam grandes variações na iluminância, condições meteorológicas, ângulos de visão e distâncias, tornando-as ideais para treinar modelos que precisam de ter um desempenho fiável em diversos cenários do mundo real.
Este conjunto de dados é particularmente valioso para:
- Sistemas de condução autónoma
- Sistemas avançados de assistência ao condutor (ADAS)
- Aplicações de monitorização de tráfego
- Planeamento urbano e análise de tráfego
- Pesquisa em visão computacional em condições reais
Principais Características
O conjunto de dados TT100K oferece várias vantagens principais:
- Escala: 100.000 imagens de alta resolução (2048×2048 pixels)
- Diversidade: 221 categorias de sinais de trânsito, abrangendo sinais de trânsito chineses
- Condições reais: Grandes variações de clima, iluminação e ângulos de visualização
- Anotações ricas: Cada sinal inclui rótulo de classe, caixa delimitadora (bounding box) e máscara de pixel
- Cobertura abrangente: Inclui sinais de proibição, aviso, obrigatórios e informativos
- Divisão Treino/Teste: Divisões pré-definidas para avaliação consistente
Estrutura do Conjunto de Dados
O conjunto de dados TT100K é dividido em três subconjuntos:
- Conjunto de Treinamento: A coleção principal de imagens de cenas de tráfego utilizada para treinar modelos para detect e classify diferentes tipos de sinais de tráfego.
- Conjunto de Validação: Um subconjunto utilizado durante o desenvolvimento do modelo para monitorar o desempenho e ajustar os hiperparâmetros.
- Conjunto de Teste: Uma coleção de imagens reservadas utilizada para avaliar a capacidade do modelo final de detect e classify sinais de tráfego em cenários do mundo real.
O conjunto de dados TT100K inclui 221 categorias de sinais de trânsito organizadas em vários grupos principais:
Sinais de Limite de Velocidade (pl, pm)
- pl_: Limites de velocidade proibitivos (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
- pm_: Limites de velocidade mínimos (pm5, pm10, pm20, pm30, pm40, pm50, pm55)
Sinais de Proibição (p, pn, pr_)
- p1-p28: Sinais de proibição gerais (proibido entrar, proibido estacionar, proibido parar, etc.)
- pn/pne: Sinais de proibido entrar e proibido estacionar
- pr: Vários sinais de restrição (pr10, pr20, pr30, pr40, pr50, etc.)
Sinais de Aviso (w_)
- w1-w66: Sinais de aviso para vários perigos, condições e situações rodoviárias
- Inclui passagens de peões, curvas apertadas, estradas escorregadias, animais, construção, etc.
Sinais de Limite de Altura/Largura (ph, pb)
- ph_: Sinais de limite de altura (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5, etc.)
- pb_: Sinais de limite de largura
Sinais Informativos (i, il, io, ip)
- i1-i15: Sinais informativos gerais
- il_: Informações de limite de velocidade (il60, il80, il100, il110)
- io: Outros sinais informativos
- ip: Placas de informação
YAML do Conjunto de Dados
Um arquivo yaml (Yet Another Markup Language) é utilizado para definir a configuração do conjunto de dados. Ele contém informações sobre os caminhos, classes e outras informações relevantes do conjunto de dados. Para o conjunto de dados TT100K, o TT100K.yaml arquivo inclui funcionalidade de download e conversão automática.
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)
Utilização
Para treinar um modelo YOLO26 no conjunto de dados TT100K por 100 épocas com um tamanho de imagem de 640, pode usar os seguintes trechos de código. O conjunto de dados será automaticamente descarregado e convertido para o formato YOLO na primeira utilização.
Exemplo de Treinamento
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
Amostras de Imagens e Anotações
Aqui estão exemplos típicos do conjunto de dados TT100K:
- Ambientes urbanos: Cenas de rua com múltiplos sinais de trânsito a várias distâncias
- Cenas de autoestrada: Sinais de estrada de alta velocidade, incluindo limites de velocidade e indicadores de direção
- Cruzamentos complexos: Múltiplos sinais em proximidade com orientações variadas
- Condições desafiadoras: Sinais sob diferentes condições de iluminação (dia/noite), clima (chuva/neblina) e ângulos de visão
O conjunto de dados inclui:
- Sinais em close-up: Sinais grandes e claramente visíveis, ocupando uma área significativa da imagem
- Sinais distantes: Sinais pequenos que exigem capacidades de detect de alta precisão
- Sinais parcialmente ocluídos: Sinais parcialmente bloqueados por veículos, árvores ou outros objetos
- Múltiplos sinais por imagem: Imagens contendo vários tipos diferentes de sinais
Citações e Agradecimentos
Se você utilizar o conjunto de dados TT100K em seu trabalho de pesquisa ou desenvolvimento, por favor, cite o seguinte artigo:
@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}
}
Gostaríamos de reconhecer a colaboração entre a Universidade de Tsinghua e a Tencent pela criação e manutenção deste valioso recurso para as comunidades de visão computacional e condução autônoma. Para mais informações sobre o conjunto de dados TT100K, visite o site oficial do conjunto de dados.
FAQ
Para que é usado o conjunto de dados TT100K?
O conjunto de dados Tsinghua-Tencent 100K (TT100K) é especificamente projetado para detect e classificação de sinais de trânsito em condições do mundo real. É utilizado principalmente para:
- Treinamento de sistemas de percepção para condução autônoma
- Desenvolvimento de Sistemas Avançados de Assistência ao Motorista (ADAS)
- Pesquisa em detecção robusta de objetos sob condições variadas
- Benchmarking de algoritmos de reconhecimento de sinais de trânsito
- Teste de desempenho do modelo em objetos pequenos em imagens grandes
Com 100.000 imagens diversas de street view e 221 categorias de sinais de trânsito, ele oferece um ambiente de teste abrangente para a detecção de sinais de trânsito no mundo real.
Quantas categorias de sinais de trânsito existem no TT100K?
O dataset TT100K contém 221 categorias diferentes de sinais de trânsito, incluindo:
- Limites de velocidade: pl5 a pl120 (limites proibitivos) e pm5 a pm55 (velocidades mínimas)
- Sinais proibitivos: mais de 28 tipos de proibição geral (p1-p28) mais restrições (pr*, pn, pne)
- Sinais de advertência: mais de 60 categorias de advertência (w1-w66)
- Limites de altura/largura: séries ph e pb para restrições físicas
- Sinais informativos: i1-i15, il*, io, ip para orientação e informação
Esta cobertura abrangente inclui a maioria dos sinais de trânsito encontrados nas redes rodoviárias chinesas.
Como posso treinar um modelo YOLO26n usando o conjunto de dados TT100K?
Para treinar um modelo YOLO26n no conjunto de dados TT100K por 100 épocas com um tamanho de imagem de 640, utilize o exemplo abaixo.
Exemplo de Treinamento
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
Para configurações de treinamento detalhadas, consulte a documentação de Treinamento.
O que torna o TT100K desafiador em comparação com outros conjuntos de dados?
O TT100K apresenta vários desafios únicos:
- Variação de escala: Os sinais variam de muito pequenos (sinais de rodovia distantes) a grandes (sinais urbanos em close-up)
- Condições do mundo real: Variações extremas de iluminação, clima e ângulos de visão
- Alta resolução: Imagens de 2048×2048 pixels exigem poder de processamento significativo
- Desequilíbrio de classes: Alguns tipos de sinais são muito mais comuns do que outros
- Cenas densas: Múltiplos sinais podem aparecer em uma única imagem
- Oclusão parcial: Os sinais podem ser parcialmente bloqueados por veículos, vegetação ou estruturas
Estes desafios tornam o TT100K uma referência valiosa para o desenvolvimento de algoritmos de detecção robustos.
Como lidar com os grandes tamanhos de imagem no TT100K?
O conjunto de dados TT100K utiliza imagens de 2048×2048 pixels, o que pode ser intensivo em recursos. Aqui estão as estratégias recomendadas:
Para Treinamento:
# 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
Recomendações:
- Comece com
imgsz=640para experimentos iniciais - Use
imgsz=1280se você tiver memória de GPU suficiente (24GB+) - Considere estratégias de tiling para sinais muito pequenos
- Use acumulação de gradiente para simular tamanhos de batch maiores
