Apprentissage par transfert avec des couches gelées dans YOLOv5

📚 Ce guide explique comment congeler YOLOv5 🚀 lors de la mise en œuvre de l'apprentissage par transfert. L'apprentissage par transfert est une puissante technique d'apprentissage automatique (ML) qui vous permet de réentraîner rapidement un modèle sur de nouvelles données sans réentraîner l'ensemble du réseau à partir de zéro. En gelant les poids des couches initiales et en ne mettant à jour que les paramètres des couches ultérieures, vous pouvez réduire de manière significative les besoins en ressources informatiques et le temps de formation. Toutefois, cette approche peut avoir un léger impact sur la précision du modèle final.

Avant de commencer

Tout d'abord, clonez le dépôt YOLOv5 et installez les dépendances nécessaires listées dans la section requirements.txt. Assurez-vous d'avoir un Python.8.0 environnement avec PyTorch.8 installés. Préformé modèles et exigé ensembles de données sera téléchargé automatiquement à partir de la dernière version de YOLOv5 libération.

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

Comment fonctionne la congélation des couches

Lorsque vous congelez des couches dans un réseau neuronalDans PyTorch, vous empêchez la mise à jour de leurs paramètresweights and biases) au cours du processus d'apprentissage. Dans PyTorch, cela se fait en définissant la propriété requires_grad des tenseurs de la couche à False. Par conséquent, les gradients ne sont pas calculés pour ces couches au cours de la période de référence. rétropropagationce qui permet d'économiser du temps de calcul et de la mémoire.

Voici comment YOLOv5 met en œuvre le gel des couches dans son script de formation:

# 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 crucial pour décider des couches à geler. Vous pouvez inspecter les noms de tous les modules et leurs paramètres à l'aide de l'extrait 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'une colonne vertébrale (couches 0 à 9 dans les configurations standard telles que YOLOv5s/m/l/x) responsable de l'extraction des caractéristiques, et d'une tête (les couches restantes) qui effectue la détection des 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 congélation

Vous pouvez contrôler les couches qui sont gelées à l'aide de la fonction --freeze dans la commande de formation. Cet argument spécifie l'index du premier non gelé Tous les modules antérieurs à cet indice verront leur poids gelé.

Gel de l'épine dorsale uniquement

Geler l'ensemble de l'ossature (couches 0 à 9), ce qui est fréquent lorsqu'il s'agit d'adapter le modèle à de nouvelles classes d'objets tout en conservant les capacités générales d'extraction de caractéristiques acquises à partir d'un vaste ensemble de données tel que COCO:

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

Cette stratégie est efficace lorsque l'ensemble de données cible présente des caractéristiques visuelles de bas niveau (arêtes, textures) similaires à celles des données d'apprentissage d'origine (par exemple, COCO), mais contient des catégories d'objets différentes.

Geler toutes les couches à l'exception de la couche de détection finale

Pour geler la quasi-totalité du réseau, en ne laissant que les couches de convolution de sortie finale (qui font partie de l'ensemble des couches de convolution de sortie). Detect module, généralement le dernier module, par exemple le module 24 dans YOLOv5s) pouvant faire l'objet d'une formation :

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

Cette approche est utile lorsque vous devez principalement ajuster le modèle pour un nombre différent de classes de sortie tout en conservant la grande majorité des caractéristiques apprises intactes. Elle nécessite le moins de ressources informatiques pour le réglage fin.

Comparaison des performances

Pour illustrer les effets des couches de gel, nous avons entraîné YOLOv5m sur la base des données de l'enquête de l'OCDE. Ensemble de données Pascal VOC pour 50 époquesà partir du modèle officiel COCO pré-entraîné. poids (yolov5m.pt). Nous avons comparé trois scénarios : formation de toutes les couches (--freeze 0), geler l'épine dorsale (--freeze 10), et la congélation de toutes les couches de détection, à l'exception de la dernière (--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

Résultats en matière de précision

Les résultats montrent que le gel de couches peut accélérer considérablement la formation, mais peut entraîner une légère réduction de la précision moyenne finale (mAP). L'apprentissage de toutes les couches donne généralement la meilleure précision, tandis que le gel d'un plus grand nombre de couches permet un apprentissage plus rapide au prix d'une performance potentiellement plus faible.

Résultats de la formation mAP50 comparant différentes stratégies de congélation Comparaison des mAP50 pendant l'entraînement

Résultats de l'entraînement mAP50-95 comparant différentes stratégies de congélation Comparaison de mAP50-95 pendant l'entraînement

Tableau récapitulatif des résultats de performance Tableau récapitulatif des indicateurs de performance

Utilisation des ressources

La congélation d'un plus grand nombre de couches permet de réduire considérablement la consommation d'énergie du GPU et l'utilisation globale. Cela fait de l'apprentissage par transfert avec des couches gelées une option intéressante lorsque l'on travaille avec des ressources matérielles limitées, ce qui permet d'entraîner des modèles plus importants ou d'utiliser des images de plus grande taille que ce qui serait possible autrement.

Pourcentage de mémoire allouée au GPU pendant l'entraînement Mémoire GPU allouée (%)

Pourcentage d'utilisation de la mémoire du GPU pendant l'entraînement Utilisation du GPU (%)

Quand utiliser la congélation en couche

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

Ressources informatiques limitées: Si vous avez des contraintes au niveau de la mémoire du GPU ou de la puissance de traitement.
Petits ensembles de données: Lorsque l'ensemble de données cible est nettement plus petit que l'ensemble de données original de pré-entraînement, le gel permet d'éviter l'adaptation excessive.
Prototypage rapide: Lorsque vous devez adapter rapidement un modèle existant à une nouvelle tâche ou à un nouveau domaine pour une première évaluation.
Domaines de caractéristiques similaires: Si les caractéristiques de bas niveau de votre nouvel ensemble de données sont très similaires à celles de l'ensemble de données sur lequel le modèle a été pré-entraîné.

Découvrez les nuances de l'apprentissage par transfert dans notre glossaire et envisagez des techniques telles que l'ajustement des hyperparamètres pour optimiser les performances.

Environnements pris en charge

Ultralytics propose différents environnements prêts à l'emploi avec des dépendances essentielles telles que CUDA CuDNN, Pythonet PyTorch préinstallés.

Carnets de notes gratuits GPU:
Google Cloud: Guide de démarrage rapide GCP
Amazon: Guide de démarrage rapide AWS
Azure: Guide de démarrage rapide AzureML
Docker: Guide de démarrage rapide de Docker

État d'avancement du projet

Ce badge confirme que tous les tests d'intégration continue (CI) des actions GitHub deYOLOv5 sont passés avec succès. Ces tests d'intégration continue évaluent rigoureusement les fonctionnalités et les performances de YOLOv5 à travers des opérations clés : entraînement, validation, inférence, exportation et tests de référence. 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.

📅C réé il y a 1 an ✏️ Mis à jour il y a 1 mois