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
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
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.
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.
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
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
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.
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.
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
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.
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
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.
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
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
𝑢 = 𝑟 ∗ 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.
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, 𝑦) + 𝑠(𝑥, 𝑦). (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
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, 𝑤𝑡,𝑖 ← 𝑤𝑡,𝑖
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 é
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
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 é
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.
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
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
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.
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.
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.
