semantic segmentation pytorch

Segmentação semântica no conjunto de dados do MIT Ade20K em Pytorch

Esta é uma implementação de Pytorch de modelos de segmentação semântica no conjunto de dados do MIT Ade20K Scene Parsing (http://sceneparsing.csail.mit.edu/).

O ADE20K é o maior conjunto de dados de código aberto para segmentação semântica e análise de cenas, lançada pela equipe do MIT Computer Vision. Siga o link abaixo para encontrar o repositório para o nosso conjunto de dados e implementações em Caffe e Torch7: https://github.com/csailvision/sceneparsing

Se você simplesmente deseja brincar com a nossa demonstração, tente este link: http://scenesegmentation.csail.mit.edu Você pode fazer upload de sua própria foto e analisá -la!

Você também pode usar este playground do Colab Notebooks aqui para mexer com o código para segmentar uma imagem.

Todos os modelos pré -gravados podem ser encontrados em: http://sceneparsing.csail.mit.edu/model/pytorch

[Da esquerda para a direita: teste de teste, verdade do solo, resultado previsto]

A codificação de cores de categorias semânticas pode ser encontrada aqui: https://docs.google.com/spreadsheets/d/1se8yetb2dets7oupe86fxgyd269pmycawe2mtkuj2w8/edit?usp=Sharing

Atualizações

• O modelo HRNET agora é suportado.
• Utilizamos arquivos de configuração para armazenar a maioria das opções que estavam no reaiser de argumentos. As definições de opções são detalhadas em config/defaults.py .
• Conformamos com a prática de Pytorch no pré -processamento de dados (RGB [0, 1], média do subscraction, divide a DST).

Destaques

Normalização em lote sincronizada em pytorch

Este módulo calcula a média e a devista padrão em todos os dispositivos durante o treinamento. Empiricamente, descobrimos que um tamanho de lote grande razoável é importante para a segmentação. Agradecemos a Jiayuan Mao por suas gentis contribuições, consulte a Batchnorm-Pytorch sincronizada para obter detalhes.

A implementação é fácil de usar como:

• É pico pico, sem c ++ em extensão extra Libs.
• É completamente compatível com a implementação de Pytorch. Especificamente, ele usa variação imparcial para atualizar a média móvel e usar o SQRT (max (var, EPS)) em vez de SQRT (VAR + EPS).
• É eficiente, apenas 20% a 30% mais lento que o UNCHBN.

Escalas dinâmicas de entrada para treinamento com múltiplas GPUs

Para a tarefa da segmentação semântica, é bom manter a proporção de imagens durante o treinamento. Por isso, reimplementamos o módulo DataParallel e fazemos com que ele dê suporte a distribuição de dados para várias GPUs no Python Dict, para que cada GPU possa processar imagens de tamanhos diferentes. Ao mesmo tempo, o Dataloader também opera de maneira diferente.

^{Agora, o tamanho do lote de um dataloader sempre é igual ao número de GPUs , cada elemento será enviado para uma GPU. Também é compatível com o multipocessamento. Observe que o índice de arquivos para o dataloader multipocessante é armazenado no processo mestre, que está contradizido com o nosso objetivo de que cada trabalhador mantenha sua própria lista de arquivos. Por isso, usamos um truque de que, embora o processo mestre ainda forneça ao Dataloader um índice para a função __getitem__ , apenas ignoramos essa solicitação e enviamos um ditado de lote aleatório. Além disso, os múltiplos trabalhadores bifurcados pelo Dataloader têm a mesma semente , você descobrirá que vários trabalhadores produzirão exatamente os mesmos dados, se usarmos o truque acima mencionado diretamente. Portanto, adicionamos uma linha de código que define a semente de defesa para numpy.random antes de ativar vários trabalhadores no Dataloader.}

Modelos de última geração

• O PSPNET é uma rede de análise de cena que agrega representação global com o módulo de pool de pirâmide (PPM). É o modelo vencedor do Ilsvrc'16 MIT Scene Parsing Challenge. Consulte https://arxiv.org/abs/1612.01105 para obter detalhes.
• Ulernet é um modelo baseado na rede de pirâmide (FPN) e módulo de pool de pirâmide (PPM). Não precisa de convolução dilatada, um operador que consome tempo e memória. Sem sinos e assobios , é comparável ou ainda melhor em comparação com o PSPNET, exigindo tempo de treinamento muito mais curto e menor memória da GPU. Consulte https://arxiv.org/abs/1807.10221 para obter detalhes.
• A HRNET é um modelo recentemente proposto que mantém representações de alta resolução em todo o modelo, sem o design tradicional de gargalo. Ele atinge o desempenho do SOTA em uma série de tarefas de rotulagem de pixels. Consulte https://arxiv.org/abs/1904.04514 para obter detalhes.

Modelos suportados

Dividimos nossos modelos em codificador e decodificador, onde os codificadores geralmente são modificados diretamente das redes de classificação, e os decodificadores consistem em convoluções finais e amostragem de ups. Fornecemos alguns modelos pré-configurados na pasta config .

Codificador:

• MobileNetv2diled
• Resnet18/resnet18dilado
• Resnet50/Resnet50dilado
• Resnet101/Resnet101Dilado
• HRNETV2 (W48)

Decodificador:

• C1 (um módulo de convolução)
• C1_deepsup (truque de supervisão profunda C1 +)
• PPM (módulo de pool de pirâmide, consulte o papel PSPNET para obter detalhes.)
• Ppm_deepsup (ppm + truque de supervisão profunda)
• UPERNET (Pirâmide Pooling + FPN Head, consulte UPERNET para obter detalhes.)

Desempenho:

IMPORTANTE: A resmnet base em nosso repositório é personalizada (diferente da da Torchvision). Os modelos básicos serão baixados automaticamente quando necessário.

Arquitetura	Testes em várias escalas	Significa IOU	Precisão de pixel (%)	Pontuação geral	Velocidade de inferência (fps)
MobileNetv2Dilated + c1_deepsup	Não	34.84	75.75	54.07	17.2
	Sim	33.84	76.80	55.32	10.3
MobileNetv2Dilated + ppm_deepsup	Não	35.76	77.77	56.27	14.9
	Sim	36.28	78.26	57.27	6.7
Resnet18Dilated + C1_Deepsup	Não	33.82	76.05	54.94	13.9
	Sim	35.34	77.41	56.38	5.8
Resnet18Dilated + PPM_DEEPSUP	Não	38.00	78.64	58.32	11.7
	Sim	38.81	79.29	59.05	4.2
Resnet50dilated + ppm_deepsup	Não	41.26	79.73	60,50	8.3
	Sim	42.14	80.13	61.14	2.6
Resnet101Dilated + PPM_DEEPSUP	Não	42.19	80,59	61.39	6.8
	Sim	42.53	80.91	61.72	2.0
UPERNET50	Não	40.44	79.80	60.12	8.4
	Sim	41.55	80.23	60,89	2.9
UPERNET101	Não	42.00	80,79	61.40	7.8
	Sim	42.66	81.01	61.84	2.3
Hrnetv2	Não	42.03	80,77	61.40	5.8
	Sim	43.20	81.47	62.34	1.9

O treinamento é comparado em um servidor com 8 NVIDIA Pascal Titan XP GPUS (memória GPU de 12 GB), a velocidade de inferência é comparada com uma única GPU NVIDIA Pascal Titan XP, sem visualização.

Ambiente

O código é desenvolvido nas seguintes configurações.

• Hardware:> = 4 GPUs para treinamento,> = 1 GPU para teste (set [--gpus GPUS] de acordo)
• Software: Ubuntu 16.04.3 LTS, CUDA> = 8.0, Python> = 3,5, pytorch> = 0.4.0
• Dependências: Numpy, Scipy, OpenCV, YACS, TQDM

Início rápido: teste em uma imagem usando nosso modelo treinado

1. Aqui está uma demonstração simples de fazer inferência em uma única imagem:

chmod +x demo_test.sh
./demo_test.sh

Este script baixa um modelo treinado (resnet50dilated + ppm_deepsup) e uma imagem de teste, executa o script de teste e salva a segmentação prevista (.png) no diretório de trabalho.

2. Para testar em uma imagem ou em uma pasta de imagens ( $PATH_IMG ), você pode simplesmente fazer o seguinte:

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

Treinamento

1. Faça o download do conjunto de dados Ade20K Scene Parsing:

chmod +x download_ADE20K.sh
./download_ADE20K.sh

2. Treine um modelo selecionando o arquivo GPUS ( $GPUS ) e configuração ( $CFG ) para usar. Durante o treinamento, os pontos de verificação por padrão são salvos na pasta ckpt .

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

• Para escolher quais GPUs usarem, você pode fazer --gpus 0-7 ou --gpus 0,2,4,6 .

Por exemplo, você pode começar com nossas configurações fornecidas:

• Trem mobileNetv2dilated + c1_deepsup

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

• Trem resnet50dilated + ppm_deepsup

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

• Treine UPERNET101

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

3. Você também pode substituir as opções no CommandLine, por exemplo python3 train.py TRAIN.num_epoch 10 .

Avaliação

1. Avalie um modelo treinado no conjunto de validação. Adicione VAL.visualize True no argumento às visualizações de saída, como mostrado no teaser.

Por exemplo:

• Avaliar mobileNetv2dilated + c1_deepsup

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

• Avalie o resnet50dilated + ppm_deepsup

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

• Avalie UPERNET101

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

Integração com outros projetos

Esta biblioteca pode ser instalada via pip para se integrar facilmente com outra base de código

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

Agora essa biblioteca pode ser facilmente consumida programaticamente. Por exemplo

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

Referência

Se você achar útil o código ou os modelos pré-treinados, cite os seguintes papéis:

Entendimento semântico das cenas através do conjunto de dados Ade20K. B. Zhou, H. Zhao, X. Puig, T. Xiao, S. Fidler, A. Barriso e 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}
}

Cena analisando o conjunto de dados Ade20K. B. Zhou, H. Zhao, X. Puig, S. Fidler, A. Barriso e A. Torralba. Visão computacional e reconhecimento de padrões (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}
}