Modell YAML-Konfiguration

Die YAML-Konfigurationsdatei des Modells dient als Architekturentwurf für neuronale Netze Ultralytics . Sie definiert, wie Schichten verbunden werden, welche Parameter jedes Modul verwendet und wie das gesamte Netzwerk über verschiedene Modellgrößen skaliert.

Konfiguration Struktur

YAML-Modelldateien sind in drei Hauptabschnitte unterteilt, die zusammen die Architektur definieren.

Abschnitt Parameter

Im Abschnitt Parameter werden die globalen Eigenschaften und das Skalierungsverhalten des Modells festgelegt:

# Parameters
nc: 80 # number of classes
scales: # compound scaling constants [depth, width, max_channels]
    n: [0.50, 0.25, 1024] # nano: shallow layers, narrow channels
    s: [0.50, 0.50, 1024] # small: shallow depth, standard width
    m: [0.50, 1.00, 512] # medium: moderate depth, full width
    l: [1.00, 1.00, 512] # large: full depth and width
    x: [1.00, 1.50, 512] # extra-large: maximum performance
kpt_shape: [17, 3] # pose models only

• nc legt die Anzahl der Klassen fest, die das Modell vorhersagt.
• scales zusammengesetzte Skalierungsfaktoren definieren, die die Modelltiefe, -breite und die maximalen Kanäle anpassen, um verschiedene Größenvarianten (Nano bis Extra Large) zu erzeugen.
• kpt_shape gilt für Posenmodelle. Es kann sein [N, 2] für (x, y) Keypoints oder [N, 3] für (x, y, visibility).

Backbone- und Head-Architektur

Die Modellarchitektur besteht aus einem Hauptteil (Merkmalsextraktion) und einem Kopfteil (aufgabenspezifisch):

backbone:
    # [from, repeats, module, args]
    - [-1, 1, Conv, [64, 3, 2]] # 0: Initial convolution
    - [-1, 1, Conv, [128, 3, 2]] # 1: Downsample
    - [-1, 3, C2f, [128, True]] # 2: Feature processing

head:
    - [-1, 1, nn.Upsample, [None, 2, nearest]] # 6: Upsample
    - [[-1, 2], 1, Concat, [1]] # 7: Skip connection
    - [-1, 3, C2f, [256]] # 8: Process features
    - [[8], 1, Detect, [nc]] # 9: Detection layer

Format der Ebenenspezifikation

Jede Schicht folgt dem gleichen Muster: [from, repeats, module, args]

Verbindungsmuster

Die from Feld schafft flexible Datenflussmuster in Ihrem gesamten Netzwerk:

- [-1, 1, Conv, [64, 3, 2]]    # Takes input from previous layer

- [[-1, 6], 1, Concat, [1]]    # Combines current layer with layer 6

- [[4, 6, 8], 1, Detect, [nc]] # Detection head using 3 feature scales

Modul Wiederholung

Die repeats erzeugt tiefere Netzabschnitte:

- [-1, 3, C2f, [128, True]] # Creates 3 consecutive C2f blocks
- [-1, 1, Conv, [64, 3, 2]] # Single convolution layer

Die tatsächliche Anzahl der Wiederholungen wird mit dem Tiefenskalierungsfaktor aus Ihrer Modellgrößenkonfiguration multipliziert.

Verfügbare Module

Die Module sind nach Funktionalität geordnet und im Ultralytics definiert. In den folgenden Tabellen sind häufig verwendete Module nach Kategorien aufgeführt, und viele weitere sind im Quellcode verfügbar:

Grundlegende Operationen

Komposit-Blöcke

Spezialisierte Module

Erweiterte Funktionen

TorchVision-Integration

Das TorchVision-Modul ermöglicht die nahtlose Integration eines beliebigen TorchVision-Modells als Backbone:

from ultralytics import YOLO

# Model with ConvNeXt backbone
model = YOLO("convnext_backbone.yaml")
results = model.train(data="coco8.yaml", epochs=100)

backbone:
  - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, False]]
head:
  - [-1, 1, Classify, [nc]]

Indexmodul für die Merkmalsauswahl

Bei der Verwendung von Modellen, die mehrere Feature-Maps ausgeben, wählt das Index-Modul bestimmte Ausgaben aus:

backbone:
    - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, True]] # Multi-output
head:
    - [0, 1, Index, [192, 4]] # Select 4th feature map (192 channels)
    - [0, 1, Index, [384, 6]] # Select 6th feature map (384 channels)
    - [0, 1, Index, [768, 8]] # Select 8th feature map (768 channels)
    - [[1, 2, 3], 1, Detect, [nc]] # Multi-scale detection

Modul-Auflösungssystem

Für die Anpassung ist es wichtig zu verstehen, wie Ultralytics die Module findet und importiert:

Modul Lookup Prozess

Ultralytics verwendet ein dreistufiges System in parse_model:

# Core resolution logic
m = getattr(torch.nn, m[3:]) if "nn." in m else getattr(torchvision.ops, m[4:]) if "ops." in m else globals()[m]

1. PyTorch: Namen beginnend mit 'nn.' → torch.nn Namensraum
2. TorchVision-Betrieb: Namen beginnend mit 'ops.' → torchvision.ops Namensraum
3. Ultralytics : Alle anderen Namen → globaler Namespace über Importe

Modul Importkette

Standardmodule werden durch Importe in tasks.py:

from ultralytics.nn.modules import (  # noqa: F401, E501
    SPPF,
    C2f,
    Conv,
    Detect,
    # ... many more modules
    Index,
    TorchVision,
)

Integration benutzerdefinierter Module

Änderung des Quellcodes

Die Änderung des Quellcodes ist der vielseitigste Weg, um Ihre benutzerdefinierten Module zu integrieren, aber es kann schwierig sein. Um ein benutzerdefiniertes Modul zu definieren und zu verwenden, gehen Sie folgendermaßen vor:

1. Definieren Sie Ihr Modul in ultralytics/nn/modules/block.py:

   class CustomBlock(nn.Module):
       def __init__(self, c1, c2):
           super().__init__()
           self.layers = nn.Sequential(nn.Conv2d(c1, c2, 3, 1, 1), nn.BatchNorm2d(c2), nn.ReLU())
   
       def forward(self, x):
           return self.layers(x)
   

2. Stellen Sie Ihr Modul auf der Paketebene zur Verfügung in ultralytics/nn/modules/__init__.py:

   from .block import CustomBlock  # noqa makes CustomBlock available as ultralytics.nn.modules.CustomBlock
   

3. Zu den Einfuhren hinzufügen in ultralytics/nn/tasks.py:

   from ultralytics.nn.modules import CustomBlock  # noqa
   

4. Umgang mit speziellen Argumenten (falls erforderlich) innen parse_model() in ultralytics/nn/tasks.py:

   elif m is CustomBlock:
       c1, c2 = ch[f], args[0]  # input channels, output channels
       args = [c1, c2, *args[1:]]
   

5. Verwenden Sie das Modul in Ihrer Modell-YAML:

   # custom_model.yaml
   nc: 1
   backbone:
       - [-1, 1, CustomBlock, [64]]
   head:
       - [-1, 1, Classify, [nc]]
   

6. Prüfen Sie die FLOPs, um sicherzustellen, dass der Vorwärtspass funktioniert:

   from ultralytics import YOLO
   
   model = YOLO("custom_model.yaml", task="classify")
   model.info()  # should print non-zero FLOPs if working
   

Beispielkonfigurationen

Grundlegendes Erkennungsmodell

# Simple YOLO detection model
nc: 80
scales:
    n: [0.33, 0.25, 1024]

backbone:
    - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
    - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
    - [-1, 3, C2f, [128, True]] # 2
    - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
    - [-1, 6, C2f, [256, True]] # 4
    - [-1, 1, SPPF, [256, 5]] # 5

head:
    - [-1, 1, Conv, [256, 3, 1]] # 6
    - [[6], 1, Detect, [nc]] # 7

TorchVision Backbone-Modell

# ConvNeXt backbone with YOLO head
nc: 80

backbone:
    - [-1, 1, TorchVision, [768, convnext_tiny, DEFAULT, True, 2, True]]

head:
    - [0, 1, Index, [192, 4]] # P3 features
    - [0, 1, Index, [384, 6]] # P4 features
    - [0, 1, Index, [768, 8]] # P5 features
    - [[1, 2, 3], 1, Detect, [nc]] # Multi-scale detection

Klassifikationsmodell

# Simple classification model
nc: 1000

backbone:
    - [-1, 1, Conv, [64, 7, 2, 3]]
    - [-1, 1, nn.MaxPool2d, [3, 2, 1]]
    - [-1, 4, C2f, [64, True]]
    - [-1, 1, Conv, [128, 3, 2]]
    - [-1, 8, C2f, [128, True]]
    - [-1, 1, nn.AdaptiveAvgPool2d, [1]]

head:
    - [-1, 1, Classify, [nc]]

Bewährte Praktiken

Architektur Design-Tipps

Beginnen Sie einfach: Beginnen Sie mit bewährten Architekturen, bevor Sie sie anpassen. Verwenden Sie bestehende YOLO als Vorlagen und ändern Sie sie schrittweise, anstatt sie von Grund auf neu aufzubauen.

Inkrementell testen: Überprüfen Sie jede Änderung Schritt für Schritt. Fügen Sie ein benutzerdefiniertes Modul nach dem anderen hinzu und prüfen Sie, ob es funktioniert, bevor Sie mit der nächsten Änderung fortfahren.

Monitor-Kanäle: Stellen Sie sicher, dass die Kanalabmessungen zwischen den angeschlossenen Ebenen übereinstimmen. Die Ausgangskanäle (c2) einer Schicht müssen mit den Eingangskanälen (c1) der nächsten Schicht in der Sequenz.

Verwenden Sie Verbindungen überspringen: Nutzen Sie die Wiederverwendung von Funktionen mit [[-1, N], 1, Concat, [1]] Muster. Diese Verbindungen helfen beim Gradientenfluss und ermöglichen es dem Modell, Merkmale aus verschiedenen Maßstäben zu kombinieren.

Angemessene Skalierung: Wählen Sie den Maßstab des Modells entsprechend Ihren Berechnungsvorgaben. Verwenden Sie nano (n) für Randgeräte, kleine (s) für eine ausgewogene Leistung, und größere Skalen (m, l, x) für maximale Genauigkeit.

Überlegungen zur Leistung

Tiefe vs. Breite: Tiefe Netze erfassen komplexe hierarchische Merkmale durch mehrere Transformationsschichten, während breite Netze in jeder Schicht mehr Informationen parallel verarbeiten. Wägen Sie je nach Komplexität Ihrer Aufgabe ab.

Verbindungen überspringen: Verbessern den Gradientenfluss beim Training und ermöglichen die Wiederverwendung von Merkmalen im gesamten Netz. Sie sind besonders wichtig in tieferen Architekturen, um verschwindende Gradienten zu verhindern.

Engpass-Blöcke: Verringerung der Rechenkosten unter Beibehaltung der Ausdruckskraft des Modells. Module wie C2f verwenden weniger Parameter als Standard-Faltungen und behalten gleichzeitig die Fähigkeit, Merkmale zu lernen.

Multiskalige Merkmale: Unerlässlich für die Erkennung von Objekten unterschiedlicher Größe im selben Bild. Verwenden Sie FPN-Muster (Feature Pyramid Network) mit mehreren Erkennungsköpfen in verschiedenen Maßstäben.

Fehlersuche

Häufige Probleme

Tipps zur Fehlersuche

Bei der Entwicklung kundenspezifischer Architekturen hilft ein systematisches Debugging, Probleme frühzeitig zu erkennen:

Identity Head für Tests verwenden

Ersetzen Sie komplexe Köpfe durch nn.Identity um Backbone-Probleme zu isolieren:

nc: 1
backbone:
    - [-1, 1, CustomBlock, [64]]
head:
    - [-1, 1, nn.Identity, []] # Pass-through for debugging

Dies ermöglicht eine direkte Überprüfung der Backbone-Ausgänge:

import torch

from ultralytics import YOLO

model = YOLO("debug_model.yaml")
output = model.model(torch.randn(1, 3, 640, 640))
print(f"Output shape: {output.shape}")  # Should match expected dimensions

Inspektion der Modellarchitektur

Das Überprüfen der FLOPs-Anzahl und das Ausdrucken der einzelnen Ebenen kann auch bei der Fehlersuche in Ihrer benutzerdefinierten Modellkonfiguration helfen. Bei einem gültigen Modell sollte die FLOPs-Zahl ungleich Null sein. Wenn sie Null ist, liegt wahrscheinlich ein Problem mit dem Vorwärtsdurchlauf vor. Die Ausführung eines einfachen Vorwärtsdurchlaufs sollte den genauen Fehler aufzeigen.

from ultralytics import YOLO

# Build model with verbose output to see layer details
model = YOLO("debug_model.yaml", verbose=True)

# Check model FLOPs. Failed forward pass causes 0 FLOPs.
model.info()

# Inspect individual layers
for i, layer in enumerate(model.model.model):
    print(f"Layer {i}: {layer}")

Schritt-für-Schritt-Validierung

1. Beginnen Sie minimal: Testen Sie zunächst mit der einfachsten möglichen Architektur
2. Inkrementell hinzufügen: Komplexität Schicht für Schicht aufbauen
3. Prüfen Sie die Abmessungen: Überprüfung der Kompatibilität von Kanal und Raumgröße
4. Validierung der Skalierung: Test mit verschiedenen Modellskalen (n, s, m)

FAQ

Wie kann ich die Anzahl der Klassen in meinem Modell ändern?

Setzen Sie die nc Parameter am Anfang Ihrer YAML-Datei, um die Anzahl der Klassen Ihres Datensatzes anzupassen.

nc: 5 # 5 classes

Kann ich ein eigenes Backbone in meinem Modell-YAML verwenden?

Ja. Sie können jedes unterstützte Modul verwenden, einschließlich TorchVision-Backbones, oder Ihr eigenes benutzerdefiniertes Modul definieren und es wie unter Integration benutzerdefinierter Module beschrieben importieren.

Wie skaliere ich mein Modell für verschiedene Größen (nano, klein, mittel, etc.)?

Verwenden Sie den scales Abschnitt in Ihrer YAML-Datei, um Skalierungsfaktoren für Tiefe, Breite und maximale Kanäle zu definieren. Das Modell wendet diese automatisch an, wenn Sie die YAML-Basisdatei laden und die Skalierung an den Dateinamen anhängen (z.B., yolo11n.yaml), oder Auto-Modus mit angegebener Auslastungsfraktion (

Was bedeutet die [from, repeats, module, args] Format bedeuten?

Dieses Format gibt an, wie die einzelnen Ebenen aufgebaut sind:

• from: Eingangsquelle(n)
• repeats: Anzahl der Wiederholungen des Moduls
• module: der Ebenentyp
• argsArgumente für das Modul

Wie kann ich Fehler bei der Kanalübereinstimmung beheben?

Prüfen Sie, ob die Ausgangskanäle einer Ebene mit den erwarteten Eingangskanälen der nächsten Ebene übereinstimmen. Verwenden Sie print(model.model.model) um die Architektur Ihres Modells zu überprüfen.

Wo kann ich eine Liste der verfügbaren Module und ihrer Argumente finden?

Prüfen Sie den Quellcode in der ultralytics/nn/modules Verzeichnis für alle verfügbaren Module und ihre Argumente.

Wie kann ich ein benutzerdefiniertes Modul zu meiner YAML-Konfiguration hinzufügen?

Definieren Sie Ihr Modul im Quelltext, importieren Sie es wie in Quelltextänderung gezeigt und referenzieren Sie es namentlich in Ihrer YAML-Datei.

Kann ich vortrainierte Gewichte mit einer eigenen YAML verwenden?

Ja, Sie können die model.load("path/to/weights") um Gewichte aus einem vorher trainierten Kontrollpunkt zu laden. Es werden jedoch nur Gewichte für Schichten geladen, die übereinstimmen.

Wie kann ich meine Modellkonfiguration validieren?

Verwenden Sie model.info() um zu prüfen, ob die Anzahl der FLOPs ungleich Null ist. Ein gültiges Modell sollte eine FLOPs-Anzahl ungleich Null aufweisen. Wenn sie Null ist, folgen Sie den Vorschlägen in Tipps zur Fehlersuche um das Problem zu finden.

📅 Erstellt vor 0 Tagen ✏️ Aktualisiert vor 0 Tagen