Editar página en GitHub (EN)

Dataset TT100K

El Tsinghua-Tencent 100K (TT100K) es un conjunto de datos de referencia de señales de tráfico a gran escala creado a partir de 100.000 panorámicas de Tencent Street View. Este conjunto de datos está diseñado específicamente para la detección y clasificación de señales de tráfico en condiciones reales, proporcionando a investigadores y desarrolladores un recurso completo para crear 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 en 221 categorías de anotación. El documento original aplica un umbral de 100 instancias por clase para el entrenamiento supervisado, lo que genera un subconjunto de 45 clases de uso común; sin embargo, la configuración del conjunto de datos de Ultralytics proporcionada conserva todas las 221 categorías anotadas, muchas de las cuales son muy dispersas. Estas imágenes capturan grandes variaciones en iluminación, condiciones climáticas, ángulos de visión y distancias, lo que lo hace ideal para entrenar modelos que necesiten funcionar de manera fiable en diversos escenarios del mundo real.

Este conjunto de datos es especialmente 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 artificial 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 las 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 enriquecidas: Cada señal incluye etiqueta de clase, cuadro delimitador y máscara de píxeles
  • Cobertura integral: Incluye señales prohibitivas, de advertencia, obligatorias e informativas
  • División de entrenamiento/prueba: Divisiones predefinidas para una evaluación coherente

Estructura del conjunto de datos

El conjunto de datos TT100K se divide en tres subconjuntos:

  1. Conjunto de entrenamiento: La colección principal de imágenes de escenas de tráfico utilizada para entrenar modelos para detectar y clasificar diferentes tipos de señales de tráfico.
  2. Conjunto de validación: Un subconjunto utilizado durante el desarrollo del modelo para supervisar el rendimiento y ajustar los hiperparámetros.
  3. Conjunto de prueba: Una colección de imágenes reservada que se utiliza para evaluar la capacidad final del modelo para detectar y clasificar 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)**

  1. pl_: Límites de velocidad prohibitivos (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_: Límites de velocidad mínimos (pm5, pm10, pm20, pm30, pm40, pm50, pm55)

Señales prohibitivas (p, pn, pr_)**

  1. p1-p28: Señales prohibitivas generales (prohibido el paso, prohibido aparcar, prohibido parar, etc.)
  2. pn/pne: Señales de prohibido el paso y prohibido aparcar
  3. pr: Varias señales de restricción (pr10, pr20, pr30, pr40, pr50, etc.)

Señales de advertencia (w_)

  1. w1-w66: Señales de advertencia para varios peligros, condiciones y situaciones de la carretera
  2. Incluye pasos de peatones, curvas cerradas, carreteras resbaladizas, animales, obras, etc.

Señales de límite de altura/anchura (ph, pb)**

  1. ph_: Señales de límite de altura (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5, etc.)
  2. pb_: Señales de límite de anchura

Señales informativas (i, il, io, ip)**

  1. i1-i15: Señales informativas generales
  2. il_: Información de límite de velocidad (il60, il80, il100, il110)
  3. io: Otras señales informativas
  4. ip: Placas de información

YAML del conjunto de datos

Se utiliza un archivo YAML (Yet Another Markup Language) para definir la configuración del conjunto de datos. Contiene información sobre las rutas, las clases y otra información relevante del conjunto de datos. Para el conjunto de datos TT100K, el archivo TT100K.yaml incluye la 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 epochs con un tamaño de imagen de 640, puedes usar los siguientes fragmentos de código. El conjunto de datos se descargará y convertirá automáticamente 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)

Imágenes y anotaciones de muestra

Estos son algunos ejemplos típicos del conjunto de datos TT100K:

  1. Entornos urbanos: Escenas callejeras con múltiples señales de tráfico a varias distancias
  2. Escenas de autopista: Señales de carretera de alta velocidad, incluidos límites de velocidad e indicadores de dirección
  3. Intersecciones complejas: Múltiples señales muy próximas entre sí con distintas orientaciones
  4. Condiciones difíciles: Señales bajo diferentes niveles de iluminación (día/noche), clima (lluvia/niebla) y ángulos de visión

El conjunto de datos incluye:

  1. Señales en primer plano: Señales grandes y claramente visibles que ocupan una parte importante de la imagen
  2. Señales distantes: Señales pequeñas que requieren capacidades de detección de alta precisión
  3. Señales parcialmente ocultas: Señales bloqueadas parcialmente por vehículos, árboles u otros objetos
  4. Múltiples señales por imagen: Imágenes que contienen varios tipos de señales diferentes

Citas y reconocimientos

Si utilizas el conjunto de datos TT100K en tu trabajo de investigación o desarrollo, por favor cita el siguiente artículo:

Cita
@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 de la Universidad de Tsinghua y Tencent por crear y mantener este valioso recurso para las comunidades de visión artificial y conducción autónoma. Para obtener más información sobre el conjunto de datos TT100K, visita 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á diseñado específicamente para la detección y clasificación de señales de tráfico en condiciones reales. Se utiliza principalmente para:

  1. Entrenar sistemas de percepción de conducción autónoma
  2. Desarrollar sistemas avanzados de asistencia al conductor (ADAS)
  3. Investigación en detección robusta de objetos en condiciones variables
  4. Evaluar algoritmos de reconocimiento de señales de tráfico
  5. Probar el rendimiento del modelo en objetos pequeños dentro de imágenes grandes

Con 100.000 imágenes diversas de vistas de calle y 221 categorías de señales de tráfico, proporciona un banco de pruebas integral para la detección 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, que incluyen:

  1. Límites de velocidad: pl5 a pl120 (límites prohibitivos) y pm5 a pm55 (velocidades mínimas)
  2. Señales prohibitivas: 28+ tipos de prohibición general (p1-p28) más restricciones (pr*, pn, pne)
  3. Señales de advertencia: 60+ categorías de advertencia (w1-w66)
  4. Límites de altura/anchura: series ph* y pb* para restricciones físicas
  5. Señales informativas: i1-i15, il*, io, ip para orientación e información

Esta cobertura integral incluye la mayoría de las señales de tráfico que se encuentran en las redes de carreteras chinas.

¿Cómo puedo entrenar un modelo YOLO26n usando 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, utiliza 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)

Para configuraciones detalladas de entrenamiento, consulta la documentación de Entrenamiento.

¿Qué hace que TT100K sea difícil en comparación con otros conjuntos de datos?

TT100K presenta varios desafíos únicos:

  1. Variación de escala: Las señales van desde muy pequeñas (señales de autopista distantes) hasta grandes (señales urbanas en primer plano)
  2. Condiciones del mundo real: Variaciones extremas en la iluminación, el clima y los ángulos de visión
  3. Alta resolución: Las imágenes de 2048×2048 píxeles requieren una potencia de procesamiento significativa
  4. Desequilibrio de clases: Algunos tipos de señales son mucho más comunes que otros
  5. Escenas densas: Pueden aparecer varias señales en una sola imagen
  6. Oclusión parcial: Las señales pueden estar parcialmente bloqueadas por vehículos, vegetación o estructuras

Estos desafíos hacen de TT100K un punto de referencia valioso para desarrollar algoritmos de detección robustos.

¿Cómo manejo los tamaños de imagen grandes en TT100K?

El conjunto de datos TT100K utiliza imágenes de 2048×2048 píxeles, que pueden consumir muchos recursos. Estas son las 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:

  • Empieza con imgsz=640 para experimentos iniciales
  • Utiliza imgsz=1280 si tienes suficiente memoria GPU (24GB+)
  • Considera estrategias de mosaico para señales muy pequeñas
  • Usa la acumulación de gradiente para simular tamaños de lote mayores
Contributors
Editar página en GitHub (EN)
GLglenn-jocher2RAraimbekovm1PRPrashantDixit01

Comentarios