efficient_densenet_pytorch

efficace_denenet_pytorch

Une implémentation Pytorch> = 1.0 de densenets, optimisée pour enregistrer la mémoire GPU.

Mises à jour récentes

1. Fonctionne maintenant sur Pytorch 1.0! Il utilise la fonction de pointage de contrôle, ce qui rend ce code beaucoup plus efficace !!!

Motivation

Bien que les densets soient assez faciles à mettre en œuvre dans les cadres d'apprentissage en profondeur, la plupart des implmatisations (comme l'original) ont tendance à être avides de mémoire. En particulier, le nombre de cartes de caractéristiques intermédiaires générées par les opérations de normalisation et de concaténation par lots augmente quadratiquement avec la profondeur du réseau. Il convient de souligner qu'il ne s'agit pas d'une propriété inhérente aux densets, mais plutôt à la mise en œuvre.

Cette implémentation utilise une nouvelle stratégie pour réduire la consommation de mémoire de densets. Nous utilisons le point de contrôle pour calculer la norme par lots et les cartes de fonctionnalités de concaténation. Ces cartes de fonctionnalités intermédiaires sont jetées pendant la passe avant et recomputées pour la passe arrière. Cela ajoute 15 à 20% des frais généraux de temps pour l'entraînement, mais réduit la consommation de cartes de caractéristiques du quadratique au linéaire.

Cette mise en œuvre est inspirée par ce rapport technique, qui décrit une stratégie de densets efficaces via le partage de mémoire.

Exigences

• Pytorch> = 1.0.0
• Cuda

Usage

Dans votre projet existant: il y a un fichier dans le dossier models .

• models/densenet.py est une implémentation basée sur les implémentations TorchVision et Project Killer.

Si vous vous souciez de la vitesse et que la mémoire n'est pas une option, passez l'argument efficient=False dans le constructeur DenseNet . Sinon, passez en efficient=True .

Options:

• Toutes les options sont décrites dans les docstrings des fichiers du modèle
• La profondeur est contrôlée par l'option block_config
• efficient=True utilise la version économe en mémoire
• Si vous souhaitez utiliser le modèle pour ImageNet, définissez small_inputs=False . Pour CIFAR ou SVHN, définissez small_inputs=True .

Exécution de la démo:

Le seul package supplémentaire que vous devez installer est Python-Fire:

pip install fire

• GPU unique:

CUDA_VISIBLE_DEVICES=0 python demo.py --efficient True --data < path_to_folder_with_cifar 10> --save < path_to_save_dir >

• GPU multiple:

CUDA_VISIBLE_DEVICES=0,1,2 python demo.py --efficient True --data < path_to_folder_with_cifar 10> --save < path_to_save_dir >

Options:

• --depth (int) - profondeur du réseau (nombre de couches de convolution) (par défaut 40)
• --growth_rate (int) - Nombre de fonctionnalités ajoutées par couche de densenet (par défaut 12)
• --n_epochs (int) - Nombre d'époques pour la formation (par défaut 300)
• --batch_size (int) - Taille de MiniBatch (par défaut 256)
• --seed (int) - Définissez manuellement la graine aléatoire (non par défaut)

Performance

Une comparaison des deux implémentations (chacune est une denset-BC avec 100 couches, la taille du lot 64, testée sur un Nvidia Pascal Titan-X):

Mise en œuvre	Cosomption de la mémoire (GB / GPU)	Speed (Sec / Mini Batch)
Naïf	2.863	0,165
Efficace	1.605	0,207
Efficace (multi-GPU)	0,985	-

Autres implémentations efficaces

• Luatorch (par Gao Huang)
• Tensorflow (par Joe Yearsley)
• Caffe (par Tongcheng Li)

Référence

 @article{pleiss2017memory,
  title={Memory-Efficient Implementation of DenseNets},
  author={Pleiss, Geoff and Chen, Danlu and Huang, Gao and Li, Tongcheng and van der Maaten, Laurens and Weinberger, Kilian Q},
  journal={arXiv preprint arXiv:1707.06990},
  year={2017}
}