Meet YOLO26: next-gen vision AI.

Link to this sectionDataset TT100K#

Il Tsinghua-Tencent 100K (TT100K) è un benchmark dataset su larga scala di segnali stradali creato da 100.000 panorami di Tencent Street View. Questo dataset è progettato specificamente per il rilevamento e la classificazione dei segnali stradali in condizioni reali, fornendo a ricercatori e sviluppatori una risorsa completa per costruire sistemi robusti di riconoscimento della segnaletica stradale.

Il dataset contiene 100.000 immagini con oltre 30.000 istanze di segnali stradali in 221 categorie di annotazione. Il paper originale applica una soglia di 100 istanze per classe per l'addestramento supervisionato, ottenendo un sottoinsieme comunemente usato di 45 classi; tuttavia, la configurazione del dataset Ultralytics fornita conserva tutte le 221 categorie annotate, molte delle quali sono molto sparse. Queste immagini catturano ampie variazioni di illuminazione, condizioni meteorologiche, angolazioni e distanze, rendendolo ideale per addestrare modelli che devono funzionare in modo affidabile in diversi scenari reali.

Questo dataset è particolarmente prezioso per:

  • Sistemi di guida autonoma
  • Sistemi avanzati di assistenza alla guida (ADAS)
  • Applicazioni di monitoraggio del traffico
  • Pianificazione urbana e analisi del traffico
  • Ricerca sulla visione artificiale in condizioni reali

Link to this sectionCaratteristiche principali#

Il dataset TT100K offre diversi vantaggi chiave:

  • Scala: 100.000 immagini ad alta risoluzione (2048×2048 pixel)
  • Diversità: 221 categorie di segnali stradali che coprono i segnali stradali cinesi
  • Condizioni reali: Ampie variazioni di meteo, illuminazione e angolazioni
  • Annotazioni ricche: Ogni segnale include etichetta di classe, bounding box e maschera di pixel
  • Copertura completa: Include segnali di divieto, pericolo, obbligo e informativi
  • Split Train/Test: Divisioni predefinite per una valutazione coerente

Link to this sectionStruttura del dataset#

Il dataset TT100K è diviso in tre sottoinsiemi:

  1. Training Set: La raccolta principale di immagini di scenari stradali utilizzata per addestrare modelli per il rilevamento e la classificazione di diversi tipi di segnali stradali.
  2. Validation Set: Un sottoinsieme utilizzato durante lo sviluppo del modello per monitorare le prestazioni e regolare gli iperparametri.
  3. Test Set: Una raccolta di immagini tenuta da parte, utilizzata per valutare la capacità del modello finale di rilevare e classificare i segnali stradali in scenari reali.

Il dataset TT100K include 221 categorie di segnali stradali organizzate in diversi gruppi principali:

Segnali di limite di velocità (pl, pm)**

  1. pl_: Limiti di velocità di divieto (es. pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_: Limiti di velocità minimi (es. pm5, pm10, pm20, pm30, pm40, pm50, pm55)

Segnali di divieto (p, pn, pr_)**

  1. p1-p29: Segnali di divieto generali (divieto di accesso, divieto di sosta, divieto di fermata, ecc.)
  2. pn/pne: Segnali di divieto di accesso e divieto di sosta
  3. pr: Vari segnali di restrizione (es. pr10, pr20, pr30, pr40, pr50)

Segnali di pericolo (w_)

  1. w1-w67: Segnali di pericolo per vari rischi stradali, condizioni e situazioni
  2. Include passaggi pedonali, curve pericolose, strade scivolose, animali, cantieri, ecc.

Segnali di limite di altezza/larghezza (ph, pb, pw*)**

  1. ph_: Segnali di limite di altezza (es. ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5)
  2. pb/pw_: Segnali di limite di larghezza

Segnali informativi (i, il, io, ip)**

  1. i1-i15: Segnali informativi generali
  2. il_: Informazioni sul limite di velocità (il50, il60, il70, il80, il90, il100, il110)
  3. io: Altri segnali informativi
  4. ip: Pannelli integrativi

Link to this sectionDataset YAML#

Un file YAML (Yet Another Markup Language) viene utilizzato per definire la configurazione del dataset. Contiene informazioni sui percorsi, le classi e altri dati rilevanti del dataset. Per il dataset TT100K, il file TT100K.yaml include funzionalità di download e conversione automatica.

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 sectionUtilizzo#

Per addestrare un modello YOLO26 sul dataset TT100K per 100 epoch con una dimensione immagine di 640, puoi utilizzare i seguenti frammenti di codice. Il dataset verrà scaricato e convertito automaticamente nel formato YOLO al primo utilizzo.

Esempio di Addestramento
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 sectionEsempi di immagini e annotazioni#

Ecco esempi tipici dal dataset TT100K:

  1. Ambienti urbani: Scene stradali con molteplici segnali stradali a varie distanze
  2. Scene autostradali: Segnali stradali ad alta velocità inclusi limiti di velocità e indicatori di direzione
  3. Intersezioni complesse: Molteplici segnali in stretta vicinanza con orientamenti variabili
  4. Condizioni impegnative: Segnali con diverse illuminazioni (giorno/notte), condizioni meteorologiche (pioggia/nebbia) e angolazioni

Il dataset include:

  1. Segnali in primo piano: Segnali grandi e chiaramente visibili che occupano un'area significativa dell'immagine
  2. Segnali distanti: Segnali piccoli che richiedono capacità di rilevamento ad alta precisione
  3. Segnali parzialmente occlusi: Segnali parzialmente bloccati da veicoli, alberi o altri oggetti
  4. Segnali multipli per immagine: Immagini contenenti diversi tipi di segnali

Link to this sectionCitazioni e riconoscimenti#

Se utilizzi il dataset TT100K nel tuo lavoro di ricerca o sviluppo, cita il seguente paper:

Citazione
@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}
}

Desideriamo ringraziare la collaborazione tra la Tsinghua University e Tencent per aver creato e mantenuto questa risorsa preziosa per le comunità della visione artificiale e della guida autonoma. Per maggiori informazioni sul dataset TT100K, visita il sito web ufficiale del dataset.

Link to this sectionFAQ#

Link to this sectionA cosa serve il dataset TT100K?#

Il dataset Tsinghua-Tencent 100K (TT100K) è progettato specificamente per il rilevamento e la classificazione dei segnali stradali in condizioni reali. Viene utilizzato principalmente per:

  1. Addestrare sistemi di percezione per la guida autonoma
  2. Sviluppare sistemi avanzati di assistenza alla guida (ADAS)
  3. Ricerca sul rilevamento robusto di oggetti in condizioni variabili
  4. Effettuare benchmarking di algoritmi di riconoscimento dei segnali stradali
  5. Testare le prestazioni del modello su piccoli oggetti in immagini grandi

Con 100.000 immagini di Street View diverse e 221 categorie di segnali stradali, fornisce un banco di prova completo per il rilevamento dei segnali stradali in condizioni reali.

Link to this sectionQuante categorie di segnali stradali ci sono in TT100K?#

Il dataset TT100K contiene 221 diverse categorie di segnali stradali, tra cui:

  1. Limiti di velocità: Limiti di divieto pl* e velocità minime pm* (es. pl40, pl120, pm30, pm55)
  2. Segnali di divieto: 29 tipi di divieto generali (p1-p29) più restrizioni (pr*, pn, pne)
  3. Segnali di pericolo: 60+ categorie di avvertimento (w1-w67)
  4. Limiti di altezza/larghezza: Serie di altezza ph* e larghezza pw* per restrizioni fisiche
  5. Segnali informativi: i1-i15, il*, io, ip per orientamento e informazioni

Questa copertura completa include la maggior parte dei segnali stradali presenti nelle reti stradali cinesi.

Link to this sectionCome posso addestrare un modello YOLO26n utilizzando il dataset TT100K?#

Per addestrare un modello YOLO26n sul dataset TT100K per 100 epoch con una dimensione immagine di 640, usa l'esempio qui sotto.

Esempio di Addestramento
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)

Per configurazioni di addestramento dettagliate, fai riferimento alla documentazione sull'addestramento.

Link to this sectionCosa rende TT100K impegnativo rispetto ad altri dataset?#

TT100K presenta diverse sfide uniche:

  1. Variazione di scala: I segnali spaziano da molto piccoli (segnali autostradali distanti) a grandi (segnali urbani in primo piano)
  2. Condizioni reali: Estreme variazioni di illuminazione, meteo e angolazioni
  3. Alta risoluzione: Le immagini da 2048×2048 pixel richiedono una notevole potenza di elaborazione
  4. Squilibrio delle classi: Alcuni tipi di segnali sono molto più comuni di altri
  5. Scene dense: Possono apparire più segnali in una singola immagine
  6. Occlusione parziale: I segnali possono essere parzialmente bloccati da veicoli, vegetazione o strutture

Queste sfide rendono TT100K un benchmark prezioso per lo sviluppo di algoritmi di rilevamento robusti.

Link to this sectionCome gestisco le grandi dimensioni delle immagini in TT100K?#

Il dataset TT100K utilizza immagini da 2048×2048 pixel, che possono richiedere molte risorse. Ecco le strategie consigliate:

Per l'addestramento:

# 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

Raccomandazioni:

  • Inizia con imgsz=640 per gli esperimenti iniziali
  • Usa imgsz=1280 se hai memoria GPU sufficiente (24GB+)
  • Valuta strategie di tiling per segnali molto piccoli
  • Usa l'accumulo di gradiente per simulare batch size più grandi
Contributori
GLglenn-jocher4RAraimbekovm1PRPrashantDixit01

Commenti