yolact
1.0.0
██╗ ██╗ ██████╗ ██╗ █████╗ ██████╗████████╗
╚██╗ ██╔╝██╔═══██╗██║ ██╔══██╗██╔════╝╚══██╔══╝
╚████╔╝ ██║ ██║██║ ███████║██║ ██║
╚██╔╝ ██║ ██║██║ ██╔══██║██║ ██║
██║ ╚██████╔╝███████╗██║ ██║╚██████╗ ██║
╚═╝ ╚═════╝ ╚══════╝╚═╝ ╚═╝ ╚═════╝ ╚═╝
Um modelo simples e totalmente convolucional para a segmentação de instâncias em tempo real. Este é o código para nossos documentos:
O modelo RESNET50 do Yolact ++ é executado a 33,5 fps em um mapa do Titan XP e atinge 34.1 no test-dev de Coco (confira nosso jornal de diário aqui).
Para usar o Yolact ++, certifique -se de compilar o código DCNV2. (Consulte a instalação)
Alguns exemplos do nosso modelo de base Yolact (33,5 fps em um mapa Titan XP e 29.8 no 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 , faça o download test-dev com este script. sh data/scripts/COCO_test.sh cd external/DCNv2
python setup.py build develop Aqui estão nossos modelos Yolact (lançados em 5 de abril de 2019), juntamente com seu FPS em um Titan XP e MAP no test-dev :
| Tamanho da imagem | Espinha dorsal | FPS | mapa | Pesos | |
|---|---|---|---|---|---|
| 550 | Resnet50-fpn | 42.5 | 28.2 | YOLACT_RESNET50_54_800000.PTH | Espelho |
| 550 | DarkNet53-fpn | 40.0 | 28.7 | YOLACT_DARKNET53_54_800000.PTH | Espelho |
| 550 | Resnet101-fpn | 33.5 | 29.8 | YOLACT_BASE_54_800000.PTH | Espelho |
| 700 | Resnet101-fpn | 23.6 | 31.2 | YOLACT_IM700_54_800000.PTH | Espelho |
Modelos Yolact ++ (lançado em 16 de dezembro de 2019):
| Tamanho da imagem | Espinha dorsal | FPS | mapa | Pesos | |
|---|---|---|---|---|---|
| 550 | Resnet50-fpn | 33.5 | 34.1 | YOLACT_PLUS_RESNET50_54_800000.PTH | Espelho |
| 550 | Resnet101-fpn | 27.3 | 34.6 | YOLACT_PLUS_BASE_54_800000.PTH | Espelho |
Para avaliar o modelo, coloque o arquivo de pesos correspondente no diretório ./weights e execute um dos seguintes comandos. O nome de cada configuração é tudo antes dos números no nome do arquivo (por exemplo, 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 você pode dizer, eval.py pode fazer uma tonelada de coisas. Execute o comando --help para ver tudo o que pode fazer.
python eval.py --helpPor padrão, treinamos em Coco. Certifique -se de baixar todo o conjunto de dados usando os comandos acima.
./weights .resnet101_reducedfc.pth a partir daqui.resnet50-19c8e357.pth daqui.darknet53.pth daqui.*_interrupt.pth na iteração atual../weights por padrão com o nome do arquivo <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 agora suporta várias GPUs sem problemas durante o treinamento:
export CUDA_VISIBLE_DEVICES=[gpus]nvidia-smi .8*num_gpus com os comandos de treinamento acima. O script de treinamento escalará automaticamente os hiperparâmetros para os valores certos.--batch_alloc=[alloc] onde [aloc] é uma lista separada por vírgula que contém o número de imagens em cada GPU. Isso deve resumir para batch_size . Yolact agora registra informações de treinamento e validação por padrão. Você pode desativar isso com --no_log . Um guia sobre como visualizar esses logs está chegando em breve, mas agora você pode olhar para LogVizualizer no utils/logger.py em busca de ajuda.
Também incluímos uma configuração para treinamento sobre anotações Pascal SBD (para experimentação rápida ou comparação com outros métodos). Para treinar no Pascal SBD, prossiga com as seguintes etapas:
benchmark.tgz ).dataset/img . Crie o diretório ./data/sbd (onde . É a raiz de Yolact) e copie dataset/img para ./data/sbd/img ../data/sbd/ .--config=yolact_resnet50_pascal_config . Verifique essa configuração para ver como estendê -la a outros modelos. Vou automatizar tudo isso com um script em breve, não se preocupe. Além disso, se você deseja o script que eu costumava converter as anotações, coloquei -o ./scripts/convert_sbd.py , mas você terá que verificar como funciona para poder usá -lo porque, na verdade, não me lembro neste momento.
Se você deseja verificar nossos resultados, pode baixar nossos pesos yolact_resnet50_pascal_config daqui. Este modelo deve obter 72,3 máscara AP_50 e 56.2 Mask AP_70. Observe que o AP "All" não é o mesmo que o "Vol" relatado em outros trabalhos para Pascal (eles usam uma média dos limiares de 0.1 - 0.9 em incrementos de 0.1 em vez do que Coco usa).
Você também pode treinar seu próprio conjunto de dados seguindo estas etapas:
infoliscenseimage : license, flickr_url, coco_url, date_capturedcategories (usamos nosso próprio formato para categorias, veja abaixo)dataset_base em data/config.py (consulte os comentários no dataset_base para obter uma explicação 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 . Se esse não for o caso do seu arquivo de anotação (como em Coco), consulte o campo label_map no dataset_base .python train.py --help ), train.py produzirá mapa de validação para as primeiras 5000 imagens no conjunto de dados a cada 2 épocas.yolact_base_config no mesmo arquivo, altere o valor do 'dataset' para 'my_custom_dataset' ou o que você nomeou o objeto de configuração acima. Em seguida, você pode usar qualquer um dos comandos de treinamento na seção anterior. Consulte este bom post de @AMIT12690 para obter dicas sobre como anotar um conjunto de dados personalizado e prepará -lo para uso com Yolact.
Se você usar o Yolact ou esta base de código em seu trabalho, 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 ++, cite
@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 perguntas sobre nosso artigo ou código, entre em contato com Daniel Bolya.
