Meet YOLO26: next-gen vision AI.

Link to this sectionDataset TT100K#

O Tsinghua-Tencent 100K (TT100K) é um conjunto de dados de referência de sinais de trânsito em larga escala criado a partir de 100.000 panoramas do Tencent Street View. Este conjunto de dados foi projetado especificamente para a detecção e classificação de sinais de trânsito em condições reais, fornecendo a pesquisadores e desenvolvedores um recurso abrangente para a criaçã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 em 221 categorias de anotação. O artigo original aplica um limite de 100 instâncias por classe para treinamento supervisionado, resultando em um subconjunto de 45 classes comumente usado; no entanto, a configuração do conjunto de dados da Ultralytics fornecida retém todas as 221 categorias anotadas, muitas das quais são muito esparsas. Essas imagens capturam grandes variações em iluminância, condições climáticas, ângulos de visão e distâncias, tornando-as ideais para treinar modelos que precisam ter um desempenho confiável em diversos cenários do mundo real.

Este conjunto de dados é particularmente valioso para:

  • Sistemas de direção autônoma
  • Sistemas avançados de assistência ao motorista (ADAS)
  • Aplicações de monitoramento de tráfego
  • Planejamento urbano e análise de tráfego
  • Pesquisa em visão computacional em condições reais

Link to this sectionPrincipais recursos#

O conjunto de dados TT100K oferece várias vantagens importantes:

  • Escala: 100.000 imagens de alta resolução (2048×2048 pixels)
  • Diversidade: 221 categorias de sinais de trânsito cobrindo sinais de trânsito chineses
  • Condições reais: Grandes variações de clima, iluminação e ângulos de visão
  • Anotações ricas: Cada sinal inclui rótulo de classe, caixa delimitadora (bounding box) e máscara de pixel
  • Cobertura abrangente: Inclui sinais proibitivos, de advertência, obrigatórios e informativos
  • Divisão de treino/teste: Divisões pré-definidas para uma avaliação consistente

Link to this sectionEstrutura do Dataset#

O conjunto de dados TT100K é dividido em três subconjuntos:

  1. Conjunto de Treinamento: A coleção principal de imagens de cenas de trânsito usada para treinar modelos para detectar e classificar diferentes tipos de sinais de trânsito.
  2. Conjunto de Validação: Um subconjunto usado durante o desenvolvimento do modelo para monitorar o desempenho e ajustar hiperparâmetros.
  3. Conjunto de Teste: Uma coleção de imagens separada usada para avaliar a capacidade do modelo final de detectar e classificar sinais de trânsito 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)**

  1. pl_: Limites de velocidade proibitivos (por exemplo, pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_: Limites de velocidade mínima (por exemplo, pm5, pm10, pm20, pm30, pm40, pm50, pm55)

Sinais Proibitivos (p, pn, pr_)**

  1. p1-p29: Sinais proibitivos gerais (proibido entrar, proibido estacionar, proibido parar, etc.)
  2. pn/pne: Sinais de proibido entrar e proibido estacionar
  3. pr: Vários sinais de restrição (por exemplo, pr10, pr20, pr30, pr40, pr50)

Sinais de Advertência (w_)

  1. w1-w67: Sinais de advertência para vários perigos, condições e situações na estrada
  2. Inclui passagens de pedestres, curvas acentuadas, estradas escorregadias, animais, construção, etc.

Sinais de Limite de Altura/Largura (ph, pb, pw*)**

  1. ph_: Sinais de limite de altura (por exemplo, ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5)
  2. pb/pw_: Sinais de limite de largura

Sinais Informativos (i, il, io, ip)**

  1. i1-i15: Sinais informativos gerais
  2. il_: Informações de limite de velocidade (il50, il60, il70, il80, il90, il100, il110)
  3. io: Outros sinais informativos
  4. ip: Placas de informação

Link to this sectionYAML do Dataset#

Um arquivo YAML (Yet Another Markup Language) é usado para definir a configuração do conjunto de dados. Ele contém informações sobre os caminhos do conjunto de dados, classes e outras informações relevantes. Para o conjunto de dados TT100K, o arquivo TT100K.yaml 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: 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 treinar um modelo YOLO26 no conjunto de dados TT100K por 100 épocas com um tamanho de imagem de 640, você pode usar os seguintes trechos de código. O conjunto de dados será baixado e convertido automaticamente para o formato YOLO no primeiro uso.

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)

Link to this sectionExemplos de Imagens e Anotações#

Aqui estão exemplos típicos do conjunto de dados TT100K:

  1. Ambientes urbanos: Cenas de rua com vários sinais de trânsito a várias distâncias
  2. Cenas de rodovia: Sinais de trânsito de alta velocidade, incluindo limites de velocidade e indicadores de direção
  3. Interseções complexas: Múltiplos sinais próximos uns dos outros com orientações variadas
  4. Condições desafiadoras: Sinais sob diferentes iluminações (dia/noite), climas (chuva/neblina) e ângulos de visão

O conjunto de dados inclui:

  1. Sinais em close: Sinais grandes e claramente visíveis ocupando uma área significativa da imagem
  2. Sinais distantes: Sinais pequenos que exigem recursos de detecção de granulação fina
  3. Sinais parcialmente ocluídos: Sinais parcialmente bloqueados por veículos, árvores ou outros objetos
  4. Múltiplos sinais por imagem: Imagens contendo vários tipos diferentes de sinais

Link to this sectionCitações e Agradecimentos#

Se você usar o conjunto de dados TT100K em seu trabalho de pesquisa ou desenvolvimento, cite o seguinte artigo:

Citação
@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 agradecer à colaboração da Universidade Tsinghua e da Tencent pela criação e manutenção deste recurso valioso para as comunidades de visão computacional e direção autônoma. Para obter mais informações sobre o conjunto de dados TT100K, visite o site oficial do conjunto de dados.

Link to this sectionFAQ#

Link to this sectionPara que o conjunto de dados TT100K é usado?#

O conjunto de dados Tsinghua-Tencent 100K (TT100K) foi projetado especificamente para detecção e classificação de sinais de trânsito em condições reais. Ele é usado principalmente para:

  1. Treinamento de sistemas de percepção de direção autônoma
  2. Desenvolvimento de Sistemas Avançados de Assistência ao Motorista (ADAS)
  3. Pesquisa em detecção robusta de objetos sob condições variadas
  4. Benchmarking de algoritmos de reconhecimento de sinais de trânsito
  5. Teste de desempenho do modelo em objetos pequenos em imagens grandes

Com 100.000 diversas imagens de vista de rua e 221 categorias de sinais de trânsito, ele fornece uma plataforma de teste abrangente para detecção de sinais de trânsito no mundo real.

Link to this sectionQuantas categorias de sinais de trânsito existem no TT100K?#

O conjunto de dados TT100K contém 221 categorias diferentes de sinais de trânsito, incluindo:

  1. Limites de velocidade: pl* limites proibitivos e pm* velocidades mínimas (por exemplo, pl40, pl120, pm30, pm55)
  2. Sinais proibitivos: 29 tipos de proibição geral (p1-p29) mais restrições (pr*, pn, pne)
  3. Sinais de advertência: mais de 60 categorias de advertência (w1-w67)
  4. Limites de altura/largura: séries ph* altura e pw* largura para restrições físicas
  5. 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.

Link to this sectionComo 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, use 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)

Para configurações detalhadas de treinamento, consulte a documentação de Treinamento.

Link to this sectionO que torna o TT100K desafiador em comparação com outros conjuntos de dados?#

O TT100K apresenta vários desafios únicos:

  1. Variação de escala: Os sinais variam de muito pequenos (sinais rodoviários distantes) a grandes (sinais urbanos próximos)
  2. Condições reais: Variações extremas de iluminação, clima e ângulos de visão
  3. Alta resolução: Imagens de 2048×2048 pixels exigem um poder de processamento significativo
  4. Desequilíbrio de classe: Alguns tipos de sinais são muito mais comuns que outros
  5. Cenas densas: Vários sinais podem aparecer em uma única imagem
  6. Oclusão parcial: Os sinais podem ser parcialmente bloqueados por veículos, vegetação ou estruturas

Esses desafios tornam o TT100K uma referência valiosa para o desenvolvimento de algoritmos de detecção robustos.

Link to this sectionComo lidar com os grandes tamanhos de imagem no TT100K?#

O conjunto de dados TT100K usa imagens de 2048×2048 pixels, que podem consumir muitos 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=640 para experimentos iniciais
  • Use imgsz=1280 se você tiver memória GPU suficiente (24GB+)
  • Considere estratégias de mosaico (tiling) para sinais muito pequenos
  • Use a acumulação de gradiente para simular tamanhos de lote maiores
Contribuidores
GLglenn-jocher4RAraimbekovm1PRPrashantDixit01

Comentários