universidade federal da bahia instituto de matemÁtica e ... · documentos de identidade, com a...
TRANSCRIPT
UNIVERSIDADE FEDERAL DA BAHIA INSTITUTO DE MATEMÁTICA E ESTATÍSTICA
DEPARTAMENTO DE CIÊNCIA DA COMPUTAÇÃO
Bruno Barbosa de Menezes
PARALELIZAÇÃO DE UM DETECTOR FACIAL UTILIZANDO A ABORDAGEM DE VIOLA-JONES
SALVADOR 2016
Bruno Barbosa de Menezes
PARALELIZAÇÃO DE UM DETECTOR FACIAL UTILIZANDO A ABORDAGEM DE VIOLA-JONES
Monografia apresentada ao Curso de Ciência
da Computação, Departamento de Ciência da Computação, Instituto de Matemática e Estatística, Universidade Federal da Bahia como requisito parcial para obtenção do grau de Bacharel em Ciência da Computação.
Orientador: Dr. Luciano Rebouças de Oliveira
SALVADOR 2016
Bruno Barbosa de Menezes
PARALELIZAÇÃO DE UM DETECTOR FACIAL UTILIZANDO A ABORDAGEM DE VIOLA-JONES
Monografia apresentada ao Curso de Ciência
da Computação, Departamento de Ciência da Computação, Instituto de Matemática e Estatística, Universidade Federal da Bahia como requisito parcial para obtenção do grau de Bacharel em Ciência da Computação.
Aprovado em 31 de Outubro de 2016
BANCA EXAMINADORA
Luciano Rebouças de Oliveira - UFBA
Pompilio José da Silva Araújo Júnior - UFBA
João Paulo Barros Silva - UFBA
AGRADECIMENTOS
Primeiramente à Deus, por ter me dado uma vida abençoada, com uma
família e amigos maravilhosos. Esses que foram responsáveis por me darem todo
alicerce para conseguir alcançar meus objetivos. Agradeço, em especial, aos meus
pais que sempre estiveram presentes em minha vida, por todo o apoio e ajuda que
me foi dada na minha trajetória, tenho satisfação e orgulho de viver junto a eles, por
serem exemplos de honestidade e dedicação. À meus amigos que proporcionaram
momentos únicos e memoráveis dentro e fora da universidade.
À Universidade Federal da Bahia, por ter dado o privilégio de estudar em uma
grande instituição de ensino. Ao meu orientador Luciano Rebouças por ter sido
participativo e atencioso durante todo o processo de desenvolvimento deste
trabalho.
Este trabalho é dedicado à todos que foram citados e é fruto de muito esforço
e determinação.
RESUMO
Sistemas em visão computacional que visam alcançar alta precisão em
detecções normalmente exige um alto custo computacional e processamento
demorado. Por esse motivo, técnicas para aceleração na detecção devem ser
encontradas. Os computadores paralelos com multiprocessadores trouxeram uma
grande contribuição para o meio acadêmico, possibilitando o processamento de
grande volume de dados em um curto intervalo de tempo. O objetivo central desse
trabalho é implementar um detector facial desde o estágio inicial, utilizando o método
de Viola-Jones, que será composto por um extrator de características, um algoritmo
de treinamento de classificadores e um localizador de faces. Será realizada a
paralelização nas etapas de extração de características e localização das faces com
o intuito de reduzir o tempo de treinamento e acelerar as detecções faciais. Os
resultados obtidos foram medidos através das métricas de avaliação de curva ROC,
taxa de acerto e medida de aceleração para avaliar a velocidade do detector, com a
finalidade de compará-lo aos trabalhos estudados. Nossa implementação conseguiu
ser 2 vezes mais rápida para imagens de baixa resolução de 300x182 e até 3 vezes
para imagens em alta resolução de 2000x1000, comparadas a implementação em
série. O extrator de características paralelizado teve um ganho surpreendente,
apresentando uma aceleração de 21 vezes em relação ao método original.
Palavras-chave: Detecção Facial. Reconhecimento Facial. Detecção de
Objetos. Paralelização de Detectores. Visão Computacional.
ABSTRACT
Systems for computer vision aimed at achieving high accuracy in detection
typically requires a high computational cost and time-consuming processing. For this
reason, techniques for accelerating the detection must be found. The parallel
multiprocessor computers have brought a great contribution to the academic world,
enabling the processing of large volumes of data (big-data) in a short time. The main
objective of this work is to implement a facial detector from an early stage, using the
Viola-Jones method, which will consist of an extractor features a classifier learning
algorithm and a locator faces. Parallelizing the feature extraction steps and location
of faces in order to reduce training time and accelerate the facial detection. The
results obtained were measured by the metric evaluation ROC curve, hit rate and
measured acceleration for evaluating the speed detector in order to compare it to the
work studied. Our implementation could be 2 times faster for lower resolution of
300x182 or even 3 times to images in high resolution images of 2000x1000,
compared to implementation in series. The extractor parallelized features had a
surprising gain, with a 21-fold acceleration in the original method.
Keywords: Face Detection. Facial recognition. Object Detection. Parallelization
Detectors. Computer Vision.
ÍNDICE DE FIGURAS
Figura 2-1: (a) Imagem original (b) Imagem no espaço YCrCb (c) Imagem usando
operações de erosão e dilatação. Extraída de Li et al. 2010, adaptada pelo autor. .. 15
Figura 2-2: (a) Imagem original (b) Segmentação da cor da pele (c) Extração das
faces candidatas (d) AdaBoost melhorado com informação da cor da pele. Extraída
de Li et al. 2010, adaptada pelo autor. ...................................................................... 16
Figura 2-3: Processo de paralelização do método proposto. Extraída de Santoso e
Pulungan, 2013, adaptada pelo autor. ...................................................................... 18
Figura 2-4: Arquitetura do sistema de detecção facial proposto pelo artigo. Extraída
de Jain e Patel, 2016, adaptada pelo autor. .............................................................. 22
Figura 2-5: Cálculo da imagem integral em GPU. Extraída de Jain e Patel, 2016,
adaptada pelo autor. ................................................................................................. 23
Figura 2-6: Comparações entre GPU e CPU, à esquerda, o tempo de
redimensionamento da imagem e, à direita, o tempo do cálculo da imagem integral.
Extraída de Jain e Patel, 2016. ................................................................................. 24
Figura 2-7: Comparação do tempo do classificador de detecção facial em CPU e
GPU. Extraída de Jain e Patel, 2016. ........................................................................ 24
Figura 2-8: Processo de cálculo da imagem integral. Extraída de Gaower e Cheming,
2011. ......................................................................................................................... 27
Figura 3-1: Visão geral do Detector Facial. ............................................................... 31
Figura 3-2: Exemplos das características usada por Viola e Jones. Extraída de Viola
e Jones, 2001, adaptada pelo autor. ......................................................................... 33
Figura 3-3: Cálculo da região D de uma imagem integral. Extraída de Viola e Jones,
2011. ......................................................................................................................... 34
Figura 3-4: Exemplos de características selecionadas pelo Adaboost. Extraída de
Viola e Jones, 2001. .................................................................................................. 35
Figura 3-5: Funcionamento da Cascata de Classificadores. ..................................... 37
Figura 4-1: Estados de um processo. ........................................................................ 42
Figura 4-2: Exemplo de um conjunto de trabalhadores (workers) preparados para
paralelização de um laço iterativo (parfor). Extraída de
https://www.mathworks.com/help/distcomp/getting-started-with-parallel-computing-
toolbox.html. Acesso em: 15 Out. 2016. .................................................................... 45
Figura 4-3: Resultado de um laço iterativo paralelizado com 4 workers. .................. 46
Figura 4-4: Uso de processamento da CPU executando 4 processos(workers) do
MATLAB. ................................................................................................................... 46
Figura 4-5: Gráfico que demonstra a escalabilidade do uso de vários
trabalhadores(workers). Extraída
dehttps://www.mathworks.com/help/distcomp/getting-started-with-parallel-computing-
toolbox.html. Acesso em: 15 Out. 2016. .................................................................... 47
Figura 4-6: Conjunto das características utilizadas na implementação do sistema.
Extraída de Viola e Jones, 2001, adaptada pelo autor. ............................................. 49
Figura 4-7: Exemplo do cálculo das características em paralelo. Cada amostra usa
milhares de características e são calculadas por um worker. ................................... 49
Figura 4-8: Paralelização do detector facial usando 4 workers. Cada quadrado verde
é o processamento da região por um worker, quando um worker finaliza seu
processamento passa a calcular uma nova região. .................................................. 50
Figura 5-1: Exemplos de Resultados que obtiveram o melhor desempenho. ........... 54
Figura 5-2: Exemplos de resultados com problemas de falsos positivos e falsos
negativos. .................................................................................................................. 55
Figura 5-3: Curva ROC do classificador. ................................................................... 56
SUMÁRIO
1 INTRODUÇÃO ................................................................................................ 10
1.1 Objetivos ......................................................................................................... 11
1.2 Contribuições .................................................................................................. 11
1.3 Mapa de capítulos .......................................................................................... 12
2 ESTADO-DA-ARTE ........................................................................................ 13
2.1 O método de Li, Xu e Wang ............................................................................ 14
2.2 O método paralelizado de Santoso e Pulungan .............................................. 17
2.3 Os sistemas paralelizados com componente GPU ......................................... 20
2.4 Relação com o presente trabalho ................................................................... 29
3 DETECÇÃO DA FACE ................................................................................... 31
3.1 Processamento de Imagens Digitais .............................................................. 31
3.2 Características de uma face ........................................................................... 32
3.2.1 Caracteristicas Haar-like ...................................................................... 32
3.2.2 Imagem integral ................................................................................... 33
3.3 Funções de classificação ................................................................................ 34
3.4 Cascata de classificadores ............................................................................. 36
3.5 Localização da face ........................................................................................ 38
4 PARALELIZAÇÃO DO DETECTOR FACIAL .................................................. 40
4.1 Paralelismo ..................................................................................................... 40
4.1.1 Processos ............................................................................................ 40
4.1.2 Estados de um processo ...................................................................... 41
4.1.3 Escalonamento de processos .............................................................. 43
4.2 Paralelização em MATLAB ............................................................................. 44
4.3 Sistema proposto ............................................................................................ 47
4.3.1 Plataforma de desenvolvimento ........................................................... 48
4.3.2 Base de dados ..................................................................................... 48
4.3.3 Treinamento ......................................................................................... 48
4.3.4 Localização da face.............................................................................. 50
5 AVALIAÇÃO DE RESULTADOS .................................................................... 52
5.1 Metodologia .................................................................................................... 52
5.2 Resultados experimentais ............................................................................... 53
6 CONCLUSÃO ................................................................................................. 58
REFERÊNCIAS ......................................................................................................... 59
10
1 INTRODUÇÃO
O estudo cientifico na área de visão computacional tem contribuído
vertiginosamente para a melhoria dos sistemas automatizados que hoje são
fundamentais em diversos ramos da vida cotidiana. As pesquisas relacionadas à
área passaram por um processo de amadurecimento, principalmente no crescimento
do número de técnicas e abordagens para implementação de sistemas. O avanço
técnico científico em visão computacional e do hardware atual tem contribuído cada
vez mais para o desenvolvimento de aplicações robustas e velozes que venham a
atender a demanda da sociedade.
As pesquisas em visão computacional vêm sendo realizadas desde a década
de 1960, constituindo um novo passo para a construção de sistemas artificiais e
simulação de habilidades biológicas, de modo a obter informações a partir de
imagens. Ballard e Brown (1982) definiram visão computacional como sendo o
estudo da extração de informação de uma imagem; mais especificamente, é a
construção de descrições explícitas e claras dos objetos em uma imagem.
Em 1972 os primeiros trabalhos sobre detecção facial foram iniciados, mas as
técnicas aplicadas por Sakai et al. (1972) utilizavam basicamente imagens de
documentos de identidade, com a face centralizada e plano de fundo liso. Até que
em 2001, Viola e Jones propuseram uma nova abordagem capaz de realizar o
processamento de detecção de faces de forma extremamente veloz, mantendo uma
alta taxa de detecção.
Atualmente sistemas de detecção facial tem se tornado cada vez mais
comuns em aplicações com câmeras digitas com sistema de detector de faces
integrado, redes sociais capazes de detectar e reconhecer usuários, uso para
segurança como controles de acesso a ambientes privativos e robôs capazes de
detectar humor de pessoas em tempo real. As possibilidades são inúmeras, mas
para realizar detecção de uma face em uma imagem existem muitos desafios que
devem ser contornados, considerando que as faces podem variar em escala, cor,
posicionamento, iluminação e alguns aspectos individuais como: cabelo, barba e uso
de acessórios que impactam no processo de localização.
11
Os computadores sempre contribuíram para o desenvolvimento de sistemas
em visão computacional, tornando viável a implementação de ideias e métodos de
detecção facial. Com o advento da computação paralela e a inserção de
computadores com multiprocessadores no mercado, novos paradigmas de
implementação de sistemas foram criados por pesquisadores e projetistas,
possibilitando a construção de detectores mais velozes e precisos.
Avaliando os presentes estudos sobre a temática e reunindo o conteúdo de
pesquisas já realizadas, desenvolver um sistema que aproveite o poder
computacional do hardware atual melhorando consideravelmente métodos da
literatura foi fator determinante e motivacional para a realização desse trabalho.
1.1 Objetivos
O objetivo central desse trabalho é implementar um detector facial desde o
estágio inicial, utilizando o método de Viola-Jones, que será composto por um
extrator de características, um algoritmo de treinamento de classificadores e um
localizador de faces. Serão paralelizadas as etapas de extração de características e
localização das faces com o intuito de reduzir o tempo de treinamento e acelerar as
detecções faciais. Em seguida, realizaremos experimentos com o objetivo de
verificar sua precisão e velocidade a fim de compará-lo aos trabalhos estudados.
1.2 Contribuições
Neste trabalho foi paralelizado o método de Viola-Jones, aumentando a
velocidade de detecção em relação ao método original numa média de 2 vezes para
imagens com resolução base de 300x182 e em até 3 vezes para imagens de alta
resolução, com base de 2000x1000. No módulo implementado para extração de
características em paralelo o ganho foi de 21 vezes em relação ao proposto por
Viola-Jones. Em termos práticos o tempo de execução deste módulo em paralelo foi
de 236.8353 segundos e em série 1 hora e 23 minutos.
12
1.3 Mapa de capítulos
O trabalho está dividido nos seguintes capítulos:
Capítulo 2 Apresenta o estado-da-arte em métodos de paralelização de
algoritmos de detecção.
Capítulo 3 Descreve detalhadamente o método de detecção de face de Viola-
Jones para, no próximo capítulo, a técnica de paralelização do detector seja
explicada.
Capítulo 4 Explica detalhadamente os conceitos e técnicas envolvidas para a
implementação de um detector paralelizado em MATLAB.
Capítulo 5 Resultados experimentais são apresentados, considerando:
desempenho de classificação do detector e tempo de detecção
Capítulo 6 Apresenta a conclusão do trabalho e propostas futuras.
13
2 ESTADO-DA-ARTE
Para tratar da temática de detecção facial e paralelização do detector foram
pesquisados sete artigos, entre 2010 e 2016. Os artigos encontrados tinham como
objetivo propor uma nova abordagem de detecção que mantivesse um alto-custo
benefício entre alta taxa de detecção e velocidade de execução.
No conjunto dos trabalhos selecionados o primeiro deles propõe um algoritmo
de detecção facial combinado com um algoritmo de detecção de cor da pele e
aprimoramento do AdaBoost, introduzido por Freund e Schapire (1999).
Primeiramente regiões da pele são segmentadas a partir da imagem detectada e
regiões de faces candidatas são obtidas em termos das características estatísticas
do rosto humano; Em seguida, concentrando-se sobre os fenômenos de
sobreposição no processo de treinamento do AdaBoost, o artigo propõe um novo
método para atualização dos pesos, ao mesmo tempo que o processo de construção
do classificador em cascata é adicionado ao processo de treinamento. Finalmente as
faces candidatas são verificadas pelo classificador. Os resultados demonstraram
que esta nova abordagem obtém melhores resultados e melhora na performance da
detecção.
No artigo de Santoso e Pulungan (2013), é proposto uma arquitetura
projetada para a paralelização de detecção de múltiplas faces que tem como base o
método de Viola e Jones (2001). Para desenvolvimento desse sistema foi observado
o problema a partir de 4 pontos de vista: processamento de dados, arquitetura de
memória compartilhada, modelo e concepção de um programa em paralelo.
Também foi construído um protótipo para realizar uma série de experimentos e
investigar o ganho da arquitetura criada.
Dentre os trabalhos referentes à paralelização, foram selecionados dois que
tinham como base o uso da graphical processing unit (GPU). Gaower e Cheming
(2011) e Jain e Patel (2016), desenvolveram um algoritmo de detecção da face
baseado no método de Viola e Jones utilizando unidade de processamento gráfico e
a API específica de desenvolvimento nvidia compute unifed device architeture
(CUDA). Para efeito de análise eles compararam o trabalho realizado com a
implementação tradicional de CPU. Uma outra publicação, utilizou uma abordagem
semelhante. Neste os autores desenvolveram um sistema de detecção facial em
14
GPU+CPU adotando também o algoritmo de Viola Jones (2001), os resultados foram
avaliados num sistema equipado com uma placa gráfica NVIDA Geforce GTX 260
que foi capaz de alcançar a velocidade de 12 fps e taxa de detecção de 92%.
2.1 O método de Li, Xu e Wang
Li et al. (2010) propuseram um novo método para atualizar o peso no
processo de formação do algoritmo de classificação AdaBoost, adicionaram esta
atualização no processo de treinamento do classificador em cascata e introduziram
um detector de cor de pele. Em seguida, combinaram estes dois métodos. Para a
pesquisa, a cor da pele é uma informação importante na face humana. O método
usado pode procurar por regiões de cor da pele que contém o rosto humano. Muitos
resultados mostram que a diferença de claridade (do inglês, lighteness) traz impacto
na cor da pele. Por isso o sistema de cores YCrCb pode ser usado para reduzir o
efeito de claridade. Diferentes tons de cor de pele segue o modelo Gaussiano 2D.
De acordo com a distribuição de Gauss de cor da pele em espaço chroma, deve
converter cada ponto do espaço RGB para YCbCr e calcular a probabilidade em que
o ponto pertence a região da pele. Segue as expressões e parâmetros:
𝑃(𝑥) = exp[−0,5(𝑥 − 𝑢)𝑇𝑆−1(𝑥 − 𝑢)]. (1)
𝑢 = 𝐸(𝑥), 𝑥 = (𝐶𝑏, 𝐶𝑟)𝑇𝑆 = 𝐸((𝑥 − 𝑢)(𝑥 − 𝑢)𝑇). (2)
𝑢 = (
115.3781
154.4629) , 𝑆 = (
158.7358 10.2461
10.2461 297.5362).
(3)
Onde p(x) é a probabilidade do ponto pertencente a região da pele, e u e S
são os parâmetros do modelo.
Regiões da cor de pele são assinadas pelo modelo. Então, decidiram
transformar a imagem no sistema YCbCr em uma imagem binária. Porém, isso torna
a região difícil de ser trabalhada, então foi aplicado um filtro de mediana e uma
operação morfológica para reduzir ruído e proteger informações úteis na imagem.
15
Figura 2-1: (a) Imagem original (b) Imagem no espaço YCrCb (c) Imagem usando operações de erosão e dilatação. Extraída de Li et al. 2010, adaptada pelo autor.
Para os autores o algoritmo AdaBoost tem a desvantagem de gerar
fenômenos de sobreajustamento(do inglês, overfitting) no processo de formação.
Isso acontece porque o treinamento geralmente contém algumas amostras que são
difíceis de classificar, concentrando em amostras difíceis e distribuindo muito peso,
levando a muitas iterações repetidas. Então para que sejam evitados esses
fenômenos de sobreposição no treinamento, o trabalho propôs uma atualização dos
pesos no algoritmo. A ideia básica é definir um limite de peso com foco em cada
iteração, quando uma determinada amostra é classificada por erro e seu atual peso
é menor do que o limiar, o peso é aumentado, caso contrário, o peso é reduzido.
Assim, um classificador é selecionado no processo de treinamento.
A detecção de cor da pele tem uma velocidade muito alta, mas devido ao
efeito de iluminação, regiões da pele que não contem faces são facilmente
confundidas com regiões de faces, de modo que trará uma alta taxa de falso
positivo. Para melhorar a velocidade e taxa de detecção reduzindo os falsos
positivos, é ideal combinar detecção de cor de pele e o classificador AdaBoost
aprimorado para ter precisão da detecção dos rostos. A ideia básica é segmentar
regiões que são candidatas para serem detectadas pelo classificador, assim não se
faz necessário a digitalização de toda imagem, melhorando a velocidade de
detecção acentuadamente.
16
Figura 2-2: (a) Imagem original (b) Segmentação da cor da pele (c) Extração das faces candidatas (d) AdaBoost melhorado com informação da cor da pele. Extraída de Li et al. 2010, adaptada pelo autor.
O trabalho em questão usou o banco de dados do MIT (do inglês,
Massachusetts Institute of Technology) para geração de amostras de treinamento,
um total de 2429 amostras positivas e 4981 amostras negativas foram utilizadas. O
Ambiente de teste foi um CPU de 2.0 GHz e 1 GB EMS de memória, implementado
na plataforma VC ++ 6.0. Os resultados mostram que a velocidade do método
desenvolvido pelo artigo é consideravelmente superior, tem menor taxa de aceitação
e um bom desempenho de detecção.
Tabela 2-1: Comparação entre taxa de detecção e taxa de falsa aceitação. Extraída de Li et al. 2010, adaptada pelo autor.
Método de
detecção/Parâmetro
de detecção
Número
de faces
Acertos Falsos
alarmes
Taxa de
acerto
Taxa de
erro
Algoritmo AdaBoost
clássico
256 213 37 83.20% 14.45%
Método textual 256 243 12 94.92% 4.68%
Tabela 2-2: Comparação da velocidade de detecção. Extraída de Li et al. 2010, adaptada pelo autor.
Método de detecção/Imagem
detectada
Imagem 1
(ms)
Imagem 2
(ms)
Imagem 3
(ms)
Imagem 4
(ms)
Algoritmo AdaBoost clássico 82.6342 80.9423 104.235 124.679
Método textual 44.4508 46.7923 60.253 85.756
Esta publicação propõe um novo método para atualização de peso, que
efetivamente evita a reduzir os fenômenos de sobreposição, melhorando a taxa de
17
detecção e reduzindo a falsa aceitação, adiciona também o processo de construção
de cascata na formação de um classificador, além de combinar dois tipos de
métodos de alta velocidade. Os resultados comprovam que este método tem uma
elevada velocidade e melhor desempenho de detecção.
2.2 O método paralelizado de Santoso e Pulungan
Das publicações estudadas, três delas trabalham com sistemas de
paralelização em CPU ou GPU, Santoso e Pulungan (2013) desenvolveram uma
arquitetura de detecção facial paralela a partir do método de Viola e Jones (2001),
eles consideram que este é um trabalho muito usado por pesquisadores devido ao
seu alto grau de precisão e velocidade. Para construção de uma arquitetura
paralelizada os autores se fundamentaram em 4 abordagens.
Taxonomia de processamento de dados. Proposto por Flyn (1972), este
modelo permite que uma única instrução possa operar em múltiplos elementos de
dados, resultando num tamanho de código reduzido e desempenho melhorado.
Operações SIMD(do inglês, single instruction multiple data stream) também reduzem
o número total de instruções e permite maior eficiência na troca de dados, levando a
um ganho de eficiência energética. Os autores verificaram três possíveis fontes do
algoritmo de Viola-Jones que podem ser paralelizados.
i. O cálculo da imagem integral.
ii. Processamento de sub-janelas: o método de Viola e Jones utiliza o
princípio de janela deslizante. Uma vez que são independentes uma das
outras, é possível ser processado em paralelo.
iii. O processamento de classificadores: Cada classificador no algoritmo
AdaBoost, pode ser calculado em paralelo uma vez que também são
independentes uns dos outros. Isso já é esperado, já que a maioria dos
classificadores serão descartados.
18
Figura 2-3: Processo de paralelização do método proposto. Extraída de Santoso e Pulungan, 2013, adaptada pelo autor.
Arquitetura de memória paralela. Na arquitetura de memória compartilhada,
várias CPUs usam um recurso da memória compartilhada, onde todas as CPUs e
memória estão ligados através de um único barramento. A principal razão para
adotar esta arquitetura é porque os autores quiseram desenvolver uma aplicação
paralela para ambientes multi-core, em vez de clusters.
Modelo de programação paralela. Na abordagem da programação paralela
de software, o melhor e mais simples modo para implementar o paralelismo é
usando multithreading. Quase todas bibliotecas, geralmente, oferecem
funcionalidades de programação multithreading e têm mecanismo para execução
automática de diferentes threads em diferentes núcleos do processador. Três
modelos de programação dão suporte a estes recursos hoje em dia: OpenMP,
threads POSIX e a message passing interface (MPI).
Projeto de programação paralela. Aumentar a eficiência e otimizar um
código de programação para arquitetura paralela é uma tarefa demorada e tende a
gerar muitos erros. Elaboração de programas paralelos exigem várias iterações de
código, análise de ajustes e desempenho, e, em muitos casos precisa ser refeito.
A arquitetura projetada no artigo, utilizou-se de uma implementação de série
existente, que se baseia no OpenCV. Em particular decidiram explorar e paralelizar
a última das três fontes mencionado na abordagem de taxonomia de processamento
de dados. Isto é feito refatorando seções do código fonte correspondentes a
implementação em série, paralelizando essas seções usando comandos disponíveis
no compilador. Cada sub-janela dentro de uma imagem pode ser
independentemente processada por um classificador. É relativamente simples
19
paralelizar o deslizamento, onde uma thread é atribuída a um conjunto de sub-
janelas da mesma linha para processar.
Para demonstrar a viabilidade da arquitetura proposta, executaram uma série
de testes em um notebook com processador Intel® Core™ 2 Duo, processador dual-
core rodando a 2,00 GHz, 2GB de memória e um Desktop com processador Intel
Core 2, processador quad-core rodando a 2,33 GHz, 2 GB de memória. Ambos
executavam o sistema operacional Microsoft Windows 7. Nos experimentos
realizados foram utilizadas imagens de 320 x 240 pixels, cada uma com quantidade
aleatória de faces. Registraram os tempos de execução (em segundos) nas
implementações em serial e paralelo para fins comparativos.
Tabela 2-3: Resultados dos experimentos de detecção facial em série e paralelo. Extraída de Santoso e Pulungan, 2013, adaptada pelo autor.
Num. Imagens Número
de Faces
Serial (seg.) Paralelo (seg.) Aceleração
2 core 4 core 2 core 4 core 2 core 4 core
1 DBHADI_1 1 2.1 1.0 0.10 0.01 21 100
2 DBHADI_2 2 3.2 1.5 0.22 0.02 14.5 75
3 DBHADI_3 3 3.2 1.5 0.22 0.02 14.5 75
4 DBHADI_4 3 4.3 2.2 0.43 0.03 10 73.3
5 DBHADI_5 4 5.6 3.3 0.56 0.05 10 66
6 DBHADI_6 7 7.3 5.7 0.67 0.06 10.8 95
7 DBHADI_7 8 8.1 6.2 0.72 0.07 11.2 88.5
8 DBHADI_8 10 9.7 7.1 0.84 0.08 11.5 88.7
9 DBHADI_9 28 10.4 8.2 0.92 0.09 11.3 91.1
10 DBHADI_10 31 11.2 9.6 1.00 0.10 11.2 96
A Tabela.2-3 indica que o sistema paralelo de detecção facial sobre um
processador de 2 núcleos tem uma melhoria de desempenho entre 10 a 21 vezes
numa imagem com 320 x 240 pixels. Em um processador de 4 núcleos a melhoria
de desempenho varia entre 66 e 100 vezes. Imagens com mais faces tem um
desempenho mais lento. Isso acontece, pois, cada face passa por mais
classificadores.
20
A abordagem proposta tem provado ser eficaz. As imagens de entrada podem
conter dezenas de milhares de sub-janelas e o classificador deve calculá-las uma
por uma. O ganho de desempenho do algoritmo paralelizado é enorme. Os
experimentos realizados validam que estes ganhos são de 21 a 100 vezes em um
processador de 2 e 4 cores, respectivamente.
2.3 Os sistemas paralelizados com componente GPU
Para Jain e Patel (2016) o rosto é uma das aplicações biométricas principais,
em que muitas obras se baseiam para desenvolver algoritmos e aplicar em
diferentes sistemas. Tradicionalmente hardware dedicado para alcançar taxa de
detecções desejadas são caros. Mesmo com hardware atual detecção de face é um
processo demorado, no momento em que grandes imagens são usadas. Por isso, o
processo de detecção deve ser acelerado. Nos últimos anos, as placas gráficas têm
aumentado o seu desempenho. Na verdade, o poder da unidade de processamento
gráfico (GPU) tem maior desempenho do que uma unidade central de
processamento (CPU). As placas gráficas podem ser usadas não só para
renderização de ilustrações, mas também para computação paralela como finalidade
geral. Os autores citam que o algoritmo proposto por Viola-Jones não são tão bons
com imagens de alta resolução. Portanto, a paralelização é a melhor forma de
alcançar mais rapidamente a detecção do rosto.
A pesquisa propôs uma implementação do método proposto por Viola-Jones
utilizando um processador gráfico e a API de desenvolvimento CUDA, uma vez que
a sua arquitetura paralela tem um alto poder computacional. O CUDA é um modelo
de extensão para a linguagem C que oferece ferramentas para explorar a
capacidade de paralelização de GPU nvidia, facilitando o desenvolvimento e
implantação de um propósito geral. CPUs tem alguns núcleos que são otimizados
para computação sequencial, enquanto GPUs possuem milhares de núcleos que
são especialmente projetados para processamento paralelo. Assim, uma aceleração
significativa pode ser conseguida através da execução em GPU, enquanto o resto
do código fica a cargo da CPU. Aplicações que necessitam trabalhar com o
processamento de pixels em visão computacional e processamento de imagens são
21
muito bem adaptados para uso geral em processadores gráficos. As GPUs são
compostas por um conjunto de multiprocessadores de streaming (SMs, do inglês
Streaming Multiprocessors), que por sua vez executam grupos de threads . Cada
SM possui vários núcleos. Um núcleo de processamento é conhecimento como
processador de streaming(SP). Geralmente, na GPU moderna cada SM contém 32
streaming processors. Então se a GPU tem 512 núcleos significa que ela contém 16
streaming multiprocessors cada um contendo 32 streaming processors.
A proposta apresentada tem duas implementações, uma em CPU e outra em
CPU e GPU. Na primeira parte todas as funcionalidades de detecção são
implementadas usando o programa com thread única(do inglês, single thread) . Na
segunda uma parte das funcionalidades são implementadas usando CPU(host) e a
maioria usando GPU(device) com paralelização de dados. Nesta arquitetura a
transformação da imagem e classificador em cascada de Viola-Jones podem ser
implementados em CPU e GPU. As tarefas de leitura e transformação da imagem
são feitas em CPU. A implementação de detecção com base na GPU é composta
por três etapas.
i. Redimensionamento da imagem original para uma pirâmide de imagens
em diferentes escalas.
ii. Cálculo das imagens integrais para extração rápida de características.
iii. Detecção da face usando cascata de classificadores.
Cada uma dessas tarefas foi paralelizada e rodam em núcleos do processador
gráfico.
22
Figura 2-4: Arquitetura do sistema de detecção facial proposto pelo artigo. Extraída de Jain e Patel, 2016, adaptada pelo autor.
No estágio de redimensionamento das imagens, a imagem original é
redimensionada para uma pirâmide de imagens em diferentes escalas, o fundo da
pirâmide sendo a imagem original e na parte superior uma imagem reduzida a
resolução 24 x 24, que é a resolução base do detector. O número de imagens
redimensionadas dependem do fator de escala, neste caso 1,2. Apesar de simples a
computação da pirâmide de imagens requer um tempo significativo. Uma abordagem
simples para redimensionamento paralelo é permitir que diferentes blocos de CUDA
thread processem diferentes escalas em paralelo. Cada thread, em um bloco de
threads, computam o valor do pixel na escala da imagem. Entretanto, blocos de
CUDA thread tem dimensões fixas. Como as dimensões da imagem diminuem
progressivamente, maior número de threads se tornam inativos para essa
abordagem.
Na representação de imagem integral, cada ponto da imagem contém o
somatório de pixels da origem até sua localização. Esse estágio pode ser
paralelizado usando prefixo vertical e horizontal. Cada thread calcula a soma de
linhas ou colunas.
23
Figura 2-5: Cálculo da imagem integral em GPU. Extraída de Jain e Patel, 2016, adaptada pelo autor.
No estágio de detecção em cascata, as características(do inglês, features) e
sub-janelas são executas em diferentes posições e escalas usando a computação
paralela por múltiplas threads. Para acelerar o cálculo das features, é necessário
usar o recurso de imagem integral previamente. A imagem integral e as features são
armazenadas e recuperadas a partir de texturas para melhoria de desempenho. As
cascatas são incialmente armazenadas em texturas e transferidas para a memória
compartilhada para acesso rápido.
Para fins experimentais, o sistema de detecção de face foi desenvolvido em
C++ e CUDA e testado em um processador Intel ® Core ™ i5 CPU 4210, sistema
host 1,07 GHz com 4 GB de RAM, equipado com uma placa gráfica NVIDIA Geforce
820M. Esta GPU possui 2 multiprocessadores, 49152 bytes de memória
compartilhada e 2 GB de memória. Existem 1024 threads por bloco e 1536 threads
ativos por multiprocessador. Para fins de comparação, uma versão de detecção de
face baseado em Viola-Jones também foi desenvolvido em single-thread para
execução em CPU. Os resultados são apresentados na Fig.2-6, ela mostra como o
tempo necessário para execução depende do tamanho da imagem. Para testar o
tempo de redimensionamento foram escolhidas imagens de tamanhos diferentes, de
10 kb a 4200 kb. A partir dos resultados, observa-se que o programa em CPU é
significativamente mais lento que em GPU. O mesmo conjunto de imagens foi
utilizado para os testes de cálculo da imagem integral.
24
Figura 2-6: Comparações entre GPU e CPU, à esquerda, o tempo de redimensionamento da imagem e, à direita, o tempo do cálculo da imagem integral. Extraída de Jain e Patel, 2016.
A detecção facial é a função algorítmica que leva mais tempo para ser
processada. Neste caso, mediu-se o tempo levado para se detectar faces na
imagem.
Figura 2-7: Comparação do tempo do classificador de detecção facial em CPU e GPU. Extraída de Jain e Patel, 2016.
No artigo de Jain e Patel (2016), os autores introduziram o uso da GPU,
explorando o paralelismo em computação de alta performance. Neste trabalho foi
possível verificar a eficiência do trabalho da GPU em imagens de várias escalas,
com diferentes tamanhos e número variado de rostos comparado ao desempenho
da implementação em CPU. A implementação em GPU é executado de 5,41 a
19,75 vezes mais veloz que a versão em CPU e as escalas são bem mais estáveis
em alta resolução nas três etapas envolvidas.
25
Gaower e Cheming (2011) adotou uma abordagem muito semelhante à usada
em Jain e Patel (2016). A diferença aqui é a construção de uma arquitetura híbrida
de CPU+GPU. Primeiramente, o algoritmo analisa e aloca as tarefas de GPU e CPU:
uma parte das tarefas que tem ampla escala de paralelismo de dados e alta
densidade aritmética na arquitetura de GPU para realizar o paralelismo a nível de
threads e a outra parte para CPU. Depois, realizar a alocação das tarefas para as
threads na GPU e garantir o escalonamento para diminuir o atraso causado pela
espera de uma thread. Finalmente, deve-se planejar o uso razoável da memória
tirando máximo proveito da largura de banda disponível.
O algoritmo de Viola-Jones é composto por três etapas principais: 1) Pré
processamento de imagens 2) Cálculo da imagem integral 3) Detecção de faces
usando cascata de classificadores. A partir disso analisam as etapas com o
propósito de separar as partes que se adequam ao uso da GPU em dois aspectos:
densidade computacional e dependência de dados e a descrição das abordagens
para realizar o paralelismo a nível de threads.
A. Pré processamento de imagens: Esta etapa transforma imagens em tons de
cinza e as redimensionam usando a técnica de pirâmides de imagem.
1) Transformação da imagem: neste passo, cada valor do pixel em tom de
cinza é calculado através da formula 1, onde (r,g,b) são os três valores
do pixel na imagem original e u o valor em tons de cinza.
𝑢 = 0.299 ∗ 𝑟 + 0.587 ∗ 𝑔 + 0.114 ∗ 𝑏. (4)
Neste processo, o cálculo de cada pixel é independente e o
pixels da imagem são grandes o suficiente que devem ser executados
em GPU. A abordagem é que cada thread calcule um pixel. O tamanho
do bloco de threads é (512,1,1) e o tamanho da matriz
(640*480/512,1,1). Enquanto isso, aloca-se três espaços de memória
na memória global para armazenar respectivamente os dados da
imagem original, a imagem em tons de cinza e a imagem em tons de
cinza ajustada. Para melhorar o desempenho copia-se os dados da
imagem original da memória global para a memória compartilhada.
26
Cada bloco compartilha 16kb da memória compartilhada e cada thread
calcula um pixel. Então cada uma é responsável por três bytes. No
entanto, no processo de cálculo, cada thread busca 3 bytes
consecutivamente para evitar conflito na memória compartilhada.
2) Redimensionamento da imagem: neste passo foi adaptado um
algoritmo de amostragem do ponto mais próximo(do inglês, nearest
point sampling) mostrado na fórmula 5 e 6, onde (u,v) é o ponto na
imagem cinza, (x,y) é o ponto da imagem a ser redimensionada e scale
é o fator da escala.
𝑢 = 𝑥 ∗ 𝑠𝑐𝑎𝑙𝑒 + 0.5. (5)
𝑣 = 𝑦 ∗ 𝑠𝑐𝑎𝑙𝑒 + 0.5. (6)
O número de imagens redimensionadas dependerá da escala
que neste caso é 1.25, totalizando 14 camadas na pirâmide de
imagens.
Este processo pode ser executado em GPU por duas razões: a
primeira que cada imagem no processo de camada e cada pixel são
computadas independente uma da outra. Por seguinte a uma grande
quantidade de pixels que devem ser calculados de acordo com a
fórmula citada. Na abordagem em questão cada bloco de thread terá o
trabalho de computar uma camada do processo, de modo que o
tamanho escolhido da grade(do inglês, grid) foi (14,1,1) e o bloco de
thread (20, 20, 1), onde cada thread computa o número de pixels
corresponde a uma camada (correspondente a camada de imagem
size/20). A imagem original em tom de cinza é armazenada na memória
de textura para obter melhor desempenho, o resultado do processo é
armazenado na memória global estabelecendo o espaço de duas
dimensões de tamanho 14*(512*385), de modo que cada linha
armazena uma camada de imagem. Todas as outras informações de
controle, como escala e redimensionamento de imagens são pré-
calculadas e armazenadas em memória compartilhada.
27
B. Cálculo da imagem integral
Assim como em Jain e Patel (2016), o processo de cálculo da imagem
integral pode ser dividido em uma soma de prefixo horizontal seguido por uma
soma de prefixos verticais para a imagem em cinza. A Fig.2-8 mostra uma
imagem 3 x 3 para exemplificar.
Figura 2-8: Processo de cálculo da imagem integral. Extraída de Gaower e Cheming, 2011.
C. Detecção da Face
Nesta seção 4 matrizes armazenam a cascata de classificadores: o
valor de duas e três features, o número de duas e três features na camada do
classificador forte. Em seguida uma janela de detecção de 20x20 percorre a
imagem com fator de deslizamento de 2 pixels na largura e 1 pixel na altura.
Todas as janelas do detector podem ser processadas de forma independente.
Para poder paralelizar o processo de detecção, mapeia-se cada janela para
uma thread, o processo é dividido em duas etapas. Na primeira parte, cada
thread processa uma janela, de modo que o número de threads é igual ao
número de janelas. O bloco criado tem um tamanho de (22,22,1) e o grid é o
(número da janela ao logo da largura/22, o número da janela ao longo da
altura/22, 1). Para cada bloco de 16KB da memória compartilhada, copia-se
as oito primeiras camadas de classificadores fortes da memória compartilhada
para a global e todas as threads do bloco acessam o mesmo classificador.
Por isso, todas as threads tem acesso simultâneo ao mesmo endereço.
Resultando numa transmissão(do inglês, broadcast) que apenas uma vez o
acesso pode conhecer a requisição de todas as threads. Enquanto isso, a
imagem integral e a imagem integral ajustada são armazenadas na memória
global.
28
Tabela 2-4: Divisão de tarefas das threads. Extraída de Gaowei e Cheming, 2011.
Tamanho da imagem
(direção X*Y)
Número de Janelas (direção
X*Y)
GRID
512*384 247*364 (12,7,1)
410*307 196*287 (9,14,1)
328*246 155*226 (8,11,1)
262*197 122*177 (6,9,1)
210*157 96*137 (5,7,1)
168*126 75*106 (4,5,1)
134*101 58*81 (3,4,1)
107*81 45*61 (3,3,1)
86*64 33*44 (2,3,1)
69*52 26*32 (1,1,1)
55*41 19*21 (1,1,1)
44*33 13*13 (1,1,1)
35*26 9*6 (1,1,1)
28*21 5*1 (1,1,1)
Na Tabela.2-4, o índice na direção X é usado duas vezes e o índice na direção Y
da thread dentro do grid indica o valor das coordenadas da janela. Cada thread usa
o valor da coordenada da janela mais o valor da coordenada da feature no
classificador como endereço para buscar os dados correspondentes da imagem
integral e imagem integral ajustada na memória global. Em seguida, realizam o
cálculo e por último compararam o resultado do cálculo com o limiar do classificador
forte, se passar por essa camada do classificador, passa a calcular a próxima
camada até terminar as oito primeiras do classificador forte, ou então abandona esta
janela. Para múltiplos threads operar em paralelo, o resultado calculado pelas
threads precisam ser escritas novamente na memória global simultaneamente. Para
evitar a cobertura de dados, adotaram uma exclusão mutua para o momento que as
threads acessarem a memória global. Duas matrizes foram pré-alocadas na
memória global para armazenar o resultado do cálculo da thread, incluindo a
coordenada da janela e o tamanho da imagem. Assim, a thread deve adcionar 1 ao
ponteiro de exclusão mútua e armazenar o resultado na matriz.
29
A aplicação foi testada em um computador com processador Intel ® Core ™
i7 920 de 4 núcleos e uma placa gráfica NVIDIA Geforce GTX260. Foram utilizadas
um total de 61 imagens de resolução 640x480 com 146 rostos frontais. 134 faces
foram detectadas corretamente, isso mostra uma taxa de detecção de 92%. Os
autores consideram que a velocidade de detecção está relacionada a cinco fatores:
o tamanho da imagem, o número de classificadores, a etapa de localização,
características ou redimensionamento na escala da imagem e o hardware da
plataforma. Os quatro primeiros estão também intimamente relacionados com a taxa
de detecção.
Tabela 2-5: Resultados da comparação na plataforma apenas com CPU e o método híbrido CPU+GPU. Extraída de Gaower e Cheming, 2011.
CPU (ms) GPU+CPU (ms) Aceleração
Transformação da imagem 1.396 0.121 11.537
Redimensionamento da imagem 8.339 2.582 3.229
Cálculo da imagem integral 10.936 3.451 3.169
Detecção da face 360.187 75.132 4.794
O sistema implementado de GPU+CPU conseguiu ser 4,7 vezes mais rápido
que a implementação que só utiliza CPU, capaz de realizar a detecção das faces em
12 fps.
2.4 Relação com o presente trabalho
O método proposto no presente trabalho, assim como na maioria dos artigos
selecionados no Estado da Arte, utilizaram para a criação de um classificador a
técnica de Boosting, especificamente o aprimoramento AdaBoost introduzido por
Freund e Schapire (1999) e paralelização de detectores. Porém, cada trabalho
possui particularidades no que diz respeito ao desenvolvimento de um sistema que
vise obter boa taxa de detecção e redução no tempo de processamento. Muitas das
técnicas e abordagens apresentadas por esses autores são semelhantes às
implementadas no sistema em estudo.
30
Diferente de LI et al. (2010), nós consideramos implementar a técnica de
combinação de cascata com o Adaboost como proposto por Viola-Jones sem alterar
o algoritmo de classificação original, partindo do pressuposto (com os nossos
estudos realizados) que a paralelização do localizador de faces seria suficiente para
melhorar o tempo de detecção.
Nosso trabalho se aproximou muito da proposta apresentada por Santoso e
Pulungan (2013). Eles decidiram desenvolver a sua arquitetura a partir do método de
Viola-Jones por considerar o seu alto grau de precisão e velocidade. Desenvolveram
então uma arquitetura paralelizada em CPU assim como o presente trabalho.
Consideramos também a importância do problema sobre os 4 pontos de vista citado
na publicação. Porém a arquitetura projetada se baseia numa implementação de
série existente, disponível na biblioteca OpenCV. Para fins acadêmicos e de
aprendizado, nós consideramos implementar um sistema desde o estágio inicial, o
que nos ofereceu maior escalabilidade e liberdade de otimização de código. Santoso
e Pulungan (2013) escolheram explorar e paralelizar a última das três fontes
mencionadas na abordagem de taxanomia de processamento de dados, mais
especificamente o processamento de classificadores, onde cada classificador é
independente e pode ser calculado em paralelo. Nós decidimos paralelizar a
aplicação em dois módulos distintos: extração de características das amostras e
localização da face. Para o trabalho proposto, a etapa pré-localização é tão
importante quanto a localização na medida que acelera o processo de treinamento e
construção de novos classificadores, pois é uma das grandes desvantagens do
método proposto por Viola e Jones (2001).
Gaower e Cheming (2011) e Jain e Patel (2016) adotaram abordagens muito
semelhantes. Ambos também optaram por utilizar o algoritmo de Viola-Jones,
porém, nestes trabalhos, a GPU foi escolhida para realizar o processo de
paralelização. Nós consideramos uma decisão acertada, mas, como nosso trabalho
foi pensado para utilizar plataformas como PC Desktop e Cluster com múltiplos
núcleos de CPU essa ideia foi descartada.
31
3 DETECÇÃO DA FACE
Um sistema de detecção de faces normalmente é composto pelas seguintes
etapas: pré-processamento do conjunto de imagens, extração de características,
treinamento do classificador e por fim localização da face. A primeira etapa é
responsável por realizar operações de processamento das imagens no conjunto de
entrada. Na extração de características as amostras processadas serão computadas
a fim de extrair características para o treinamento de um classificador. No
treinamento, essas características serão fundamentais para diferenciar o que
pertence ao conjunto de interesse e o que não pertence. A etapa de treinamento irá
gerar parâmetros que serão utilizados na localização da face. A partir destes
parâmetros, o estágio final é capaz de localizar faces em uma imagem.
Figura 3-1: Visão geral do Detector Facial.
3.1 Processamento de Imagens Digitais
Uma imagem digital pode ser definida por uma função bidimensional f(x,y), na
qual x e y são coordenadas espaciais(plano), e a amplitude de f em qualquer par de
coordenadas(x,y) é chamada de intensidade ou nível de cinza da imagem nesse
ponto. Quando x,y e os valores da intensidade de f são quantidades finitas e
discretas, chamamos de imagem digital.
O pré-processamento tem como objetivo preparar a imagem digital para ser
usada em etapas posteriores. Primeiramente convertemos o espaço de cor da
imagem para cinza, caso a imagem de entrada seja colorida. Cada pixel da imagem
cinza é calculado a partir da média ponderada das componentes de cor do
respectivo pixel RGB (do inglês, red green blue) da imagem colorida.
32
𝑢 = 𝑟 ∗ 0.3 + 𝑔 ∗ 0.59 + 𝑏 ∗ 0.11 . (7)
Onde (r,g,b) são os três valores do pixel da imagem original ou colorida e u o
valor correspondente ao pixel da imagem cinza.
3.2 Características de uma face
Para a detecção de um objeto, o detector precisa ter um conjunto de
características que o permitam encontrar o objeto de interesse. As características
são usadas como método de extração de dados, pois cada conjunto delas são
altamente distintivas.
3.2.1 Caracteristicas Haar-like
Existem muitas motivações para o uso de características ao invés de pixels. A
razão mais comum é que o sistema baseado em função das características é muito
mais veloz que um sistema baseado em função dos pixels. Isso acontece porque o
número de características são consideravelmente inferiores ao número de pixels
numa imagem.
Considerando essas questões Viola e Jones (2001) propuseram a utilização
de funções básicas de Haar introduzido por Papageorgiu et al. (1988). Para ser mais
específico, eles usam três tipos de características.
1. Característica de dois retângulos: O valor é a diferença entre a soma dos
pixels dentro de duas regiões retangulares de mesmo tamanho.
2. Característica de três retângulos: O valor é a soma de um retângulo
central menos a soma dos dois retângulos das extremidades.
3. Característica de quatro retângulos: O valor é cálculo através da diferença
entre pares diagonais de retângulos.
33
Figura 3-2: Exemplos das características usada por Viola e Jones. Extraída de Viola e Jones, 2001, adaptada pelo autor.
A resolução base do detector tem 24 x 24, isso gera um conjunto bastante
grande de características, neste caso 160.000 mil. Viola e Jones (2001) deu o nome
desta versão aprimorada de características haar (do inglês, haar like features).
3.2.2 Imagem integral
Com o objetivo de acelerar o cálculo das características, usaram uma
representação intermediária da imagem chamada Imagem Integral, proposto por
CROW (1984). Nesta representação, cada ponto x,y da imagem contém o somatório
de pixels da origem da imagem até sua localização. Podendo ser calculada com
uma única passagem na imagem original, de acordo com a equação.
𝑖𝑖(𝑥, 𝑦) = ∑ 𝑖(𝑥′, 𝑦′)
𝑥′≤𝑥,𝑦′≤𝑦
, (8)
Onde ii(x,y) é a imagem integral calculada e i(x,y) é a imagem original, usando
os seguintes pares de recorrência;
𝑠(𝑥, 𝑦) = 𝑠(𝑥, 𝑦 − 1) + 𝑖(𝑥, 𝑦). (9)
34
𝑖𝑖(𝑥, 𝑦) = 𝑖𝑖(𝑥 − 1, 𝑦) + 𝑠(𝑥, 𝑦). (10)
Onde s(x,y) é a soma cumulativa da linha S(x,1) = 0 e ii(-1,y) = 0.
Desse modo, é possível encontrar o valor de uma área retangular qualquer
utilizando quatro pontos do vértice da área desejada. Na Fig.3-3 o valor da imagem
no ponto 1 é referente a soma de pixels do retângulo A. O valor do ponto 2 é A + B e
no ponto 3 é A + C, e na posição 4 é A + B + C +D. Dessa forma é possível calcular
a soma dentro do retângulo D em tempo constante realizando um simples cálculo 4
+ 1 – (2 + 3).
Figura 3-3: Cálculo da região D de uma imagem integral. Extraída de Viola e Jones, 2011.
3.3 Funções de classificação
Existem diversas abordagens que se propõe em construir um classificador
para detecção de objetos. Redes neurais, modelos gaussianos e SVM(do inglês,
Support Vector Machine) são alguns dos exemplos de classificadores utilizados e
citados na literatura. Viola e Jones (2001) optou por uma variante do algoritmo de
aprendizado AdaBoost, de Freund e Schapire (1995) para seleção de características
e treinamento do classificador.
Para que um classificador seja construído é necessário um conjunto de
características (do inglês, features) calculadas para cada imagem do conjunto de
35
amostras. Porém, um conjunto de 160.000 mil características associados a cada
amostra é um número muito maior que o número de pixels. Embora cada
característica seja calculada de forma eficiente, o processo completo seria muito
custoso. Para contornar esse problema o Adaboost seleciona um número muito
pequeno dessas características. A Fig.3-4 mostra um conjunto de características
altamente relevantes para uma face. Observa-se, na primeira característica, que a
região dos olhos geralmente é mais escura que a região das bochechas. Na
segunda característica, percebe-se a diferença entre as intensidades luminosas da
região dos olhos e do nariz.
Figura 3-4: Exemplos de características selecionadas pelo Adaboost. Extraída de Viola e Jones,
2001.
O AdaBoost utiliza uma combinação linear de vários classificadores fracos(do
inglês, weak learners), selecionando um pequeno número de características
significativamente relevantes para formar um classificador forte. O algoritmo abaixo
descreve o processo de treinamento do classificador:
Dado um conjunto de imagens (𝑥1, 𝑦1), … , (𝑥𝑚, 𝑦𝑛) onde
𝑦𝑖 = 0,1 para imagens positivas e negativas, respectivamente.
Inicializar os pesos 𝑤1,𝑖 = 1
2𝑚,
1
𝑙 para 𝑦0 = 0,1,
respectivamente, onde m e l são o número de imagens
negativas e positivas.
Para t = 1 até T:
1. Normalizar os pesos, 𝑤𝑡,𝑖 ← 𝑤𝑡,𝑖
∑ 𝑤𝑡,𝑗𝑛𝑗=1
36
2. Selecionar o melhor classificador fraco de acordo com
o seguinte erro poderado:
∈𝑡=𝑚𝑖𝑛𝑓,𝑝,𝜃 (∑ 𝑤𝑖|ℎ(𝑥𝑖,𝑓,𝑝,𝜃)− 𝑦𝑖|𝑖
3. Definir ℎ𝑡(𝑥) = ℎ(𝑥, 𝑓𝑡 , 𝑝𝑡, 𝜃𝑡), onde 𝑓𝑡 , 𝑝𝑡, 𝜃𝑡 são
minimizadores de 𝜖𝑡.
4. Atualizar os pesos:
𝑤𝑡+1,𝑖 = 𝑤𝑡,𝑖𝛽𝑡1−𝑒𝑖
Onde 𝑒𝑖 = 0 se o exemplo foi classificado
corretamente ou 𝑒𝑖 = 1 caso contrário , e 𝛽𝑡 =𝜖𝑡
1− 𝜖𝑡
O classificador forte é dado por:
𝐶(𝑥) = {1, ∑ 𝛼𝑡ℎ𝑡(𝑥) ≥
1
2
𝑇
𝑡=1
∑ 𝛼𝑡
𝑇
𝑡=1
0, 𝑐𝑎𝑠𝑜 𝑐𝑜𝑛𝑡𝑟á𝑟𝑖𝑜
Onde 𝛼𝑡 = 𝑙𝑜𝑔1
𝛽𝑡
O algoritmo apresentado por Viola e Jones (2001) obteve uma taxa de
detecção de 95% e uma a margem de falsos positivo inexpressiva diante do
conjunto total de imagens.
3.4 Cascata de classificadores
A maior vantagem em explorar o algoritmo de Cascata de Classificadores é a
sua capacidade de otimizar a taxa de detecção e reduzir drasticamente o tempo de
processamento. Este algoritmo consiste em criar N estágios dentro de uma cascata
usando funções de classificação do AdaBoost. Neste processo os estágios inicias
descartam um grande número de regiões que contém o objeto de interesse e os
estágios mais avançados se tornam cada vez mais eficazes evitando falsos positivos
nas regiões analisadas. Se uma região analisada pelo primeiro nível da cascata é
37
aceita, essa é direcionada para o próximo estágio, assim segue até o último estágio
da cadeia, se for aceita é considerada pertencente ao conjunto de interesse. Se em
qualquer estágio a região analisada for recusada, ela é imediatamente rejeitada e
não considerada como pertencente ao conjunto de interesse.
Figura 3-5: Funcionamento da Cascata de Classificadores.
O processo de construção da cascata é conduzido por um conjunto de metas
de detecção e desempenho determinada pelo algoritmo de classificação. O número
de estágios da cascata e o tamanho de cada estágio deve ser o suficiente para
alcançar boa taxa de acerto, baixa ocorrência de falsos positivos e redução no
tempo de processamento.
A taxa de falso positivo é dada por:
𝐹 = ∑ 𝑓𝑖
𝐾
𝑖=1
, (11)
Onde F é a taxa de falso positivo do classificador, K é o número de
classificadores 𝑓𝑖 é a taxa de falso positivo do i-ésimo classificador dos exemplos
que conseguem alcança-lo, a taxa de detecção é dada por:
𝐷 = ∑ 𝑑𝑖,
𝐾
𝑖=1
(12)
Onde D é a taxa de detecção do classificador, K é o número de
classificadores e 𝑑𝑖é a taxa de detecção do i-ésimo classificador dos exemplos que
38
conseguem alcança-lo. Atribuindo valores para taxa de detecção e falso positivo é
possível definir metas para cada estágio da cascata. Se uma taxa detecção de 0,9
pode ser alcançada pelo décimo estágio da cascata, então cada um dos estágios
possuem uma taxa de 0,99, pois 0,9 ≈ 0,9910. Embora esses números pareçam ser
difíceis de ser alcançados, torna mais simples, uma vez que necessite alcançar uma
taxa de falso positivo de aproximadamente 30% (0.3010 ≈ 6 × 10−6). No trabalho
apresentado por Viola e Jones (2001), o treinamento de uma cascata de
classificadores contou com 32 estágios e 4297 características. Para o treinamento
desse classificador, precisou-se de semanas numa máquina com um processador
de 466Mhz.
3.5 Localização da face
Para que o Detector final identifique as regiões classificadas corretamente é
necessário fazer uso dos conceitos de Janela de Busca e Múltipla Escala.
Como as características podem ser avaliadas em qualquer escala em tempo
constante através da técnica de Imagem Integral, a Janela de Busca é escolhida
para ser redimensionada em vez da imagem. Esta janela deve ser maior ou igual ao
tamanho da janela de treinamento, caso as imagens treinadas pelo Adaboost teve
resolução de 24 x 24, o tamanho mínimo da Janela de Busca deve manter essa
proporção.
A imagem deve ser percorrida pela Janela de Busca em um fator de
deslocamento ∆ em largura e altura até existirem janelas a serem analisadas.
Cuidados devem ser tomados para não exceder os limites de pixels da imagem
original. Por exemplo, se a imagem tem resolução de 640 x 480 e janela de busca
24 x 24, o deslocamento deve ser realizado até o pixel 616 no eixo x e 456 no eixo y.
A imagem também precisa ser percorrida em várias escalas. Então, é
necessário utilizar um fator 𝛿 de escalonamento da sub-janela ou Janela de Busca.
Ao fim do processo de deslizamento a imagem será percorrida novamente com um
novo tamanho da sub-janela. Também pode ser utilizada uma técnica chamada
pirâmide de imagem(do inglês, image pyramids) onde a imagem de entrada é
39
redimensionada em vários tamanhos menores através do fator de escalonamento
até alcançar o tamanho da Janela de Busca.
Alguns cuidados devem ser tomados na escolha de parâmetros para o
detector; O aumento no fator de deslocamento afeta positivamente a velocidade do
detector, mas por outro lado prejudica a precisão, isso acontece porque o salto
maior em pixels na imagem faz com que informações úteis sejam perdidas, gerando
assim uma taxa maior de falsos negativos. O aumento no fator de escalonamento
acarreta na redução da taxa de detecção, ao mesmo tempo que diminui a taxa de
falso positivos. Baseado em experimentos, Viola e Jones (2001) sugeriu 1,25 como
valor ideal para o fator de escalonamento e 1 para deslocamento.
40
4 PARALELIZAÇÃO DO DETECTOR FACIAL
Na seção anterior, dividimos o sistema de detecção facial em quatro etapas:
pré-processamento do conjunto de imagens, extração de características,
treinamento do classificador e localização da face. Pensando em acelerar o
processo de treinamento e principalmente a detecção facial, as etapas de extração
de características e localização da face foram implementadas em uma arquitetura
paralelizada projetada para trabalhar em ambiente multiprogramado.
4.1 Paralelismo
Segundo Tanembaum (2003), em um sistema mutiprogramado, a CPU salta
de programa para programa, executando cada um deles na velocidade de dezenas
ou centenas de milissegundos. Para ser preciso, enquanto a cada instante a CPU
executa somente um programa, no decorrer de um segundo ela pode trabalhar
sobre vários programas, dando aos usuários a ilusão de paralelismo. Essa sensação
é chamada de pseuparalelismo. Para contrastar com o verdadeiro paralelismo de
hardware de sistemas com multiprocessadores(que tem duas ou mais CPUs
compartilhando mesma memória física). Ter controle sobre múltiplas atividades em
paralelo é uma tarefa muito difícil para as pessoas. Contudo, projetistas de sistemas
operacionais vem desenvolvendo ao longo dos anos modelos conceituais que
facilitem o paralelismo.
4.1.1 Processos
No geral, processo é entendido como um programa em execução, porém, na
realidade, trata-se de uma estrutura mais complexa que contém, além do programa
no seu formato executável, todas as informações necessárias à execução e ao
controle da execução do mesmo.
O programa é uma entidade passiva, ou seja, pode ser visto como o conteúdo
de um arquivo em disco, enquanto que o processo é uma entidade ativa, possuindo
41
um contador de programa(PC), que específica a próxima instrução a ser executada,
e um conjunto de recursos a serem alocados.
Em sistemas operacionais mais antigos, cada processo possuía um único
fluxo de controle, ou seja, as instruções são executadas seqüencialmente. Já nos
sistemas mais modernos, um processo pode inicializar um ou mais subprocessos,
que são executados em paralelo ou de forma concorrente com o processo pai e,
para todos os efeitos, apresentam as mesmas características e particularidades de
um processo qualquer, no que diz respeito a contexto e fluxo de controle
Tabela 4-1: Contexto de um processo.
Processo
Contador de programa
Pilha
Conjunto de registradores
Registradores de estado
Espaço próprio de endereço
Variáveis globais
Arquivos abertos
Semáforos
Informações de contabilização
Processos filhos
4.1.2 Estados de um processo
A execução de um processo se inicia com sua criação e carga em memória,
para que de lá possa ser escalado para tomar o controle da UCP (unidade central de
processamento) e realizar seu processamento. Quando em memória, o processo
pode estar em três estados: em execução, em espera ou no estado de pronto para
execução.
Um processo para poder ser escalado para execução precisa estar no estado
de pronto (do inglês, ready). Um processo em execução pode perder o controle da
UCP de forma voluntária (quando ele próprio realiza uma operação de
42
Entrada/Saída) ou de forma involuntária (quando por algum critério gerencial o
próprio sistema operacional retoma o controle da UCP). Um processo em estado de
espera fica nesta situação até que sua pendência seja satisfeita e de lá passa para o
estado de pronto.
Quando um processo em execução solicita um recurso que não está
disponível naquele momento (como por exemplo a alocação de um arquivo ou de
um periférico) ou cuja obtenção seja operacionalizada fora da UCP (como por
exemplo leitura de registros em disco), ele automaticamente perde o controle da
UCP e passa do estado de execução para o de espera.
O processo estando no estado de espera passa para o estado de pronto
assim que tiver sua solicitação de recurso aceita pelo sistema. No estado de pronto
ele está em condições de reiniciar sua execução e fica aguardando apenas chegar
sua vez de retomar o controle da UCP.
Figura 4-1: Estados de um processo.
Os sistemas preemptivos admitem interromper a execução de um processo
toda vez que seu tempo (do inglês, quantum) permitido para alocação da UCP
expirar, pode ocorrer que um processo saia da UCP direto para o estado de pronto,
ao invés de espera. Dessa forma um processo pode mudar de estado diante de um
evento originado por ele.
43
4.1.3 Escalonamento de processos
Os principais objetivos do escalonamento (do inglês, scheduling) de
processos são:
Manter a UCP ocupada a maior parte do tempo.
Balancear a utilização do processador pelos processos em execução.
Garantir tempos de resposta razoáveis aos usuários.
Maximizar o throughput (capacidade de atendimento a processos) do
sistema.
Para atender tais objetivos, muitas vezes conflitantes, os SOs precisam levar
em consideração:
Características dos processos em execução (batch, interativo, tempo-
real, CPUbounded, IO_bounded).
Características da instalação.
Disponibilidade de recursos.
O escalonamento dos processos é realizado por um módulo do sistema
operacional chamado de dispatcher (scheduler). Existem diversos com a mesma
finalidade e cada um apresenta características próprias favorecendo um ou outro
critério para a escolha do próximo processo a tomar o controle da UCP. Os critérios
geralmente considerados incluem os seguintes parâmetros ou medidas de eficiência:
·
Utilização da UCP - o desejado é manter a UCP mais ocupada possível.
O grau de utilização da UCP varia de 0 (idle) a 100%. Geralmente a
ocupação da UCP gira no entorno dos 40% para sistemas com carga
moderada e aproximadamente 90% para os com carga pesada.
throughput - medida que representa o número de processos concluídos
por unidade de tempo.
44
turnaround time - mede o tempo total gasto na execução de um
processo, desde o momento em que ele é submetido até o instante em
que é finalizado.
response time - mede o tempo entre a submissão do processo até o
momento que ele gera a primeira resposta ao usuário.
waiting time - mede o tempo em que o processo fica aguardando por
execução na fila de processos prontos (do inglês, ready queue).
Existem basicamente dois tipos de algoritmos para escalonamento de
processos: O preemptivo que pode interromper um processo em execução, tirando-
lhe o controle da UCP e repassa-la para outro processo que estiver na fila de
espera. O não preemptivo que tem a autonomia de utilizar a UCP, nenhum outro
processo ou o próprio SO pode lhe tirar este recurso, ele manterá o uso da UCP
pelo tempo que necessitar.
4.2 Paralelização em MATLAB
A plataforma MATLAB fornece a seus desenvolvedores uma biblioteca para
computação paralela com uma série de recursos e ferramentas, para a solução de
problemas envolvendo multiprocessadores, GPUs e clusters.
A computação paralela em MATLAB permite a realização de muitos cálculos
em simultâneo. Dessa forma grandes problemas podem ser resolvidos dividindo o
código em pedaços menores com a finalidade de executá-los ao mesmo tempo. As
principais razões para considerar a computação paralela são:
Economia de tempo através de distribuição de tarefas e execução simultânea
Resolver problemas de imenso volume de dados(do inglês, big data) através
da distribuição desses dados.
Tirar proveito de recursos em computadores pessoais, acelerar clusters e
computação em nuvem.
Com a ferramenta de computação paralela do MATLAB é possível:
45
Acelerar o processamento do código usando ferramentas iterativas de
computação paralela, como parfor e parfeval.
Ampliar a computação usando ferramentas iterativas de processamento Big
Data.
Usar gpuArray para acelerar o cálculo de implementações em GPU.
Usar batch para executar cálculos em clusters e computação em nuvem.
Quando se inicia uma rotina de laço iterativo em paralelo(parfor) no MATLAB
cria-se uma sessão de trabalhadores(do inglês, workers) para execução dessas
iterações. Cada iteração executada em paralelo em MATLAB devem ser
completamente independentes de todas as outras. Dada uma rotina A o cálculo de
um worker de valor A(100) pode não ser o mesmo realizado pelo worker do valor
A(500). Não há nenhuma garantia de sequência, de modo que A(900) pode ser
calculado antes de A(400).
Figura 4-2: Exemplo de um conjunto de trabalhadores (workers) preparados para paralelização de um laço iterativo (parfor). Extraída de https://www.mathworks.com/help/distcomp/getting-started-with-
parallel-computing-toolbox.html. Acesso em: 15 Out. 2016.
É possível decidir a quantidade de workers utilizados na aplicação
desenvolvida. A função parpool(n); abre um a sessão paralelizada com n workers e
a função delete(gcp) obtém e fecha a sessão.
Um worker em MATLAB é visto pelo Sistema Operacional como um processo,
no momento que um processo fica responsável por calcular uma rotina de código ele
46
é enviado pra memória no estado de pronto até que seja escalado pelo SO para
tomar o controle da UCP e realizar o processamento do código desejado, no
momento do processamento este processo passa para o estado de em execução e
após realizar a operação passa para o estado de finalizado, assim esse
procedimento se repete até completar o processamento de todo laço iterativo(for).
Se for definido pelo usuário que a sua aplicação desenvolvida necessite
trabalhar com mais de um worker, por exemplo 4, são criados 4 processos pelo
sistema operacional e junto a outros processos que estão na fila para serem
executados o SO realizará o escalonamento.
Figura 4-3: Resultado de um laço iterativo paralelizado com 4 workers.
Na Fig.4-4 obtemos uma saída do laço iterativo parfor que é completamente
inesperado caso fosse implementado com o laço for, logo não há qualquer garantia
de ordem na execução dos processos devido ao escalonamento realizado pelo SO.
Figura 4-4: Uso de processamento da CPU executando 4 processos(workers) do MATLAB.
47
Segundo Tanembaum (2003) os objetivos de um escalonador de processos
(dispatcher) é manter a UCP ocupada a maior parte do tempo e balancear a
utilização do processador pelos processos em execução. Na Fig.4-5, nota-se como
esses objetivos foram bem cumpridos, pois a CPU trabalha a todo tempo em 100% e
consegue balancear bem os processos, mantendo aproximadamente um uso de
25% para cada um. Obviamente, a outros processos sendo executados em
simultâneo com os processos do MATLAB, mas com uma carga de uso da CPU bem
menor.
Figura 4-5: Gráfico que demonstra a escalabilidade do uso de vários trabalhadores(workers). Extraída dehttps://www.mathworks.com/help/distcomp/getting-started-with-parallel-computing-toolbox.html.
Acesso em: 15 Out. 2016.
A Fig.4-6 mostra a escalabilidade de um PC multicore, observa-se que a
aceleração na paralelização é significante até 8 workers, a partir disso o ganho se
torna inexpressivo.
4.3 Sistema proposto
A aplicação desenvolvida utilizou da abordagem de Viola e Jones (2011) para
implementação de um detector facial automatizado. Como citado no início deste
capitulo o sistema é dividido em 4 etapas: pré-processameto das imagens, extração
48
de características, treinamento de um classificador e localização da face.
Paralelizando duas dessas etapas.
4.3.1 Plataforma de desenvolvimento
A plataforma de desenvolvimento escolhida para a implementação da
aplicação foi o MATLAB R2014b. Os principais motivos para a escolha do software
foi a sua praticidade em trabalhar com matrizes e sua coleção de bibliotecas de
funções específicas para Visão Computacional. Especialmente o Parallel Computing
Toolbox e Computer Vision System Toolbox. O software foi executado no sistema
Microsoft Windows 10.
4.3.2 Base de dados
A base de dados utilizada para o treinamento do classificador, contém um
total de 15000 imagens. Deste conjunto, 5000 são imagens de faces retiradas do
banco de dados Faces in the wild. As outras 10000 são imagens de ambientes
internos e externos que não contém faces. Elas foram obtidas em visita ao site
SciSoftware, que oferece um conjunto de 3000 imagens negativas. Foi criado duas
rotinas, uma para recortar o conjunto de imagens negativas em pedaços menores de
mesmo tamanho gerando outro conjunto de 10000 imagens, e outra para
redimensionamento de todas as imagens para a resolução escolhida, neste caso foi
24 x 24.
4.3.3 Treinamento
Inicialmente todas as imagens para o treinamento são convertidas para o
espaço de cor cinza, os templates escolhidos para extração de características do
conjunto de amostras foram de dois, três e quatro retângulos como observado na
Fig.4-6.
49
Figura 4-6: Conjunto das características utilizadas na implementação do sistema. Extraída de Viola e Jones, 2001, adaptada pelo autor.
Para paralelização desta etapa, cada escopo de código dentro do parfor são
rotinas sem quaisquer dependências entre as iterações. Dessa forma, os
workers(processos) se intercalam para calcular os valores das features do conjunto
de amostras do treinamento como visto da Fig. 4-7. Milhares de features são usadas
e calculadas por amostra, cada worker é responsável por calcular todo esse
conjunto de features por amostra, quando seu processamento é finalizado toma
posse de uma nova imagem. No fim deste processo será gerado duas matrizes, uma
contendo o conjunto dos valores das características calculadas para cada amostra
positiva e um outro para negativas.
Figura 4-7: Exemplo do cálculo das características em paralelo. Cada amostra usa milhares de características e são calculadas por um worker.
Estas matrizes serão passadas como parâmetro para a função Adaboost.m
construir o classificador. O classificador treinado é composto por 14 estágios e 65
50
classificadores fracos e irá gerar um conjunto de parâmetros do classificador que
será usado para detecção das faces na etapa de localização.
4.3.4 Localização da face
Para a implementação do detector facial, cada imagem de entrada é
transformada para imagem em cinza e os parâmetros para localização são definidos
previamente. O fator de escala e deslocamento usados foram de 1,25 e 1,
respectivamente. O tamanho da janela de busca tem resolução base de 24 x 24. Em
seguida a imagem convertida e os parâmetros são enviados para a função de
detecção da face paralelizada (parallelDetection.m). A classificação realizada em
cada sub-janela na imagem é totalmente independente, dessa forma
implementamos um detector paralelizado que utiliza os workers do MATLAB, onde
esses se intercalam para o cálculo dessas sub-janelas como observado na Fig.4-8.
Figura 4-8: Paralelização do detector facial usando 4 workers. Cada quadrado verde é o processamento da região por um worker, quando um worker finaliza seu processamento passa a
calcular uma nova região.
51
Os workers se intercalam para o cálculo da região de classificação, caso uma
região já tenha sido calculada, o worker tomará posse de uma nova região, até não
sobrar nenhuma sub-janela para ser processada, ao fim deste processo, a imagem é
redimensionada em tamanhos menores usando a técnica de pirâmides de imagem.
As escalas serão reduzidas de acordo com o parâmetro de escala 1,25 até alcançar
o tamanho da Janela de Busca de 24x24. Após realizada a classificação em toda a
imagem em diferentes escalas, poderá ocorrer efeitos de sobreposição( do inglês,
overlaps), onde muitas detecções podem se sobrepor ao redor da face. Para
solucionar este problema, uma rotina de agregação de janelas retorna apenas uma
delas que será a detecção candidata.
52
5 AVALIAÇÃO DE RESULTADOS
Este capítulo tem por objetivo apresentar uma metodologia para a avaliação
de performance e tempo de execução do detector e analisar o comportamento dos
experimentos realizados.
5.1 Metodologia
Com a finalidade de avaliar a acurácia do detector foram usadas 500 imagens
para teste, com variação angular das faces e diferentes condições de iluminação.
Dessas uma parte foi coletada manualmente na internet e a outra foi obtida do
Dataset do MIT + CMU. Este mesmo conjunto de imagens foi utilizado para avaliar o
tempo de execução do detector e tempo de processamento do extrator de
características.
Para se avaliar o sistema de maneira sistemática alguma métrica de avaliação
deve ser utilizada. A análise de Características de Operação do Receptor (ROC, do
inglês receiver operating characteristic) é capaz de extrair interpretações e analisar
resultados de um classificador a partir de uma curva. Foi introduzida em
Aprendizagem de Máquina e Mineração de dados, considerada uma ferramenta útil
e poderosa para a avaliação de modelos de classificação. Particularmente em
domínios nos quais existe uma grande desproporção entre as classes ou quando se
deve levar em consideração diferentes custos/benefícios para os diferentes
erros/acertos de classificação. Considerando um problema com apenas duas
classes (p – classe positiva, n – classe negativa). Alguns termos são comumente
utilizados em métricas de avaliação:
Verdadeiro positivo (VP) – O elemento de entrada é classificado como
pertencente ao conjunto de interesse.
Verdadeiro Negativo (VN) – O elemento de entrada é classificado como não
pertencente ao conjunto de interesse.
Falso positivo (FP) – O elemento de entrada é classificado erroneamente
como pertencente ao conjunto de interesse.
53
Falso negativo (FN) – O elemento de entrada é classificado erroneamente
como não pertencente ao conjunto de interesse.
Dado esses termos as medidas utilizadas para se avaliar um classificador são:
Taxa de acerto = 𝑉𝑃
𝑉𝑃+𝐹𝑁
Precisão = 𝑉𝑃
𝑉𝑃+𝐹𝑃
Exatidão = 𝑉𝑃+𝑉𝑁
𝑉𝑃+𝑉𝑁+𝐹𝑃+𝐹𝑁
Para a avaliação do tempo de detecção, executamos imagens em diferentes
resoluções em um ambiente programado para rodar com até 4 workers. Os testes
foram realizados 4 vezes para cada imagem e o resultado é uma média aritmética
das 4 verificações. Para o extrator de características realizamos duas rotinas de
teste, uma rodando em série e outra em paralelo(4 workers) usando o conjunto de
15000 imagens do treinamento.
5.2 Resultados experimentais
Os resultados foram obtidos através de uma sequência de rotinas de teste
executadas em um PC Desktop Intel Core i7 3.4 GHz de 4 núcleos físicos e 16gb de
memória RAM de 1333MHz. A Fig.5-1 mostra exemplos de sucesso do detector
implementado e a Tabela 5-1 apresenta um comparativo entre nossa implementação
e o método de Viola e Jones. A Fig.5-2 mostra problemas na detecção das faces,
apresentando falsos positivos e falsos negativos.
54
Figura 5-1: Exemplos de Resultados que obtiveram o melhor desempenho.
Tabela 5-1: Comparação da taxa de acerto entre o Detector desenvolvido e o método original.
Taxa de Acerto
Detector desenvolvido 83%
Viola-Jones 95%
De forma geral os resultados da detecção se mostraram bons em relação ao
método de Viola e Jones, os casos de falsos positivos foram poucos, isso é reflexo
do número de amostras utilizadas para o treinamento, fazendo com que o
classificador seja capaz de realizar operações de comparação entre as amostras,
selecionando características que diferenciem face de não face com maior eficácia.
Foram realizados vários testes alterando o fator de escala e deslocamento, mas os
valores definidos por Viola e Jones (2001) obtiveram o melhor equilíbrio entre taxa
de detecção e tempo de processamento.
55
Figura 5-2: Exemplos de resultados com problemas de falsos positivos e falsos negativos.
Os falsos negativos que apareceram nos testes podem ser consequência do
número de estágios e classificadores utilizados, que influenciam eliminando muitas
regiões promissoras durante o processo de cascata. Provavelmente um número
menor reduziria esta taxa, mas por consequência surgiriam mais problemas de
falsos positivos. Nas nossas observações a variação angular das faces e uso de
acessórios também contribuem para erros na detecção. Para contornar isso seria
interessante utilizar um Dataset de treino com maior variação de faces.
56
Figura 5-3: Curva ROC do classificador.
A tabela 5-2 demonstra o ganho de tempo do processamento em segundos
de algumas imagens em diferentes resoluções sendo executadas com até 4
workers.
Tabela 5-2: Resultados comparativos da aplicação executada em múltiplos núcleos e diferentes resoluções de imagem.
300x182 (s) 600x400 (s) 960x720 (s) 2000x1000 (s)
1 worker 2.1955 9.5244 28.4927 84.4053
2 workers 1.6757 5.3735 14.7318 43.1638
3 workers 1.2899 4.2724 11.1514 32.1582
4 workers 1.2663 3.7763 9.7064 27.9790
Observa-se que em todas as resoluções o ganho de 1 worker para 4 workers
foi significativo, reduzindo o tempo em todos os casos para mais da metade.
Portanto, essa vantagem reduz à medida que se trabalha com mais workers, como
foi mostrado na seção 4.2, a paralelização em MATLAB demonstra uma boa
escalabilidade até 8 workers, depois disso o ganho se torna inexpressivo. Nota-se
também como o método de Viola-Jones demonstra um desempenho ruim para
57
imagens em alta resolução, portanto, a aplicação paralelizada beneficia
consideravelmente estes casos, na imagem de 2000x1000 o tempo com 4 workers
foi 3 vezes mais veloz comparado aos resultados obtidos ao executar com apenas 1
worker. Estes testes podem apresentar resultados diferentes se executados em
outras configurações ou se um outro conjunto de imagens for utilizado,
principalmente imagens com número maior de faces.
Tabela 5-3: Resultado comparativo do extrator de características sendo executado em série e paralelo.
Extração das caraterísticas (s)
Em série 5020.0555
Paralelizado (4 workers) 236.8353
O comparativo entre o extrator de características em série e paralelizado
demonstra uma diferença em tempo de execução muito significativa, a extração das
características executada em paralelo chega a ser aproximadamente 21,19 vezes
mais rápida que a extração em série, estes resultados são animadores pois reduzem
consideravelmente o tempo de treinamento de um classificador.
58
6 CONCLUSÃO
Neste trabalho, foi realizado o estudo de artigos do Estado da Arte sobre
sistemas automatizados de detecção facial e paralelização de detectores. Propomos
a implementação de um sistema completo desde seu estágio inicial com base no
método de Viola e Jones e paralelizamos duas etapas desde método com o intuito
de melhorar o tempo de detecção do classificador e do treinamento. Para comparar
o nosso trabalho com os artigos estudados realizamos uma avaliação detalhada da
nossa aplicação.
Utilizamos de métricas para avaliar a qualidade de detecção e o tempo de
localização das faces. Os resultados obtidos em relação a qualidade demonstraram
uma boa taxa de detecção com poucos falsos positivos e negativos, porém, uma
taxa de acerto inferior ao trabalho de Viola e Jones (2001).
Em relação ao tempo nosso trabalho se mostrou muito expressivo a medida
que a aplicação trabalhava com mais núcleos, principalmente quando imagens de
alta resolução eram utilizadas. Apesar do ganho significativo no tempo de detecção
ao usar paralelismo, consideramos que o método de Viola e Jones puro não é ideal
para detecção de imagens de alta resolução, tornando o processo de detecção
muito lento e custoso. Porém, a escolha da aplicação paralelizada beneficiou esses
casos, acelerando o processo de detecção em até 3 vezes. A paralelização na
extração de características apresentou resultados surpreendentes, sendo muito
efetivo para redução no tempo de treinamento.
Para melhorar o desempenho do sistema, sugerimos para trabalhos futuros
combinar o classificador com uma outra técnica de detecção para melhorar ainda
mais a precisão de detecção, executar o trabalho desenvolvido em cluster e estudar
a viabilidade de paralelização em GPU.
59
REFERÊNCIAS
BHUTEKAR, Shivashankar; MANJARAMKAR, Arati. Parallel face Detection and
Recognition on GPU. Intertional Journal of Computer Science and Information
Technologies, v. 5, n. 2, p. 2013-2018, 2014.
CHOUCHENE, Marwa et al. Optimized parallel implementation of face detection
based on GPU component. Science Direct, v. 39, p. 393-404, 2015.
CROW, Franklin. Summed-area tables for texture mapping. In Proceedings of
SIGGRAPH, v. 18(3), p. 207–212, 1984.
DAVIS, William S., Sistemas Operacionais - Uma Visão Sistemática, Ed. Campus,
1990.
FLYNN, Michael. Some Computer Organizations and Their Effectiveness. IEEE
Transactions on Computers, v. c-21, n. 9, 1972.
FREUND, Yoav; SCHAPIRE, Robert E. A decision-theoretic generalization of on-
line learning and an application to boosting. In Computational Learning Theory:
Eurocolt ’95, p. 23–37, 1995.
FREUND, Yoav; SCHAPIRE, Robert E. A Short Introduction to Boosting. Journal
of Japanese Society for Artificial Intelligence, v. 5, n. 14, p. 771-780, 1999.
GAOWEI; CHEMING. The face detection system based on GPU+CPU desktop
cluster. IEEE, 2011.
GONZALEZ, R. C.; WOODS, R. E. Digital Image Processing. Third edition. New
Jersey Pearson Prentice Hall, 2008.
JAIN, Vaibhav; PATEL, Dinesh. A GPU based implementation of Robust Face
Detection System. Procedia Computer Science, p. 156-163, 2016.
60
LI, Gang et al. An Improved AdaBoost Face Detection Algorithm Based on
Optimizing Skin Color Model. Sixth International Conference on Natural
Computation, 2010.
MACHADO, Francis; Maia, Luiz. Introdução à Arquitetura de Sistemas
Operacionais, Ed. LTC, 1994.
MATHWORKS. Parallel Computing Toolbox Documentation. Disponível em
https://www.mathworks.com/help/distcomp/getting-started-with-parallel-computing-
toolbox.html. Acesso em: 15 Out. 2016.
PRATI, R. C. et al. Curvas ROC para avaliação de classificadores. IEEE, 2008.
PARAGEORGIU, Constantine et al. A general framework for object detection. In
International Conference on Computer Vision, 1998.
SANTOSO, Hadi; PULUNGAN, Reza. A Parallel Architeture for Multiple-Face
Detection Technique Using AdaBoost Algorithm and Haar Cacade. Information
Systems International Conference (ISISCO), p 2-4, 2013.
SAKAI, Toshiyuki et al. Computer Analysis and Classification of Protographs of
Human Faces. First USA-JAPAN Computer Conference, p-5562, 1972.
SCISOFTWARE. Tutorial: OpenCV haartraining (Rapid Object Detection With a
Cascade of Boosted Classifiers Based on Haar-like features). Disponível em
http://note.sonots.com/SciSoftware/haartraining.html. Acesso em: 05 Out. 2016.
SCHAPIRE, Robert E. et al. Boosting the margin: A new explanation for the
effectiveness of voting methods. Ann. Stat., v. 26(5), p. 1651–1686, 1998.
SHEKHAR, Deepak; VARAGANTI, Kiran. Parallelization of Face Detection
Engine. 39th International Conference on Parallel Processing Workshops, 2010.
61
SUNG, Kah-Kay; POGGIO, Tomaso. Example-Based Learning for View-Based
Human Face Detection. IEEE Patt. Anal. Mach. Intell., v. 20, p. 39–51, 1998.
TANEMBAUM, Andrew. Sistemas Operacionais Modernos. Segunda Edição,
Pearson Education do Brasil, 2003.
VIOLA, Paul; JONES, Michael. Rapid object detection using a boosted cascade
of simple features. Conference on Computer Vision and Pattern Recognition, 2001.
VIOLA, Paul; JONES, Michael. Robust Real-Time Face Detection. International
Journal of Computer Vision, v. 2, n. 57, p. 137-154, 2004.
ZHANG, Cha; ZHANG, Zhengyou. A Survey of Recent Advances in Face
Detection. Microsoft Research, 2010.