Meet YOLO26: next-gen vision AI.

Link to this sectionTT100K 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 Verkehrszeichen-Erkennungssysteme.

Der Datensatz enthält 100.000 Bilder mit über 30.000 Verkehrszeichen-Instanzen in 221 Annotationskategorien. Das Originalpapier wendet für das überwachte Training einen Schwellenwert von 100 Instanzen pro Klasse an, was zu einer häufig verwendeten Teilmenge von 45 Klassen führt; 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 bei 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
  • Erweiterte Fahrerassistenzsysteme (ADAS)
  • Verkehrsüberwachungsanwendungen
  • Stadtplanung und Verkehrsanalyse
  • Computer Vision Forschung unter realen Bedingungen

Link to this sectionHauptfunktionen#

Der TT100K Datensatz bietet mehrere wichtige Vorteile:

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

Link to this sectionDatensatzstruktur#

Der TT100K Datensatz ist in drei Teilmengen unterteilt:

  1. Training Set: Die primäre Sammlung von Verkehrsszenenbildern, die zum Training von Modellen für die Erkennung und Klassifizierung verschiedener Arten von Verkehrszeichen verwendet wird.
  2. Validation Set: Eine Teilmenge, die während der Modellentwicklung verwendet wird, um die Leistung zu überwachen und Hyperparameter anzupassen.
  3. Test Set: Eine zurückgehaltene Sammlung von Bildern, die verwendet wird, um die Fähigkeit des finalen Modells zu bewerten, Verkehrszeichen in realen Szenarien zu erkennen und zu klassifizieren.

Der TT100K Datensatz enthält 221 Verkehrszeichenkategorien, die in mehrere Hauptgruppen organisiert sind:

Geschwindigkeitsbegrenzungsschilder (pl, pm)**

  1. pl_: Verbotene Höchstgeschwindigkeiten (z.B. pl5, pl10, pl20, pl30, pl40, pl50, pl60, pl70, pl80, pl100, pl120)
  2. pm_: Mindestgeschwindigkeiten (z.B. pm5, pm10, pm20, pm30, pm40, pm50, pm55)

Verbotsschilder (p, pn, pr_)**

  1. p1-p29: Allgemeine Verbotsschilder (Einfahrt verboten, Parkverbot, Haltverbot, etc.)
  2. pn/pne: Einfahrt-verboten- und Parkverbotsschilder
  3. pr: Verschiedene Beschränkungsschilder (z.B. pr10, pr20, pr30, pr40, pr50)

Warnschilder (w_)

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

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

  1. ph_: Höhenbegrenzungsschilder (z.B. ph2, ph2.5, ph3, ph3.5, ph4, ph4.5, ph5)
  2. pb/pw_: Breitenbegrenzungsschilder

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

  1. i1-i15: Allgemeine Hinweisschilder
  2. il_: Geschwindigkeitsbegrenzungshinweise (il50, il60, il70, il80, il90, il100, il110)
  3. io: Andere Hinweisschilder
  4. ip: Informationstafeln

Link to this sectionDatensatz-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 Details. 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: 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 sectionVerwendung#

Um ein YOLO26 Modell auf dem TT100K Datensatz für 100 epochs mit 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)

Link to this sectionBeispielbilder und Annotationen#

Hier sind typische Beispiele aus dem TT100K Datensatz:

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

Der Datensatz beinhaltet:

  1. Nahaufnahmen von Schildern: Große, deutlich sichtbare Schilder, die einen signifikanten Bildbereich einnehmen
  2. Entfernte Schilder: Kleine Schilder, die feinkörnige 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

Link to this sectionZitate und Danksagungen#

Wenn du den TT100K Datensatz in deiner Forschungs- oder Entwicklungsarbeit verwendest, zitiere bitte das folgende Papier:

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 die 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-Community anerkennen. Für weitere Informationen über den TT100K Datensatz besuche die offizielle Datensatz-Webseite.

Link to this sectionFAQ#

Link to this sectionWofür wird der TT100K Datensatz verwendet?#

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

  1. Das Training von Wahrnehmungssystemen für autonomes Fahren
  2. Die Entwicklung von Advanced Driver Assistance Systems (ADAS)
  3. Forschung zur robusten Objekterkennung unter variierenden Bedingungen
  4. Benchmarking von Algorithmen zur Verkehrszeichenerkennung
  5. Testen der Modellleistung bei kleinen Objekten in großen Bildern

Mit 100.000 diversen Street View Bildern und 221 Verkehrszeichenkategorien bietet er eine umfassende Testumgebung für die Verkehrszeichenerkennung in der realen Welt.

Link to this sectionWie viele Verkehrszeichenkategorien gibt es in TT100K?#

Der TT100K Datensatz enthält 221 verschiedene Verkehrszeichenkategorien, einschließlich:

  1. Geschwindigkeitsbegrenzungen: pl* Verbotsbegrenzungen und pm* Mindestgeschwindigkeiten (z.B. pl40, pl120, pm30, pm55)
  2. Verbotsschilder: 29 allgemeine Verbotsarten (p1-p29) plus Beschränkungen (pr*, pn, pne)
  3. Warnschilder: 60+ Warnkategorien (w1-w67)
  4. Höhen-/Breitenbegrenzungen: ph* Höhen- und pw* Breitenserien für physische Beschränkungen
  5. Hinweisschilder: i1-i15, il*, io, ip für Führung und Information

Diese umfassende Abdeckung beinhaltet die meisten Verkehrszeichen, die in chinesischen Straßennetzen zu finden sind.

Link to this sectionWie kann ich ein YOLO26n Modell mit dem TT100K Datensatz trainieren?#

Um ein YOLO26n Modell auf dem TT100K Datensatz für 100 Epochen mit 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.

Link to this sectionWas macht TT100K im Vergleich zu anderen Datensätzen herausfordernd?#

TT100K stellt mehrere einzigartige Herausforderungen dar:

  1. Skalierungsvariation: Schilder reichen von sehr klein (entfernte Autobahnschilder) bis groß (nahe städtische Schilder)
  2. Reale Bedingungen: Extreme Variationen bei Licht, Wetter und Blickwinkeln
  3. Hohe Auflösung: 2048×2048 Pixel Bilder erfordern signifikante Rechenleistung
  4. Klassenungleichgewicht: Einige Schildertypen kommen viel häufiger vor 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.

Link to this sectionWie gehe ich mit den großen Bildgrößen in TT100K um?#

Der TT100K Datensatz verwendet 2048×2048 Pixel Bilder, die ressourcenintensiv sein können. 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 ausreichend GPU-Speicher hast (24GB+)
  • Erwäge Tiling-Strategien für sehr kleine Schilder
  • Verwende Gradientenakkumulation, um größere Batch-Größen zu simulieren
Mitwirkende
GLglenn-jocher4RAraimbekovm1PRPrashantDixit01

Kommentare