Detectron.pytorch
1.0.0
Utilisez-le à la place: https://github.com/facebookresearch/maskrcnn-benchmark
Exemple de sortie de E2E_MASK_RCNN-R-101-FPN_2X en utilisant du poids pré-entraîné par Detectron.
Exemple correspondant Sortie de Detectron.
Exemple de sortie de E2E_KEYPOINT_RCNN-R-50-FPN_S1X en utilisant un poids pré-entraîné de Detectron.
Ce code suit l'architecture d'implémentation de Detectron. Seule une partie de la fonctionnalité est prise en charge. Vérifiez cette section pour plus d'informations.
Avec ce code, vous pouvez ...
Ce référentiel est initialement construit sur JWyang / Faster-RCNN.pytorch. Cependant, après de nombreuses modifications, la structure change beaucoup et elle est désormais plus similaire à Detectron. Je fais délibérément tout ce qui est similaire ou identique à la mise en œuvre de Detectron, afin de reproduire le résultat directement à partir de fichiers de poids officiels pré-élaborés.
Cette implémentation a les fonctionnalités suivantes:
C'est un code pytorch pur . Bien sûr, il y a du code CUDA.
Il prend en charge la formation par lots multi-images .
Il prend en charge plusieurs GPUS de formation .
Il prend en charge trois méthodes de mise en commun . Notez que seul ROI Align est révisé pour correspondre à l'implémentation dans CAFE2. Alors, utilisez-le.
Il est efficace de la mémoire . Pour le lots de données, deux techniques sont disponibles pour réduire l'utilisation de la mémoire: 1) Groupement d'aspects : images de groupe avec un rapport d'aspect similaire dans un lot 2) Aspect Cramping : Images de recadrage qui sont trop longues. Le regroupement d'aspect est implémenté dans Detectron, il est donc utilisé pour défaut. L'aspect recadrage est l'idée de JWyang / Faster-Rcnn.pytorch, et elle n'est pas utilisée pour défaut.
En plus de cela, j'implémente un module nn.DataParallel personnalisé qui permet une taille de blob de lots différentes sur différents GPU. Vérifiez ma section NN.Dataparalleal pour plus de détails à ce sujet.
Cloner le repo:
git clone https://github.com/roytseng-tw/mask-rcnn.pytorch.git
Testé sous Python3.
Compilez le code CUDA:
cd lib # please change to this directory
sh make.sh
Si vous utilisez Volta GPUS, décommentez cette ligne dans lib/mask.sh et n'oubliez pas de reporter une barre oblique inverse sur la ligne ci-dessus. CUDA_PATH par défaut à /usr/loca/cuda . Si vous souhaitez utiliser une bibliothèque CUDA sur un chemin différent, modifiez cette ligne en conséquence.
Il compilera tous les modules dont vous avez besoin, y compris NMS, ROI_POOING, ROI_CROP et ROI_ALIGN. (En fait, le GPU NMS n'est jamais utilisé ...)
Notez que si vous utilisez CUDA_VISIBLE_DEVICES pour définir des GPU, assurez-vous qu'au moins un GPU est visible lors de la compilation du code.
Créez un dossier de données sous le dépôt,
cd {repo_root}
mkdir data
Coco : Téléchargez les images et les annotations de Coco sur le site Web de Coco.
Et assurez-vous de mettre les fichiers comme structure suivante:
coco
├── annotations
| ├── instances_minival2014.json
│ ├── instances_train2014.json
│ ├── instances_train2017.json
│ ├── instances_val2014.json
│ ├── instances_val2017.json
│ ├── instances_valminusminival2014.json
│ ├── ...
|
└── images
├── train2014
├── train2017
├── val2014
├──val2017
├── ...
Téléchargez Coco Mini Annotations d'ici. Veuillez noter que la minival est exactement équivalente à l'ensemble VAL 2017 récemment défini. De même, le syndicat de Valminusminival et le train 2014 équivaut exactement au train de 2017.
N'hésitez pas à mettre l'ensemble de données à n'importe quel endroit que vous souhaitez, puis à lier Soft l'ensemble de données dans le data/ dossier:
ln -s path/to/coco data/coco
Recommande de mettre les images sur un SSD pour une meilleure performance de formation possible
J'utilise des poids pré-entraînés ImageNet de Caffe pour les réseaux de squelette.
Téléchargez-les et mettez-les dans le {repo_root}/data/pretrained_model .
Vous pouvez la commande suivante pour les télécharger tous:
argparse_color_formater , colorama , requests python tools/download_imagenet_weights.py
Remarque : Les poids pré-entraînés à la CAFE ont des performances légèrement meilleures que Pytorch pré-entraîné. Suggérez d'utiliser des modèles de CAFE pré-entraînés à partir du lien ci-dessus pour reproduire les résultats. Soit dit en passant, Detectron utilise également des poids pré-étendus de CAFE.
Si vous souhaitez utiliser des modèles pré-formés Pytorch, n'oubliez pas de transposer des images de BGR à RVB, et utilisez également le même prétraitement de données (moins la moyenne et la normalisation) comme utilisé dans le modèle pré-entraîné par pytorche.
Outre l'utilisation des poids pré-entraînés pour Resnet ci-dessus, vous pouvez également utiliser les poids de Detectron en modifiant la ligne correspondante dans le fichier de configuration du modèle comme suit:
RESNETS:
IMAGENET_PRETRAINED_WEIGHTS: 'data/pretrained_model/R-50.pkl'
R-50-GN.PKL et R-101-GN.pkl sont requis pour GN_BASELINES.
X-101-32X8D.PKL, X-101-64X4D.PKL et X-152-32X8D-IN5K.PKL sont requis pour les squelettes ResNext.
Ne modifiez rien dans les fichiers de configuration fournis (configs / ** / xxxx.yml) sauf si vous savez ce que vous faites
Utilisez la variable d'environnement CUDA_VISIBLE_DEVICES pour contrôler les GPU à utiliser.
Batch_size: NUM_GPUS x TRAIN.IMS_PER_BATCH
efficace_batch_size: batch_size x iter_size
Changement de quelque chose: new value of something / old value of something
Les options de configuration suivantes seront ajustées automatiquement en fonction des configurations de formation réelles: 1) Nombre de GPU NUM_GPUS , 2) Taille du lot par GPU TRAIN.IMS_PER_BATCH , 3) Mettez à jour la période iter_size
SOLVER.BASE_LR : ajustez directement la propotion au changement de Batch_size.SOLVER.STEPS , SOLVER.MAX_ITER : ajustez inversement propotionnel au changement d'efficacité_batch_size.Prenez le Mask-RCNN avec Res50 Backbone par exemple.
python tools/train_net_step.py --dataset coco2017 --cfg configs/baselines/e2e_mask_rcnn_R-50-C4.yml --use_tfboard --bs {batch_size} --nw {num_workers}
Utilisez --bs pour écraser la taille du lot par défaut à une valeur appropriée qui s'intègre dans vos GPU. Similiar for --nw , le nombre de threads de chargeur de données par défaut est par défaut dans config.py.
Spécifiez —-use_tfboard pour enregistrer les pertes sur Tensorboard.
Remarque : Utilisez --dataset keypoints_coco2017 lors de la formation pour KeyPoint-RCNN.
--iter_size Comme dans Caffe, mettez à jour le réseau une fois ( optimizer.step() ) toutes les itérations iter_size (avant + arrière). Cette façon d'avoir une taille de lot efficace plus grande pour la formation. Notez que le nombre d'étapes n'est augmenté qu'après la mise à jour du réseau.
python tools/train_net_step.py --dataset coco2017 --cfg configs/baselines/e2e_mask_rcnn_R-50-C4.yml --bs 4 --iter_size 4
iter_size par défaut 1.
python tools/train_net_step.py ... --load_ckpt {path/to/the/checkpoint}
ou en utilisant le fichier de point de contrôle de Detectron
python tools/train_net_step.py ... --load_detectron {path/to/the/checkpoint}
python tools/train_net_step.py ... --load_ckpt {path/to/the/checkpoint} --resume
Lorsque vous reprenez la formation, le nombre d'étapes et l'état d'optimiseur seront également restaurés à partir du point de contrôle. Pour SGD Optimizer, Optimizer State contient l'élan pour chaque paramètre formable.
Remarque : --resume n'est pas encore pris en charge pour --load_detectron
python tools/train_net_step.py ... --no_save --set {config.name1} {value1} {config.name2} {value2} ...
python tools/train_net_step.py ... --no_save --set DEBUG True
--no_save pour éviter d'enregistrer n'importe quel point de contrôle ou de journalisation. python train_net_step.py --help
En bref, utilisez train_net_step.py .
Dans train_net_step.py :
SOLVER.LR_POLICY: steps_with_decay est pris en charge. (Déprécié) Dans train_net.py certaines options de configuration n'ont aucun effet et méritent d'être remarquées:
SOLVER.LR_POLICY , SOLVER.MAX_ITER , SOLVER.STEPS , SOLVER.LRS : Pour l'instant, la politique de formation est contrôlée par ces arguments de ligne de commande:
--epochs : Combien d'époches à former. Une époque signifie un voyage à travers l'ensemble des ensembles de formation. Par défaut est 6.--lr_decay_epochs : Epochs pour décomposer le taux d'apprentissage. La désintégration se produit au début d'une époque. L'époque est indexée à 0. Par défaut est [4, 5]. Pour plus d'arguments de ligne de commande, veuillez vous référer à python train_net.py --help
SOLVER.WARM_UP_ITERS , SOLVER.WARM_UP_FACTOR , SOLVER.WARM_UP_METHOD : l'échauffement de la formation n'est pas pris en charge.
Par exemple, testez Mask-RCNN sur Coco2017 Val Set
python tools/test_net.py --dataset coco2017 --cfg config/baselines/e2e_mask_rcnn_R-50-FPN_1x.yaml --load_ckpt {path/to/your/checkpoint}
Utilisez --load_detectron pour charger le point de contrôle de Detectron. Si plusieurs GPU sont disponibles, ajoutez --multi-gpu-testing .
Spécifiez une direction de sortie différente, utilisez --output_dir {...} . Par défaut à {the/parent/dir/of/checkpoint}/test
python tools/infer_simple.py --dataset coco --cfg cfgs/baselines/e2e_mask_rcnn_R-50-C4.yml --load_ckpt {path/to/your/checkpoint} --image_dir {dir/of/input/images} --output_dir {dir/to/save/visualizations}
--output_dir par défaut vers infer_outputs .
Colonne vertébrale:
ResNet50_conv4_body , ResNet50_conv5_body , ResNet101_Conv4_Body , ResNet101_Conv5_Body , ResNet152_Conv5_Body[fpn_]ResNet101_Conv4_Body , [fpn_]ResNet101_Conv5_Body , [fpn_]ResNet152_Conv5_Bodyfpn_ResNet50_conv5_body , fpn_ResNet50_conv5_P2only_body , fpn_ResNet101_conv5_body , fpn_ResNet101_conv5_P2only_body , fpn_ResNet152_conv5_body , fpn_ResNet152_conv5_P2only_body Box Head: ResNet_roi_conv5_head , roi_2mlp_head , roi_Xconv1fc_head , roi_Xconv1fc_gn_head
Mask Head: mask_rcnn_fcn_head_v0upshare , mask_rcnn_fcn_head_v0up , mask_rcnn_fcn_head_v1up , mask_rcnn_fcn_head_v1up4convs , mask_rcnn_fcn_head_v1up4convs_gn
Tête des points clés: roi_pose_head_v1convX
Remarque : La dénomination est similaire à celle utilisée dans Detectron. Supprimez simplement tout add_ .
Seul Coco est soutenu pour l'instant. Cependant, la mise en œuvre de la bibliothèque d'ensembles de données est presque identique à celle de Detectron, il devrait donc être facile d'ajouter plus de jeux de données pris en charge par Detectron.
Les fichiers de configuration spécifiques à l'architecture sont placés sous des configurations. Le fichier de configuration général Lib / Core / Config.py a presque toutes les options avec les mêmes valeurs par défaut que dans Deterctron's , il est donc sans effort de transformer les configurations spécifiques à l'architecture à partir de Detectron.
Certaines options de Detectron ne sont pas utilisées car les fonctionnalités correspondantes ne sont pas encore implémentées. Par exemple, l'augmentation des données sur les tests.
MODEL.LOAD_IMAGENET_PRETRAINED_WEIGHTS = True : s'il faut charger des poids prétraités d'imageNet.RESNETS.IMAGENET_PRETRAINED_WEIGHTS = '' : Chemin vers des poids de réseau résiduel prétrainés. Si commencez par '/' , il est traité comme un chemin absolu. Sinon, traitez comme un chemin relatif à ROOT_DIR .TRAIN.ASPECT_CROPPING = False , TRAIN.ASPECT_HI = 2 , TRAIN.ASPECT_LO = 0.5 : options pour la culture d'aspect pour restreindre la plage du rapport d'aspect de l'image.RPN.OUT_DIM_AS_IN_DIM = True , RPN.OUT_DIM = 512 , RPN.CLS_ACTIVATION = 'sigmoid' : L'implémentation officielle de RPN a les mêmes canaux de fonction d'entrée et de sortie et utilise Sigmoïde comme fonction d'activation pour la prédiction de la classe FG / BG. Dans l'implémentation de Jwyang, il corrige le numéro de canal de sortie à 512 et utilise Softmax comme fonction d'activation.MODEL.NUM_CLASSES . Il sera défini en fonction de l'ensemble de données spécifié par --dataset .TRAIN.WEIGHTS , TRAIN.DATASETS et TEST.DATASETSMODEL.CONV_BODY , FAST_RCNN.ROI_BOX_HEAD ...), supprimez add_ dans la chaîne si existe.RESNETS.IMAGENET_PRETRAINED_WEIGHTS pointant vers le fichier de poids pré-entraîné. Sinon, définissez MODEL.LOAD_IMAGENET_PRETRAINED_WEIGHTS à False .OUTPUT_DIR: . à la dernière ligneNUM_GPUS dans le fichier de configuration. Il est utilisé pour déduire la taille du lot d'origine pour la formation, et le taux d'apprentissage sera mis à l'échelle linéairement en fonction du changement de taille du lot. Un bon ajustement du taux d'apprentissage est important pour la formation avec une taille de lot différente.RESNETS.USE_GN: True . Benchmark.md
