Transfer-Learning mit eingefrorenen Layern in YOLOv5#

📚 Dieser Leitfaden erklärt, wie du beim Implementieren von Transfer-Learning 🚀-Layer in YOLOv5 einfrierst. Transfer-Learning ist eine leistungsstarke Technik des maschinellen Lernens (ML), mit der du ein Modell schnell mit neuen Daten neu trainieren kannst, ohne das gesamte Netzwerk von Grund auf neu zu trainieren. Indem du die Gewichte der anfänglichen Layer einfrierst und nur die Parameter späterer Layer aktualisierst, kannst du den Bedarf an Rechenressourcen und die Trainingszeit deutlich reduzieren. Dieser Ansatz kann jedoch die endgültige Genauigkeit des Modells geringfügig beeinträchtigen.

Bevor du beginnst#

Klone zuerst das YOLOv5-Repository und installiere die erforderlichen Abhängigkeiten aus requirements.txt. Stelle sicher, dass du eine Python>=3.8.0-Umgebung mit installiertem PyTorch>=1.8 verwendest. Vortrainierte Modelle und erforderliche Datensätze werden automatisch aus dem neuesten YOLOv5-Release heruntergeladen.

git clone https://github.com/ultralytics/yolov5 # clone repository
cd yolov5
pip install -r requirements.txt # install dependencies

So funktioniert das Einfrieren von Layern#

Wenn du Layer in einem neuronalen Netzwerk einfrierst, verhinderst du, dass ihre Parameter (Gewichte und Biases) während des Trainings aktualisiert werden. In PyTorch erreichst du dies, indem du das Attribut requires_grad der Tensoren des Layers auf False setzt. Dadurch werden für diese Layer während der Rückpropagation keine Gradienten berechnet, wodurch Rechenaufwand und Speicherbedarf gespart werden.

So implementiert YOLOv5 das Einfrieren von Layern in seinem Trainingsskript:

# Freeze specified layers
freeze = [f"model.{x}." for x in range(freeze)]  # Define layers to freeze based on module index
for k, v in model.named_parameters():
    v.requires_grad = True  # Ensure all parameters are initially trainable
    if any(x in k for x in freeze):
        print(f"Freezing layer: {k}")
        v.requires_grad = False  # Disable gradient calculation for frozen layers

Modellarchitektur untersuchen#

Das Verständnis der Struktur des YOLOv5-Modells ist entscheidend, um festzulegen, welche Layer eingefroren werden sollen. Mit dem folgenden Python-Codeausschnitt kannst du die Namen aller Module und ihrer Parameter anzeigen:

# Assuming 'model' is your loaded YOLOv5 model instance
for name, param in model.named_parameters():
    print(name)

"""
Example Output:
model.0.conv.conv.weight
model.0.conv.bn.weight
model.0.conv.bn.bias
model.1.conv.weight
model.1.bn.weight
model.1.bn.bias
model.2.cv1.conv.weight
model.2.cv1.bn.weight
...
"""

Die YOLOv5-Architektur besteht typischerweise aus einem Backbone (Layer 0–9 in Standardkonfigurationen wie YOLOv5s/m/l/x), der für die Merkmalsextraktion zuständig ist, und einem Kopf (den übrigen Layern), der die Objekterkennung durchführt.

# Example YOLOv5 v6.0 backbone structure
backbone:
    # [from, number, module, args]
    - [-1, 1, Conv, [64, 6, 2, 2]]  # Layer 0: Initial convolution (P1/2 stride)
    - [-1, 1, Conv, [128, 3, 2]] # Layer 1: Downsampling convolution (P2/4 stride)
    - [-1, 3, C3, [128]]          # Layer 2: C3 module
    - [-1, 1, Conv, [256, 3, 2]] # Layer 3: Downsampling convolution (P3/8 stride)
    - [-1, 6, C3, [256]]          # Layer 4: C3 module
    - [-1, 1, Conv, [512, 3, 2]] # Layer 5: Downsampling convolution (P4/16 stride)
    - [-1, 9, C3, [512]]          # Layer 6: C3 module
    - [-1, 1, Conv, [1024, 3, 2]]# Layer 7: Downsampling convolution (P5/32 stride)
    - [-1, 3, C3, [1024]]         # Layer 8: C3 module
    - [-1, 1, SPPF, [1024, 5]]    # Layer 9: Spatial Pyramid Pooling Fast

# Example YOLOv5 v6.0 head structure
head:
    - [-1, 1, Conv, [512, 1, 1]] # Layer 10
    - [-1, 1, nn.Upsample, [None, 2, "nearest"]] # Layer 11
    - [[-1, 6], 1, Concat, [1]] # Layer 12: Concatenate with backbone P4 (from layer 6)
    - [-1, 3, C3, [512, False]] # Layer 13: C3 module
    # ... subsequent head layers for feature fusion and detection

Optionen zum Einfrieren#

Mit dem Argument --freeze im Trainingsbefehl kannst du festlegen, welche Layer eingefroren werden. Dieses Argument gibt den Index des ersten nicht eingefrorenen Moduls an; alle Module vor diesem Index werden mit eingefrorenen Gewichten versehen. Verwende model.model (ein nn.Sequential), um die Reihenfolge der Module zu überprüfen, wenn du bestätigen musst, welche Indizes einem bestimmten Block entsprechen.

Nur das Backbone einfrieren#

Um das gesamte Backbone (Layer 0 bis 9) einzufrieren, was häufig bei der Anpassung des Modells an neue Objektklassen verwendet wird, während die auf einem großen Datensatz wie COCO erlernten allgemeinen Fähigkeiten zur Merkmalsextraktion erhalten bleiben:

python train.py --weights yolov5m.pt --data your_dataset.yaml --freeze 10

Diese Strategie ist effektiv, wenn dein Zieldatensatz ähnliche visuelle Merkmale niedriger Ebene (Kanten, Texturen) wie die ursprünglichen Trainingsdaten (z. B. COCO) aufweist, aber andere Objektkategorien enthält.

Alles außer den abschließenden Erkennungs-Layern einfrieren#

Um fast das gesamte Netzwerk einzufrieren und nur die abschließenden Ausgabekonvolutions-Layer (Teil des Detect-Moduls, typischerweise des letzten Moduls, z. B. Modul 24 in YOLOv5s) trainierbar zu lassen:

python train.py --weights yolov5m.pt --data your_dataset.yaml --freeze 24

Dieser Ansatz ist nützlich, wenn du das Modell hauptsächlich an eine andere Anzahl von Ausgabeklassen anpassen und gleichzeitig den Großteil der erlernten Merkmale unverändert beibehalten möchtest. Er erfordert die geringsten Rechenressourcen für das Feinabstimmen.

Leistungsvergleich#

Um die Auswirkungen des Einfrierens von Layern zu veranschaulichen, haben wir YOLOv5m 50 Epochen lang auf dem Pascal-VOC-Datensatz trainiert, ausgehend von den offiziellen, auf COCO vortrainierten Gewichten (yolov5m.pt). Wir haben drei Szenarien verglichen: das Training aller Layer (--freeze 0), das Einfrieren des Backbones (--freeze 10) und das Einfrieren aller Layer außer den abschließenden Erkennungs-Layern (--freeze 24).

# Example command for training with backbone frozen
python train.py --batch 48 --weights yolov5m.pt --data voc.yaml --epochs 50 --cache --img 512 --hyp data/hyps/hyp.VOC.yaml --freeze 10

Genauigkeitsergebnisse#

Die Ergebnisse zeigen, dass das Einfrieren von Layern das Training deutlich beschleunigen kann, aber zu einer leichten Verringerung der endgültigen mAP (mittlere durchschnittliche Präzision) führen kann. Das Training aller Layer erzielt im Allgemeinen die beste Genauigkeit, während das Einfrieren von mehr Layern ein schnelleres Training ermöglicht, möglicherweise jedoch auf Kosten einer geringeren Leistung.

Trainingsergebnisse der mAP50 im Vergleich verschiedener Strategien zum Einfrieren Vergleich der mAP50 während des Trainings

Trainingsergebnisse der mAP50-95 im Vergleich verschiedener Strategien zum Einfrieren Vergleich der mAP50-95 während des Trainings

YOLOv5 frozen layer training performance

*Summary table of performance metrics*

Ressourcennutzung#

Das Einfrieren von mehr Layern reduziert den GPU-Speicherbedarf und die Gesamtauslastung erheblich. Dadurch wird Transfer-Learning mit eingefrorenen Layern zu einer attraktiven Option bei begrenzten Hardware-Ressourcen, da du größere Modelle trainieren oder größere Bildgrößen verwenden kannst, als es sonst möglicherweise möglich wäre.

Prozentsatz des während des Trainings zugewiesenen GPU-Speichers Zugewiesener GPU-Speicher (%)

Prozentsatz der GPU-Speicherauslastung während des Trainings GPU-Auslastung (%)

Wann du Layer einfrieren solltest#

Das Einfrieren von Layern während des Transfer-Learnings ist in mehreren Situationen besonders vorteilhaft:

Begrenzte Rechenressourcen: Wenn dein GPU-Speicher oder deine Rechenleistung begrenzt ist.
Kleine Datensätze: Wenn dein Zieldatensatz deutlich kleiner als der ursprüngliche Datensatz zum Vortraining ist, hilft das Einfrieren, Überanpassung zu verhindern.
Schnelle Prototypenentwicklung: Wenn du ein vorhandenes Modell für eine erste Bewertung schnell an eine neue Aufgabe oder Domäne anpassen musst.
Ähnliche Merkmalsbereiche: Wenn die Merkmale niedriger Ebene in deinem neuen Datensatz denen des Datensatzes, auf dem das Modell vortrainiert wurde, sehr ähnlich sind.

Erfahre mehr über die Feinheiten des Transfer-Learnings in unserem Glossareintrag und ziehe Techniken wie die Hyperparameter-Optimierung zur Leistungsoptimierung in Betracht.

Unterstützte Umgebungen#

Ultralytics bietet verschiedene sofort einsatzbereite Umgebungen mit vorinstallierten wichtigen Abhängigkeiten wie CUDA, CuDNN, Python und PyTorch.

Kostenlose GPU-Notebooks:
Google Cloud: Kurzanleitung für GCP
Amazon: Kurzanleitung für AWS
Azure: Kurzanleitung für AzureML
Docker: Docker-Schnellstartanleitung

Projektstatus#

Dieses Abzeichen bestätigt, dass alle Tests der YOLOv5-GitHub-Actions zur kontinuierlichen Integration (CI) erfolgreich bestanden werden. Diese CI-Tests bewerten die Funktionalität und Leistung von YOLOv5 bei wichtigen Vorgängen gründlich: Training, Validierung, Inferenz, Export und Benchmarks. Sie gewährleisten einen konsistenten und zuverlässigen Betrieb unter macOS, Windows und Ubuntu und werden automatisch alle 24 Stunden sowie bei jedem neuen Code-Commit ausgeführt.

Mitwirkende

RAraimbekovm² GLglenn-jocher² PDpderrenger¹

Erstellt vor 2 MonatenAktualisiert letzte Woche