Compartilhar via

Detecção de objetos usando Fast R-CNN

  • Artigo

Sumário

Resumo

imagem de imagem

Este tutorial descreve como usar o CNTK Fast R-CNN com o BrainScript e cntk.exe. O Fast R-CNN usando a API do Python do CNTK é descrito aqui.

Os exemplos acima são imagens de exemplo e anotações de objeto para o conjunto de dados de supermercado (primeira imagem) e o conjunto de dados PASCAL VOC (segunda imagem) usado neste tutorial.

Fast R-CNN é um algoritmo de detecção de objetos proposto por Ross Girshick em 2015. O documento é aceito no ICCV 2015 e arquivado em https://arxiv.org/abs/1504.08083. O Fast R-CNN baseia-se em trabalhos anteriores para classificar com eficiência propostas de objeto usando redes convolucionais profundas. Em comparação com o trabalho anterior, o Fast R-CNN emprega um esquema de pool de interesses que permite reutilizar os cálculos das camadas convolucionais.

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

Instalação

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

pip install -r requirements.txt

Problema conhecido: para instalar o scikit-learn, talvez você precise executar conda install scikit-learn se usar o Anaconda Python. Você precisará ainda de Scikit-Image e OpenCV para executar esses exemplos. Baixe os pacotes de roda correspondentes e instale-os manualmente. No Linux, você pode conda install scikit-image opencv. Para usuários do Windows, visite http://www.lfd.uci.edu/~gohlke/pythonlibs/e baixe:

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

Depois de baixar os respectivos binários de roda, instale-os com:

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

[! OBSERVAÇÃO]: se você vir a mensagem Nenhum módulo nomeado anteriormente ao executar os scripts, execute pip install future.

Este código de tutorial pressupõe que você esteja usando a versão de 64bits do Python 3.5 ou 3.6, uma vez que os arquivos DLL Fast R-CNN necessários em utils são predefinidos para essas versões. Se sua tarefa exigir o uso de uma versão diferente do Python, recompile esses arquivos DLL por conta própria no ambiente correto (veja abaixo).

O tutorial pressupõe ainda que a pasta em que cntk.exe reside está na variável de ambiente PATH. (Para adicionar a pasta ao SEU PATH, você pode executar o seguinte comando em uma linha de comando (supondo que a pasta em que cntk.exe está em seu computador seja C:\src\CNTK\x64\Release): set PATH=C:\src\CNTK\x64\Release;%PATH%.)

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

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

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

  • cd $FRCN_ROOT/lib

  • make

    • Em vez disso make , você pode executar python setup.py build_ext --inplace na mesma pasta. No Windows, talvez seja necessário comentar os args de compilação extra em lib/setup.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"],
  )
]

  • copie os binários gerados cython_bboxcython_nms de $FRCN_ROOT/lib/utils para $CNTK_ROOT/Examples/Image/Detection/fastRCNN/utils.

Exemplo de dados e modelo de linha de base

Usamos um modelo alexnet pré-treinado como base para o treinamento Fast-R-CNN. O AlexNet pré-treinado está disponível em https://www.cntk.ai/Models/AlexNet/AlexNet.model. Armazene o modelo em $CNTK_ROOT/PretrainedModels. Para baixar os dados, execute

python install_grocery.py

da Examples/Image/DataSets/Grocery pasta.

Executar o exemplo de toy

No exemplo de toy, treinamos um modelo CNTK Fast R-CNN para detectar itens de supermercado em uma geladeira. Todos os scripts necessários estão em $CNTK_ROOT/Examples/Image/Detection/FastRCNN/BrainScript.

Guia rápido

Para executar o exemplo de toy, verifique se ele PARAMETERS.pydataset está definido como "Grocery".

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

A saída do script 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 delimitadoras e os rótulos previstos, você pode executar B3_VisualizeOutputROIs.py (clique nas imagens para ampliar):

imagem imagemimagemimagem

Detalhes da etapa

A1: O script A1_GenerateInputROIs.py primeiro gera candidatos ROI para cada imagem usando a pesquisa seletiva. Em seguida, armazena-os em um formato de texto CNTK como entrada para cntk.exe. Além disso, os arquivos de entrada CNTK necessários para as imagens e os rótulos de verdade básica são gerados. O script gera as seguintes pastas e arquivos na FastRCNN pasta:

  • proc – pasta raiz para conteúdo gerado.
    • grocery_2000 – contém todas as pastas e arquivos gerados para o grocery exemplo usando 2000 ROIs. Se você executar novamente com um número diferente de ROIs, o nome da pasta será alterado correspondentemente.
      • rois - contém as coordenadas ROI brutas para cada imagem armazenada em arquivos de texto.
      • cntkFiles - contém os arquivos de entrada CNTK formatados para imagens (train.txt e test.txt), coordenadas ROI (xx.rois.txt) e rótulos ROI (xx.roilabels.txt) para train e test. (Detalhes do formato são fornecidos abaixo.)

Todos os parâmetros estão contidos PARAMETERS.py, por exemplo, alteração cntk_nrRois = 2000 para definir o número de ROIs usados para treinamento e teste. Descrevemos parâmetros na seção Parâmetros abaixo.

A2: O script A2_RunWithBSModel.py executa o cntk usando cntk.exe e um arquivo de configuração do BrainScript (detalhes da configuração). O modelo treinado é armazenado na pasta cntkFiles/Output da subpasta correspondente proc . O modelo treinado é testado separadamente no conjunto de treinamento e no conjunto de testes. Durante o teste para cada imagem e cada ROI correspondente, um rótulo é previsto e armazenado nos arquivos test.z e train.z na cntkFiles pasta.

A3: A etapa de avaliação analisa a saída do CNTK e calcula o mAP comparando os resultados previstos com as anotações de verdade básicas. A supressão não máxima é usada para mesclar ROIs sobrepostos. Você pode definir o limite para supressão não máxima em PARAMETERS.py (detalhes).

Scripts adicionais

Há três scripts opcionais que você pode executar para visualizar e analisar os dados:

  • B1_VisualizeInputROIs.py visualiza os ROIs de entrada do candidato.
  • B2_EvaluateInputROIs.py calcula o recall dos ROIs de verdade básica em relação aos ROIs candidatos.
  • B3_VisualizeOutputROIs.py visualize as caixas delimitadoras e os rótulos previstos.

Executar Pascal VOC

Os dados pascal VOC (CLASSES de Objeto Visual PASCAL) são um conjunto bem conhecido de imagens padronizadas para reconhecimento de classe de objeto. Treinar ou testar o CNTK Fast R-CNN nos dados do Pascal VOC requer uma GPU com pelo menos 4 GB de RAM. Como alternativa, você pode executar usando a CPU, o que, no entanto, levará algum tempo.

Obtendo os dados do PASCAL VOC

Você precisa dos dados 2007 (trainval e test) e 2012 (trainval), bem como os ROIs pré-compilados usados no artigo original. Você precisa seguir a estrutura de pastas descrita abaixo. Os scripts pressupõem que os dados pascal residem em $CNTK_ROOT/Examples/Image/DataSets/Pascal. Se você estiver usando uma pasta diferente, defina pascalDataDir correspondentemente PARAMETERS.py .

A VOCdevkit2007 pasta deve ter esta aparência (semelhante a 2012):

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

Executando o CNTK no Pascal VOC

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

  • Execute A1_GenerateInputROIs.py para gerar os arquivos de entrada formatados em CNTK para treinamento e teste dos dados ROI baixados.
  • Execute A2_RunWithBSModel.py para treinar um modelo Fast R-CNN e resultados de teste de computação.
  • Execute A3_ParseAndEvaluateOutput.py para calcular o mAP (precisão média média) do modelo treinado.
    • Observe que isso é um trabalho em andamento e os resultados são preliminares, pois estamos treinando novos modelos de linha de base.
    • Certifique-se de ter a versão mais recente do mestre CNTK para os arquivos fastRCNN/pascal_voc.py e fastRCNN/voc_eval.py para evitar erros de codificação.

Treinar em seus próprios dados

Preparar um conjunto de dados personalizado

Opção nº 1: Ferramenta de Marcação de Objeto Visual (recomendado)

A VOTT (Visual Object Tagging Tool) é uma ferramenta de anotação entre plataformas para marcar ativos de vídeo e imagem.

Captura de tela de votação

O VOTT fornece os seguintes recursos:

  • Marcação assistida por computador e acompanhamento de objetos em vídeos usando o algoritmo de rastreamento do Camshift.
  • Exportar marcas e ativos para o formato CNTK Fast-RCNN para treinar um modelo de detecção de objetos.
  • Executar e validar um modelo de detecção de objeto CNTK treinado em novos vídeos para gerar modelos mais fortes.

Como anotar com VOTT:

  1. Baixar a versão mais recente
  2. Siga o Readme para executar um trabalho de marcação
  3. Depois de marcar marcas de exportação para o diretório do conjunto de dados

Opção nº 2: usando scripts de anotação

Para treinar um modelo CNTK Fast R-CNN em 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 pela primeira etapa de execução do Fast R-CNN (A1_GenerateInputROIs.py). Primeiro, armazene suas imagens na estrutura de pastas a seguir

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

Para as imagens negativas, você não precisa criar anotações. Para as outras duas pastas, use os scripts fornecidos:

  • Execute C1_DrawBboxesOnImages.py para desenhar caixas delimitadoras nas imagens.
    • No conjunto imgDir = <your_image_folder> de scripts (/positive ou /testImages) antes de executar.
    • Adicione anotações usando o cursor do mouse. Depois que todos os objetos em uma imagem são anotados, pressionar a tecla 'n' grava o arquivo .bboxes.txt e, em seguida, prossegue para a próxima imagem, 'u' desfaz (ou seja, remove) o último retângulo e 'q' encerra a ferramenta de anotação.
  • Execute C2_AssignLabelsToBboxes.py para atribuir rótulos às caixas delimitadoras.
    • No conjunto imgDir = <your_image_folder> de scripts (/positive ou /testImages) antes de executar...
    • ... e adapte as classes no script para refletir suas categorias de objeto, por exemplo classes = ("dog", "cat", "octopus").
    • O script carrega esses retângulos anotados manualmente para cada imagem, exibe-os um por um e solicita que o usuário forneça a classe de objeto clicando no respectivo botão à esquerda da janela. Anotações de verdade terrestre marcadas como "indecisas" ou "excluídas" são totalmente excluídas do processamento adicional.

Treinar no conjunto de dados personalizado

Antes de executar o CNTK Fast R-CNN usando scripts A1-A3, você precisa adicionar seu conjunto de dados a PARAMETERS.py:

  • Defina dataset = "CustomDataset"
  • Adicione os parâmetros para o conjunto de dados na classe CustomDatasetPython. Você pode começar copiando os parâmetros de GroceryParameters
    • Adapte as classes para refletir suas categorias de objeto. Seguindo o exemplo acima, isso seria semelhante self.classes = ('__background__', 'dog', 'cat', 'octopus').
    • Defina self.imgDir = <your_image_folder>.
    • Opcionalmente, você pode ajustar mais parâmetros, por exemplo, para geração de ROI e poda (consulte seção Parâmetros ).

Pronto para treinar com seus próprios dados! (Use as mesmas etapas do exemplo de toy.)

Detalhes técnicos

Parâmetros

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

  • dataset - qual conjunto de dados usar
  • cntk_nrRois - quantos ROIs usar para treinamento e teste
  • nmsThreshold - Limite de supressão não máximo (no intervalo [0,1]). Quanto menor, mais ROIs serão combinados. Ele é usado para avaliação e visualização.

Todos os parâmetros para a geração ROI, como largura e altura mínimas e máximas, etc., são descritos na PARAMETERS.py classe ParametersPython. Todos eles são definidos como um valor padrão que é razoável. Você pode substituí-los na # project-specific parameters seção correspondente ao conjunto de dados que você está usando.

Configuração do CNTK

O arquivo de configuração do CNTK BrainScript usado para treinar e testar o Fast R-CNN é fastrcnn.cntk. A parte que está construindo a rede é a BrainScriptNetworkBuilder seçã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 adiante. fcLayers contém as camadas totalmente conectadas com os pesos pré-treinados, que serão treinados ainda mais. Os nomes network.featuresde nó, network.conv5_y etc. podem ser derivados da análise da saída de log da chamada cntk.exe (contida na saída de log do A2_RunWithBSModel.py script).

A definição do modelo(model (features, rois) = ...) primeiro normaliza os recursos subtraindo 114 para cada canal e pixel. Em seguida, os recursos normalizados são enviados por push pelo convLayersROIPooling seguido e, por fim, pelo fcLayers. A forma de saída (largura:altura) da camada de pooling ROI está definida como (6:6) , pois esse é o tamanho da forma que o modelo de AlexNet pré-treinado fcLayers espera. A saída do fcLayers é alimentada em uma camada densa que prevê um valor por rótulo (NumLabels) para cada ROI.

As seis linhas a seguir definem a entrada:

  • uma imagem do tamanho 1000 x 1000 x 3 ($ImageH$:$ImageW$:$ImageC$),
  • rótulos de verdade básica para cada ROI ($NumLabels$:$NumTrainROIs$)
  • e quatro coordenadas por ROI (4:$NumTrainROIs$) correspondentes a (x, y, w, h), todas relativas à largura e altura completas 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. O critério (CrossEntropyWithSoftmax) e o erro (ClassificationError) são especificados axis = 1 para considerar o erro de previsão por ROI.

A seção de leitor da configuração do CNTK está listada abaixo. Ele usa três desserializadores:

  • ImageDeserializer para ler os dados da imagem. Ele capta os nomes de arquivo de imagem, train.txtdimensiona a imagem para a largura e a altura desejadas, preservando a taxa de proporção (preenchimento de á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 arquivo de entrada são descritos na próxima seção.

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 arquivo de entrada CNTK

Há três arquivos de entrada para CNTK Fast R-CNN correspondentes aos três desserializadores descritos acima:

  1. train.txt contém em cada linha primeiro um número de sequência, depois um nome de arquivo de imagem e, finalmente, um 0 (que ainda é necessário por motivos herdados 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 e, em seguida, o |rois identificador seguido por uma sequência de números. São grupos de quatro números correspondentes a (x, y, w, h) de um ROI, todos relativos à largura e altura completas da imagem. Há um total de 4 * números de números 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 e, em seguida, o |roiLabels identificador seguido por uma sequência de números. São grupos de números de números de rótulos (zero ou um) por ROI codificando a classe de verdade básica em uma representação única. Há um total de números de rótulos * número de números 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

R-CNNs for Object Detection foram apresentados pela primeira vez em 2014 por Ross Girshick et al., e foram mostrados para superar abordagens anteriores de última geração em um dos principais desafios de reconhecimento de objetos no campo: Pascal VOC. Desde então, dois artigos de acompanhamento foram publicados que contêm melhorias significativas de velocidade: Fast R-CNN e Faster R-CNN.

A ideia básica da R-CNN é pegar uma rede neural profunda que foi originalmente treinada para classificação de imagens usando milhões de imagens anotadas e modificá-la para fins de detecção de objetos. A ideia básica do primeiro artigo R-CNN é ilustrada na Figura abaixo (tirada do papel): (1) Dada uma imagem de entrada, (2) em uma primeira etapa, um grande número de propostas de região são geradas. (3) Essas propostas de região ou ROIs (Regiões de Interesses) são enviadas independentemente pela rede que gera um vetor de, por exemplo, 4096 valores de ponto flutuante para cada ROI. Por fim, (4) um classificador é aprendido, que usa a representação ROI flutuante 4096 como entrada e gera um rótulo e confiança para cada ROI.

Imagem

Embora essa abordagem funcione bem em termos de precisão, é muito caro computar, pois a Rede Neural precisa ser avaliada para cada ROI. O R-CNN rápido resolve essa desvantagem avaliando apenas a maior parte da rede (para ser específico: as camadas de convolução) uma única vez por imagem. De acordo com os autores, isso leva a uma aceleração de 213 vezes durante o teste e uma aceleração de 9x durante o treinamento sem perda de precisão. Isso é obtido usando uma camada de pooling ROI que projeta o ROI no mapa de recursos convolucionais e executa o pooling máximo para gerar o tamanho de saída desejado que a camada a seguir está esperando. No exemplo de AlexNet usado neste tutorial, a camada de pool de ROI é colocada entre a última camada convolucional e a primeira camada totalmente conectada (consulte 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 usa parte do código desses repositórios, notadamente (mas não exclusivamente) para treinamento de SVM e avaliação de modelo.

Treinamento SVM vs NN

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

A Pesquisa Seletiva é um método para localizar um grande conjunto de possíveis locais de objeto em uma imagem, independentemente da classe do objeto real. Ele funciona agrupando pixels de imagem em segmentos e executando clustering hierárquico para combinar segmentos do mesmo objeto em propostas de objeto.

imagemde imagem

Para complementar os ROIs detectados da Pesquisa Seletiva, adicionamos ROIs que cobrem uniformemente a imagem em diferentes escalas e proporções. A primeira imagem mostra uma saída de exemplo da Pesquisa Seletiva, em que cada local de objeto possível é visualizado por um retângulo verde. ROIs muito pequenos, muito grandes, etc. são descartados (segunda imagem) e, por fim, ROIs que cobrem uniformemente a imagem são adicionados (terceira imagem). Esses retângulos são usados como ROIs (Regiões de Interesse) no pipeline R-CNN.

O objetivo da geração ROI é encontrar um pequeno conjunto de ROIs que, no entanto, cobrem o maior número possível de objetos na imagem. Essa computação deve ser suficientemente rápida e, ao mesmo tempo, encontrar locais de objeto em diferentes escalas e proporções. A Pesquisa Seletiva mostrou-se com bom desempenho para essa tarefa, com boa precisão para acelerar as compensações.

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

Os métodos de detecção de objetos geralmente geram várias detecções que cobrem totalmente ou parcialmente o mesmo objeto em uma imagem. Esses ROIs precisam ser mesclados para poder contar objetos e obter seus locais exatos na imagem. Isso é feito tradicionalmente usando uma técnica chamada NMS (Supressão Não Máxima). A versão do NMS que usamos (e que também foi usada nas publicações R-CNN) não mescla ROIs, mas tenta identificar quais ROIs melhor abrangem os locais reais de um objeto e descarta todos os outros ROIs. Isso é implementado selecionando iterativamente o ROI com maior confiança e removendo todos os outros ROIs que se sobrepõem significativamente a esse ROI e são classificados como sendo da mesma classe. O limite para a sobreposição pode ser definido em PARAMETERS.py (detalhes).

Resultados de detecção antes (primeira imagem) e depois (segunda imagem) Supressão não máxima:

imagem de imagem

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

Depois de treinado, a qualidade do modelo pode ser medida usando critérios diferentes, como precisão, recall, precisão, área abaixo da curva etc. Uma métrica comum que é usada para o desafio de reconhecimento de objeto PASCAL VOC é medir a AP (Precisão Média) para cada classe. A descrição a seguir da Precisão Média é obtida de Everingham et. al. A média de precisão (mAP) é calculada tomando a média sobre os APs de todas as classes.

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

image

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

image

onde p( ̃r) é a precisão medida em recall ̃r. A intenção de interpolar a curva de precisão/recall dessa forma é reduzir o impacto dos "wiggles" na curva de precisão/recall, causado por pequenas variações na classificação de exemplos. Deve-se observar que, para obter uma pontuação alta, um método deve ter precisão em todos os níveis de recall – isso penaliza os métodos que recuperam apenas um subconjunto de exemplos com alta precisão (por exemplo, exibições laterais de carros).