Modifica la pagina su GitHub (EN)

Dataset TT100K

Il Tsinghua-Tencent 100K (TT100K) è un dataset benchmark di segnali stradali su larga scala 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 distribuite in 221 categorie di annotazione. Il documento 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 mantiene 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 l'addestramento di modelli che devono operare in modo affidabile in diversi scenari del mondo reale.

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 computer vision in condizioni reali

Caratteristiche 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 la segnaletica cinese
  • Condizioni reali: Ampie variazioni di meteo, illuminazione e angolazioni
  • Annotazioni ricche: Ogni segnale include etichetta di classe, BBox e maschera pixel
  • Copertura completa: Include segnali di divieto, pericolo, obbligo e informativi
  • Split Train/Test: Divisioni predefinite per una valutazione coerente

Struttura del dataset

Il dataset TT100K è suddiviso in tre sottoinsiemi:

  1. Set di Addestramento: La raccolta principale di immagini di scenari stradali utilizzata per addestrare i modelli a rilevare e classificare diversi tipi di segnali stradali.
  2. Set di Validazione: Un sottoinsieme utilizzato durante lo sviluppo del modello per monitorare le prestazioni e ottimizzare gli iperparametri.
  3. Set di Test: Una raccolta di immagini tenuta da parte utilizzata per valutare la capacità finale del modello 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 (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_: Limiti di velocità minimi (pm5, pm10, pm20, pm30, pm40, pm50, pm55)

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

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

Segnali di Pericolo (w_)

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

Segnali di Limite di Altezza/Larghezza (ph, pb)**

  1. ph_: Segnali di limite di altezza (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5, ecc.)
  2. pb_: Segnali di limite di larghezza

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

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

YAML del dataset

Un file YAML (Yet Another Markup Language) viene utilizzato per definire la configurazione del dataset. Contiene informazioni sui percorsi del dataset, le classi e altre informazioni rilevanti. 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: 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)

Utilizzo

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 training
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)

Immagini campione e annotazioni

Ecco esempi tipici dal dataset TT100K:

  1. Ambienti urbani: Scenari stradali con molteplici segnali a varie distanze
  2. Scenari autostradali: Segnali stradali ad alta velocità inclusi limiti di velocità e indicatori di direzione
  3. Incroci complessi: Molteplici segnali in stretta prossimità con orientamenti variabili
  4. Condizioni difficili: Segnali sotto diverse illuminazioni (giorno/notte), meteo (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 a grana fine
  3. Segnali parzialmente occlusi: Segnali parzialmente bloccati da veicoli, alberi o altri oggetti
  4. Molteplici segnali per immagine: Immagini contenenti diversi tipi di segnali

Citazioni e ringraziamenti

Se utilizzi il dataset TT100K nel tuo lavoro di ricerca o sviluppo, ti preghiamo di citare il seguente articolo:

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

Vorremmo ringraziare la collaborazione tra l'Università Tsinghua e Tencent per aver creato e mantenuto questa preziosa risorsa per le comunità di computer vision e guida autonoma. Per maggiori informazioni sul dataset TT100K, visita il sito ufficiale del dataset.

FAQ

A 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. È 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. Benchmarking di algoritmi di riconoscimento della segnaletica stradale
  5. Testare le prestazioni del modello su piccoli oggetti in immagini grandi

Con 100.000 immagini diversificate di strade e 221 categorie di segnali stradali, fornisce un banco di prova completo per il rilevamento della segnaletica stradale in contesti reali.

Quante categorie di segnali stradali ci sono in TT100K?

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

  1. Limiti di velocità: da pl5 a pl120 (limiti di divieto) e da pm5 a pm55 (velocità minime)
  2. Segnali di divieto: 28+ tipi di divieto generali (p1-p28) più restrizioni (pr*, pn, pne)
  3. Segnali di pericolo: 60+ categorie di pericolo (w1-w66)
  4. Limiti di altezza/larghezza: serie ph* e pb* 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.

Come posso addestrare un modello YOLO26n usando 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 training
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 Training.

Cosa 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: Variazioni estreme di illuminazione, meteo e angolazioni
  3. Alta risoluzione: Le immagini da 2048×2048 pixel richiedono una potenza di calcolo significativa
  4. Sbilanciamento delle classi: Alcuni tipi di segnali sono molto più comuni di altri
  5. Scenari densi: Molteplici segnali possono apparire 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 sviluppare algoritmi di rilevamento robusti.

Come gestisco le grandi dimensioni delle immagini in TT100K?

Il dataset TT100K utilizza immagini da 2048×2048 pixel, che possono essere pesanti in termini di 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 del gradiente per simulare batch size più grandi
Contributors
Modifica la pagina su GitHub (EN)
GLglenn-jocher2RAraimbekovm1PRPrashantDixit01

Commenti