Region-based CNNs (R-CNNs)
==========================
Redes neurais convolucionais baseadas em regiões ou regiões com recursos
CNN (R-CNNs) são uma abordagem pioneira que aplica modelos profundos
para detecção de objetos :cite:`Girshick.Donahue.Darrell.ea.2014`.
Nesta seção, discutiremos R-CNNs e uma série de melhorias feitas a eles:
Fast R-CNN :cite:`Girshick.2015`, Faster R-CNN
:cite:`Ren.He.Girshick.ea.2015` e Mask R-CNN
:cite:`He.Gkioxari.Dollar.ea.2017`. Devido às limitações de espaço,
limitaremos nossa discussão aos designs desses modelos.
R-CNNs
------
Os modelos R-CNN primeiro selecionam várias regiões propostas de uma
imagem (por exemplo, as caixas de âncora são um tipo de método de
seleção) e, em seguida, rotulam suas categorias e caixas delimitadoras
(por exemplo, deslocamentos). Em seguida, eles usam uma CNN para
realizar cálculos avançados para extrair recursos de cada área proposta.
Depois, usamos os recursos de cada região proposta para prever suas
categorias e caixas delimitadoras. :numref:`fig_r-cnn` mostra um
modelo R-CNN.
.. _fig_r-cnn:
.. figure:: ../img/r-cnn.svg
Modelo R-CNN.
Especificamente, os R-CNNs são compostos por quatro partes principais:
1. A pesquisa seletiva é realizada na imagem de entrada para selecionar
várias regiões propostas de alta qualidade
:cite:`Uijlings.Van-De-Sande.Gevers.ea.2013`. Essas regiões
propostas são geralmente selecionados em várias escalas e têm
diferentes formas e tamanhos. A categoria e a caixa delimitadora da
verdade fundamental de cada região proposta é etiquetada.
2. Um CNN pré-treinado é selecionado e colocado, de forma truncada,
antes da camada de saída. Ele transforma cada região proposta nas
dimensões de entrada exigido pela rede e usa computação direta para
gerar os recursos extraídos das regiões propostas.
3. Os recursos e a categoria rotulada de cada região proposta são
combinados como um exemplo para treinar várias máquinas de vetores de
suporte para classificação de objeto. Aqui, cada máquina de vetor de
suporte é usada para determinar se um exemplo pertence a uma
determinada categoria.
4. Os recursos e a caixa delimitadora rotulada de cada região proposta
são combinados como um exemplo para treinar um modelo de regressão
linear para a predição da caixa delimitadora de verdade básica.
Embora os modelos R-CNN usem CNNs pré-treinados para extrair recursos de
imagem com eficácia, a principal desvantagem é a velocidade lenta. Como
você pode imaginar, podemos selecionar milhares de regiões propostas a
partir de uma única imagem, exigindo milhares de cálculos diretos da CNN
para realizar a detecção de objetos. Essa enorme carga de computação
significa que os R-CNNs não são amplamente usados em aplicativos reais.
Fast R-CNN
----------
O principal gargalo de desempenho de um modelo R-CNN é a necessidade de
extrair recursos de forma independente para cada região proposta. Como
essas regiões têm um alto grau de sobreposição, a extração de recursos
independentes resulta em um alto volume de cálculos repetitivos. Fast
R-CNN melhora o R-CNN por apenas executar CNN computação progressiva na
imagem como um todo.
.. _fig_fast_r-cnn:
.. figure:: ../img/fast-rcnn.svg
Modelo Fast R-CNN.
:numref:`fig_fast_r-cnn` mostra um modelo Fast R-CNN. Suas principais
etapas de computação são descritas abaixo:
1. Comparado a um modelo R-CNN, um modelo Fast R-CNN usa a imagem
inteira como o Entrada da CNN para extração de recursos, em vez de
cada região proposta. Além disso, esta rede é geralmente treinada
para atualizar os parâmetros do modelo. Enquanto o a entrada é uma
imagem inteira, a forma de saída do CNN é
:math:`1 \times c \times h_1 \times w_1`.
2. Supondo que a pesquisa seletiva gere :math:`n` regiões propostas,
seus diferentes formas indicam regiões de interesses (RoIs) de
diferentes formas na CNN resultado. Características das mesmas formas
devem ser extraídas dessas RoIs (aqui assumimos que a altura é
:math:`h_2` e a largura é :math:`w_2`). R-CNN rápido apresenta o pool
de RoI, que usa a saída CNN e RoIs como entrada para saída uma
concatenação dos recursos extraídos de cada região proposta com o
forma :math:`n \times c \times h_2 \times w_2`.
3. Uma camada totalmente conectada é usada para transformar a forma de
saída em :math:`n \times d`, onde :math:`d` é determinado pelo design
do modelo.
4. Durante a previsão da categoria, a forma da saída da camada
totalmente conectada é novamente transformada em :math:`n \times q` e
usamos a regressão softmax (:math:`q` é o número de categorias).
Durante a previsão da caixa delimitadora, a forma do a saída da
camada conectada é novamente transformada em :math:`n \times 4`. Isso
significa que prevemos a categoria e a caixa delimitadora para cada
região proposta.
A camada de pooling de RoI no Fast R-CNN é um pouco diferente das
camadas de pool que discutimos antes. Em uma camada de pooling normal,
definimos a janela de pool, preenchimento e passo para controlar a forma
de saída. Em uma camada de pooling de RoI, podemos especificar
diretamente a forma de saída de cada região, como especificar a altura e
a largura de cada região como :math:`h_2, w_2`. Supondo que o altura e
largura da janela RoI são :math:`h` e :math:`w`, esta janela é dividida
em uma grade de subjanelas com a forma h_2 :raw-latex:`\times `w_2$. O
tamanho de cada subjanela é de cerca de :math:`(h/h_2) \times (w/w_2)`.
A altura e largura da subjanela devem ser sempre inteiros e o maior
elemento é usado como saída para um determinada subjanela. Isso permite
que a camada de pooling de RoI extraia recursos do mesmo formato de RoIs
de formatos diferentes.
Em :numref:`fig_roi`, selecionamos uma região :math:`3\times 3` como
um RoI da entrada :math:`4 \times 4`. Para este RoI, usamos uma camada
de pool de :math:`2\times 2` RoI para obter uma única saída
:math:`2\times 2`. Quando dividimos a região em quatro subjanelas, elas
contêm respectivamente os elementos 0, 1, 4 e 5 (5 é o maior); 2 e 6 (6
é o maior); 8 e 9 (9 é o maior); e 10.
.. _fig_roi:
.. figure:: ../img/roi.svg
Camada de *pooling* RoI :math:`2 \times 2` .
.. raw:: html
.. raw:: html
Usamos a função ``ROIPooling`` para demonstrar a computação da camada de
pooling RoI. Suponha que a CNN extraia o elemento ``X`` com altura e
largura 4 e apenas um único canal.
.. code:: python
from mxnet import np, npx
npx.set_np()
X = np.arange(16).reshape(1, 1, 4, 4)
X
.. parsed-literal::
:class: output
array([[[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.]]]])
.. raw:: html
.. raw:: html
Usamos a função ``roi_pool`` de\ ``torchvision`` para demonstrar a
computação da camada de pooling RoI. Suponha que a CNN extraia o
elemento ``X`` com altura e largura 4 e apenas um único canal.
.. code:: python
import torch
import torchvision
X = torch.arange(16.).reshape(1, 1, 4, 4)
X
.. parsed-literal::
:class: output
tensor([[[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.]]]])
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
rois = np.array([[0, 0, 0, 20, 20], [0, 0, 10, 30, 30]])
.. raw:: html
.. raw:: html
.. code:: python
rois = torch.Tensor([[0, 0, 0, 20, 20], [0, 0, 10, 30, 30]])
.. raw:: html
.. raw:: html
.. raw:: html
.. code:: python
npx.roi_pooling(X, rois, pooled_size=(2, 2), spatial_scale=0.1)
.. parsed-literal::
:class: output
array([[[[ 5., 6.],
[ 9., 10.]]],
[[[ 9., 11.],
[13., 15.]]]])
.. raw:: html
.. raw:: html
.. code:: python
torchvision.ops.roi_pool(X, rois, output_size=(2, 2), spatial_scale=0.1)
.. parsed-literal::
:class: output
tensor([[[[ 5., 6.],
[ 9., 10.]]],
[[[ 9., 11.],
[13., 15.]]]])
.. raw:: html
.. raw:: html
.. raw:: html
`Discussões `__
.. raw:: html
.. raw:: html
`Discussões `__
.. raw:: html
.. raw:: html