FCOS

FCO: detección de objetos de una etapa totalmente convolucional

Este proyecto aloja el código para implementar el algoritmo FCOS para la detección de objetos, como se presenta en nuestro documento:

 FCOS: Fully Convolutional One-Stage Object Detection;
Zhi Tian, Chunhua Shen, Hao Chen, and Tong He;
In: Proc. Int. Conf. Computer Vision (ICCV), 2019.
arXiv preprint arXiv:1904.01355 

El papel completo está disponible en: https://arxiv.org/abs/1904.01355.

La implementación basada en Detectron2 se incluye en Adelaidet.

Aquí también está un modelo en tiempo real con 46 fps y 40.3 en AP en Coco Minival.

Reflejos

• Totalmente sin anclaje: FCOS evita por completo el cálculo complicado relacionado con las cajas de anclaje y todos los hiperparametros de las cajas de anclaje.
• Mejor rendimiento: el detector de una etapa muy simple logra un rendimiento mucho mejor (38.7 frente a 36.8 en AP con resnet-50) que R-CNN más rápido. Vea más modelos y resultados experimentales aquí.
• Entrenamiento y pruebas más rápidas: con el mismo Hardwares y Backbone ResNet-50-FPN, los FCO también requieren menos horas de entrenamiento (6.5h frente a 8.8h) que R-CNN más rápida. FCOS también toma 12 ms menos tiempo de inferencia por imagen que R-CNN más rápido (44 ms vs. 56 ms).
• Rendimiento de última generación: nuestro mejor modelo basado en resnext-64x4d-101 y las convoluciones deformables alcanzan un 49.0% en AP en Coco Test-Dev (con pruebas de escala múltiple).

Actualizaciones

• Los FCO con búsqueda rápida y diversa (FAD) de arquitectura neural son avalables en FAD. (30/10/2020)
• Script para exportar modelos ONNX. (21/11/2019)
• Los nuevos NMS (ver #165) aceleran modelos basados en Resne (X) T por hasta un 30% y modelos basados en Mobilenet en un 40%, con exactamente el mismo rendimiento. Mira aquí. (12/10/2019)
• Se lanzan nuevos modelos con mucho mejor rendimiento. El mejor modelo logra el 49% en AP en Coco Test-Dev con pruebas de múltiples escala. (11/09/2019)
• FCO con backbones de Vovnet está disponible en Vovnet-FCos. (08/08/2019)
• Un truco de usar una pequeña región central del BBox para el entrenamiento mejora AP en casi 1 punto como se muestra aquí. (23/07/2019)
• FCO con backbones de HRNet está disponible en HRNET-FCOS. (07/03/2019)
• Las FCO con FPN AutomL buscados (R50, R101, ResNext101 y MobileNetv2 Backbones) están disponibles en NAS-FCO. (30/06/2019)
• FCOS se ha implementado en MMDetection. Muchas gracias a @yhcao6 y @hellock. (17/05/2019)

Hardware requerido

Usamos 8 GPU NVIDIA V100.
Pero 4 1080TI GPU también pueden entrenar un FCOS basado en RENNE-FPN totalmente completo ya que las FCO es eficiente en la memoria.

Instalación

Instalación solo para pruebas

Para los usuarios que solo desean usar FCO como detector de objetos en sus proyectos, pueden instalarlo por PIP. Para hacerlo, corre:

 pip install torch  # install pytorch if you do not have it
pip install git+https://github.com/tianzhi0549/FCOS.git
# run this command line for a demo 
fcos https://github.com/tianzhi0549/FCOS/raw/master/demo/images/COCO_val2014_000000000885.jpg

Consulte aquí para el uso de la interfaz.

Para una instalación completa

Esta implementación de FCOS se basa en MaskRCNN-Benchmark. Por lo tanto, la instalación es la misma que la Maskrcnn Benchmark original.

Verifique Install.MD para obtener instrucciones de instalación. También es posible que desee ver el ReadMe.md original de Maskrcnn-Benchmark.

Una demostración rápida

Una vez que se realiza la instalación, puede seguir los pasos a continuación para ejecutar una demostración rápida.

 # assume that you are under the root directory of this project,
# and you have activated your virtual environment if needed.
wget https://huggingface.co/tianzhi/FCOS/resolve/main/FCOS_imprv_R_50_FPN_1x.pth?download=true -O FCOS_imprv_R_50_FPN_1x.pth
python demo/fcos_demo.py

Inferencia

La línea de comando de inferencia en la división del minival de coco:

 python tools/test_net.py 
    --config-file configs/fcos/fcos_imprv_R_50_FPN_1x.yaml 
    MODEL.WEIGHT FCOS_imprv_R_50_FPN_1x.pth 
    TEST.IMS_PER_BATCH 4    

Tenga en cuenta que:

1. Si el nombre de su modelo es diferente, reemplace FCOS_imprv_R_50_FPN_1x.pth con el suyo.
2. Si realiza un error fuera de memoria, intente reducir TEST.IMS_PER_BATCH a 1.
3. Si desea evaluar un modelo diferente, cambie --config-file a su archivo de configuración (en Configs/FCOS) y MODEL.WEIGHT a su archivo de pesas.
4. La inferencia multi-GPU está disponible, consulte el #78.
5. Mejoramos la eficiencia posterior al proceso mediante el uso de NMS múltiples (ver #165), que ahorra 18 ms en promedio. La métrica de inferencia en las siguientes tablas se ha actualizado en consecuencia.

Modelos

Para su conveniencia, proporcionamos los siguientes modelos capacitados (pronto llegarán más modelos).

Resne (x) TS:

Todos los modelos basados en resne (x) T están entrenados con 16 imágenes en una normalización de lotes mini lotes y congelados (es decir, consistentes con modelos en Maskrcnn_Benchmark).

Modelo	Capacitación multiescala	Tiempo de prueba / IM	AP (Minival)	Enlace
FCOS_IMPRV_R_50_FPN_1X	No	44ms	38.7	descargar
FCOS_IMPRV_DCNV2_R_50_FPN_1X	No	54ms	42.3	descargar
FCOS_IMPRV_R_101_FPN_2X	Sí	57 ms	43.0	descargar
FCOS_IMPRV_DCNV2_R_101_FPN_2X	Sí	73 ms	45.6	descargar
FCOS_IMPRV_X_101_32X8D_FPN_2X	Sí	110 ms	44.0	descargar
FCOS_IMPRV_DCNV2_X_101_32X8D_FPN_2X	Sí	143 ms	46.4	descargar
FCOS_IMPRV_X_101_64X4D_FPN_2X	Sí	112 ms	44.7	descargar
FCOS_IMPRV_DCNV2_X_101_64X4D_FPN_2X	Sí	144 ms	46.6	descargar

Tenga en cuenta que imprv denota improvements en nuestro documento Tabla 3. Estos cambios casi sin costos mejoran el rendimiento en ~ 1.5% en total. Por lo tanto, recomendamos encarecidamente usarlos. Los siguientes son los modelos originales presentados en nuestro artículo inicial.

Modelo	Capacitación multiescala	Tiempo de prueba / IM	AP (Minival)	AP (Test-Dev)	Enlace
FCOS_R_50_FPN_1X	No	45ms	37.1	37.4	descargar
FCOS_R_101_FPN_2X	Sí	59ms	41.4	41.5	descargar
FCOS_X_101_32X8D_FPN_2X	Sí	110 ms	42.5	42.7	descargar
FCOS_X_101_64X4D_FPN_2X	Sí	113 ms	43.0	43.2	descargar

MobileNets:

Actualizamos la normalización por lotes para modelos basados en MobileNet. Si desea usar SYNCBN, instale Pytorch 1.1 o posterior.

Modelo	Tamaño de lote de entrenamiento	Capacitación multiescala	Tiempo de prueba / IM	AP (Minival)	Enlace
Fcos_syncbn_bs32_c128_mnv2_fpn_1x	32	No	26 ms	30.9	descargar
Fcos_syncbn_bs32_mnv2_fpn_1x	32	No	33 ms	33.1	descargar
FCOS_BN_BS16_MNV2_FPN_1X	16	No	44ms	31.0	descargar

[1] 1x y 2x significan que el modelo está entrenado para 90k y 180k iteraciones, respectivamente.
[2] Todos los resultados se obtienen con un solo modelo y sin ningún aumento en el tiempo de prueba, como múltiples escala, volteo y etc.
[3] c128 denota que el modelo tiene 128 (en lugar de 256) canales en torres (es decir, MODEL.RESNETS.BACKBONE_OUT_CHANNELS en configuración).
[4] dcnv2 denota redes convolucionales deformables V2. Tenga en cuenta que para los modelos basados en resnet, aplicamos convoluciones deformables de la etapa C3 a C5 en backbones. Para los modelos basados en resnext, solo la etapa C4 y C5 usan convoluciones deformables. Todos los modelos utilizan convoluciones deformables en la última capa de torres de detectores.
[5] El modelo FCOS_imprv_dcnv2_X_101_64x4d_FPN_2x con pruebas de múltiples escala logra 49.0% en AP en Coco Test-Dev. Utilice TEST.BBOX_AUG.ENABLED True para habilitar las pruebas de múltiples escala.

Capacitación

La siguiente línea de comando entrenará FCOS_IMPRV_R_50_FPN_1X en 8 GPU con descenso de gradiente estocástico síncrono (SGD):

 python -m torch.distributed.launch 
    --nproc_per_node=8 
    --master_port=$((RANDOM + 10000)) 
    tools/train_net.py 
    --config-file configs/fcos/fcos_imprv_R_50_FPN_1x.yaml 
    DATALOADER.NUM_WORKERS 2 
    OUTPUT_DIR training_dir/fcos_imprv_R_50_FPN_1x

Tenga en cuenta que:

1. Si desea usar menos GPU, cambie --nproc_per_node a la cantidad de GPU. No es necesario cambiar otra configuración. El tamaño total de lotes no depende de nproc_per_node . Si desea cambiar el tamaño total de lotes, cambie SOLVER.IMS_PER_BATCH en configs/fcos/fcos_r_50_fpn_1x.yaml.
2. Los modelos se guardarán en OUTPUT_DIR .
3. Si desea entrenar FCO con otras troncos, cambie --config-file .
4. Si desea entrenar FCO en su propio conjunto de datos, siga esta instrucción #54.
5. Ahora, el entrenamiento con 8 GPU y 4 GPU puede tener el mismo rendimiento. La brecha de rendimiento anterior se debió a que no sincronizamos num_pos entre las GPU al calcular la pérdida.

ONNX

Consulte el directorio ONNX para un ejemplo de exportación del modelo a ONNX. Se puede descargar un modelo convertido aquí. Le recomendamos que use Pytorch> = 1.4.0 (o nocturno) y TorchVision> = 0.5.0 (o nocturno) para modelos ONNX.

Contribuyendo al proyecto

Cualquier solicitud o problemas de extracción es bienvenido.

Citas

Considere citar nuestro artículo en sus publicaciones si el proyecto ayuda a su investigación. La referencia de Bibtex es la siguiente.

 @inproceedings{tian2019fcos,
  title   =  {{FCOS}: Fully Convolutional One-Stage Object Detection},
  author  =  {Tian, Zhi and Shen, Chunhua and Chen, Hao and He, Tong},
  booktitle =  {Proc. Int. Conf. Computer Vision (ICCV)},
  year    =  {2019}
}

 @article{tian2021fcos,
  title   =  {{FCOS}: A Simple and Strong Anchor-free Object Detector},
  author  =  {Tian, Zhi and Shen, Chunhua and Chen, Hao and He, Tong},
  booktitle =  {IEEE T. Pattern Analysis and Machine Intelligence (TPAMI)},
  year    =  {2021}
}

Expresiones de gratitud

Nos gustaría agradecer a @yqyao por los trucos de muestreo central y giou. También agradecemos a @Bearcatt por su sugerencia de posicionar la rama central con regresión de caja (consulte el #89).

Licencia

Para uso académico, este proyecto tiene licencia bajo la licencia BSD de 2 cláusulas; consulte el archivo de licencia para obtener más detalles. Para uso comercial, comuníquese con los autores.