Seite auf GitHub bearbeiten (EN)

TT100K Datensatz

Der Tsinghua-Tencent 100K (TT100K) ist ein groß angelegter Benchmark-Datensatz für Verkehrszeichen, der aus 100.000 Tencent Street View Panoramen erstellt wurde. Dieser Datensatz wurde speziell für die Erkennung und Klassifizierung von Verkehrszeichen unter realen Bedingungen entwickelt und bietet Forschern und Entwicklern eine umfassende Ressource zum Aufbau robuster Systeme zur Verkehrszeichenerkennung.

Der Datensatz enthält 100.000 Bilder mit über 30.000 Verkehrszeicheninstanzen in 221 Annotationskategorien. Das ursprüngliche Paper wendet einen Schwellenwert von 100 Instanzen pro Klasse für das überwachte Training an, was einen häufig verwendeten 45-Klassen-Subsatz ergibt; die bereitgestellte Ultralytics Datensatzkonfiguration behält jedoch alle 221 annotierten Kategorien bei, von denen viele sehr spärlich sind. Diese Bilder erfassen große Variationen in Beleuchtung, Wetterbedingungen, Blickwinkeln und Entfernungen, was sie ideal für das Training von Modellen macht, die in diversen realen Szenarien zuverlässig funktionieren müssen.

Dieser Datensatz ist besonders wertvoll für:

  • Autonome Fahrsysteme
  • Fahrerassistenzsysteme (ADAS)
  • Verkehrsüberwachungsanwendungen
  • Stadtplanung und Verkehrsanalyse
  • Computer Vision Forschung unter realen Bedingungen

Hauptmerkmale

Der TT100K Datensatz bietet mehrere entscheidende Vorteile:

  • Skalierung: 100.000 hochauflösende Bilder (2048×2048 Pixel)
  • Vielfalt: 221 Verkehrszeichenkategorien, die chinesische Verkehrszeichen abdecken
  • Reale Bedingungen: Große Variationen bei Wetter, Beleuchtung und Blickwinkeln
  • Reiche Annotationen: Jedes Zeichen enthält Klassenlabel, Bounding Box und Pixel-Maske
  • Umfassende Abdeckung: Beinhaltet Verbots-, Warn-, Gebots- und Hinweisschilder
  • Train/Test-Split: Vordefinierte Aufteilungen für eine konsistente Evaluierung

Datensatzstruktur

Der TT100K Datensatz ist in drei Subsets unterteilt:

  1. Trainingsdatensatz: Die primäre Sammlung von Verkehrsszenen-Bildern, die zum Trainieren von Modellen für die Erkennung und Klassifizierung verschiedener Verkehrszeichenarten verwendet wird.
  2. Validierungsdatensatz: Ein Subset, das während der Modellentwicklung verwendet wird, um die Leistung zu überwachen und Hyperparameter anzupassen.
  3. Testdatensatz: Eine zurückgehaltene Sammlung von Bildern, die zur Bewertung der Fähigkeit des finalen Modells verwendet wird, Verkehrszeichen in realen Szenarien zu erkennen und zu klassifizieren.

Der TT100K Datensatz umfasst 221 Verkehrszeichenkategorien, die in mehrere Hauptgruppen organisiert sind:

Geschwindigkeitsbegrenzungsschilder (pl, pm)**

  1. pl_: Verbots-Geschwindigkeitsbegrenzungen (pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_: Mindestgeschwindigkeitsbegrenzungen (pm5, pm10, pm20, pm30, pm40, pm50, pm55)

Verbotsschilder (p, pn, pr_)**

  1. p1-p28: Allgemeine Verbotsschilder (Einfahrt verboten, Parkverbot, Halteverbot usw.)
  2. pn/pne: Einfahrts- und Parkverbotsschilder
  3. pr: Verschiedene Restriktionsschilder (pr10, pr20, pr30, pr40, pr50 usw.)

Warnschilder (w_)

  1. w1-w66: Warnschilder für verschiedene Straßengefahren, Bedingungen und Situationen
  2. Beinhaltet Fußgängerüberwege, scharfe Kurven, rutschige Straßen, Tiere, Baustellen usw.

Höhen-/Breitenbegrenzungsschilder (ph, pb)**

  1. ph_: Höhenbegrenzungsschilder (ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5 usw.)
  2. pb_: Breitenbegrenzungsschilder

Hinweisschilder (i, il, io, ip)**

  1. i1-i15: Allgemeine Hinweisschilder
  2. il_: Informationen zur Geschwindigkeitsbegrenzung (il60, il80, il100, il110)
  3. io: Andere Hinweisschilder
  4. ip: Informationstafeln

Datensatz-YAML

Eine YAML (Yet Another Markup Language) Datei wird verwendet, um die Datensatzkonfiguration zu definieren. Sie enthält Informationen über die Pfade des Datensatzes, Klassen und andere relevante Informationen. Für den TT100K Datensatz beinhaltet die TT100K.yaml Datei eine automatische Download- und Konvertierungsfunktionalität.

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)

Verwendung

Um ein YOLO26 Modell auf dem TT100K Datensatz für 100 Epochen bei einer Bildgröße von 640 zu trainieren, kannst du die folgenden Code-Schnipsel verwenden. Der Datensatz wird bei der ersten Verwendung automatisch heruntergeladen und in das YOLO-Format konvertiert.

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

Beispielbilder und Annotationen

Hier sind typische Beispiele aus dem TT100K Datensatz:

  1. Städtische Umgebungen: Straßenszenen mit mehreren Verkehrszeichen in verschiedenen Entfernungen
  2. Autobahnszenen: Hochgeschwindigkeits-Straßenschilder, einschließlich Geschwindigkeitsbegrenzungen und Richtungsanzeiger
  3. Komplexe Kreuzungen: Mehrere Schilder in unmittelbarer Nähe mit unterschiedlichen Orientierungen
  4. Herausfordernde Bedingungen: Schilder unter verschiedenen Lichtverhältnissen (Tag/Nacht), Wetter (Regen/Nebel) und Blickwinkeln

Der Datensatz beinhaltet:

  1. Nahaufnahmen von Schildern: Große, deutlich sichtbare Schilder, die einen beträchtlichen Teil des Bildbereichs einnehmen
  2. Entfernte Schilder: Kleine Schilder, die fein abgestimmte Erkennungsfähigkeiten erfordern
  3. Teilweise verdeckte Schilder: Schilder, die teilweise durch Fahrzeuge, Bäume oder andere Objekte blockiert sind
  4. Mehrere Schilder pro Bild: Bilder, die verschiedene Schildertypen enthalten

Zitate und Danksagungen

Wenn du den TT100K Datensatz in deiner Forschung oder Entwicklungsarbeit verwendest, zitiere bitte das folgende Paper:

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

Wir möchten der Zusammenarbeit zwischen der Tsinghua Universität und Tencent für die Erstellung und Pflege dieser wertvollen Ressource für die Computer Vision- und autonome Fahr-Communitys danken. Weitere Informationen zum TT100K Datensatz findest du auf der offiziellen Datensatz-Website.

FAQ

Wofür wird der TT100K Datensatz verwendet?

Der Tsinghua-Tencent 100K (TT100K) Datensatz ist speziell für die Erkennung und Klassifizierung von Verkehrszeichen unter realen Bedingungen konzipiert. Er wird hauptsächlich verwendet für:

  1. Das Trainieren von Wahrnehmungssystemen für autonomes Fahren
  2. Die Entwicklung von Fahrerassistenzsystemen (ADAS)
  3. Forschung im Bereich robuster Objekterkennung unter wechselnden Bedingungen
  4. Benchmarking von Algorithmen zur Verkehrszeichenerkennung
  5. Das Testen der Modellleistung bei kleinen Objekten in großen Bildern

Mit 100.000 diversen Street View Bildern und 221 Verkehrszeichenkategorien bietet er ein umfassendes Testumfeld für die Verkehrszeichenerkennung unter realen Bedingungen.

Wie viele Verkehrszeichenkategorien gibt es in TT100K?

Der TT100K Datensatz enthält 221 verschiedene Verkehrszeichenkategorien, darunter:

  1. Geschwindigkeitsbegrenzungen: pl5 bis pl120 (Verbotsbegrenzungen) und pm5 bis pm55 (Mindestgeschwindigkeiten)
  2. Verbotsschilder: 28+ allgemeine Verbotsarten (p1-p28) plus Restriktionen (pr*, pn, pne)
  3. Warnschilder: 60+ Warnkategorien (w1-w66)
  4. Höhen-/Breitenbegrenzungen: ph* und pb* Serie für physische Restriktionen
  5. Hinweisschilder: i1-i15, il*, io, ip für Führung und Information

Diese umfassende Abdeckung beinhaltet die meisten Verkehrszeichen, die im chinesischen Straßennetz vorkommen.

Wie kann ich ein YOLO26n Modell mit dem TT100K Datensatz trainieren?

Um ein YOLO26n Modell auf dem TT100K Datensatz für 100 Epochen bei einer Bildgröße von 640 zu trainieren, verwende das folgende Beispiel.

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

Detaillierte Trainingskonfigurationen findest du in der Training-Dokumentation.

Was macht TT100K im Vergleich zu anderen Datensätzen anspruchsvoll?

TT100K stellt einige einzigartige Herausforderungen dar:

  1. Skalenvariation: Schilder reichen von sehr klein (entfernte Autobahnschilder) bis groß (Nahaufnahmen in der Stadt)
  2. Reale Bedingungen: Extreme Variationen bei Beleuchtung, Wetter und Blickwinkeln
  3. Hohe Auflösung: 2048×2048 Pixel Bilder erfordern erhebliche Rechenleistung
  4. Klassenungleichgewicht: Manche Schildertypen sind wesentlich häufiger als andere
  5. Dichte Szenen: Mehrere Schilder können in einem einzigen Bild erscheinen
  6. Teilweise Verdeckung: Schilder können teilweise durch Fahrzeuge, Vegetation oder Strukturen blockiert sein

Diese Herausforderungen machen TT100K zu einem wertvollen Benchmark für die Entwicklung robuster Erkennungsalgorithmen.

Wie gehe ich mit den großen Bildgrößen in TT100K um?

Der TT100K Datensatz verwendet 2048×2048 Pixel große Bilder, was ressourcenintensiv sein kann. Hier sind empfohlene Strategien:

Für das Training:

# 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

Empfehlungen:

  • Beginne mit imgsz=640 für erste Experimente
  • Verwende imgsz=1280, wenn du über ausreichend GPU-Speicher (24GB+) verfügst
  • Erwäge Kachelstrategien für sehr kleine Schilder
  • Nutze Gradient Accumulation, um größere Batch-Größen zu simulieren
Contributors
Seite auf GitHub bearbeiten (EN)
GLglenn-jocher2RAraimbekovm1PRPrashantDixit01

Kommentare