semantic segmentation pytorch

Segmentación semántica en el conjunto de datos MIT ADE20K en Pytorch

Esta es una implementación de Pytorch de modelos de segmentación semántica en el conjunto de datos de análisis de la escena MIT ADE20K (http://sceneparsing.csail.mit.edu/).

ADE20K es el conjunto de datos de código abierto más grande para la segmentación semántica y el análisis de la escena, lanzado por MIT Computer Vision Team. Siga el siguiente enlace para encontrar el repositorio de nuestro conjunto de datos e implementaciones en Caffe y Torch7: https://github.com/csailvision/sceneParsing

Si simplemente desea jugar con nuestra demostración, pruebe este enlace: http://scenesegmentation.csail.mit.edu ¡Puede cargar su propia foto y analizarla!

También puede usar este patio de cuaderno Colab aquí para jugar con el código para segmentar una imagen.

Se pueden encontrar todos los modelos previos a: http://sceneparsing.csail.mit.edu/model/pytorch

[De izquierda a derecha: imagen de prueba, verdad terrestre, resultado predicho]

La codificación de color de las categorías semánticas se puede encontrar aquí: https://docs.google.com/spreadsheets/d/1se8yetb2dets7oupe86fxgyd269pmycawe2mtkuj2w8/edit?usp=sharing

Actualizaciones

• El modelo HRNET ahora es compatible.
• Utilizamos archivos de configuración para almacenar la mayoría de las opciones que estaban en el analizador de argumentos. Las definiciones de opciones se detallan en config/defaults.py .
• Nos ajustamos a la práctica de Pytorch en el preprocesamiento de datos (RGB [0, 1], suscribe media, divide STD).

Reflejos

Normalización de lotes sincronizados en Pytorch

Este módulo calcula la diana media y estándar en todos los dispositivos durante el entrenamiento. Encontramos empíricamente que un tamaño de lote grande razonable es importante para la segmentación. Agradecemos a Jiayuan Mao por sus amables contribuciones, consulte Sincronized-BatchNorm-Pytorch para obtener más detalles.

La implementación es fácil de usar como:

• Es puro-python, no hay C ++ Extension Extension Libs.
• Es completamente compatible con la implementación de Pytorch. Específicamente, utiliza una varianza imparcial para actualizar el promedio móvil y usar SQRT (Max (VAR, EPS)) en lugar de SQRT (VAR + EPS).
• Es eficiente, solo del 20% al 30% más lento que UNSYNCBN.

Escalas dinámicas de entrada para entrenamiento con múltiples GPU

Para la tarea de segmentación semántica, es bueno mantener la relación de aspecto de las imágenes durante el entrenamiento. Por lo tanto, volvemos a implementar el módulo DataParallel y hacemos que admita la distribución de datos a múltiples GPU en Python DICT, para que cada GPU pueda procesar imágenes de diferentes tamaños. Al mismo tiempo, el DataLoader también funciona de manera diferente.

^{Ahora el tamaño de lote de un dataLoader siempre es igual al número de GPU , cada elemento se enviará a una GPU. También es compatible con el procesamiento múltiple. Tenga en cuenta que el índice de archivos para el dataloader de procesamiento múltiple se almacena en el proceso maestro, que contradice con nuestro objetivo que cada trabajador mantenga su propia lista de archivos. Por lo tanto, usamos un truco que aunque el proceso maestro todavía le da a DataLoader un índice para la función __getitem__ , simplemente ignoramos dicha solicitud y enviamos un dict de lote aleatorio. Además, los múltiples trabajadores bifurcados por el dataloader tienen la misma semilla , encontrará que varios trabajadores producirán exactamente los mismos datos, si usamos el truco mencionado anteriormente directamente. Por lo tanto, agregamos una línea de código que establece la semilla Defaut para numpy.random antes de activar múltiples trabajadores en DataLoader.}

Modelos de última generación

• PSPNET es una red de analización de escena que agrega la representación global con el módulo de agrupación de pirámides (PPM). Es el modelo ganador del desafío de análisis de la escena del MIT ILSVRC'16. Consulte https://arxiv.org/abs/1612.01105 para más detalles.
• Upernet es un modelo basado en la red Pyramid de características (FPN) y el módulo de agrupación de pirámides (PPM). No necesita una convolución dilatada, un operador que consume tiempo y memoria. Sin campanas y silbatos , es comparable o incluso mejor en comparación con PSPNET, al tiempo que requiere un tiempo de entrenamiento mucho más corto y menos memoria de GPU. Consulte https://arxiv.org/abs/1807.10221 para obtener más detalles.
• HRNET es un modelo recientemente propuesto que conserva representaciones de alta resolución en todo el modelo, sin el diseño tradicional de cuello de botella. Logra el rendimiento de SOTA en una serie de tareas de etiquetado de píxeles. Consulte https://arxiv.org/abs/1904.04514 para más detalles.

Modelos compatibles

Dividimos nuestros modelos en codificador y decodificador, donde los codificadores generalmente se modifican directamente de las redes de clasificación, y los decodificadores consisten en convoluciones finales y muestreo ascendente. Hemos proporcionado algunos modelos preconfigurados en la carpeta config .

Codificador:

• Mobilenetv2dilated
• Resnet18/resnet18dilated
• Resnet50/resnet50dilated
• Resnet101/resnet101dilated
• HRNETV2 (W48)

Descifrador:

• C1 (un módulo de convolución)
• C1_DeepSup (C1 + truco de supervisión profunda)
• PPM (módulo de agrupación de pirámides, consulte el papel PSPNET para más detalles).
• Ppm_deepsup (ppm + truco de supervisión profunda)
• UPERNET (Pyramid Pooling + FPN Head, vea Upernet para más detalles).

Actuación:

IMPORTANTE: El resnet base en nuestro repositorio es personalizado (diferente al de TorchVision). Los modelos base se descargarán automáticamente cuando sea necesario.

Arquitectura	Prueba multiescala	Significa iou	Precisión de píxeles (%)	Puntaje general	Velocidad de inferencia (FPS)
MobileNetv2Dilated + C1_DeepSup	No	34.84	75.75	54.07	17.2
	Sí	33.84	76.80	55.32	10.3
MobileNetv2Dilated + ppm_deepsup	No	35.76	77.77	56.27	14.9
	Sí	36.28	78.26	57.27	6.7
Resnet18dilated + c1_deepsup	No	33.82	76.05	54.94	13.9
	Sí	35.34	77.41	56.38	5.8
Resnet18dilated + ppm_deepsup	No	38.00	78.64	58.32	11.7
	Sí	38.81	79.29	59.05	4.2
Resnet50dilated + ppm_deepsup	No	41.26	79.73	60.50	8.3
	Sí	42.14	80.13	61.14	2.6
Resnet101dilated + ppm_deepsup	No	42.19	80.59	61.39	6.8
	Sí	42.53	80.91	61.72	2.0
UPERNET50	No	40.44	79.80	60.12	8.4
	Sí	41.55	80.23	60.89	2.9
UPERNET101	No	42.00	80.79	61.40	7.8
	Sí	42.66	81.01	61.84	2.3
Hrnetv2	No	42.03	80.77	61.40	5.8
	Sí	43.20	81.47	62.34	1.9

La capacitación se comparó en un servidor con 8 GPU de Nvidia Pascal Titan XP (memoria GPU de 12 GB), la velocidad de inferencia se compare con una sola GPU Nvidia Pascal Titan XP, sin visualización.

Ambiente

El código se desarrolla en las siguientes configuraciones.

• Hardware:> = 4 GPU para entrenamiento,> = 1 GPU para pruebas (establecer [--gpus GPUS] en consecuencia)
• Software: Ubuntu 16.04.3 LTS, CUDA> = 8.0, Python> = 3.5, Pytorch> = 0.4.0
• Dependencias: Numpy, Scipy, OpenCV, YACS, TQDM

Inicio rápido: prueba en una imagen usando nuestro modelo entrenado

1. Aquí hay una demostración simple para hacer inferencia en una sola imagen:

chmod +x demo_test.sh
./demo_test.sh

Este script descarga un modelo capacitado (resnet50dilated + ppm_deepsup) y una imagen de prueba, ejecuta el script de prueba y guarda la segmentación predicha (.png) al directorio de trabajo.

2. Para probar en una imagen o una carpeta de imágenes ( $PATH_IMG ), simplemente puede hacer lo siguiente:

 python3 -u test.py --imgs $PATH_IMG --gpu $GPU --cfg $CFG

Capacitación

1. Descargue el conjunto de datos de análisis de la escena ADE20K:

chmod +x download_ADE20K.sh
./download_ADE20K.sh

2. Entrena un modelo seleccionando las GPU ( $GPUS ) y el archivo de configuración ( $CFG ) para usar. Durante el entrenamiento, los puntos de control de forma predeterminada se guardan en la carpeta ckpt .

python3 train.py --gpus $GPUS --cfg $CFG 

• Para elegir qué GPU usar, puede hacer --gpus 0-7 o --gpus 0,2,4,6 .

Por ejemplo, puede comenzar con nuestras configuraciones proporcionadas:

• Train MobileNetv2Dilated + C1_DeepSup

python3 train.py --gpus GPUS --cfg config/ade20k-mobilenetv2dilated-c1_deepsup.yaml

• Train ResNet50Dilated + ppm_deepsup

python3 train.py --gpus GPUS --cfg config/ade20k-resnet50dilated-ppm_deepsup.yaml

• Entrenar UPERNET101

python3 train.py --gpus GPUS --cfg config/ade20k-resnet101-upernet.yaml

3. También puede anular las opciones en línea de comandos, por ejemplo, python3 train.py TRAIN.num_epoch 10 .

Evaluación

1. Evaluar un modelo capacitado en el conjunto de validación. Agregue VAL.visualize True en las visualizaciones de argumento a salida como se muestra en el teaser.

Por ejemplo:

• Evaluar MobileNetv2Dilated + C1_DeepSup

python3 eval_multipro.py --gpus GPUS --cfg config/ade20k-mobilenetv2dilated-c1_deepsup.yaml

• Evaluar resnet50dilated + ppm_deepsup

python3 eval_multipro.py --gpus GPUS --cfg config/ade20k-resnet50dilated-ppm_deepsup.yaml

• Evaluar UPERNET101

python3 eval_multipro.py --gpus GPUS --cfg config/ade20k-resnet101-upernet.yaml

Integración con otros proyectos

Esta biblioteca se puede instalar a través de pip para integrarse fácilmente con otra base de código

pip install git+https://github.com/CSAILVision/semantic-segmentation-pytorch.git@master

Ahora esta biblioteca se puede consumir fácilmente programáticamente. Por ejemplo

 from mit_semseg . config import cfg
from mit_semseg . dataset import TestDataset
from mit_semseg . models import ModelBuilder , SegmentationModule 

Referencia

Si encuentra útil el código o los modelos previamente capacitados, cite los siguientes documentos:

Comprensión semántica de las escenas a través del conjunto de datos ADE20K. B. Zhou, H. Zhao, X. Puig, T. Xiao, S. Fidler, A. Barriuso y A. Torralba. International Journal on Computer Vision (IJCV), 2018. (Https://arxiv.org/pdf/1608.05442.pdf)

 @article{zhou2018semantic,
  title={Semantic understanding of scenes through the ade20k dataset},
  author={Zhou, Bolei and Zhao, Hang and Puig, Xavier and Xiao, Tete and Fidler, Sanja and Barriuso, Adela and Torralba, Antonio},
  journal={International Journal on Computer Vision},
  year={2018}
}

Escena analizando a través del conjunto de datos ADE20K. B. Zhou, H. Zhao, X. Puig, S. Fidler, A. Barriuso y A. Torralba. Visión por computadora y reconocimiento de patrones (CVPR), 2017. (Http://people.csail.mit.edu/bzhou/publication/scene-parse-camera-ready.pdf)

 @inproceedings{zhou2017scene,
    title={Scene Parsing through ADE20K Dataset},
    author={Zhou, Bolei and Zhao, Hang and Puig, Xavier and Fidler, Sanja and Barriuso, Adela and Torralba, Antonio},
    booktitle={Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition},
    year={2017}
}