Apprentissage par transfert avec des couches gelées dans YOLOv5
📚 Ce guide explique comment geler les couches YOLOv5 🚀 lors de la mise en œuvre de l'apprentissage par transfert. L'apprentissage par transfert est une technique puissante d'apprentissage automatique (AA) qui vous permet de réentraîner rapidement un modèle sur de nouvelles données sans avoir à réentraîner l'ensemble du réseau à partir de zéro. En gelant les poids des couches initiales et en mettant à jour uniquement les paramètres des couches ultérieures, vous pouvez réduire considérablement les besoins en ressources de calcul et le temps d'entraînement. Cependant, cette approche pourrait légèrement impacter la précision du modèle final.
Avant de commencer
Tout d'abord, clonez le référentiel YOLOv5 et installez les dépendances nécessaires répertoriées dans requirements.txt. Assurez-vous d'avoir un Python>=3.8.0 environnement avec PyTorch>=1.8 installé. Pré-entraîné modèles et requis jeux de données sera téléchargé automatiquement à partir de la dernière version de YOLOv5 version.
git clone https://github.com/ultralytics/yolov5 # clone repository
cd yolov5
pip install -r requirements.txt # install dependencies
Comment fonctionne le gel de calques
Lorsque vous gelez des couches dans un réseau neuronal, vous empêchez leurs paramètres (poids et biais) d'être mis à jour pendant le processus d'entraînement. Dans PyTorch, ceci est réalisé en définissant le requires_grad attribut des tensors de la couche à False. Par conséquent, les gradients ne sont pas calculés pour ces couches pendant rétropropagation, ce qui permet d'économiser des calculs et de la mémoire.
Voici comment YOLOv5 implémente le gel de calques 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
Exploration de l'architecture du modèle
Il est essentiel de comprendre la structure du modèle YOLOv5 pour décider quels calques figer. Vous pouvez inspecter les noms de tous les modules et 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) chargé de l'extraction de 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
Vous pouvez contrôler les couches qui sont gelées en utilisant le --freeze argument dans la commande d'entraînement. Cet argument spécifie l'index du premier non gelé module ; tous les modules précédant cet index auront leurs poids gelés.
Geler uniquement le Backbone
Pour geler l'ensemble 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 de caractéristiques apprises à partir d'un grand 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 votre 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 toutes les couches sauf les couches de détection finales
Pour geler presque l'ensemble du réseau, en ne laissant que les dernières couches de convolution de sortie (qui font partie du Detect module, généralement le dernier module, par exemple, le module 24 dans YOLOv5s) entraînable :
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 de calcul pour le fine-tuning.
Comparaison des performances
Pour illustrer les effets du gel des couches, nous avons entraîné YOLOv5m sur le jeu de données Jeu de données Pascal VOC pour 50 epochs, en partant du modèle COCO officiel pré-entraîné poids (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 de détection sauf les dernières (--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 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 du mAP (précision moyenne) final. L'entraînement de toutes les couches donne généralement la meilleure précision, tandis que le gel de plus de couches offre un entraînement plus rapide au prix d'une performance potentiellement inférieure.
Comparaison mAP50 pendant l'entraînement
Comparaison mAP50-95 pendant l'entraînement
Tableau récapitulatif des métriques de performance
Utilisation des ressources
Le fait de geler davantage 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 l'on travaille avec des ressources matérielles limitées, ce qui permet d'entraîner des modèles plus grands ou d'utiliser des tailles d'image plus importantes que ce qui serait possible autrement.
Mémoire GPU allouée (%)
Utilisation du GPU (%)
Quand utiliser le gel de couches
Le gel des couches pendant l'apprentissage par transfert est particulièrement avantageux dans plusieurs situations :
- Ressources de calcul limitées : Si vous avez des contraintes sur la mémoire GPU ou la puissance de traitement.
- Petits ensembles de données : Lorsque votre ensemble de données cible est considérablement plus petit que l'ensemble de données de pré-entraînement d'origine, le gel permet d'éviter le surapprentissage.
- Prototypage rapide : Lorsque vous devez rapidement adapter un modèle existant à une nouvelle tâche ou à un nouveau domaine pour une évaluation initiale.
- 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é.
Explorez davantage les nuances de l’apprentissage par transfert dans notre entrée de glossaire et envisagez des techniques telles que le réglage des hyperparamètres pour optimiser les performances.
Environnements pris en charge
Ultralytics propose divers environnements prêts à l'emploi avec des dépendances essentielles telles que CUDA, CuDNN, Python et PyTorch préinstallés.
- Notebooks GPU Gratuits:
- 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 Docker
État du projet
Ce badge confirme que tous les tests d'intégration continue (CI) des actions GitHub YOLOv5 réussissent. Ces tests CI évaluent rigoureusement la fonctionnalité et les performances de YOLOv5 à travers les opérations clés : l'entraînement, la validation, l'inférence, l'exportation et les 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.
