yolact
1.0.0
██╗ ██╗ ██████╗ ██╗ █████╗ ██████╗████████╗
╚██╗ ██╔╝██╔═══██╗██║ ██╔══██╗██╔════╝╚══██╔══╝
╚████╔╝ ██║ ██║██║ ███████║██║ ██║
╚██╔╝ ██║ ██║██║ ██╔══██║██║ ██║
██║ ╚██████╔╝███████╗██║ ██║╚██████╗ ██║
╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
Un modèle simple et entièrement convolutionnel pour la segmentation des instances en temps réel. Ceci est le code de nos papiers:
Le modèle RESNET50 de Yolact ++ fonctionne à 33,5 ips sur un Titan XP et atteint 34,1 carte sur test-dev de Coco (consultez notre document de journal ici).
Afin d'utiliser Yolact ++, assurez-vous de compiler le code DCNV2. (Voir l'installation)
Quelques exemples de notre modèle de base Yolact (33,5 ips sur un Titan XP et 29,8 Carte sur test-dev de Coco):
git clone https://github.com/dbolya/yolact.git
cd yolactconda env create -f environment.yml # Cython needs to be installed before pycocotools
pip install cython
pip install opencv-python pillow pycocotools matplotlib ./data/coco . sh data/scripts/COCO.shtest-dev , téléchargez test-dev avec ce script. sh data/scripts/COCO_test.sh cd external/DCNv2
python setup.py build develop Voici nos modèles Yolact (publiés le 5 avril 2019) avec leur FPS sur un Titan XP et MAP sur test-dev :
| Taille de l'image | Colonne vertébrale | FPS | carte | Poids | |
|---|---|---|---|---|---|
| 550 | Resnet50-fpn | 42.5 | 28.2 | yolact_resnet50_54_800000.pth | Miroir |
| 550 | Darknet53-fpn | 40.0 | 28.7 | yolact_darknet53_54_800000.pth | Miroir |
| 550 | Resnet101-fpn | 33.5 | 29.8 | yolact_base_54_800000.pth | Miroir |
| 700 | Resnet101-fpn | 23.6 | 31.2 | yolact_im700_54_800000.pth | Miroir |
Modèles Yolact ++ (publiés le 16 décembre 2019):
| Taille de l'image | Colonne vertébrale | FPS | carte | Poids | |
|---|---|---|---|---|---|
| 550 | Resnet50-fpn | 33.5 | 34.1 | yolact_plus_resnet50_54_800000.pth | Miroir |
| 550 | Resnet101-fpn | 27.3 | 34.6 | yolact_plus_base_54_800000.pth | Miroir |
Pour évaluer le modèle, placez le fichier de poids correspondant dans le répertoire ./weights et exécutez l'une des commandes suivantes. Le nom de chaque configuration est tout avant les chiffres du nom de fichier (par exemple, yolact_base pour yolact_base_54_800000.pth ).
# Quantitatively evaluate a trained model on the entire validation set. Make sure you have COCO downloaded as above.
# This should get 29.92 validation mask mAP last time I checked.
python eval.py --trained_model=weights/yolact_base_54_800000.pth
# Output a COCOEval json to submit to the website or to use the run_coco_eval.py script.
# This command will create './results/bbox_detections.json' and './results/mask_detections.json' for detection and instance segmentation respectively.
python eval.py --trained_model=weights/yolact_base_54_800000.pth --output_coco_json
# You can run COCOEval on the files created in the previous command. The performance should match my implementation in eval.py.
python run_coco_eval.py
# To output a coco json file for test-dev, make sure you have test-dev downloaded from above and go
python eval.py --trained_model=weights/yolact_base_54_800000.pth --output_coco_json --dataset=coco2017_testdev_dataset # Display qualitative results on COCO. From here on I'll use a confidence threshold of 0.15.
python eval.py --trained_model=weights/yolact_base_54_800000.pth --score_threshold=0.15 --top_k=15 --display # Run just the raw model on the first 1k images of the validation set
python eval.py --trained_model=weights/yolact_base_54_800000.pth --benchmark --max_images=1000 # Display qualitative results on the specified image.
python eval.py --trained_model=weights/yolact_base_54_800000.pth --score_threshold=0.15 --top_k=15 --image=my_image.png
# Process an image and save it to another file.
python eval.py --trained_model=weights/yolact_base_54_800000.pth --score_threshold=0.15 --top_k=15 --image=input_image.png:output_image.png
# Process a whole folder of images.
python eval.py --trained_model=weights/yolact_base_54_800000.pth --score_threshold=0.15 --top_k=15 --images=path/to/input/folder:path/to/output/folder # Display a video in real-time. "--video_multiframe" will process that many frames at once for improved performance.
# If you want, use "--display_fps" to draw the FPS directly on the frame.
python eval.py --trained_model=weights/yolact_base_54_800000.pth --score_threshold=0.15 --top_k=15 --video_multiframe=4 --video=my_video.mp4
# Display a webcam feed in real-time. If you have multiple webcams pass the index of the webcam you want instead of 0.
python eval.py --trained_model=weights/yolact_base_54_800000.pth --score_threshold=0.15 --top_k=15 --video_multiframe=4 --video=0
# Process a video and save it to another file. This uses the same pipeline as the ones above now, so it's fast!
python eval.py --trained_model=weights/yolact_base_54_800000.pth --score_threshold=0.15 --top_k=15 --video_multiframe=4 --video=input_video.mp4:output_video.mp4 Comme vous pouvez le voir, eval.py peut faire une tonne de choses. Exécutez la commande --help pour voir tout ce qu'il peut faire.
python eval.py --helpPar défaut, nous nous entraînons sur CoCo. Assurez-vous de télécharger l'intégralité de l'ensemble de données à l'aide des commandes ci-dessus.
./weights .resnet101_reducedfc.pth d'ici.resnet50-19c8e357.pth d'ici.darknet53.pth d'ici.*_interrupt.pth à l'itération actuelle../weights par défaut avec le nom de fichier <config>_<epoch>_<iter>.pth . # Trains using the base config with a batch size of 8 (the default).
python train.py --config=yolact_base_config
# Trains yolact_base_config with a batch_size of 5. For the 550px models, 1 batch takes up around 1.5 gigs of VRAM, so specify accordingly.
python train.py --config=yolact_base_config --batch_size=5
# Resume training yolact_base with a specific weight file and start from the iteration specified in the weight file's name.
python train.py --config=yolact_base_config --resume=weights/yolact_base_10_32100.pth --start_iter=-1
# Use the help option to see a description of all available command line arguments
python train.py --helpYolact prend maintenant en charge plusieurs GPU de manière transparente pendant la formation:
export CUDA_VISIBLE_DEVICES=[gpus]nvidia-smi .8*num_gpus avec les commandes de formation ci-dessus. Le script de formation réduira automatiquement les hyperparamètres aux bonnes valeurs.--batch_alloc=[alloc] où [alloc] est une liste séparée par virgule contenant le nombre d'images sur chaque GPU. Cela doit résumer à batch_size . Yolact enregistre désormais les informations de formation et de validation par défaut. Vous pouvez désactiver cela avec --no_log . Un guide sur la façon de visualiser ces journaux arrive bientôt, mais vous pouvez maintenant consulter LogVizualizer dans utils/logger.py pour l'aide.
Nous incluons également une configuration pour la formation sur les annotations SBD Pascal (pour l'expérimentation rapide ou la comparaison avec d'autres méthodes). Pour vous entraîner sur Pascal SBD, procédez aux étapes suivantes:
benchmark.tgz ).dataset/img . Créez le répertoire ./data/sbd (où . Est la racine de Yolact) et copiez dataset/img sur ./data/sbd/img ../data/sbd/ .--config=yolact_resnet50_pascal_config . Vérifiez cette configuration pour voir comment l'étendre à d'autres modèles. Je vais automatiser tout cela avec un script bientôt, ne vous inquiétez pas. De plus, si vous voulez le script que j'avais utilisé pour convertir les annotations, je l'ai mis ./scripts/convert_sbd.py , mais vous devrez vérifier comment cela fonctionne pour pouvoir l'utiliser parce que je ne me souviens pas vraiment à ce stade.
Si vous souhaitez vérifier nos résultats, vous pouvez télécharger nos poids yolact_resnet50_pascal_config à partir d'ici. Ce modèle doit obtenir 72.3 Mask AP_50 et 56.2 Mask AP_70. Notez que l'AP "All" n'est pas le même que le "Vol" AP signalé dans d'autres articles pour Pascal (ils utilisent une moyenne des seuils de 0.1 - 0.9 par incréments de 0.1 au lieu de ce que Coco utilise).
Vous pouvez également vous entraîner sur votre propre ensemble de données en suivant ces étapes:
infoliscenseimage : license, flickr_url, coco_url, date_capturedcategories (nous utilisons notre propre format pour les catégories, voir ci-dessous)dataset_base dans data/config.py (voir les commentaires dans dataset_base pour une explication de chaque champ): my_custom_dataset = dataset_base . copy ({
'name' : 'My Dataset' ,
'train_images' : 'path_to_training_images' ,
'train_info' : 'path_to_training_annotation' ,
'valid_images' : 'path_to_validation_images' ,
'valid_info' : 'path_to_validation_annotation' ,
'has_gt' : True ,
'class_names' : ( 'my_class_id_1' , 'my_class_id_2' , 'my_class_id_3' , ...)
})class_names . Si ce n'est pas le cas pour votre fichier d'annotation (comme dans CoCo), consultez le champ label_map dans dataset_base .python train.py --help ), train.py sortira la carte de validation pour les 5000 premières images de l'ensemble de données toutes les 2 époques.yolact_base_config dans le même fichier, modifiez la valeur pour 'dataset' en 'my_custom_dataset' ou tout ce que vous avez nommé l'objet config ci-dessus. Ensuite, vous pouvez utiliser l'une des commandes de formation dans la section précédente. Voir ce joli post par @ AMIT12690 pour des conseils sur la façon d'annoter un ensemble de données personnalisé et de le préparer à une utilisation avec Yolact.
Si vous utilisez Yolact ou cette base de code dans votre travail, veuillez citer
@inproceedings{yolact-iccv2019,
author = {Daniel Bolya and Chong Zhou and Fanyi Xiao and Yong Jae Lee},
title = {YOLACT: {Real-time} Instance Segmentation},
booktitle = {ICCV},
year = {2019},
}
Pour Yolact ++, veuillez citer
@article{yolact-plus-tpami2020,
author = {Daniel Bolya and Chong Zhou and Fanyi Xiao and Yong Jae Lee},
journal = {IEEE Transactions on Pattern Analysis and Machine Intelligence},
title = {YOLACT++: Better Real-time Instance Segmentation},
year = {2020},
}
Pour des questions sur notre papier ou notre code, veuillez contacter Daniel Bolya.
