Melhorando o desempenho do rastreamento de pontos de interesse em
imagens através do paralelismo em GPU
Crystian Wendel M. Leão¹, João Marcelo X. N. Teixeira¹, Eduardo S. Albuquerque²,
Veronica Teichrieb¹, Judith Kelner¹
¹Centro de Informática
Universidade Federal de Pernambuco
{cwml, jmxnt, vt, jk}@cin.ufpe.br
Resumo
O rastreamento de pontos de interesse é uma etapa
fundamental de muitos algoritmos de Visão
Computacional. Neste trabalho é proposta uma
adaptação do Ferns, um conhecido rastreador de
pontos de interesse em imagens, de forma a aproveitar
a capacidade de processamento paralelo fornecida
pelas GPUs atuais. Foi realizada uma análise em todo
o código fonte original da implementação do
algoritmo de forma a identificar regiões críticas e
quais delas eram passíveis de paralelização. Em
seguida, implementou-se a fase de rastreamento de
pontos de interesse em GPU e os resultados obtidos
foram comparados com os valores de referência em
CPU. As vantagens da nova versão são enumeradas e
justificam sua utilização, sempre que houver uma GPU
com suporte à CUDA disponível.
1. Introdução
A capacidade de reconhecer pontos de interesse
em imagens geradas a partir de diferentes pontos de
vista representa o foco de muitos algoritmos de Visão
Computacional. A área de pesquisa em Realidade
Aumentada (RA) se utiliza de vários desses algoritmos
com o objetivo de sobrepor informações virtuais no
ambiente real do usuário [1]. Especificamente em
aplicações de RA sem marcadores, onde a carga
computacional é mais intensa, quando comparado à
RA com marcadores, é de importância fundamental a
utilização de algoritmos capazes de identificar de
forma correta regiões de textura na vizinhança de
pontos chave das imagens capturadas. Além disso,
outro requisito bastante importante nesse caso é o
desempenho em tempo real. O usuário deve receber
retorno instantâneo da aplicação, e a grande maioria
²Instituto de Informática
Universidade Federal de Goiás
eduardo@inf.ufg.br
dos rastreadores existentes não oferece desempenho
satisfatório por apresentarem implementações
sequenciais e pouco otimizadas em CPU. Para
solucionar esse problema crítico de desempenho,
outras plataformas passaram a ser utilizadas como
ambiente de execução desses algoritmos. Uma delas é
a Graphics Processing Unit (GPU), que pode ser
utilizada de maneira genérica, com programação
semelhante à linguagem C, através da arquitetura de
CUDA (Compute Unified Device Architecture) [1].
Muitos algoritmos já foram implementados pela
comunidade nessa plataforma, e obtiveram ganhos
satisfatórios com a abordagem paralela, o que validou e
sedimentou a utilização da GPU como alternativa de
plataforma de execução. Em [2], uma versão paralela
do rastreador Kanade-Lucas-Tomasi (KLT) é proposta
e com ela é possível rastrear até 512 pontos chave
simultaneamente em tempo real. Em [3], foi criada
uma versão paralela do Scale Invariant Feature
Transform (SIFT) e, para imagens com resolução de
640x480, é possível conseguir um desempenho de 27,1
quadros por segundo ao se utilizar uma placa de vídeo
NVIDIA GeForce 8800 GTX. Em [4], um rastreador
bayesiano através de filtro de partículas foi
implementado e obteve um ganho de desempenho de
20 vezes, quando comparado à implementação original
em CPU. Por fim, em [5], um filtro de partículas é
utilizado para rastrear faces, e é capaz de detectar até 6
delas a uma taxa de 28 quadros por segundo, usando
uma resolução de 1024x768 pixels.
Visto que há uma tendência de melhoria de
desempenho através da utilização de algoritmos
paralelos, o objetivo deste trabalho é modificar um
conhecido rastreador de pontos de interesse em
imagens, o Ferns [6], para que seja possível executá-lo
em paralelo na GPU. O escopo deste artigo se limita à
implementação da fase de rastreamento do algoritmo e
os resultados obtidos com a adaptação realizada,
comparando o desempenho com a versão de referência
em CPU.
O restante do artigo está organizado da seguinte
forma: a seção 2 fornece os conceitos básicos
necessários ao entendimento do rastreador usando
Ferns. A seção 3 detalha a arquitetura CUDA utilizada
e as vantagens oferecidas pela mesma. A seção 4 lista
como se deram as alterações no algoritmo original e
quais pontos específicos foram atacados, no que diz
respeito à paralelização. Por fim, as seções 5 e 6
realizam uma análise dos resultados obtidos com a
versão implementada e apontam possíveis melhorias e
trabalhos futuros, respectivamente.
2. Ferns
A técnica Ferns foi desenvolvida por Vincent
Lepetit como sucessão à técnica Randomized Trees, e
ambas tratam o problema do casamento de padrões
como um problema de classificação [6]. Ele prova, em
seu trabalho, que patches (pedaços de uma imagem)
podem ser classificados se utilizando apenas de testes
binários aleatórios de luminância entre pixels,
agrupados em estruturas chamadas de Ferns, que
particionam o espaço entre todos os patches possíveis.
No trabalho, Lepetit trata todas as aparições possíveis
dos patches como classes, e os Ferns moldam uma
distribuição de probabilidade sobre estas classes. Um
grupo de testes não consegue ser discriminativo o
suficiente, mas utilizando vários grupos de Ferns, é
possível obter bons resultados.
Dessa forma, dado um patch qualquer, o algoritmo
tenta encontrar a classe correspondente a este patch.
Considere todas as classes, e
os resultados dos testes em cada um dos
testes binários. Formalmente, procura-se por
̂ , (1)
onde C é uma variável aleatória que representa a
classe. De acordo com a fórmula de Bayes, pode-se
deduzir que
. (2)
Assumindo uma distribuição uniforme para e classe vermelha, passando por cada Fern. Ao
dado que o denominador representa um fator de escala,
que independe da classe em questão, pode-se entender
o problema como a solução de
̂ (3)
A fórmula anterior pode ser interpretada da
seguinte maneira: para cada classe, obtém-se a
probabilidade de dado um patch pertencente a mesma,
os resultados dos testes serem iguais aos observados, e
seleciona-se a maior destas probabilidades. O problema
desta abordagem é a necessidade de armazenar um
valor de probabilidade para cada classe, para cada um
dos possíveis resultados do conjunto de testes, ou seja,
valores.
Através de uma abordagem bayesiana semi-
ingênua, é possível agrupar os testes em conjuntos
pequenos, e assumir independência entre eles. Com
isto tem-se
∏ (4)
onde os N testes foram divididos em grupos
com testes, e representa o resultado obtido
dos testes do K-ésimo Fern. Utilizando esta
abordagem, é necessário armazenar apenas
valores.
Em uma visão geral, o algoritmo pode ser dividido
em duas partes: treinamento e reconhecimento. Na
etapa de treinamento, o objetivo é construir as
distribuições de probabilidade das classes para cada
resultado possível de cada Fern. Essa etapa acontece
da seguinte maneira: são geradas várias homografias da
imagem a ser reconhecida, e de cada uma delas são
extraídos vários pontos chave. Cada um destes pontos
chave, os quais se sabe a qual classe pertencem, pois a
homografia foi gerada pelo algoritmo, é utilizado para
gerar a distribuição de probabilidade, sendo os pontos
chave detectados com maior frequência escolhidos
como as classes. A Figura 1, disponível em [7], mostra
um exemplo do treinamento quando se utiliza apenas
três Ferns, cada um deles com três testes. A Figura 2,
também disponível em [7], ilustra o resultado do
treinamento.
Figura 1. Cada cor representa uma classe. A
figura mostra um patch, conhecidamente da
final, a probabilidade de um patch da classe
vermelha passar pelo primeiro Fern e retornar
5 como resultado é incrementada, e assim
sucessivamente.

Figura 2. Ao final do treinamento teremos as
distribuições de probabilidade montadas.
Na fase de reconhecimento, basta passar o patch
em questão por cada Fern, e somar as distribuições de
cada Fern, para cada uma das classes. Finalmente, a
distribuição com maior valor é escolhida. A Figura 3
ilustra este processo.
Figura 3. Para análise, temos que passar o
patch por todos os Ferns, e somar as
distribuições associadas com cada resultado
de cada Fern, e ao final apenas escolher a
classe com maior probabilidade.
3. CUDA
CUDA é uma arquitetura de computação paralela
de propósito geral da NVIDIA, lançada em novembro
de 2006, que permite que GPUs da NVIDIA (aquelas a
partir da série 8) sejam utilizadas para resolver
problemas computacionais variados.
CUDA permite que linguagens de alto nível, como
C, sejam utilizadas para programação em GPU, de
maneira simples. Para uma aplicação qualquer ter
vantagem na sua implementação em CUDA, ela deve
necessariamente ser paralelizável. Quanto maior o grau
de paralelismo da aplicação, melhor será a ocupação e
o consequente aproveitamento do hardware gráfico,
uma vez que milhares de threads podem ser executadas
paralelamente na GPU. Este trabalho faz uso da versão
1.1 de CUDA, uma vez que ela dá suporte a operações
atômicas, artifício utilizado durante o desenvolvimento
da versão paralela do algoritmo. Qualquer versão
superior a esta também será suportada.
4. Implementação
A metodologia de desenvolvimento adotada nesse
projeto consistiu em inicialmente realizar uma análise
de desempenho sobre o código de referência utilizado
[8]. O código está escrito em C++ e utilizou-se o
Microsoft Visual Studio 2008 para compilá-lo. Através
da busca por possíveis “gargalos” na execução do
algoritmo original, verificou-se que aproximadamente
99% do tempo é gasto em três etapas: construção da
pirâmide gaussiana (17,04%), extração de pontos
chave (11,78%) e classificação dos mesmos utilizando
Ferns (70,30%). Uma análise posterior constatou que
todas essas três etapas apresentavam características
favoráveis à paralelização (sequência bem definida de
operações, poucos desvios no fluxo de dados,
independência entre os dados processados etc.). Sendo
assim, este trabalho focou na implementação e
otimização dessas três etapas em GPU.
4.1. Construção da pirâmide gaussiana
A etapa de construção da pirâmide gaussiana tem
como objetivo preparar a imagem para a extração de
pontos chave. Inicialmente, dada uma imagem de
entrada, cria-se uma borda em volta da mesma, apenas
replicando os pixels da primeira e última linha, e da
primeira e última coluna. Em seguida, cria-se uma
nova imagem a partir da suavização gaussiana da
mesma, com kernel de tamanho 7x7. Essas duas
imagens compõem o primeiro nível da pirâmide. Para
criar o 2º nível, realiza-se uma sub-amostragem na
imagem não suavizada através da aplicação de uma
suavização gaussiana, com kernel de tamanho 5x5, e
descartando, após isto, todas as linhas e colunas pares,
obtendo assim uma imagem com metade da largura e
altura da anterior. Com esta imagem menor, aplica-se a
mesma suavização com o kernel 7x7 do passo anterior.
Ao final da etapa tem-se 2 imagens, onde
representa o nível máximo da pirâmide criada.
A geração da pirâmide gaussiana em GPU toma
como ponto de partida a imagem com a borda
construída em CPU (o tempo gasto com essa
construção é inferior a 1% do tempo total). Além disso,
o algoritmo de convolução em paralelo utilizado é
aquele disponibilizado no SDK de CUDA, com
modificações mínimas. O kernel trabalha com imagens
cujos valores de largura e altura sejam múltiplos de 48
para ser executado. Para tornar o tamanho da imagem
de entrada genérico, adiciona-se uma segunda borda à
imagem, de cor preta, de forma que a imagem se
adeque às restrições do algoritmo. A sub-amostragem
implementada em GPU utiliza a mesma convolução do
passo anterior, porém com kernel de tamanho 5x5.
4.2. Extração de pontos chave
A etapa de extração de pontos chave da imagem
tem por objetivo selecionar os patches mais prováveis
de pertencerem à imagem a ser rastreada, para
posterior utilização na etapa de classificação com
Ferns. A implementação de referência faz uso do
YAPE (Yet Another Point Detector), um extrator de
pontos chave convencional [9].
Para cada imagem suavizada nos diferentes níveis
de pirâmide em GPU, calcula-se a sua laplaciana. A
partir de comparações e cálculos considerando a 8-
vizinhança de cada pixel, determina-se se o mesmo
será considerado um ponto chave.
Para cada ponto selecionado, armazena-se um
score que representa o quão forte o ponto chave é em
relação aos demais. Esta etapa de extração de pontos
chave é completamente realizada em GPU, e o
processo é paralelizado como um todo, ou seja, cada
pixel é testado se é um ponto chave em uma thread
separada, e à medida que novos pontos são
encontrados, eles são salvos em um vetor. Através de
operações atômicas, esses pontos são salvos
sequencialmente na memória da GPU.
Após a extração dos pontos, eles são ordenados de
acordo com o score, com a ajuda de um algoritmo de
ordenação em GPU pertencente ao SDK de CUDA,
mais especificamente o Radix Sort.
4.3. Classificação dos pontos chave utilizando
Ferns
A etapa de classificação nos Ferns é a mais
custosa do processo, e tem por objetivo classificar um
patch da imagem em uma das classes obtidas na etapa
de treinamento.
Conforme explicado anteriormente, armazena-se
valores de distribuições de probabilidade,
onde é a quantidade de classes, é a quantidade de
testes por Fern e é a quantidade de Ferns, e
pares de endereços de pixels, que representam os testes
binários de cada Fern. Cada ponto chave obtido é
passado por cada Fern, executando assim testes,
e de acordo com o resultado obtido nos testes, obtém-
se valores de distribuições de probabilidade. O
processo é repetido para cada Fern. Cada um destes
valores representa a probabilidade do patch analisado
pertencer a uma das classes. Após passar por todos os
Ferns, somam-se as probabilidades associadas com os
resultados, para no final se ter uma única distribuição
com valores, onde é o número de classes. Por
fim, seleciona-se a maior destas probabilidades, e a
classe associada a ela é a escolhida.
Essa etapa foi paralelizada como um todo, sendo a
análise de cada patch executada em uma thread
diferente.
Durante a inicialização, as distribuições de
probabilidade previamente calculadas na fase de
treinamento são copiadas para a memória da GPU,
assim como os endereços dos pixels dos testes de cada
Fern. Os valores dos endereços dos pixels dos testes,
que estão armazenados como deslocamento em X e
deslocamento em Y, são transformados em um valor de
deslocamento absoluto dentro da imagem, de acordo
com a largura da mesma, para uma otimização nos
testes.
Na etapa de classificação existe bastante demanda
por leitura de memória global para obtenção dos
valores das probabilidades. Por essa razão, utilizou-se
memória de textura, para um melhor desempenho, já
que a mesma é acessada em blocos de dados e é
acelerada por uma cache auxiliar.
Após a classificação, os pontos são copiados de
volta para a memória da CPU, e o algoritmo no host
executa o restante das operações.
5. Resultados
Todos os testes realizados foram executados em
uma máquina com as seguintes configurações: Core 2
Quad Q9400, 2,66 GHz, com 4 GB de RAM, Windows
7 Professional 64 bits, e uma placa de vídeo NVIDIA
GeForce 9800 GX2.
A entrada do algoritmo, em todos os testes,
correspondeu a um vídeo que acompanha a distribuição
do código de referência do Ferns [8], no qual uma
pessoa expõe para a câmera, em variadas poses, um
mousepad com uma imagem de um gato, como mostra
a Figura 4. Todos os tempos de execução medidos se
referem ao tempo médio quando o algoritmo é
executado com essa entrada específica, e analisa todos
os seus frames. A resolução deste vídeo é de 720x480
pixels.
 Figura 5. O tempo relativo de cada uma das
Figura 4. Quatro quadros do vídeo usado nos etapas no algoritmo original, em CPU, e na
testes, disponível em [8]. versão adaptada para GPU.
Os autores consideraram os resultados iniciais
obtidos com esse trabalho satisfatórios tanto com Tempos de execução
relação ao tempo de execução, pois houve uma redução
considerável, quanto à classificação dos pontos chave 70 63,6
em si, pois os resultados foram absolutamente iguais 60
àqueles do algoritmo original. Vale salientar que este
50
trabalho se encontra em sua primeira fase de
otimização. 40 GPU
Na primeira etapa, construção da pirâmide 30
15,33 16,27
gaussiana da imagem, obteve-se um tempo médio de 20 13,48
10,12 CPU
6,59
6,59 ms, contra 13,48 ms em CPU. Apesar do 10
algoritmo de convolução paralela ser bastante eficiente 0
em relação a sua versão em CPU, o fato de se utilizar 1ª Etapa 2ª Etapa 3ª Etapa
imagens pequenas nos últimos níveis da pirâmide,
acarreta em tempos similares entre CPU e GPU. 1ª Etapa 2ª Etapa 3ª Etapa
Na segunda etapa, extração de pontos chave, Speedup 104,55% 51,48% 290,90%
obteve-se um tempo médio de 10,12 ms, contra 15,33 Figura 6. Na parte superior, o tempo de
ms em CPU. Esta etapa também é bastante custosa por execução em milissegundos de cada uma das
acessar bastante memória global da GPU, assim como etapas em CPU e em GPU. Na parte inferior, o
por utilizar operações atômicas, que degradam ganho percentual de velocidade em cada uma
consideravelmente o desempenho da GPU. das etapas.
Na terceira e última etapa, classificação dos pontos
chave utilizando Ferns, implementada em CUDA, 6. Conclusões e trabalhos futuros
obteve-se um tempo médio de 16,27 ms, contra 63,60
ms em CPU, com uma média de 921 pontos chave Este trabalho propôs uma implementação paralela
analisados por quadro. do Ferns, um rastreador de pontos de interesse bastante
Comparando o tempo de execução como um todo, utilizado em aplicações de RA e Visão Computacional.
a taxa de quadros média do algoritmo em CPU, que era Através da análise realizada por meio de testes
de aproximadamente 9,8, foi melhorada para 21,16, o envolvendo a implementação de referência, verificou-
que representa uma melhora considerável no tempo de se que a versão implementada pelos autores apresentou
resposta para o usuário do sistema de RA. as seguintes vantagens:
A Figura 5 ilustra a fatia de tempo relativa de cada
uma das etapas do algoritmo em CPU e em GPU. A
 Aumento de desempenho – ganho de 290% na
Figura 6 mostra a melhoria conseguida em cada uma
etapa de classificação e ganho de até 115% no
das etapas, comparando os resultados em GPU com os
tempo total em comparação à versão original
tempos em CPU.
em CPU;
 Redução da carga de processamento da CPU –
o host fica livre para processar as informações
da aplicação, usando o rastreador
 implementado em GPU apenas como uma
biblioteca;
 Economia de memória da CPU – as
distribuições de probabilidade são agora
armazenadas na memória da GPU
(aproximadamente 280 MB), o que acelera o
acesso e diminui a utilização de memória no
host.
Pretende-se, como trabalhos futuros, implementar
o algoritmo por completo em GPU, ambas as fases de
treinamento e rastreamento. Além das novas partes a
serem implementadas, existem muitas otimizações que
podem ser feitas, envolvendo a não utilização de
operações atômicas, melhor utilização dos kernels
disponíveis, e aplicação da memória de textura sempre
que possível. Além disso, pretende-se implementar
suporte à plataformas multi-GPU e utilizar o conceito
de threads persistentes, de forma a balancear melhor a
carga de processamento entre as diferentes threads na
placa de vídeo. Outro trabalho futuro, que seria uma
contribuição para este trabalho é a implementação do
algoritmo para CPU Multi-core, e realizar uma
comparação de desempenho com a versão em GPU.
7. Referências
[1] T. Farias et al., "High Performance Computing: CUDA as
a Supporting Technology for Next Generation Augmented
Reality Applications," in Livro dos Minicursos do SVR 2008.
Recife: Gráfica e Copiadora Naciona, 2008, pp. 91-116.
[2] C. Zach, D. Gallup, and J.-M. Frahm, "Fast gain-adaptive
KLT tracking on the GPU," IEEE Computer Society
Conference on Computer Vision and Pattern Recognition
Workshops, 2008, pp. 1-7.
[3] SiftGPU: A GPU Implementation of Scale Invariant
Feature Transform (SIFT).
http://www.cs.unc.edu/~ccwu/siftgpu/, 2010.
[4] Geoffrey Ulman, "Bayesian Particle Filter Tracking with
CUDA," George Mason University, 2010.
[5] Oscar Mateo Lozano and Kazuhiro Otsuka, "Real-time
Visual Tracker by Stream Processing," Journal of Signal
Processing Systems, vol. 57, no. 2, 2009, pp. 285-295.
[6] Mustafa Özuysal, Michael Calonder, Vincent Lepetit, and
Pascal Fua, "Fast Keypoint Recognition using Random
Ferns”, TPAMI 32(3), IEEE Computer Society, Washington,
2010, pp. 448-461.
[7] A Semi-Naive Bayesian Classifier for Fast Patch
Classification.
http://cvlab.epfl.ch/alumni/oezuysal/ferns.html, 2010.
[8] Ferns: Planar Object Detection Demo.
http://cvlab.epfl.ch/software/ferns/index.php, 2010.
[9] Vincent Lepetit and Pascal Fua, "Towards Recognizing
Feature Points using Classification Trees," Swiss Federal
Institute of Technology, Lausanne, Switzerland, 2004.
[10] R. Azuma et al., "Recent advances in augmented
reality," Computer Graphics and Applications, IEEE, vol. 21,
no. 6, Nov. 2001, pp. 34 -47.