Transfer Learning mit eingefrorenen Layern in YOLOv5

📚 Dieser Leitfaden erklärt, wie man YOLOv5 🚀 Layer beim Implementieren von Transfer Learning einfriert (freeze). Transfer Learning ist eine leistungsstarke Machine Learning (ML) Technik, die es dir ermöglicht, ein Modell schnell mit neuen Daten neu zu trainieren, ohne das gesamte Netzwerk von Grund auf neu zu trainieren. Indem du die Gewichte der anfänglichen Layer einfrierst und nur die Parameter der späteren Layer aktualisierst, kannst du den Bedarf an Rechenressourcen und die Trainingszeit erheblich reduzieren. Dieser Ansatz könnte jedoch die endgültige Modell-Genauigkeit leicht beeinflussen.

Bevor du beginnst

Klonen zuerst das YOLOv5-Repository und installiere die notwendigen Abhängigkeiten, die in requirements.txt aufgeführt sind. Stelle sicher, dass du eine Python>=3.8.0-Umgebung mit installiertem PyTorch>=1.8 hast. Vorab trainierte Modelle und erforderliche Datasets 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

Wie Layer-Einfrieren funktioniert

Wenn du Layer in einem neural network einfrierst, verhinderst du, dass deren Parameter (Gewichte und Biases) während des Trainingsprozesses aktualisiert werden. In PyTorch wird dies erreicht, indem das requires_grad-Attribut der Tensoren der Layer auf False gesetzt wird. Folglich werden für diese Layer während der Backpropagation keine Gradienten berechnet, was Rechenleistung und Speicher spart.

Hier erfährst du, wie YOLOv5 das Layer-Einfrieren in seinem Trainingsskript implementiert:

# 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

Erkunden der Modellarchitektur

Das Verständnis der Struktur des YOLOv5-Modells ist entscheidend, um zu entscheiden, welche Layer eingefroren werden sollen. Du kannst die Namen aller Module und deren Parameter mit dem folgenden Python-Schnipsel untersuchen:

# 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 verantwortlich ist, und einem Head (die verbleibenden Layer), 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

Du kannst steuern, welche Layer eingefroren werden, indem du das Argument --freeze im Trainingsbefehl verwendest. Dieses Argument spezifiziert den Index des ersten nicht eingefrorenen Moduls; alle Module vor diesem Index haben ihre Gewichte eingefroren. Verwende model.model (ein nn.Sequential), um die Modulreihenfolge zu prüfen, falls du bestätigen musst, welche Indizes einem bestimmten Block entsprechen.

Nur Backbone einfrieren

Um den gesamten Backbone einzufrieren (Layer 0 bis 9), was üblich ist, wenn das Modell an neue Objektklassen angepasst wird, während die allgemeinen Fähigkeiten zur Merkmalsextraktion, die aus einem großen Datensatz wie COCO gelernt wurden, beibehalten werden sollen:

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

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

Alle außer die finalen Erkennungs-Layer einfrieren

Um fast das gesamte Netzwerk einzufrieren und nur die finalen Ausgabe-Konvolutions-Layer (Teil des Detect-Moduls, typischerweise das letzte Modul, 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 musst, während die überwiegende Mehrheit der gelernten Merkmale intakt bleibt. Er erfordert die geringsten Rechenressourcen für das Fine-Tuning.

Leistungsvergleich

Um die Auswirkungen des Einfrierens von Layern zu veranschaulichen, haben wir YOLOv5m auf dem Pascal VOC Datensatz für 50 Epochen trainiert, ausgehend von den offiziellen, vorab trainierten COCO-Gewichten (yolov5m.pt). Wir haben drei Szenarien verglichen: Training aller Layer (--freeze 0), Einfrieren des Backbones (--freeze 10) und Einfrieren aller bis auf die finalen Erkennungs-Layer (--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 hyp.finetune.yaml --freeze 10

Genauigkeitsergebnisse

Die Ergebnisse zeigen, dass das Einfrieren von Layern das Training erheblich beschleunigen kann, aber zu einer leichten Verringerung der endgültigen mAP (mean Average Precision) führen kann. Das Training aller Layer liefert im Allgemeinen die beste Genauigkeit, während das Einfrieren von mehr Layern ein schnelleres Training auf Kosten einer potenziell geringeren Leistung bietet.

mAP50-Vergleich während des Trainings

mAP50-95-Vergleich während des Trainings

Ressourcennutzung

Das Einfrieren von mehr Layern reduziert den GPU-Speicherbedarf und die Gesamtauslastung erheblich. Dies macht Transfer Learning mit eingefrorenen Layern zu einer attraktiven Option bei begrenzten Hardware-Ressourcen und ermöglicht das Training größerer Modelle oder die Verwendung größerer Bildgrößen, als dies sonst möglich wäre.

Belegter GPU-Speicher (%)

GPU-Auslastung (%)

Wann man Layer-Einfrieren verwenden sollte

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

1. Begrenzte Rechenressourcen: Wenn du Einschränkungen beim GPU-Speicher oder der Prozessorleistung hast.
2. Kleine Datensätze: Wenn dein Zieldatensatz deutlich kleiner ist als der ursprüngliche Pre-training-Datensatz, hilft das Einfrieren, Overfitting zu vermeiden.
3. Schnelles Prototyping: Wenn du ein bestehendes Modell schnell für eine erste Evaluierung an eine neue Aufgabe oder Domäne anpassen musst.
4. Ähnliche Merkmalsdomänen: Wenn die Merkmale auf niedriger Ebene in deinem neuen Datensatz sehr ähnlich zu denen im Datensatz sind, auf dem das Modell vorab trainiert wurde.

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

Unterstützte Umgebungen

Ultralytics bietet verschiedene gebrauchsfertige Umgebungen mit vorinstallierten, essenziellen Abhängigkeiten wie CUDA, CuDNN, Python und PyTorch.

• Kostenlose GPU-Notebooks:
• Google Cloud: GCP-Schnellstartanleitung
• Amazon: AWS-Schnellstartanleitung
• Azure: AzureML-Schnellstartanleitung
• Docker: Docker-Schnellstartanleitung

Projektstatus

Dieses Abzeichen bestätigt, dass alle YOLOv5 GitHub Actions Continuous Integration (CI)-Tests erfolgreich bestanden wurden. Diese CI-Tests bewerten rigoros die Funktionalität und Leistung von YOLOv5 bei wichtigen Vorgängen: Training, Validierung, Inferenz, Export und Benchmarks. Sie stellen einen konsistenten und zuverlässigen Betrieb unter macOS, Windows und Ubuntu sicher und laufen automatisch alle 24 Stunden sowie bei jedem neuen Code-Commit.