Conjunto de datos TT100K
El Tsinghua-Tencent 100K (TT100K) es un conjunto de datos de referencia a gran escala para señales de tráfico, creado a partir de 100.000 panorámicas de Tencent Street View. Este conjunto de datos está diseñado específicamente para la detect y clasificación de señales de tráfico en condiciones del mundo real, proporcionando a investigadores y desarrolladores un recurso completo para construir sistemas robustos de reconocimiento de señales de tráfico.
El conjunto de datos contiene 100.000 imágenes con más de 30.000 instancias de señales de tráfico distribuidas en 221 categorías diferentes. Estas imágenes capturan grandes variaciones en la iluminación, las condiciones climáticas, los ángulos de visión y las distancias, lo que lo hace ideal para entrenar modelos que necesitan funcionar de manera fiable en diversos escenarios del mundo real.
Este conjunto de datos es particularmente valioso para:
- Sistemas de conducción autónoma
- Sistemas avanzados de asistencia al conductor (ADAS)
- Aplicaciones de monitorización de tráfico
- Planificación urbana y análisis de tráfico
- Investigación en visión por computador en condiciones del mundo real
Características clave
El conjunto de datos TT100K ofrece varias ventajas clave:
- Escala: 100.000 imágenes de alta resolución (2048×2048 píxeles)
- Diversidad: 221 categorías de señales de tráfico que cubren señales de tráfico chinas
- Condiciones del mundo real: Grandes variaciones en el clima, la iluminación y los ángulos de visión
- Anotaciones detalladas: Cada señal incluye etiqueta de clase, caja delimitadora y máscara de píxeles
- Cobertura exhaustiva: Incluye señales de prohibición, advertencia, obligación e informativas
- División de entrenamiento/prueba: Divisiones predefinidas para una evaluación consistente
Estructura del conjunto de datos
El conjunto de datos TT100K se divide en tres subconjuntos:
- Conjunto de entrenamiento: La colección principal de imágenes de escenas de tráfico utilizada para entrenar modelos para detect y classify diferentes tipos de señales de tráfico.
- Conjunto de validación: Un subconjunto utilizado durante el desarrollo del modelo para monitorizar el rendimiento y ajustar los hiperparámetros.
- Conjunto de prueba: Una colección de imágenes reservadas utilizada para evaluar la capacidad del modelo final para detect y classify señales de tráfico en escenarios del mundo real.
El conjunto de datos TT100K incluye 221 categorías de señales de tráfico organizadas en varios grupos principales:
Señales de Límite de Velocidad (pl, pm)
- pl_: Límites de velocidad de prohibición (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
- pm_: Límites de velocidad mínimos (pm5, pm10, pm20, pm30, pm40, pm50, pm55)
Señales de Prohibición (p, pn, pr_)
- p1-p28: Señales de prohibición generales (prohibido el paso, prohibido estacionar, prohibido detenerse, etc.)
- pn/pne: Señales de prohibido el paso y prohibido estacionar
- pr: Diversas señales de restricción (pr10, pr20, pr30, pr40, pr50, etc.)
Señales de Advertencia (w_)
- w1-w66: Señales de advertencia para diversos peligros, condiciones y situaciones en la carretera
- Incluye pasos de peatones, curvas pronunciadas, carreteras resbaladizas, animales, obras, etc.
Señales de Límite de Altura/Anchura (ph, pb)
- ph_: Señales de límite de altura (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5, etc.)
- pb_: Señales de límite de anchura
Señales Informativas (i, il, io, ip)
- i1-i15: Señales informativas generales
- il_: Información de límite de velocidad (il60, il80, il100, il110)
- io: Otras señales informativas
- ip: Placas informativas
YAML del conjunto de datos
Un archivo yaml (Yet Another Markup Language) se utiliza para definir la configuración del conjunto de datos. Contiene información sobre las rutas, clases y otra información relevante del conjunto de datos. Para el conjunto de datos TT100K, el TT100K.yaml archivo incluye funcionalidad de descarga y conversión 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)
Uso
Para entrenar un modelo YOLO26 en el conjunto de datos TT100K durante 100 épocas con un tamaño de imagen de 640, puede utilizar los siguientes fragmentos de código. El conjunto de datos se descargará automáticamente y se convertirá al formato YOLO en el primer uso.
Ejemplo de entrenamiento
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
sample_images y anotaciones
A continuación se muestran ejemplos típicos del conjunto de datos TT100K:
- Entornos urbanos: Escenas callejeras con múltiples señales de tráfico a varias distancias
- Escenas de autopista: Señales de carretera de alta velocidad, incluyendo límites de velocidad e indicadores de dirección
- Intersecciones complejas: Múltiples señales muy próximas con orientaciones variadas
- Condiciones desafiantes: Señales bajo diferentes condiciones de iluminación (día/noche), meteorológicas (lluvia/niebla) y ángulos de visión
El conjunto de datos incluye:
- Señales en primer plano: Señales grandes y claramente visibles que ocupan una parte significativa del área de la imagen
- Señales distantes: Señales pequeñas que requieren capacidades de detect de grano fino
- Señales parcialmente ocluidas: Señales parcialmente bloqueadas por vehículos, árboles u otros objetos
- Múltiples señales por imagen: Imágenes que contienen varios tipos de señales diferentes
Citas y agradecimientos
Si utiliza el conjunto de datos TT100K en su trabajo de investigación o desarrollo, cite el siguiente artículo:
@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}
}
Queremos agradecer la colaboración entre la Universidad de Tsinghua y Tencent por crear y mantener este valioso recurso para las comunidades de visión por computador y conducción autónoma. Para más información sobre el conjunto de datos TT100K, visite el sitio web oficial del conjunto de datos.
Preguntas frecuentes
¿Para qué se utiliza el conjunto de datos TT100K?
El conjunto de datos Tsinghua-Tencent 100K (TT100K) está específicamente diseñado para la detect y clasificación de señales de tráfico en condiciones del mundo real. Se utiliza principalmente para:
- Entrenamiento de sistemas de percepción para la conducción autónoma
- Desarrollo de Sistemas Avanzados de Asistencia al Conductor (ADAS)
- Investigación en detect de objetos robusta bajo condiciones variables
- Evaluación comparativa de algoritmos de reconocimiento de señales de tráfico
- Prueba del rendimiento del modelo en objetos pequeños dentro de imágenes grandes
Con 100.000 imágenes diversas de vista de calle y 221 categorías de señales de tráfico, proporciona un banco de pruebas exhaustivo para la detect de señales de tráfico en el mundo real.
¿Cuántas categorías de señales de tráfico hay en TT100K?
El conjunto de datos TT100K contiene 221 categorías diferentes de señales de tráfico, incluyendo:
- Límites de velocidad: pl5 a pl120 (límites de prohibición) y pm5 a pm55 (velocidades mínimas)
- Señales de prohibición: más de 28 tipos de prohibición general (p1-p28) más restricciones (pr*, pn, pne)
- Señales de advertencia: más de 60 categorías de advertencia (w1-w66)
- Límites de altura/anchura: series ph y pb para restricciones físicas
- Señales informativas: i1-i15, il*, io, ip para orientación e información
Esta cobertura exhaustiva incluye la mayoría de las señales de tráfico encontradas en las redes de carreteras chinas.
¿Cómo puedo entrenar un modelo YOLO26n utilizando el conjunto de datos TT100K?
Para entrenar un modelo YOLO26n en el conjunto de datos TT100K durante 100 épocas con un tamaño de imagen de 640, utilice el ejemplo siguiente.
Ejemplo de entrenamiento
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 obtener información detallada sobre las configuraciones de entrenamiento, consulta la documentación de Entrenamiento.
¿Qué hace que TT100K sea desafiante en comparación con otros conjuntos de datos?
TT100K presenta varios desafíos únicos:
- Variación de escala: Las señales varían desde muy pequeñas (señales de autopista distantes) hasta grandes (señales urbanas en primer plano)
- Condiciones del mundo real: Variaciones extremas en la iluminación, el clima y los ángulos de visión
- Alta resolución: Imágenes de 2048×2048 píxeles requieren una potencia de procesamiento significativa
- Desequilibrio de clases: Algunos tipos de señales son mucho más comunes que otros
- Escenas densas: Múltiples señales pueden aparecer en una sola imagen
- Oclusión parcial: Las señales pueden estar parcialmente bloqueadas por vehículos, vegetación o estructuras
Estos desafíos hacen de TT100K un valioso referente para el desarrollo de algoritmos de detect robustos.
¿Cómo manejo las imágenes de gran tamaño en TT100K?
El conjunto de datos TT100K utiliza imágenes de 2048×2048 píxeles, lo que puede ser intensivo en recursos. Aquí se presentan estrategias recomendadas:
Para el entrenamiento:
# 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
Recomendaciones:
- Comience con
imgsz=640para experimentos iniciales - Utilice
imgsz=1280si dispone de suficiente memoria GPU (24GB+) - Considere estrategias de mosaico para señales muy pequeñas
- Utilice la acumulación de gradientes para simular tamaños de lote mayores
