Apprentissage par transfert avec des couches gelées

📚 Ce guide explique comment figer YOLOv5 🚀 couches lors de l'apprentissage par transfert. L'apprentissage par transfert est un moyen utile de recycler rapidement un modèle sur de nouvelles données sans avoir à recycler l'ensemble du réseau. Au lieu de cela, une partie des poids initiaux est gelée en place, et le reste des poids est utilisé pour calculer la perte et est mis à jour par l'optimiseur. Cette méthode nécessite moins de ressources que l'entraînement normal et permet d'accélérer les temps d'entraînement, bien qu'elle puisse également entraîner des réductions de la précision finale de l'entraînement.

Avant de commencer

Clone le repo et installe le fichier requirements.txt dans un fichier Python>=3.8.0 incluant PyTorch>=1.8. Les modèles et les ensembles de données se téléchargent automatiquement à partir de la dernièreversion de YOLOv5 .

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

Geler l'épine dorsale

Toutes les couches qui correspondent à train.py freeze dans train.py seront gelés en fixant leurs gradients à zéro avant le début de l'entraînement.

# Freeze
freeze = [f'model.{x}.' for x in range(freeze)]  # layers to freeze
for k, v in model.named_parameters():
    v.requires_grad = True  # train all layers
    if any(x in k for x in freeze):
        print(f'freezing {k}')
        v.requires_grad = False

Pour voir la liste des noms de modules :

for k, v in model.named_parameters():
    print(k)

"""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
...
model.23.m.0.cv2.bn.weight
model.23.m.0.cv2.bn.bias
model.24.m.0.weight
model.24.m.0.bias
model.24.m.1.weight
model.24.m.1.bias
model.24.m.2.weight
model.24.m.2.bias
"""

En examinant l'architecture du modèle, nous pouvons voir que l'épine dorsale du modèle est constituée des couches 0 à 9 :

# YOLOv5 v6.0 backbone
backbone:
  # [from, number, module, args]
  - [-1, 1, Conv, [64, 6, 2, 2]]  # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C3, [128]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C3, [256]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 9, C3, [512]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C3, [1024]]
  - [-1, 1, SPPF, [1024, 5]]  # 9


# YOLOv5 v6.0 head
head:
  - [-1, 1, Conv, [512, 1, 1]]
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 6], 1, Concat, [1]]  # cat backbone P4
  - [-1, 3, C3, [512, False]]  # 13

  - [-1, 1, Conv, [256, 1, 1]]
  - [-1, 1, nn.Upsample, [None, 2, 'nearest']]
  - [[-1, 4], 1, Concat, [1]]  # cat backbone P3
  - [-1, 3, C3, [256, False]]  # 17 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 14], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C3, [512, False]]  # 20 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C3, [1024, False]]  # 23 (P5/32-large)

  - [[17, 20, 23], 1, Detect, [nc]]  # Detect(P3, P4, P5)

nous pouvons donc définir la liste de gel pour qu'elle contienne tous les modules dont le nom contient 'model.0.' - 'model.9.' dans leur nom :

python train.py --freeze 10

Geler toutes les couches

Pour geler le modèle complet à l'exception des couches de convolution de sortie finale dans Detect(), nous définissons la liste de gel pour qu'elle contienne tous les modules dont le nom contient 'model.0.' - 'model.23.' dans leur nom :

python train.py --freeze 24

Résultats

Nous entraînons YOLOv5m on VOC sur les deux scénarios ci-dessus, ainsi qu'un modèle par défaut (pas de gel), à partir du modèle officiel COCO prétraîné. --weights yolov5m.pt:

train.py --batch 48 --weights yolov5m.pt --data voc.yaml --epochs 50 --cache --img 512 --hyp hyp.finetune.yaml

Comparaison de la précision

Les résultats montrent que le gel accélère la formation, mais réduit légèrement la précision finale.

Comparaison de l'utilisation des GPU

Il est intéressant de noter que plus le nombre de modules gelés est important, moins la mémoire du GPU est nécessaire pour l'apprentissage, et plus l'utilisation du GPU est faible. Cela indique que les grands modèles, ou les modèles formés à une taille d'image plus grande, peuvent bénéficier du gel afin de s'entraîner plus rapidement.

Environnements pris en charge

Ultralytics fournit une gamme d'environnements prêts à l'emploi, chacun préinstallé avec des dépendances essentielles telles que CUDA, CUDNN, Pythonet PyTorchpour lancer tes projets.

• Cahiers de notes gratuits sur les GPU:
• Google Cloud: Guide de démarrage rapide de GCP
• Amazon: Guide de démarrage rapide AWS
• Azure: Guide de démarrage rapide d'AzureML
• Docker: Guide de démarrage rapide de Docker

Statut du projet

Ce badge indique que tous les tests d'intégration continue (CI) de YOLOv5 GitHub Actions sont passés avec succès. Ces tests CI vérifient rigoureusement la fonctionnalité et les performances de YOLOv5 sur différents aspects clés : entraînement, validation, inférence, exportation et benchmarks. Ils garantissent un fonctionnement cohérent et fiable sur macOS, Windows et Ubuntu, avec des tests effectués toutes les 24 heures et à chaque nouveau commit.

Commentaires