yolact
1.0.0
██╗ ██╗ ██████╗ ██╗ █████╗ ██████╗████████╗
╚██╗ ██╔╝██╔═══██╗██║ ██╔══██╗██╔════╝╚══██╔══╝
╚████╔╝ ██║ ██║██║ ███████║██║ ██║
╚██╔╝ ██║ ██║██║ ██╔══██║██║ ██║
██║ ╚██████╔╝███████╗██║ ██║╚██████╗ ██║
╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
Un modelo simple y totalmente convolucional para la segmentación de instancias en tiempo real. Este es el código para nuestros documentos:
El modelo RESNET50 de Yolact ++ se ejecuta a 33.5 fps en un Titan XP y logra el mapa 34.1 en test-dev de Coco (consulte nuestro documento de la revista aquí).
Para usar Yolact ++, asegúrese de compilar el código DCNV2. (Ver instalación)
Algunos ejemplos de nuestro modelo base de yolact (33.5 fps en un mapa Titan XP y 29.8 en Coco's test-dev ):
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 , descargue test-dev con este script. sh data/scripts/COCO_test.sh cd external/DCNv2
python setup.py build develop Aquí están nuestros modelos Yolact (lanzados el 5 de abril de 2019) junto con su FPS en un Titan XP y MAP en test-dev :
| Tamaño de imagen | Columna vertebral | FPS | mapa | Pesas | |
|---|---|---|---|---|---|
| 550 | Resnet50-fpn | 42.5 | 28.2 | yolact_resnet50_54_800000.pth | Espejo |
| 550 | Darknet53-FPN | 40.0 | 28.7 | yolact_darknet53_54_800000.pth | Espejo |
| 550 | Resnet101-fpn | 33.5 | 29.8 | yolact_base_54_800000.pth | Espejo |
| 700 | Resnet101-fpn | 23.6 | 31.2 | yolact_im700_54_800000.pth | Espejo |
Modelos Yolact ++ (lanzado el 16 de diciembre de 2019):
| Tamaño de imagen | Columna vertebral | FPS | mapa | Pesas | |
|---|---|---|---|---|---|
| 550 | Resnet50-fpn | 33.5 | 34.1 | yolact_plus_resnet50_54_800000.pth | Espejo |
| 550 | Resnet101-fpn | 27.3 | 34.6 | yolact_plus_base_54_800000.pth | Espejo |
Para evaluar el modelo, coloque el archivo de pesas correspondientes en el directorio ./weights y ejecute uno de los siguientes comandos. El nombre de cada configuración es todo antes de los números en el nombre del archivo (por ejemplo, yolact_base para 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 Como puede ver, eval.py puede hacer un montón de cosas. Ejecute el comando --help para ver todo lo que puede hacer.
python eval.py --helpPor defecto, entrenamos en Coco. Asegúrese de descargar todo el conjunto de datos utilizando los comandos anteriores.
./weights .resnet101_reducedfc.pth desde aquí.resnet50-19c8e357.pth desde aquí.darknet53.pth desde aquí.*_interrupt.pth en la iteración actual../weights de forma predeterminada con el nombre del archivo <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 ahora admite múltiples GPU sin problemas durante el entrenamiento:
export CUDA_VISIBLE_DEVICES=[gpus]nvidia-smi .8*num_gpus con los comandos de entrenamiento anteriores. El script de capacitación escalará automáticamente los hiperparámetros a los valores correctos.--batch_alloc=[alloc] donde [Alloc] es una lista de coma sepe que contiene el número de imágenes en cada GPU. Esto debe sumar a batch_size . Yolact ahora registra información de capacitación y validación de forma predeterminada. Puede deshabilitar esto con --no_log . Próximamente vendrá una guía sobre cómo visualizar estos registros, pero ahora puede ver LogVizualizer en utils/logger.py para obtener ayuda.
También incluimos una configuración para el entrenamiento sobre anotaciones PASCAL SBD (para experimentación rápida o comparación con otros métodos). Para entrenar en Pascal SBD, continúe con los siguientes pasos:
benchmark.tgz ).dataset/img . Cree el directorio ./data/sbd (donde . Es la raíz de Yolact) y copie dataset/img a ./data/sbd/img ../data/sbd/ .--config=yolact_resnet50_pascal_config . Verifique esa configuración para ver cómo extenderla a otros modelos. Pronto automatizaré todo esto con un script, no te preocupes. Además, si desea el script que usé para convertir las anotaciones, lo puse ./scripts/convert_sbd.py , pero tendrá que verificar cómo funciona para poder usarlo porque en realidad no recuerdo en este momento.
Si desea verificar nuestros resultados, puede descargar nuestros pesos yolact_resnet50_pascal_config desde aquí. Este modelo debe obtener 72.3 Mask AP_50 y 56.2 Mask AP_70. Tenga en cuenta que el "AP" AP no es lo mismo que el AP "Vol" informado en otros documentos para Pascal (usan un promedio de los umbrales de 0.1 - 0.9 en incrementos de 0.1 en lugar de lo que Coco usa).
También puede entrenar en su propio conjunto de datos siguiendo estos pasos:
infoliscenseimage : license, flickr_url, coco_url, date_capturedcategories (usamos nuestro propio formato para categorías, ver más abajo)dataset_base en data/config.py (consulte los comentarios en dataset_base para obtener una explicación de cada campo): 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 este no es el caso de su archivo de anotación (como en Coco), consulte el campo label_map en dataset_base .python train.py --help ), train.py emitirá el mapa de validación para las primeras 5000 imágenes en el conjunto de datos cada 2 épocas.yolact_base_config en el mismo archivo, cambie el valor para 'dataset' a 'my_custom_dataset' o lo que haya llamado el objeto de configuración anterior. Luego puede usar cualquiera de los comandos de capacitación en la sección anterior. Vea esta buena publicación de @AMIT12690 para obtener consejos sobre cómo anotar un conjunto de datos personalizado y prepararlo para usar con Yolact.
Si usa yolact o esta base de código en su trabajo, cite
@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},
}
Para yolact ++, por favor cita
@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},
}
Para preguntas sobre nuestro documento o código, comuníquese con Daniel Bolya.
