Meet YOLO26: next-gen vision AI.

Link to this sectionConjunto de datos TT100K#

El Tsinghua-Tencent 100K (TT100K) es un conjunto de datos de referencia a gran escala de 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 detección y clasificación de señales de tráfico en condiciones del mundo real, proporcionando a investigadores y desarrolladores un recurso integral 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 de anotación. El artículo 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 las 221 categorías anotadas, muchas de las cuales son muy escasas. Estas imágenes capturan grandes variaciones de iluminación, condiciones climáticas, ángulos de visión y 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 control de tráfico
  • Planificación urbana y análisis de tráfico
  • Investigación en visión artificial en condiciones del mundo real

Link to this sectionCaracterí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 ricas: Cada señal incluye etiqueta de clase, caja delimitadora y máscara de píxeles
  • Cobertura integral: Incluye señales prohibitivas, de advertencia, obligatorias e informativas
  • División entrenamiento/prueba: Divisiones predefinidas para una evaluación coherente

Link to this sectionEstructura del dataset#

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 controlar el rendimiento y ajustar los hiperparámetros.
  3. Conjunto de prueba: Una colección de imágenes reservada utilizada 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 (ej., pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_: Límites de velocidad mínimos (ej., pm5, pm10, pm20, pm30, pm40, pm50, pm55)

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

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

Señales de advertencia (w_)

  1. w1-w67: Señales de advertencia para diversos peligros, condiciones y situaciones en la carretera
  2. Incluye pasos de peatones, curvas cerradas, carreteras resbaladizas, animales, construcción, etc.

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

  1. ph_: Señales de límite de altura (ej., ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5)
  2. pb/pw_: 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 (il50, il60, il70, il80, il90, il100, il110)
  3. io: Otras señales informativas
  4. ip: Placas de información

Link to this sectionYAML del dataset#

Se utiliza un archivo YAML (Yet Another Markup Language) para definir la configuración del conjunto de datos. Contiene información sobre las rutas del conjunto de datos, las clases y otra información relevante. 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: 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 sectionUso#

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)

Link to this sectionMuestras de imágenes y anotaciones#

Estos son 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, incluyendo 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 desafiantes: 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 significativa 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 ocluidas: 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

Link to this sectionCitas y agradecimientos#

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 entre 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.

Link to this sectionFAQ#

Link to this section¿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 del mundo real. 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 de objetos robusta bajo condiciones variables
  4. Evaluación comparativa de 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.

Link to this section¿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:

  1. Límites de velocidad: límites prohibitivos pl* y velocidades mínimas pm* (ej., pl40, pl120, pm30, pm55)
  2. Señales prohibitivas: 29 tipos de prohibición general (p1-p29) más restricciones (pr*, pn, pne)
  3. Señales de advertencia: más de 60 categorías de advertencia (w1-w67)
  4. Límites de altura/anchura: series de altura ph* y anchura pw* 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.

Link to this section¿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 epochs con un tamaño de imagen de 640, utiliza el ejemplo a continuación.

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 Training.

Link to this section¿Qué hace que TT100K sea desafiante 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 múltiples señales en una sola imagen
  6. Oclusión parcial: Las señales pueden estar bloqueadas parcialmente por vehículos, vegetación o estructuras

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

Link to this section¿Cómo manejo los tamaños de imagen grandes en TT100K?#

El conjunto de datos TT100K utiliza imágenes de 2048×2048 píxeles, lo que puede consumir muchos recursos. Aquí tienes 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 teselado (tiling) para señales muy pequeñas
  • Utiliza la acumulación de gradientes para simular tamaños de lote mayores
Colaboradores
GLglenn-jocher3RAraimbekovm1PRPrashantDixit01

Comentarios