Partilhar via

Deteção de objetos usando R-CNN rápido

  • Artigo

Tabela de Conteúdos

Resumo

imagem

Este tutorial descreve como usar CNTK Fast R-CNN com BrainScript e cntk.exe. O R-CNN rápido que utiliza a API Python CNTK é descrito aqui.

Acima são exemplos de imagens e anotações de objetos para o conjunto de dados de mercearia (primeira imagem) e o conjunto de dados Pascal VOC (segunda imagem) usado neste tutorial.

Fast R-CNN é um algoritmo de deteção de objetos proposto por Ross Girshick em 2015. O papel é aceite no ICCV 2015, e arquivado em https://arxiv.org/abs/1504.08083. A Fast R-CNN baseia-se em trabalhos anteriores para classificar eficientemente as propostas de objetos utilizando redes profundas convolucionais. Em comparação com o trabalho anterior, a Fast R-CNN emprega uma região de pooling de interesses que permite reutilizar os cálculos das camadas convolucionais.

Material adicional: um tutorial detalhado para deteção de objetos usando CNTK Fast R-CNN com BrainScript (incluindo treino opcional SVM e publicação do modelo treinado como API de repouso) pode ser encontrado aqui.

Configuração

Para executar o código neste exemplo, você precisa de um ambiente CNTK Python (consulte aqui para obter ajuda de configuração). Além disso, precisa de instalar alguns pacotes adicionais. Vá à pasta FastRCNN e corra:

pip install -r requirements.txt

Problema conhecido: para instalar scikit-learn poderá ter de correr conda install scikit-learn se utilizar a Anaconda Python. Você precisará ainda Scikit-Image e OpenCV para executar estes exemplos. Por favor, descarregue as embalagens de rodas correspondentes e instale-as manualmente. Em Linux pode conda install scikit-image opencv. Para utilizadores do Windows, visite http://www.lfd.uci.edu/~gohlke/pythonlibs/e descarregue:

  • Python 3.5
    • scikit_image-0.12.3-cp35-cp35m-win_amd64.whl
    • opencv_python-3.2.0-cp35-cp35m-win_amd64.whl

Assim que descarregar os respetivos binários de rodas, instale-os com:

pip install your_download_folder/scikit_image-0.12.3-cp35-cp35m-win_amd64.whl

[! NOTA]: se vir a mensagem Nenhum módulo nomeado passado ao executar os scripts, execute .pip install future

Este código tutorial pressupõe que está a utilizar a versão 64bit do Python 3.5 ou 3.6, uma vez que os ficheiros DLL Fast R-CNN necessários em usos são pré-construídos para essas versões. Se a sua tarefa requerer a utilização de uma versão Python diferente, por favor recomponha estes ficheiros DLL no ambiente correto (ver abaixo).

O tutorial assume ainda que a pasta onde reside cntk.exe está no seu ambiente PATH variável. (Para adicionar a pasta ao seu PATH pode executar o seguinte comando a partir de uma linha de comando (assumindo que a pasta onde cntk.exe está na sua máquina é C:\src\CNTK\x64\Release): set PATH=C:\src\CNTK\x64\Release;%PATH%.)

Binários pré-compilados para regressão da caixa de delimitação e supressão não máxima

A pasta Examples\Image\Detection\FastRCNN\BrainScript\fastRCNN\utils contém binários pré-compilados que são necessários para executar Fast R-CNN. As versões que estão atualmente contidas no repositório são Python 3.5 e 3.6, todas 64 bits. Se precisar de uma versão diferente, pode compilá-la seguindo estes passos:

  • git clone --recursive https://github.com/rbgirshick/fast-rcnn.git

  • cd $FRCN_ROOT/lib

  • make

    • Em vez disso make , podes fugir python setup.py build_ext --inplace da mesma pasta. No Windows poderá ter de comentar os args de compilação extra em lib/configuração.py:
    ext_modules = [
  Extension(
      "utils.cython_bbox",
      ["utils/bbox.pyx"],
      #extra_compile_args=["-Wno-cpp", "-Wno-unused-function"],
  ),
  Extension(
      "utils.cython_nms",
      ["utils/nms.pyx"],
      #extra_compile_args=["-Wno-cpp", "-Wno-unused-function"],
  )
]

  • copiar os binários gerados cython_bbox e cython_nms de $FRCN_ROOT/lib/utils .$CNTK_ROOT/Examples/Image/Detection/fastRCNN/utils

Dados de exemplo e modelo de base

Usamos um modelo AlexNet pré-treinado como base para o treino Fast-R-CNN. O AlexNet pré-treinado está disponível em https://www.cntk.ai/Models/AlexNet/AlexNet.model. Por favor, guarde o modelo em $CNTK_ROOT/PretrainedModels. Para descarregar os dados por favor corra

python install_grocery.py

Examples/Image/DataSets/Grocery da pasta.

Executar o exemplo de brinquedo

No exemplo de brinquedo treinamos um modelo CNTK Fast R-CNN para detetar artigos de mercearia num frigorífico. Todos os scripts necessários estão dentro $CNTK_ROOT/Examples/Image/Detection/FastRCNN/BrainScript.

Guia rápido

Para executar o exemplo do brinquedo, certifique-se de que PARAMETERS.pydataset dentro está definido para "Grocery".

  • Corra A1_GenerateInputROIs.py para gerar os ROIs de entrada para treino e teste.
  • Corra A2_RunWithBSModel.py para treinar e testar usando cntk.exe e BrainScript.
  • Corra A3_ParseAndEvaluateOutput.py para calcular o mAP (precisão média média) do modelo treinado.

A saída do roteiro A3 deve conter o seguinte:

Evaluating detections
AP for         avocado = 1.0000
AP for          orange = 1.0000
AP for          butter = 1.0000
AP for       champagne = 1.0000
AP for          eggBox = 0.7500
AP for          gerkin = 1.0000
AP for         joghurt = 1.0000
AP for         ketchup = 0.6667
AP for     orangeJuice = 1.0000
AP for           onion = 1.0000
AP for          pepper = 1.0000
AP for          tomato = 0.7600
AP for           water = 0.5000
AP for            milk = 1.0000
AP for         tabasco = 1.0000
AP for         mustard = 1.0000
Mean AP = 0.9173
DONE.

Para visualizar as caixas de delimitação e as etiquetas previstas pode executar B3_VisualizeOutputROIs.py (clique nas imagens para ampliar):

imagemimagemimagem imagem

Detalhes do passo

A1: O script A1_GenerateInputROIs.py gera primeiro candidatos ROI para cada imagem usando pesquisa seletiva. Em seguida, armazena-os num formato de texto CNTK como entrada para cntk.exe. Adicionalmente, são gerados os ficheiros de entrada CNTK necessários para as imagens e as etiquetas de verdade terrestre. O script gera as seguintes pastas e ficheiros sob a FastRCNN pasta:

  • proc - pasta de raiz para conteúdo gerado.
    • grocery_2000 - contém todas as pastas e ficheiros gerados, por grocery exemplo, utilizando 2000 ROIs. Se voltar a funcionar com um número diferente de ROIs, o nome da pasta mudará de forma correspondente.
      • rois - contém as coordenadas ROI brutas para cada imagem armazenada em ficheiros de texto.
      • cntkFiles - contém os ficheiros de entrada CNTK formatados para imagens (train.txt e test.txt), coordenadas ROI (xx.rois.txt) e etiquetas ROI (xx.roilabels.txt) para train e test. (Os detalhes do formato são fornecidos abaixo.)

Todos os parâmetros estão contidos em PARAMETERS.py, por exemplo, alterações cntk_nrRois = 2000 para definir o número de ROIs utilizados para treino e teste. Descrevemos parâmetros na secção Parâmetros abaixo.

A2: O script A2_RunWithBSModel.py executa cntk usando cntk.exe e um ficheiro config BrainScript (detalhes de configuração). O modelo treinado é armazenado na pasta cntkFiles/Output da sub-pasta correspondente proc . O modelo treinado é testado separadamente tanto no conjunto de treino como no conjunto de testes. Durante o teste para cada imagem e cada ROI correspondente, é prevista e armazenada uma etiqueta nos ficheiros test.z e train.z na cntkFiles pasta.

A3: O passo de avaliação analisa a produção da CNTK e calcula o mAP comparando os resultados previstos com as anotações da verdade no solo. A supressão não máxima é utilizada para fundir ROIs sobrepostos. Pode definir o limiar para a supressão não máxima (PARAMETERS.pydetalhes).

Scripts adicionais

Existem três scripts opcionais que pode executar para visualizar e analisar os dados:

  • B1_VisualizeInputROIs.py visualiza a entrada de candidatos ROIs.
  • B2_EvaluateInputROIs.py calcula a recordação da verdade básica ROIs em relação ao candidato ROIs.
  • B3_VisualizeOutputROIs.py visualizar as caixas de delimitação e os rótulos previstos.

Executar Pascal VOC

Os dados pascal vOC (PASCAL Visual Object Classes) são um conjunto bem conhecido de imagens padronizadas para reconhecimento de classe de objetos. O treino ou teste CNTK Fast R-CNN nos dados do VOC Pascal requer uma GPU com pelo menos 4GB de RAM. Em alternativa, pode correr usando o CPU, que no entanto levará algum tempo.

Obtenção dos dados do VOC Pascal

Precisa dos dados de 2007 (comboio e teste) e 2012 (trainval), bem como dos ROIs pré-comutadores utilizados no papel original. É necessário seguir a estrutura da pasta descrita abaixo. Os scripts assumem que os dados pascal residem em $CNTK_ROOT/Examples/Image/DataSets/Pascal. Se estiver a utilizar uma pasta diferente, por favor, coloque-a pascalDataDir em PARAMETERS.py conformidade.

A VOCdevkit2007 pasta deve ser semelhante (semelhante para 2012):

VOCdevkit2007/VOC2007
VOCdevkit2007/VOC2007/Annotations
VOCdevkit2007/VOC2007/ImageSets
VOCdevkit2007/VOC2007/JPEGImages

Execução CNTK em Pascal VOC

Para executar os dados do VOC Pascal, certifique-se de que o in PARAMETERS.pydataset está definido para "pascal".

  • Corra A1_GenerateInputROIs.py para gerar os ficheiros de entrada formatados da CNTK para treino e teste a partir dos dados roi descarregados.
  • Corra A2_RunWithBSModel.py para treinar um modelo Fast R-CNN e calcular os resultados dos testes.
  • Corra A3_ParseAndEvaluateOutput.py para calcular o mAP (precisão média média) do modelo treinado.
    • Por favor, note que este é um trabalho em andamento e os resultados são preliminares, uma vez que estamos a formar novos modelos de base.
    • Certifique-se de que tem a versão mais recente do mestre CNTK para os ficheiros fastRCNN/pascal_voc.py e fastRCNN/voc_eval.py para evitar erros de codificação.

Treine os seus próprios dados

Preparar um conjunto de dados personalizado

Opção #1: Ferramenta de marcação de objetos visuais (recomendado)

A Ferramenta de Marcação de Objetos Visuais (VOTT) é uma ferramenta de anotação de plataforma cruzada para a marcação de ativos de vídeo e imagem.

Tiro de tela vott

Vott fornece as seguintes características:

  • Marcação assistida por computador e rastreio de objetos em vídeos usando o algoritmo de rastreamento Camshift.
  • Exportação de etiquetas e ativos para o formato CNTK Fast-RCNN para a formação de um modelo de deteção de objetos.
  • Executar e validar um modelo de deteção de objetos CNTK treinado em novos vídeos para gerar modelos mais fortes.

Como anotar com VOTT:

  1. Descarregue o mais recente Lançamento
  2. Siga o Readme para executar um trabalho de marcação
  3. Depois de marcar as etiquetas de exportação para o diretório de conjuntos de dados

Opção #2: Utilização de Scripts de Anotação

Para formar um modelo CNTK Fast R-CNN no seu próprio conjunto de dados, fornecemos dois scripts para anotar regiões retangulares em imagens e atribuir rótulos a essas regiões. Os scripts armazenarão as anotações no formato correto, conforme exigido pelo primeiro passo de execução fast R-CNN (A1_GenerateInputROIs.py). Primeiro, guarde as suas imagens na seguinte estrutura de pasta

  • <your_image_folder>/negative - imagens usadas para o treino que não contenham quaisquer objetos
  • <your_image_folder>/positive - imagens utilizadas para o treino que contêm objetos
  • <your_image_folder>/testImages - imagens utilizadas para testes que contenham objetos

Para as imagens negativas não é necessário criar anotações. Para as outras duas pastas, utilize os scripts fornecidos:

  • Corra C1_DrawBboxesOnImages.py para desenhar caixas de delimitação nas imagens.
    • No conjunto imgDir = <your_image_folder> de scripts (/positive ou /testImages) antes de correr.
    • Adicione anotações utilizando o cursor do rato. Uma vez anotados todos os objetos numa imagem, a tecla premente 'n' escreve o ficheiro .bboxes.txt e, em seguida, segue para a imagem seguinte, 'u' desfaz (isto é, remove) o último retângulo, e 'q' deixa a ferramenta de anotação.
  • Corra C2_AssignLabelsToBboxes.py para atribuir etiquetas às caixas de delimitação.
    • No conjunto imgDir = <your_image_folder> de scripts (/positive ou /testImages) antes de correr...
    • ... e adaptar as aulas no script para refletir as categorias de objetos, por exemplo classes = ("dog", "cat", "octopus").
    • O script carrega estes retângulos anotados manualmente para cada imagem, exibe-os um a um e pede ao utilizador que forneça a classe do objeto clicando no respetivo botão à esquerda da janela. As anotações da verdade no chão marcadas como "indecisas" ou "excluir" estão totalmente excluídas do processamento.

Treine no conjunto de dados personalizado

Antes de executar cNTK Fast R-CNN usando scripts A1-A3, precisa adicionar o seu conjunto de dados para PARAMETERS.py:

  • Conjunto dataset = "CustomDataset"
  • Adicione os parâmetros para o seu conjunto de dados sob a classe CustomDatasetPython . Pode começar por copiar os parâmetros a partir de GroceryParameters
    • Adapte as aulas para refletir as categorias de objetos. Seguindo o exemplo acima, isto pareceria self.classes = ('__background__', 'dog', 'cat', 'octopus').
    • Definir self.imgDir = <your_image_folder>.
    • Opcionalmente pode ajustar mais parâmetros, por exemplo, para a geração roi e poda (ver secção parâmetros ).

Pronto para treinar com os seus próprios dados! (Use os mesmos passos que para o exemplo de brinquedo.)

Detalhes técnicos

Parâmetros

Os principais parâmetros em PARAMETERS.py são

  • dataset - quais os dados definidos para utilizar
  • cntk_nrRois - quantas ERI utilizar para treino e teste
  • nmsThreshold - Limiar de supressão não máximo (ao intervalo [0,1]). Quanto mais baixo formos, mais CR será combinado. Usado tanto para avaliação como para visualização.

Todos os parâmetros para a geração ROI, tais como a largura mínima e máxima e altura, etc., são descritos sob PARAMETERS.py a classe ParametersPython . Estão todos definidos para um valor predefinido que é razoável. Pode sobrepor-os na # project-specific parameters secção correspondente ao conjunto de dados que está a utilizar.

Configuração CNTK

O ficheiro de configuração CNTK BrainScript que é usado para treinar e testar Fast R-CNN é fastrcnn.cntk. A parte que está a construir a rede é a BrainScriptNetworkBuilder secção no Train comando:

BrainScriptNetworkBuilder = {
    network     = BS.Network.Load ("../../../../../../../PretrainedModels/AlexNet.model")
    convLayers  = BS.Network.CloneFunction(network.features, network.conv5_y, parameters = "constant")
    fcLayers    = BS.Network.CloneFunction(network.pool3, network.h2_d)

    model (features, rois) = {
        featNorm = features - 114
        convOut  = convLayers (featNorm)
        roiOut   = ROIPooling (convOut, rois, (6:6))
        fcOut    = fcLayers (roiOut)
        W        = ParameterTensor{($NumLabels$:4096), init="glorotUniform"}
        b        = ParameterTensor{$NumLabels$, init = 'zero'}
        z        = W * fcOut + b
    }.z

    imageShape = $ImageH$:$ImageW$:$ImageC$         # 1000:1000:3
    labelShape = $NumLabels$:$NumTrainROIs$         # 21:64
    ROIShape   = 4:$NumTrainROIs$                   # 4:64

    features = Input {imageShape}
    roiLabels = Input {labelShape}
    rois = Input {ROIShape}

    z = model (features, rois)

    ce = CrossEntropyWithSoftmax(roiLabels, z, axis = 1)
    errs = ClassificationError(roiLabels, z, axis = 1)

    featureNodes    = (features:rois)
    labelNodes      = (roiLabels)
    criterionNodes  = (ce)
    evaluationNodes = (errs)
    outputNodes     = (z)
}

Na primeira linha o AlexNet pré-treinado é carregado como o modelo base. As duas partes seguintes da rede são clonadas: convLayers contém as camadas convolucionais com pesos constantes, ou seja, não são treinadas mais. fcLayers contém as camadas totalmente ligadas com os pesos pré-treinados, que serão treinados mais adiante. Os nomes network.featuresdos nós , network.conv5_y etc. podem ser derivados do olhar para a saída de registo da chamada cntk.exe (contida na saída de registo do A2_RunWithBSModel.py script).

A definição do modelo normalizamodel (features, rois) = ... primeiro as funcionalidades subtraindo 114 para cada canal e pixel. Em seguida, as características normalizadas são empurradas através do convLayers seguido pelo ROIPooling e finalmente o fcLayers. A forma de saída (largura:altura) da camada de agrupamento ROI está definida para uma (6:6) vez que este é o tamanho nd de forma que o pré-treinado fcLayers do modelo AlexNet espera. A saída do fcLayers é alimentada numa camada densa que prevê um valor por etiqueta (NumLabels) para cada ROI.

As seguintes seis linhas definem a entrada:

  • uma imagem do tamanho 1000 x 1000 x 3 ($ImageH$:$ImageW$:$ImageC$),
  • rótulos de verdade terrestre para cada ROI ($NumLabels$:$NumTrainROIs$)
  • e quatro coordenadas por ROI (4:$NumTrainROIs$) correspondentes a (x, y, w, h), todas relativas à largura e altura total da imagem.

z = model (features, rois) alimenta as imagens de entrada e ROIs no modelo de rede definido e atribui a saída a z. Tanto o critério (CrossEntropyWithSoftmax) como o erro (ClassificationError) são especificados axis = 1 para ter em conta o erro de previsão por ROI.

A secção de leitores da configuração CNTK está listada abaixo. Usa três desercializadores:

  • ImageDeserializer para ler os dados de imagem. Recolhe os nomes dos ficheiros de imagem de train.txt, escala a imagem para a largura e altura desejadas, preservando a relação de aspeto (acolchoando áreas vazias com 114) e transpõe o tensor para ter a forma de entrada correta.
  • Um CNTKTextFormatDeserializer para ler as coordenadas roi de train.rois.txt.
  • Um segundo CNTKTextFormatDeserializer para ler os rótulos roi de train.roislabels.txt.

Os formatos de ficheiro de entrada são descritos na secção seguinte.

reader = {
    randomize = false
    verbosity = 2
    deserializers = ({
        type = "ImageDeserializer" ; module = "ImageReader"
        file = train.txt
        input = {
            features = { transforms = (
                { type = "Scale" ; width = $ImageW$ ; height = $ImageW$ ; channels = $ImageC$ ; scaleMode = "pad" ; padValue = 114 }:
                { type = "Transpose" }
            )}
            ignored = {labelDim = 1000}
        }
    }:{
        type = "CNTKTextFormatDeserializer" ; module = "CNTKTextFormatReader"
        file = train.rois.txt
        input = { rois = { dim = $TrainROIDim$ ; format = "dense" } }
    }:{
        type = "CNTKTextFormatDeserializer" ; module = "CNTKTextFormatReader"
        file = train.roilabels.txt
        input = { roiLabels = { dim = $TrainROILabelDim$ ; format = "dense" } }
    })
}

Formato de ficheiro de entrada CNTK

Existem três ficheiros de entrada para CNTK Fast R-CNN correspondentes aos três deserializadores acima descritos:

  1. train.txt contém em cada linha primeiro um número de sequência, em seguida, um número de ficheiros de imagem e finalmente um 0 (que ainda é necessário por razões antigas do ImageReader).
0 image_01.jpg 0
1 image_02.jpg 0
...
  1. train.rois.txt (formato de texto CNTK) contém em cada linha primeiro um número de sequência, em seguida, o |rois identificador seguido de uma sequência de números. Estes são grupos de quatro números correspondentes a (x, y, w, h) de um ROI, todos relativos à largura e altura total da imagem. Há um total de 4 * número de rois por linha.
0 |rois 0.2185 0.0 0.165 0.29 ...
  1. train.roilabels.txt (formato de texto CNTK) contém em cada linha primeiro um número de sequência, em seguida, o |roiLabels identificador seguido de uma sequência de números. Trata-se de grupos de números de rótulos (zero ou um) por ROI que codificam a classe da verdade terrestre numa representação única. Há um total de números de rótulos * número de rois por linha.
0 |roiLabels 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0  ...

Detalhes do algoritmo

R-CNN rápido

Os R-CNNs para deteção de objetos foram apresentados pela primeira vez em 2014 por Ross Girshick et al., e mostraram-se que superaram as abordagens anteriores de última geração num dos principais desafios de reconhecimento de objetos no campo: Pascal VOC. Desde então, foram publicados dois trabalhos de seguimento que contêm melhorias significativas na velocidade: Fast R-CNN e Faster R-CNN.

A ideia básica da R-CNN é pegar numa rede neural profunda que foi originalmente treinada para a classificação de imagem usando milhões de imagens anotadas e modificá-la para efeitos de deteção de objetos. A ideia básica do primeiro artigo da R-CNN é ilustrada na figura abaixo (retirada do papel): (1) Dada uma imagem de entrada, (2) num primeiro passo, são geradas propostas de uma grande parte da região. (3) Estas propostas de região, ou Regiões de Interesses (IDE), são então enviadas independentemente através da rede que produz um vetor de, por exemplo, 4096 valores de ponto flutuante para cada ROI. Finalmente, (4) aprende-se um classificador que toma a representação roi flutuante 4096 como entrada e produz um rótulo e confiança para cada ROI.

imagem

Embora esta abordagem funcione bem em termos de precisão, é muito dispendioso calcular, uma vez que a Rede Neural tem de ser avaliada para cada ROI. A Fast R-CNN aborda esta desvantagem avaliando apenas a maior parte da rede (para ser específico: as camadas de convolução) um único tempo por imagem. De acordo com os autores, isto leva a uma aceleração de 213 vezes durante os testes e uma aceleração de 9x durante o treino sem perda de precisão. Isto é conseguido usando uma camada de piscina ROI que projeta o ROI para o mapa de características convolucional e executa o máximo de pooling para gerar o tamanho de saída desejado que a camada seguinte espera. No exemplo alexNet usado neste tutorial, a camada de agrupamento ROI é colocada entre a última camada convolucional e a primeira camada totalmente conectada (ver código BrainScript).

A implementação original do Caffe usada nos jornais R-CNN pode ser encontrada no GitHub: RCNN, Fast R-CNN e Faster R-CNN. Este tutorial utiliza alguns dos códigos destes repositórios, nomeadamente (mas não exclusivamente) para formação em SVM e avaliação de modelos.

Formação SVM vs NN

Patrick Buehler fornece instruções sobre como treinar um SVM na saída CNTK Fast R-CNN (utilizando as funcionalidades 4096 da última camada totalmente conectada) bem como uma discussão sobre prós e contras aqui.

A Busca Seletiva é um método para encontrar um grande conjunto de possíveis localizações de objetos numa imagem, independentemente da classe do objeto real. Funciona agrupando pixels de imagem em segmentos, e, em seguida, executando agrupamentos hierárquicos para combinar segmentos do mesmo objeto em propostas de objetos.

imagemimagem

Para complementar os ROIs detetados da Pesquisa Seletiva, adicionamos ROIs que cobrem a imagem em diferentes escalas e relações de aspeto. A primeira imagem mostra uma saída de exemplo de Pesquisa Seletiva, onde cada possível localização do objeto é visualizada por um retângulo verde. As CR que são demasiado pequenas, demasiado grandes, etc. são descartadas (segunda imagem) e, finalmente, rois que cobrem uniformemente a imagem são adicionadas (terceira imagem). Estes retângulos são então utilizados como Regiões de Interesses (NEA) no gasoduto R-CNN.

O objetivo da geração ROI é encontrar um pequeno conjunto de ROIs que, por mais apertado que cubra o maior número possível de objetos na imagem. Esta computação tem de ser suficientemente rápida, ao mesmo tempo que encontra localizações de objetos em escalas e relações de aspeto diferentes. A Selective Search mostrou-se a funcionar bem para esta tarefa, com boa precisão para acelerar as trocas.

NMS (supressão não máxima)

Os métodos de deteção de objetos frequentemente descodam múltiplas deteções que cobrem total ou parcialmente o mesmo objeto numa imagem. Estes ROIs precisam de ser fundidos para poderem contar objetos e obter as suas localizações exatas na imagem. Isto é tradicionalmente feito usando uma técnica chamada Não Supressão Máxima (NMS). A versão de NMS que utilizamos (e que também foi utilizada nas publicações R-CNN) não funde roIs, mas tenta identificar quais os ROIs que melhor cobrem as localizações reais de um objeto e descarta todos os outros ROIs. Isto é implementado selecionando iterativamente o ROI com maior confiança e removendo todos os outros ROIs que se sobrepõem significativamente a este ROI e são classificados como sendo da mesma classe. O limiar para a sobreposição pode ser definido PARAMETERS.py (detalhes).

Resultados de deteção antes (primeira imagem) e depois (segunda imagem) Supressão Não Máxima:

imagem

mAP (precisão média média)

Uma vez treinado, a qualidade do modelo pode ser medida com critérios diferentes, tais como precisão, recolha, precisão, área-sub-curva, etc. Uma métrica comum que é usada para o desafio de reconhecimento de objetos Pascal VOC é medir a precisão média (AP) para cada classe. A seguinte descrição de Average Precision é tirada de Everingham et. al. A precisão média média (mAP) é calculada tomando a média acima dos APs de todas as classes.

Para uma determinada tarefa e classe, a curva de precisão/recordação é calculada a partir da saída classificada de um método. A recuperação é definida como a proporção de todos os exemplos positivos classificados acima de um determinado rank. Precisão é a proporção de todos os exemplos acima desse escalão que são da classe positiva. O AP resume a forma da curva de precisão/recordação, e é definido como a precisão média num conjunto de onze níveis de recuperação igualmente espaçados [0,0.1, . . . ,1]:

imagem

A precisão em cada nível de recolha r é interpolada tomando a precisão máxima medida para um método para o qual a recordação correspondente excede r:

imagem

onde p é a precisão medida na recordação. A intenção de interpolar a curva de precisão/recordação desta forma é reduzir o impacto dos "movimentos" na curva de precisão/recuperação, causada por pequenas variações no ranking de exemplos. Note-se que, para obter uma pontuação elevada, um método deve ter precisão a todos os níveis de recuperação – isto penaliza métodos que recuperam apenas um subconjunto de exemplos com elevada precisão (por exemplo, vistas laterais dos automóveis).