simclr
v1
Nouvelles! Nous avons publié une implémentation TF2 de SimCLR (avec les points de contrôle convertis dans TF2), ils se trouvent dans le dossier tf2/.
Nouvelles! Des Colabs pour les propriétés intrigantes des pertes contrastées sont ajoutés, voir ici.
Nous avons ouvert ici un total de 65 modèles pré-entraînés, correspondant à ceux du tableau 1 de l'article SimCLRv2 :
| Profondeur | Largeur | Sask. | Param (M) | FT (1%) | PI (10%) | PI (100%) | Évaluation linéaire | Supervisé |
|---|---|---|---|---|---|---|---|---|
| 50 | 1X | FAUX | 24 | 57,9 | 68,4 | 76,3 | 71,7 | 76,6 |
| 50 | 1X | Vrai | 35 | 64,5 | 72.1 | 78,7 | 74,6 | 78,5 |
| 50 | 2X | FAUX | 94 | 66,3 | 73,9 | 79.1 | 75,6 | 77,8 |
| 50 | 2X | Vrai | 140 | 70,6 | 77,0 | 81,3 | 77,7 | 79,3 |
| 101 | 1X | FAUX | 43 | 62.1 | 71.4 | 78.2 | 73,6 | 78,0 |
| 101 | 1X | Vrai | 65 | 68,3 | 75.1 | 80,6 | 76,3 | 79,6 |
| 101 | 2X | FAUX | 170 | 69.1 | 75,8 | 80,7 | 77,0 | 78,9 |
| 101 | 2X | Vrai | 257 | 73.2 | 78,8 | 82,4 | 79,0 | 80,1 |
| 152 | 1X | FAUX | 58 | 64,0 | 73,0 | 79,3 | 74,5 | 78.3 |
| 152 | 1X | Vrai | 89 | 70,0 | 76,5 | 81,3 | 77.2 | 79,9 |
| 152 | 2X | FAUX | 233 | 70.2 | 76,6 | 81.1 | 77,4 | 79.1 |
| 152 | 2X | Vrai | 354 | 74.2 | 79,4 | 82,9 | 79,4 | 80,4 |
| 152 | 3X | Vrai | 795 | 74,9 | 80,1 | 83.1 | 79,8 | 80,5 |
Ces points de contrôle sont stockés dans Google Cloud Storage :
Nous fournissons également des exemples sur la façon d'utiliser les points de contrôle dans le dossier colabs/ .
Les modèles pré-entraînés (réseau de base avec couche de classificateur linéaire) se trouvent ci-dessous. Notez que pour ces points de contrôle SimCLRv1, la tête de projection n'est pas disponible.
| Modèle de point de contrôle et de module hub | ImageNet Top-1 |
|---|---|
| ResNet50 (1x) | 69.1 |
| ResNet50 (2x) | 74.2 |
| ResNet50 (4x) | 76,6 |
Des points de contrôle SimCLRv1 supplémentaires sont disponibles : gs://simclr-checkpoints/simclrv1.
Une note sur les signatures du module TensorFlow Hub : default est la sortie de représentation du réseau de base ; logits_sup sont les logits de classification supervisés pour les catégories ImageNet 1000. D'autres (par exemple initial_max_pool , block_group1 ) sont des couches intermédiaires de ResNet ; reportez-vous à resnet.py pour les détails. Consultez ce didacticiel pour plus d'informations sur l'utilisation des modules TensorFlow Hub.
Nos modèles sont formés avec des TPU. Il est recommandé d'exécuter une formation distribuée avec des TPU lorsque vous utilisez notre code pour la pré-formation.
Notre code peut également fonctionner sur un seul GPU. Il ne prend pas en charge les multi-GPU, pour des raisons telles que BatchNorm globale et la perte de contraste entre les cœurs.
Le code est compatible avec TensorFlow v1 et v2. Consultez le fichier Requirements.txt pour connaître tous les prérequis et vous pouvez également les installer à l'aide de la commande suivante.
pip install -r requirements.txt
Pour pré-entraîner le modèle sur CIFAR-10 avec un seul GPU, essayez la commande suivante :
python run.py --train_mode=pretrain
--train_batch_size=512 --train_epochs=1000
--learning_rate=1.0 --weight_decay=1e-4 --temperature=0.5
--dataset=cifar10 --image_size=32 --eval_split=test --resnet_depth=18
--use_blur=False --color_jitter_strength=0.5
--model_dir=/tmp/simclr_test --use_tpu=False
Pour pré-entraîner le modèle sur ImageNet avec Cloud TPU, consultez d'abord le didacticiel Google Cloud TPU pour obtenir des informations de base sur l'utilisation de Google Cloud TPU.
Une fois que vous avez créé une machine virtuelle avec Cloud TPU et pré-téléchargé les données ImageNet pour tensorflow_datasets, veuillez définir les variables d'environnement suivantes :
TPU_NAME=<tpu-name>
STORAGE_BUCKET=gs://<storage-bucket>
DATA_DIR=$STORAGE_BUCKET/<path-to-tensorflow-dataset>
MODEL_DIR=$STORAGE_BUCKET/<path-to-store-checkpoints>
La commande suivante peut être utilisée pour pré-entraîner un ResNet-50 sur ImageNet (qui reflète les hyperparamètres par défaut dans notre article) :
python run.py --train_mode=pretrain
--train_batch_size=4096 --train_epochs=100 --temperature=0.1
--learning_rate=0.075 --learning_rate_scaling=sqrt --weight_decay=1e-4
--dataset=imagenet2012 --image_size=224 --eval_split=validation
--data_dir=$DATA_DIR --model_dir=$MODEL_DIR
--use_tpu=True --tpu_name=$TPU_NAME --train_summary_steps=0
Une taille de lot de 4 096 nécessite au moins 32 TPU. 100 époques prennent environ 6 heures avec 32 TPU v3. Notez que le taux d'apprentissage de 0,3 avec learning_rate_scaling=linear est équivalent à celui de 0,075 avec learning_rate_scaling=sqrt lorsque la taille du lot est de 4096. Cependant, l'utilisation de la mise à l'échelle sqrt lui permet de mieux s'entraîner lorsque la taille du lot est plus petite.
Pour affiner une tête linéaire (avec un seul GPU), essayez la commande suivante :
python run.py --mode=train_then_eval --train_mode=finetune
--fine_tune_after_block=4 --zero_init_logits_layer=True
--variable_schema='(?!global_step|(?:.*/|^)Momentum|head)'
--global_bn=False --optimizer=momentum --learning_rate=0.1 --weight_decay=0.0
--train_epochs=100 --train_batch_size=512 --warmup_epochs=0
--dataset=cifar10 --image_size=32 --eval_split=test --resnet_depth=18
--checkpoint=/tmp/simclr_test --model_dir=/tmp/simclr_test_ft --use_tpu=False
Vous pouvez vérifier les résultats à l'aide d'un tensorboard, tel que
python -m tensorboard.main --logdir=/tmp/simclr_test
À titre de référence, les analyses ci-dessus sur CIFAR-10 devraient vous donner une précision d'environ 91 %, bien qu'elles puissent être encore optimisées.
Pour affiner une tête linéaire sur ImageNet à l'aide de Cloud TPU, définissez d'abord CHKPT_DIR sur le répertoire du modèle pré-entraîné et définissez un nouveau MODEL_DIR , puis utilisez la commande suivante :
python run.py --mode=train_then_eval --train_mode=finetune
--fine_tune_after_block=4 --zero_init_logits_layer=True
--variable_schema='(?!global_step|(?:.*/|^)Momentum|head)'
--global_bn=False --optimizer=momentum --learning_rate=0.1 --weight_decay=1e-6
--train_epochs=90 --train_batch_size=4096 --warmup_epochs=0
--dataset=imagenet2012 --image_size=224 --eval_split=validation
--data_dir=$DATA_DIR --model_dir=$MODEL_DIR --checkpoint=$CHKPT_DIR
--use_tpu=True --tpu_name=$TPU_NAME --train_summary_steps=0
À titre de référence, les analyses ci-dessus sur ImageNet devraient vous donner une précision d'environ 64,5 %.
Vous pouvez accéder aux sous-ensembles ImageNet à 1 % et 10 % utilisés pour l'apprentissage semi-supervisé via des ensembles de données tensorflow : définissez simplement dataset=imagenet2012_subset/1pct et dataset=imagenet2012_subset/10pct dans la ligne de commande pour affiner ces sous-ensembles.
Vous pouvez également trouver les ID d'image de ces sous-ensembles dans imagenet_subsets/ .
Pour affiner l'ensemble du réseau sur ImageNet (1% des étiquettes), référez-vous à la commande suivante :
python run.py --mode=train_then_eval --train_mode=finetune
--fine_tune_after_block=-1 --zero_init_logits_layer=True
--variable_schema='(?!global_step|(?:.*/|^)Momentum|head_supervised)'
--global_bn=True --optimizer=lars --learning_rate=0.005
--learning_rate_scaling=sqrt --weight_decay=0
--train_epochs=60 --train_batch_size=1024 --warmup_epochs=0
--dataset=imagenet2012_subset/1pct --image_size=224 --eval_split=validation
--data_dir=$DATA_DIR --model_dir=$MODEL_DIR --checkpoint=$CHKPT_DIR
--use_tpu=True --tpu_name=$TPU_NAME --train_summary_steps=0
--num_proj_layers=3 --ft_proj_selector=1
Définissez le checkpoint sur ceux qui sont uniquement pré-entraînés mais non affinés. Étant donné que les points de contrôle SimCLRv1 ne contiennent pas de tête de projection, il est recommandé d'exécuter avec les points de contrôle SimCLRv2 (vous pouvez toujours exécuter avec les points de contrôle SimCLRv1, mais variable_schema doit exclure head ). Les num_proj_layers et ft_proj_selector doivent être ajustés en conséquence suite à l'article SimCLRv2 pour obtenir les meilleures performances.
Ce dépôt fournit une solution pour convertir les points de contrôle Tensorflow SimCLRv1 pré-entraînés en points de contrôle Pytorch.
Ce dépôt fournit une solution pour convertir les points de contrôle Tensorflow SimCLRv2 pré-entraînés en points de contrôle Pytorch.
(N'hésitez pas à partager votre implémentation en créant un ticket)
Implémentations dans PyTorch :
Implémentations dans Tensorflow 2 / Keras (l'implémentation officielle de TF2 a été ajoutée dans le dossier tf2/) :
Taille du lot : les résultats originaux de SimCLR ont été ajustés sous une taille de lot importante (c'est-à-dire 4096), ce qui conduit à des résultats sous-optimaux lors de l'entraînement utilisant une taille de lot plus petite. Cependant, avec un bon ensemble d'hyper-paramètres (principalement taux d'apprentissage, température, profondeur de la tête de projection), de petites tailles de lots peuvent donner des résultats comparables à des lots de grande taille (par exemple, voir le tableau 2 de cet article).
Modèles pré-entraînés / Points de contrôle : SimCLRv1 et SimCLRv2 sont pré-entraînés avec des désintégrations de poids différentes, de sorte que les modèles pré-entraînés des deux versions ont des échelles de normes de poids très différentes (les poids convolutionnels dans SimCLRv1 ResNet-50 sont en moyenne 16,8 fois ceux de SimCLRv2). Pour affiner les modèles pré-entraînés des deux versions, vous pouvez utiliser un optimiseur LARS, mais cela nécessite des hyperparamètres très différents (par exemple, taux d'apprentissage, perte de poids) si vous utilisez l'optimiseur d'élan. Donc, dans ce dernier cas, vous souhaiterez peut-être soit rechercher des hparams très différents selon la version utilisée, soit redimensionner le poids (c'est-à-dire les paramètres kernel de conv de base_model dans les points de contrôle) pour vous assurer qu'ils sont à peu près dans la même échelle. .
Article SimCLR :
@article{chen2020simple,
title={A Simple Framework for Contrastive Learning of Visual Representations},
author={Chen, Ting and Kornblith, Simon and Norouzi, Mohammad and Hinton, Geoffrey},
journal={arXiv preprint arXiv:2002.05709},
year={2020}
}
Article SimCLRv2 :
@article{chen2020big,
title={Big Self-Supervised Models are Strong Semi-Supervised Learners},
author={Chen, Ting and Kornblith, Simon and Swersky, Kevin and Norouzi, Mohammad and Hinton, Geoffrey},
journal={arXiv preprint arXiv:2006.10029},
year={2020}
}
Ce n'est pas un produit Google officiel.
