Apprentissage par transfert avec des couches gelées dans YOLOv5#

📚 Ce guide explique comment geler les couches de YOLOv5 🚀 lors de la mise en œuvre de l'apprentissage par transfert. L'apprentissage par transfert est une technique puissante d'apprentissage automatique (ML) qui te permet de réentraîner rapidement un modèle sur de nouvelles données sans réentraîner l'ensemble du réseau depuis zéro. En gelant les poids des premières couches et en mettant à jour uniquement les paramètres des couches ultérieures, tu peux réduire considérablement les besoins en ressources de calcul et le temps d'entraînement. Cependant, cette approche peut avoir un léger impact sur l'exactitude finale du modèle.

Avant de commencer#

Commence par cloner le dépôt YOLOv5 et installer les dépendances nécessaires répertoriées dans requirements.txt. Assure-toi de disposer d'un environnement Python>=3.8.0 avec PyTorch>=1.8 installé. Les modèles préentraînés et les jeux de données requis seront téléchargés automatiquement depuis la dernière version de YOLOv5.

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

Fonctionnement du gel des couches#

Lorsque tu gèles des couches dans un réseau neuronal, tu empêches la mise à jour de leurs paramètres (poids et biais) pendant l'entraînement. Dans PyTorch, cela s'obtient en définissant l'attribut requires_grad des tenseurs de la couche sur False. Par conséquent, aucun gradient n'est calculé pour ces couches pendant la rétropropagation, ce qui économise du calcul et de la mémoire.

Voici comment YOLOv5 implémente le gel des couches dans son script d'entraînement :

# 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

Explorer l'architecture du modèle#

Comprendre la structure du modèle YOLOv5 est essentiel pour décider quelles couches geler. Tu peux inspecter les noms de tous les modules et de leurs paramètres à l'aide de l'extrait de code Python suivant :

# 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
...
"""

L'architecture YOLOv5 se compose généralement d'un backbone (couches 0 à 9 dans les configurations standard comme YOLOv5s/m/l/x) responsable de l'extraction des caractéristiques, et d'une tête (les couches restantes) qui effectue la détection d'objets.

# 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

Options de gel#

Tu peux contrôler les couches gelées à l'aide de l'argument --freeze dans la commande d'entraînement. Cet argument spécifie l'index du premier module non gelé ; tous les modules précédant cet index auront leurs poids gelés. Utilise model.model (un nn.Sequential) pour inspecter l'ordre des modules si tu dois confirmer quels indices correspondent à un bloc particulier.

Geler uniquement le backbone#

Pour geler l'intégralité du backbone (couches 0 à 9), ce qui est courant lors de l'adaptation du modèle à de nouvelles classes d'objets tout en conservant les capacités générales d'extraction des caractéristiques apprises à partir d'un vaste jeu de données comme COCO :

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

Cette stratégie est efficace lorsque ton jeu de données cible partage des caractéristiques visuelles de bas niveau similaires (contours, textures) avec les données d'entraînement d'origine (par exemple, COCO), mais contient des catégories d'objets différentes.

Geler tout sauf les dernières couches de détection#

Pour geler presque l'intégralité du réseau en laissant entraînables uniquement les couches de convolution finales de sortie (qui font partie du module Detect, généralement le dernier module, par exemple le module 24 dans YOLOv5s) :

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

Cette approche est utile lorsque tu dois principalement adapter le modèle à un nombre différent de classes de sortie tout en conservant la grande majorité des caractéristiques apprises. Elle nécessite le moins de ressources de calcul pour le réglage fin.

Comparaison des performances#

Pour illustrer les effets du gel des couches, nous avons entraîné YOLOv5m sur le jeu de données Pascal VOC pendant 50 époques, en partant des [poids](https://ultralytics-translation-2.invalid préentraînés officiels de COCO (yolov5m.pt). Nous avons comparé trois scénarios : l'entraînement de toutes les couches (--freeze 0), le gel du backbone (--freeze 10) et le gel de toutes les couches sauf les dernières couches de détection (--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

Résultats de précision#

Les résultats montrent que le gel des couches peut accélérer considérablement l'entraînement, mais peut entraîner une légère réduction de la mAP (précision moyenne) finale. L'entraînement de toutes les couches produit généralement la meilleure précision, tandis que le gel d'un plus grand nombre de couches accélère l'entraînement au prix d'une baisse potentielle des performances.

Comparaison de la mAP50 pendant l'entraînement

Comparaison de la mAP50-95 pendant l'entraînement

Utilisation des ressources#

Le gel d'un plus grand nombre de couches réduit considérablement les besoins en mémoire GPU et l'utilisation globale. Cela fait de l'apprentissage par transfert avec des couches gelées une option intéressante lorsque tu travailles avec des ressources matérielles limitées, car tu peux entraîner des modèles plus grands ou utiliser des tailles d'image supérieures à ce qui serait autrement possible.

Mémoire GPU allouée (%)

Utilisation du GPU (%)

Quand utiliser le gel des couches#

Le gel des couches pendant l'apprentissage par transfert est particulièrement avantageux dans plusieurs situations :

1. Ressources de calcul limitées : si tu es limité par la mémoire GPU ou la puissance de calcul.
2. Petits jeux de données : lorsque ton jeu de données cible est nettement plus petit que le jeu de données de préentraînement d'origine, le gel aide à prévenir le surapprentissage.
3. Prototypage rapide : lorsque tu dois adapter rapidement un modèle existant à une nouvelle tâche ou à un nouveau domaine pour une première évaluation.
4. Domaines de caractéristiques similaires : si les caractéristiques de bas niveau de ton nouveau jeu de données sont très similaires à celles du jeu de données sur lequel le modèle a été préentraîné.

Découvre plus en détail les subtilités de l'apprentissage par transfert dans notre entrée du glossaire et envisage des techniques comme l'optimisation des hyperparamètres pour optimiser les performances.

Environnements pris en charge#

Ultralytics propose divers environnements prêts à l'emploi avec des dépendances essentielles comme CUDA, CuDNN, Python et PyTorch préinstallées.

• Notebooks GPU gratuits :
• Google Cloud : Guide de démarrage rapide de GCP
• Amazon : Guide de démarrage rapide d’AWS
• Azure : Guide de démarrage rapide d’AzureML
• Docker : Guide de démarrage rapide de Docker

État du projet#

Ce badge confirme que tous les tests d'intégration continue (CI) des GitHub Actions de YOLOv5 réussissent. Ces tests de CI évaluent rigoureusement les fonctionnalités et les performances de YOLOv5 pour les opérations clés : entraînement, validation, inférence, exportation et benchmarks. Ils garantissent un fonctionnement cohérent et fiable sur macOS, Windows et Ubuntu, en s'exécutant automatiquement toutes les 24 heures et à chaque nouveau commit de code.