Skip to content

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.

Congélation des résultats de l'entraînement mAP50

Congélation des résultats de l'entraînement mAP50-95

RĂ©sultats du tableau

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.

Pourcentage de mémoire allouée au GPU de formation

Pourcentage d'utilisation de la mémoire du GPU de formation

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.

Statut du projet

YOLOv5 CI

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.



Créé le 2023-11-12, Mis à jour le 2024-01-14
Auteurs : glenn-jocher (4)

Commentaires