Capítulo

8Visão computacional em python utilizando as bi-bliotecas scikit-image e scikit-learn

Romuere R. V. Silva, José G. F. Lopes, Flávio H. D. Araújo, Fátima N. S.Medeiros e Daniela M. Ushizima

Abstract

Computer vision algorithms use matrices as input and produce a more compact informa-tion as output. These algorithms play a major role in applications of object classificationand scene identification captured digitally. Nowadays, there are several libraries that im-plement computer vision algorithms. Our focus is to present python-based libraries, suchas scikit-image and scikit-learn, that provide functions for digital image processing andmachine learning, respectively. These open-source libraries allow writing sophisticatealgorithms to solve problems in classification, clusterization, and content-based imageretrieval. We illustrate the application of these libraries by describing a computer vi-sion workflow that detects real situations of traffic imprudence from surveillance cameraimages.

Resumo

Algoritmos de visão computacional utilizam matrizes como entrada e produzem uma in-formação mais compacta como saída. Esses algoritmos são utilizados em aplicações paraclassificação de objetos e cenas capturadas digitalmente. Atualmente existem diversas bi-bliotecas que implementam algoritmos de visão computacional. Nosso foco é apresentaras bibliotecas scikit-image e scikit-learn, que possuem funções de processamento digi-tal de imagens e aprendizado de máquina, respectivamente. Essas bibliotecas de códigoaberto permitem a escrita de sofisticados algoritmos para resolver problemas em classi-ficação, clusterização e recuperação de imagens baseada em conteúdo. Nós ilustramosa aplicação dessas bibliotecas descrevendo um sistema de visão computacional para umproblema real de imprudência no trânsito utilizando imagens de câmeras.

III Escola Regional de Informática do Piauí. Livro Anais - Artigos e Minicursos, v. 1, n. 1, p. 407-428, jun, 2017.www.eripi.com.br/2017 - ISBN: 978-85-7669-395-6

8.1. IntroduçãoA área de Visão Computacional utiliza modelos de descrição de objetos e cenas captura-das digitalmente para tomada de decisões, automatização de tarefas, seja na indústria demanufatura, farmacêutica, automobilística, dentre outras.

Atualmente existem diversas bibliotecas que implementam algoritmos de visãocomputacional tais como: OpenCV e Matlab. No entanto, as opções anteriores apre-sentam maiores desafios dado que a biblioteca OpenCV é geralmente usada por desen-volvedores mais avançados, e a licença do software Matlab apresenta custo elevado queinviabiliza seu uso em circunstâncias mais amplas, como em sala de aula, projetos deestudantes e pequenas empresas.

As bibliotecas scikit-image e scikit-learn são de código aberto e possuem umaextensa documentação com inúmeras funções para viabilizar o processamento digital deimagens, classificação, clusterização e recuperação de imagens baseada em conteúdo. Es-sas bibliotecas são utilizadas em diversas aplicações que dependem da linguagem pythonpara desenvolvimento.

Esse capítulo tem o objetivo de introduzir os principais comandos da linguagempython que habilitam o desenvolvedor a realizar processamento de imagens, includindoa utilização das bibliotecas scikit-image e scikit-learn aplicadas a um problema real deVisão Computacional.

8.2. Visão ComputacionalCom a popularização dos dispositivos eletrônicos para captura de imagens e vídeos, aanálise automática desses dados através de programas computacionais tornou-se essencialnas mais variadas áreas de domínio da ciência. Para isso, algoritmos e representaçõessão desenvolvidos para permitir que uma máquina reconheça objetos, pessoas, cenas eatividades. Nestes termos, o computador passa a desempenhar tarefas complexas e sercapaz de reconhecer objetos em figuras e filmes.

De forma geral, algoritmos de visão computacional utilizam matrizes bidimensi-onais ou hiperdimensionais como entrada e produzem uma informação mais compactacomo saída, como por exemplo a classificação de um objeto. No caso de decisões emsistemas de controle de qualidade de materiais, a tomada de decisão geralmente é ummódulo no sistema de monitoramento, responsável pela detecção de rachaduras a partirde imagens produzidas durante o processo de deformação para teste de resistência de ma-teriais cerâmicos. A Figura 8.1 ilustra a relação entre as áreas de visão computacional,computação gráfica e processamento digital de imagens. Usualmente estas áreas se con-fundem, contudo elas se diferenciam principalmente pelo tipo de dados na entrada e saídado sistema.

8.3. Problema AbordadoÉ extensa a lista de aplicações possíveis dos algoritmos de visão computacional, que sãoparticularmente relevantes na realização de tarefas insalubres e repetitivas que de outraforma seriam delegadas a seres humanos. Outras aplicações são auxiliar na percepçãorobótica, em agentes autônomos e aprimorar habilidades humanas tais como interface

Figura 8.1: Visão Computacional × Computação Gráfica × Processamento Digi-tal de Imagens. A entrada e a saída é o que define cada área. Adaptado de[Ushizima et al. 2014].

humano-computador e visualização.

Dentre as possíveis aplicações em visão computacional utilizaremos imagens detrânsito com foco na detecção de capacete de motociclistas. Alguns fatores determinam ointeresse nesse tipo aplicação: 1) o número de acidentes de trânsitos envolvendo motoci-clistas tem aumentado nos últimos anos em vários países; 2) motocicletas são os veículosque se tornaram mais populares devido ao seu baixo custo; 3) o principal equipamentode segurança é o capacete e, apesar disso, muitos motociclistas não fazem uso do equi-pamento ou mesmo o fazem incorretamente [Silva et al. 2017]. Utilizaremos uma basede imagens que possui 255 imagens com motociclistas que estão ou não fazendo uso docapacete1 adequadamente. A partir dessa base será possível realizar experimentos de seg-mentação para determinação de uma região de interesse, extração e seleção de atributos,e classificação. A Figura 8.2 mostra as principais etapas para a resolução do problemaabordado.

8.4. Segmentação de ImagensO processo de agrupamento dos pixels em uma componente conexa relevante é denomi-nado de segmentação. Esse processo consiste em subdividir uma imagem em regiões ouobjetos segundo um critério significativo. Agrupar pixels ou conjuntos de pixels está di-retamente relacionado ao problema em estudo e geralmente requer algoritmos iterativos.

A separação dos pixels relativos a cada objeto, ou região, é uma etapa fundamental

1Imagens disponíveis em https://github.com/romuere/databases

Figura 8.2: Metodologia fundamental para exploração de imagens usando visão compu-tacional conforme proposto nesse tutorial.

para o sucesso da análise da imagem. Embora o ser humano possa facilmente identificarregiões de características semelhantes ou objetos presentes em uma imagem, a realizaçãoda mesma tarefa por um computador requer a implementação de algoritmos especialistasem analisar características dos pixels ou da distribuição dos mesmos na imagem.

Em outras palavras, a segmentação é um processo que divide uma região espacial(imagem) R em n sub-regiões. O valor de n varia de acordo com o problema a ser traba-lhado. Por exemplo, no processamento e análise de imagens de células, a segmentaçãofrequentemente consiste em identificar três regiões (n = 3), a saber, fundo (background),citoplasma e núcleo.

Durante o processamento digital de imagens, uma das formas de particionar aimagens em subconjuntos de pixels é realizar limiarização através do método clássico deOtsu [Otsu 1979]. Nesse método, assume-se que a imagem possui duas classes de pixels:de primeiro plano e de fundo. Então, calcula-se o valor ótimo de limiar que separa asclasses de modo que a variação intra-classe seja mínima. O cálculo deste limiar é dadopor:

σ2w(t) = w0(t)σ2

0 (t)+w1(t)σ21 (t), (1)

em que os pesos w0(t) e w1(t) são as probabilidades das duas classes serem separadaspelo limiar t, sendo as variâncias dessas classes σ0 e σ1.

Para calcular o probabilidade da classe, utiliza-se o histograma com L = 256 níveisde cinza da imagem:

w0(t) =t−1

∑i=0

p(i)

w1(t) =L

∑i=t

p(i)

(2)

O algoritmo é definido da seguinte forma:

1. Calcule o histograma e as probabilidades para cada nível de intensidade;

2. Selecione os valores inicias para wi(0);

3. Passe por todos os valores possíveis de limiar de t = 0, ..., 255;

(a) Atualize os valores de wi;

(b) Calcule σ2j (t);

4. o valor ótimo será o máximo; σ2j (t).

Com o valor de limiar calculado, podemos obter uma segmentação como mostradona Figura 8.3.

Figura 8.3: Exemplar da base de imagens após a segmentação utilizando Otsu.

8.4.1. Código em python

Assim como a maioria das bibliotecas de processamento digital de imagens, o scikit-image possui a implementação do limiar de Otsu. O objetivo de utilizar essa rotina foiobter uma Região de Interesse (Region of Interest - ROI) com o recorte do segmentocontendo a cabeça do motociclista.

O Código Fonte 8.1 mostra os passos para realizar a segmentação de uma imagembaseado no limiar de Otsu. Após transformar a imagem em níveis de cinza em uma ima-gem binária (Linha 9), é feito um pós-processamento para remover pequenas regiões queforam segmentadas e que não fazem parte da região de interesse (Linhas 10 a 20), comomostra a Figura 8.4 com exemplos dessa etapa. Isso é feito para evitar que pequenasregiões, como cantos ou objetos, que não pertencem à região da cabeça do motociclista,sejam incluídos no recorte. O passo seguinte é fazer o recorte baseado na região segmen-tada e obter a imagem de onde serão extraídos os atributos para a posterior classificaçãodo segmento (Figura 8.5).

1 from skimage . i o i m p o r t imread # fu nc a o do p a c o t e skimage p a r a l e i t u r a deimagens

from skimage . c o l o r i m p o r t r g b 2 g r e y # fu nc a o que t r a n s f o r m a uma imagemRGB ( c o l o r i d a ) em n i v e i s de c i n z a

3 from skimage . f i l t e r s i m p o r t t h r e s h o l d _ o t s u # fu nc a o que implementa ol i m i a r de Otsu

i m p o r t numpy as np # p a c o t e py thon que o f e r e c e s u p o r t e a a r r a y s em a t r i z e s m u l t i d i m e n s i o n a i s

5 from skimage . measure i m p o r t l a b e l , r e g i o n p r o p s

7 pa th_ image = " / home / u s e r s / image . png " # e n d e r e c o da imagem

imagem = imread ( pa th_ image ) # l e i t u r a da imagem9 grey_ image = r g b 2 g r e y ( imagem ) # C o n v e r t e a s imagens em n i v e i s de c i n z a s

o t s u = t h r e s h o l d _ o t s u ( grey_ image ) /255 # C a l c u l a o l i m i a r u t i l i z a n d o ometodo de Otsu

11 img_o t su = grey_ image < o t s u # p i x e l s com v a l o r e s menores que ’ o t s u ’s e r a o brancos , ca so c o n t r a r i o s e r a o p r e t o s

13 #−−−−−−−−−−−−−−−−−−−−remove pequenas r e g i o e s−−−−−−−−−−−−−−−−−−−−#l a b e l _ i m g = l a b e l ( seg , c o n n e c t i v i t y = grey_ image . ndim ) # d e t e c t a r e g i o e s

nao c o n e c t a d a s15 p r o p s = r e g i o n p r o p s ( l a b e l _ i m g ) # c a l c u l a p r o p r i e d a d e i m p o r t a n t e s de cada

r e g i a o e n c o n t r a d a ( ex . a r e a )

17 # Conve r t t o d a s as r e g i o e s que possuem um v a l o r de a r e a menor que amaior a r e a em background da imagem

a r e a = np . a s a r r a y ( [ p r o p s [ i ] . a r e a f o r i i n r a n g e ( l e n ( p r o p s ) ) ] ) # a r e a decada r e g i a o e n c o n t r a d a

19 max_index = np . argmax ( a r e a ) # i n d e x da maior r e g i a of o r i i n r a n g e ( l e n ( p r o p s ) ) :

21 i f ( p r o p s [ i ] . a r e a < p r o p s [ a r e a ] . a r e a ) :l a b e l _ i m g [ np . where ( l a b e l _ i m g == i +1) ] = 0# r e g i a o menor que a

maior eh marcada como background23

l a b e l _ i m g = l a b e l _ i m g *1# t r a n s f o r m a imagem de v a l o r e s b o o l e a n o s p a r ai n t e i r o s

25

#−−−−−−−−−−−−−−−−r e c o r t e da r e g i a o de i n t e r e s s e −−−−−−−−−−−−−−−−#27 # Obtendo os l i m i t e s v e r t i c a i s das imagens segmen tadas

ymin = np . min ( np . where ( l a b e l _ i m g == True ) [ 1 ] )29 ymax = np . max ( np . where ( l a b e l _ i m g == True ) [ 1 ] )

imagem_cor tada = imagem [ : , ymin : ymax , : ]

Código Fonte 8.1: Método de Otsu aplicado a duas imagens.

Figura 8.4: Imagem processada após a retirada doe artefatos.

8.5. Extração de AtributosAtributos de forma, cor e textura são propriedades presentes em objetos registrados namaioria das imagens. Estas características podem ser quantificadas e usadas como descri-tores da imagem ou dos objetos numa cena. Esses descritores compõem um conjunto depropriedades representadas em um vetor de escalares, denominado descritor da imagem.

Figura 8.5: Exemplares da base de imagens após a determinação da região de interesse.

Assim sendo, cada objeto pode ser representado por um ponto em um espaço Rn, definidoem termos das n características extraídas. Em alguns casos, é desejável que os descrito-res apresentem a propriedade de invariância a transformações afins, ou seja, invariante arotação, escala, e translação.

Podemos representar uma região de dois modos: através de características exter-nas, pertencentes a fronteira, ou em termos de características internas, pertencentes aospixels que constituem a região. Escolher o modo de representação consiste em um passoessencial para permitir com que as imagens sejam processadas em um computador. Osegundo passo é descrever a região com base na representação escolhida.

Após a extração de atributos, todas as informações obtidas são agrupadas em umvetor de escalares denominado vetor de atributos. A Figura 8.7 mostra um exemplo deextração de atributos.

Figura 8.6: Extração de atributos para reconhecimento de padrões.

8.5.1. Matriz de Coocorrência de Níveis de Cinza

A matriz de coocorrência de níveis de cinza, do inglês Grey-Level Co-occurrence Ma-trix (GLCM) é uma técnica que tem como base a análise de textura em imagens. NaGLCM são analisadas as coocorrências existentes entre pares de pixels através de algumpadrão. A matriz GLCM é sempre quadrada e armazena as informações das intensida-des relativas dos pixels. Por este motivo, as imagens utilizadas são sempre em tons decinza [Haralick 1973].

As probabilidades de coocorrências são calculadas entre dois níveis de cinza i e j,utilizando uma orientação Θ e uma distância conhecida como espaçamento entre pares depixels. Essa orientação pode assumir os valores 0o, 45o, 90o e 135o graus. Para cada rela-cionamento espacial possível (distância e orientação) existe uma matriz de coocorrência.Desse modo, todas as informações sobre a textura de uma imagem estarão contidas nessamatriz [Baraldi and Parmiggiani 1995].

Figura 8.7: Exemplo de cálculo da matriz GLCM com espaçamento entre pares de pixelsigual a 1 e Θ = 0o. Intensidade de pixels da imagem (esquerda), GLCM (direita).

A Figura 8.8 mostra a matriz de coocorrência calculada para duas amostras da basede imagens de motociclistas. Pode-se observar a diferença do padrão de espalhamentoentre as matrizes (Figuras 8.8(b) e (d)), onde a primeira concentra informação ao longo dadiagonal, enquanto a outra apresenta transições entre níveis de cinza mais heterogêneas.

Haralick [Haralick 1973] definiu 14 características significativas para a GLCM hámais de quarenta anos atrás, e muitas outras medidas derivadas dessas foram acrescen-tadas [Sabino et al. 2004]. Contudo, a utilização de algumas dessas características podegerar melhor desempenho do que a utilização de todas. Assim, nesse trabalho são fei-tos cálculos dos seguintes atributos de textura: contraste (Equação 3), dissimilaridade(Equação 4), homogeneidade (Equação 5), energia (Equação 6), correlação (Equação 7)e segundo momento angular (ASM) (Equação 8).

Contraste =L−1

∑i, j=0

Pi j(i− j)2, (3)

onde L é a quantidade de níveis de cinza e P é a GLCM.

Dissimilaridade =L−1

∑i, j=0

Pi j|i− j|. (4)

Homogeneidade =L−1

∑i, j=0

Pi j

1+(i− j)2 . (5)

Energia =

√√√√ L−1

∑i, j=0

(Pi j)2. (6)

Figura 8.8: Amostras de imagens (a) e (c) e suas respectivas matrizes GLCM (b) e (d).

Correlacao =L−1

∑i, j=0

(i−µi)( j−µ j)Pi j√(σi)2(σ j)2

, (7)

onde µ é a média e σ é o desvio padrão.

ASM =L−1

∑i, j=0

(Pi j)2. (8)

8.5.1.1. Código em python

A obtenção da GLCM é realizada em duas etapas sendo a primeira o cálculo da matrizde coocorrências e a segunda o cálculo dos atributos de Haralick a partir dessa matriz. Abiblioteca sckit-image possui duas funções com esse objetivo: greycomatrix é responsável

por calcular a matriz e tem como parâmetros a imagem, o ângulo, e a distância. O parâme-tro normed é responsável por retornar a matriz normalizada caso seu valor seja atribuídocomo True; e greycoprops que recebe como parâmetro a matriz calculada anteriormentee o atributo que se deseja calcular. O Código Fonte 8.5 mostra as etapas de obtenção daGLCM.

from skimage . f e a t u r e i m p o r t g r e y c o m a t r i x , g r e y c o p r o p s # fu n ca o do p a c o t eskimage p a r a c a l c u l a r a m a t r i z GLCM e os a t r i b u t o s da m a t r i z

2

image_pa th = " / home / u s e r / image . png " # e n d e r e c o da imagem4 image = imread ( image_pa th ) # l e i t u r a da imagem

image_gray = r g b 2 g r e y ( image ) # t r a n s f o r m a r de RGB p a r a n i v e l de c i n z a6 d = 1 # d i s t a n c i a e n t r e p i x e l s p a r a GLCM

m a t r i x = g r e y c o m a t r i x ( image , [ d ] , [ 0 ] , normed=True ) # c a l c u l o da m a t r i zem 0 g r a u s

8 p r o p s = np . z e r o s ( ( 6 ) ) # v e t o r p a r a a rmazena r a t r i b u t o sp r o p s [ 0 ] = g r e y c o p r o p s ( ma t r ix , ’ c o n t r a s t ’ ) # c a l c u l a c o n t r a s t

10 p r o p s [ 1 ] = g r e y c o p r o p s ( ma t r ix , ’ d i s s i m i l a r i t y ’ ) # c a l c u l a d i s s i m i l a r i d a d ep r o p s [ 2 ] = g r e y c o p r o p s ( ma t r ix , ’ homogene i ty ’ ) # c a l c u l a homogeneidade

12 p r o p s [ 3 ] = g r e y c o p r o p s ( ma t r ix , ’ e ne rg y ’ ) # c a l c u l a e n e r g i ap r o p s [ 4 ] = g r e y c o p r o p s ( ma t r ix , ’ c o r r e l a t i o n ’ ) # c a l c u l a c o r r e l a c a o

14 p r o p s [ 5 ] = g r e y c o p r o p s ( ma t r ix , ’ASM’ ) # c a l c u l a segundo momento a n g u l a r

Código Fonte 8.2: Cálculo da matriz GLCM e dos atributos de Haralick.

8.6. Aprendizagem de Máquina e Classificação de ImagensA tarefa de reconhecer padrões equivale a classificar determinado objeto ou situação comopertencente ou não a um certo número de categorias previamente estabelecidas. Em al-goritmos de visão computacional o aprendizado de máquina é geralmente utilizado paraclassificar imagens. Para isso, são utilizados os vetores de atributos da etapa de extraçãode atributos.

Usualmente são utilizados algoritmos de aprendizado de máquina supervisiona-dos, ou seja, é preciso apresentar dados pré-classificados e “ensinar” o algoritmo a iden-tificar diferentes objetos. Nesse caso, é necessário uma base de dados que contenha aomenos parte dos dados previamente avaliados e rotulados por um especialista. Dessaforma o algoritmo poderá aprender os padrões dos objetos de cada classe. Os algo-ritmos de aprendizado de máquina supervisionados mais conhecidos são: Máquina deVetor de Suporte (SVM) [Cortes and Vapnik 1995], Perceptron de Múltiplas Camadas(MLP) [Haykin 2001] e Random Forest (RF) [Breiman 2001].

8.6.1. Máquina de Vetor de Suporte - SVM

Os estudos sobre SVM foram introduzidos por Cortes e Vapnik [Cortes and Vapnik 1995].De um modo geral, a SVM faz um mapeamento do espaço de entrada para um espaço dedimensionalidade maior. Em seguida, é calculado um hiperplano de separação ótimo.O hiperplano é escolhido de modo a maximizar a distância de separação entre as clas-ses [Haykin 2001]. Diz-se que duas classes são linearmente separáveis se existe umhiperplano divisório entre as amostras de classes diferentes. A Figura 8.9 ilustra duasclasses linearmente separáveis e seu hiperplano de separação ótimo.

Hiperplano de separação ótimo

Vetores deSuporte

Figura 8.9: Hiperplano de separação ótimo para classes linearmente separáveis. Imagemadaptada de [Haykin 2001].

A SVM é um algoritmo de aprendizado supervisionado, ou seja, possui as fasesde treinamento e teste. Na fase de treinamento, os atributos e as classes dos objetos sãoas entradas do classificador e o objetivo é projetar os vetores de suporte. Os vetores desuporte são utilizados para se obter o hiperplano de separação ótimo (Figura 8.9). Na fasede teste, o hiperplano é utilizado para encontrar uma saída a partir de um vetor de entrada.

Para utilizar SVM para reconhecimento de padrões, o algoritmo requer a transfor-mação de funções não-linearmente separáveis em funções linearmente separáveis. Paraisso, é necessário que seja aumentada a dimensionalidade do problema [Cover 1965]. Asfunções que aumentam a dimensionalidade do espaço de entrada são chamadas funçõesde kernel [Haykin 2001].

As funções de kernel são aplicadas nos vetores de entrada, os quais possuem di-mensão N, e se obtém um novo vetor de dimensão X , onde X > N. Após esse cálculo, sãoobtidos os vetores de suporte, responsáveis por definir o hiperplano de separação ótimo. Ohiperplano estará a uma igual distância (ρ0) dos vetores de suporte de cada classe, comomostrado na Figura 8.9. Um novo objeto é classificado utilizando o hiperplano ótimo,com cada lado do hiperplano representa uma classe diferente.

8.6.2. Random Forest

O algoritmo Random Forest [Breiman 2001] é uma combinação de predições de diversasárvores em que cada árvore depende dos valores de um vetor independente, amostradosaleatoriamente e com a mesma distribuição para todas as árvores da floresta. Aqui, florestaé a nomenclatura dada a uma coleção de árvores de decisão. Após a geração de um grandenúmero de árvores, as classes com maior número de votos são eleitas.

Em um Random Forest, cada nó é dividido usando o melhor dentre um subcon-junto de indicadores escolhidos aleatoriamente naquele nó. Esta estratégia, apesar de umtanto contraditória, funciona adequadamente em comparação com muitos outros classifi-cadores, além de ser robusto a superajuste nos parâmetros [Breiman 2001]. Além disso, éde fácil utilização pois possui apenas dois parâmetros: o número de variáveis no subcon-junto aleatório em cada nó e o número de árvores da floresta.

A partir de um vetor de atributos, são gerados outros vetores de atributos, quesão embaralhados em relação ao vetor original. É gerado um vetor para cada árvoredo Random Forest. Em seguida, os vetores de atributos são passados como parâmetro

para as árvores de decisão. Cada árvore irá gerar um resultado para a classificação e, osresultados são combinados obtendo uma saída unificada. A Figura 8.10 mostra os passosdo classificador Random Forest.

D Embaralhar

D1 2 n-1 nD D D

...

Combinação

Figura 8.10: Passos do classificador Random Forest, onde D é o vetor de atributos original,D1, D2 . . ., Dn−1, Dn são os vetores de atributos gerados a partir de D.

8.6.2.1. Código em python

A classificação de objetos em python pode ser realizada através da biblioteca scikit-learn.Esta biblioteca permite a utilização de algoritmos de aprendizagem de máquina, clus-terização, seleção de atributos, dentre outros. As etapas básicas para classificação são:divisão do conjunto de dados em treino e teste; criação de uma instância do classificadorutilizado; treino do classificador; predição utilizando os dados de teste; e cálculo da taxade acerto seguindo alguma métrica de avaliação de desempenho. O Código Fonte 8.3mostra as etapas de classificação de um conjunto de dados para os classificadores SVM eRandom Forest.

from s k l e a r n . svm i m p o r t SVC #SVM p a r a c l a s s i f i c a c a o2 from s k l e a r n . ensemble i m p o r t R a n d o m F o r e s t C l a s s i f i e r #RF p a r a

c l a s s i f i c a c a ofrom s k l e a r n . m o d e l _ s e l e c t i o n i m p o r t t r a i n _ t e s t _ s p l i t # p a c o t e p a r a

d i v i d i r os dados em t r e i n o e t e s t e

4 from s k l e a r n . m e t r i c s i m p o r t a c c u r a c y _ s c o r e # m e t r i c a de a v a l i a c a o

6 t r a i n = 0 . 3 #30% dos dados p a r a t r e i n a r o c l a s s i f i c a d o rt e s t = 1− t r a i n # r e s t a n t e dos dados (70%) p a r a t e s t a r o c l a s s i f i c a d o r

8 ’ ’ ’ f e a t u r e s = m a t r i z com t o d o s os a t r i b u t o s c a l c u l a d o , cada l i n h ap o s s u i os a t r i b u t o s de uma imagem , l a b e l s = v e t o r com a c l a s s e decada imagem na mesma ordem da v a r i a v e l m a t r i z ’ ’ ’

X _ t r a i n , X_ te s t , y _ t r a i n , y _ t e s t = t r a i n _ t e s t _ s p l i t ( f e a t u r e s , l a b e l s ,t e s t _ s i z e = t e s t ) # d i v i d e os dados em c o n j u n t o s de t r e i n o e t e s t e

10

c l f_ svm = SVC ( ) # c r i a uma i n s t a n c i a da SVM12 c l f_ svm . f i t ( X _ t r a i n , y _ t r a i n ) # t r e i n a m e n t o da SVM

pred_svm = c l f . p r e d i c t ( X _ t e s t ) # t e s t e da SVM14 acc_svm = a c c u r a c y _ s c o r e ( y _ t e s t , p r ed )

16 c l f _ r f = R a n d o m F o r e s t C l a s s i f i e r ( ) # c r i a uma i n s t a n c i a da Random F o r e s tc l f _ r f . f i t ( X _ t r a i n , y _ t r a i n ) # t r e i n a m e n t o da Random F o r e s t

18 p r e d _ r f = c l f . p r e d i c t ( X _ t e s t ) # t e s t e da Random F o r e s ta c c _ r f = a c c u r a c y _ s c o r e ( y _ t e s t , p r ed ) # compara os v e t o r e s de t e s t e e

p r e d i t o p a r a o c a l c u l o da t a x a de a c e r t o

Código Fonte 8.3: Classificação de imagens utilizando os classificadores Random Foreste Máquina de Vetor de Suporte.

Observando o Código Fonte 8.3 é possível ajustar alguns valores ou parâmetros,dentre os quais a taxa de treino-teste. O aumento dessa taxa pode melhorar a aprendi-zagem do classificador, visto que quanto mais dados disponíveis para esta etapa, maisrobusto será o modelo a ser utilizado no teste do classificador. O Random Forest pos-sui alguns parâmetros que podem melhorar a classificação dos dados, o principal deles éo número de árvores utilizadas que é geralmente padronizada e igual a 10. Em relaçãoà SVM podemos modificar o tipo de kernel e seu coeficiente. A medida de avaliaçãode desempenho também pode ser modificada pois dependendo da aplicação a medida deacurácia pode não ser a melhor opção.

8.6.3. Análise de Componentes Principais

A análise por componentes principais, do inglês Principal components analysis (PCA)foi baseada na transformada de Karhunen–Loève. Essa transformada visa decomporuma matriz de dados em um conjunto de coeficientes, posteriormente esses coeficien-tes são quantizados e codificados para que se tenha uma determinada taxa de compres-são [Pedrini 2007].

Considere um espaço multiespectral onde cada ponto tem seu respectivo vetor:

X =

#»x1#»x2...

#»xk

(9)

O valor médio da posição dos pontos é dado por:

# »mx = E(X) =1K

K

∑k=1

#»xk, (10)

em que E(.) é o operador esperança, # »mx é o vetor médio de X e #»xk são os vetores querepresentam cada ponto num total de K pontos.

A matriz de covariância de X é definida por:

Cx =1

K−1

K

∑k=1

(xk−mx)(xk−mx)t . (11)

A matriz de covariância tem como função medir a dispersão dos dados, onde os elementosda diagonal representam a variância, e os restantes a covariância das amostras [Richards 2006].Uma vez que Cx é real e simétrica, é possível encontrar n autovetores. É importante paraa análise de componentes principais, verificar se existe um novo sistema de coordenadasno qual as amostras seriam representadas com mínima correlação [Richards 2006]. Se #»yrepresenta os dados em um novo sistema de coordenadas temos que:

#»y = Dt( #»x − # »mx), (12)

em que t representa o operador de transposição e D é a matriz de transformação quemapeia as amostras que estavam no espaço #»x para o #»y essa expressão é chamada detransformada de Hotelling. As linhas da matriz D são formadas pelos autovetores deCx ordenados de tal forma que a primeira linha corresponde ao autovetor relacionadoao maior autovalor e a última linha corresponde ao autovetor correspondente ao menorautovalor [Gonzalez 2007].

A matriz de covariância no novo espaço pode ser definida como:

Cy = DCxDt (13)

em que Cy é diagonal e D é a matriz de rotação. Portanto, Cy pode ser representado daseguinte forma:

Cy =

λ1 0 0 . . . 00 λ2 0 . . . 0...

...... . . . ...

0 0 0 . . . λn

em que λi representa os n autovalores de Cx. Os autovalores são organizados de tal ma-neira que: λ1 > λ2 · · ·> λn [Richards 2006]. Por definição os elementos de Cy serão asvariâncias da amostra de dados mapeadas no novo espaço.

A reconstrução de #»x por meio de #»y pode ser feita da seguinte forma:

#»x = Dt #»y + # »mx. (14)

Utilizamos o PCA com o objetivo de diminuir a quantidade de atributos mantendoa acurácia na etapa de classificação.

8.6.3.1. Código em python

O Código Fonte 8.4 mostra as etapas para o cálculo do PCA e posterior classificação dosatributos obtidos com a GLCM.

1 from s k l e a r n . d e c o m p o s i t i o n i m p o r t PCA# b i b l i o t e c a que implementa aa n a l i s e de componentes p r i n c i p a i s

3 # Q u a n t i d a d e de componene tes d e s e j a d a s , e s s e s v a l o r e s devem s e r menoresque a q u a n t i d a d e de a t r i b u t o s . Aqui e x t r a i m o s 6 a t r i b u t o s de cada

componente no s i s t e m a de c o r e s RGB, t o t a l i z a n d o 18 a t r i b u t o scomponents = [ 2 , 4 , 8 , 1 0 , 1 2 ]

5

# Funcao que c a l c u l a a PCA7 d e f pca ( X _ t r a i n , X_ te s t , y _ t r a i n , n_comp ) :

" " "9 PCA t r a n s f o r m a t i o n f o r u s i n g a ’ t r a i n i n g ’ s e t and a ’ t e s t i n g ’ s e t

" " "11 pca = PCA( n_components=n_comp )

pca . f i t ( X _ t r a i n , y _ t r a i n )13 t r a n s f o r m = pca . t r a n s f o r m ( X _ t e s t )

r e t u r n t r a n s f o r m15

r e s u l t s = np . z e r o s ( 5 ) # v a r i a v e l que armazena os r e s u l t a d o s p a r a cadacomponente

17

# p a r a cada q u a n t i d a d e de componentes o PCA eh e x e c u t a d o nos c o n j u n t o sde t r e i n o e t e s t e . Apos i s s o , os dados sao c l a s s i f i c a d o s

19 f o r id_comp , comp i n enumera t e ( components ) :X _ t r a i n _ p c a = pca ( X _ t r a i n , X _ t r a i n , y _ t r a i n , comp )

21 X _ t e s t _ p c a = pca ( X _ t r a i n , X_ te s t , y _ t r a i n , comp )c _ r f = R a n d o m F o r e s t C l a s s i f i e r ( )

23 c _ r f . f i t ( X _ t r a i n _ p c a , y _ t r a i n )p red = c _ r f . p r e d i c t ( X _ t e s t _ p c a )

25 acc = a c c u r a c y _ s c o r e ( y _ t e s t , p r ed )r e s u l t s [ id_comp ] = acc

Código Fonte 8.4: Cálculo das componentes principais

A Figura 8.11 mostra os resultados obtidos utilizando PCA para redução de atri-butos. É possível observar que com 10 componentes obtivemos o maior valor de acuráciapara o classificador Random Forest, isso demonstra a eficácia da utilização de técnicas deseleção de atributos para classificação. Entretanto, em relação ao classificador SVM nãohouve mudança nos resultados.

8.7. Considerações FinaisOs resultados mostrados na Figura 8.11 concluem que sem uma quantidade de compo-nentes superior a 4 os resultados de acurácia são menos precisos que resultados contendomais componentes. Além disso, o método proposto aqui possui falhas em determinadasamostras de imagens como na Figura 8.12. Logo, algumas modificações podem ser feitaspara melhorar a fase segmentação como, por exemplo, o uso da Transformada Circular deHough [Silva et al. 2017].

Figura 8.11: Acurácia para a classificação da base de dados de motociclistas utilizandoanálise de componentes principais como seletor de atributos.

Figura 8.12: Exemplo de uma imagem com falha na segmentação.

Referências[Baraldi and Parmiggiani 1995] Baraldi, A. and Parmiggiani, F. (1995). An investigation

of the textural characteristics associated with gray level cooccurrence matrix statisticalparameters. Geoscience and Remote Sensing, IEEE Transactions on, 33(2):293–304.

[Breiman 2001] Breiman, L. (2001). Random forests. Machine Learning, 45(1):5–32.

[Cortes and Vapnik 1995] Cortes, C. and Vapnik, V. (1995). Support-vector networks.Machine Learning, 20:273–297.

[Cover 1965] Cover, T. M. (1965). Geometrical and statistical properties of systems oflinear inequalities with applications in pattern recognition. IEEE Transactions on Elec-tronic Computers, EC-14(3):326 –334.

[Gonzalez 2007] Gonzalez, R C, W. R. E. (2007). Digital Image Processing. PrenticeHall, Inc., Upper Saddle River, New Jersey, NJ, USA, 3 edition.

[Haralick 1973] Haralick, R.M., S. K. D. I. (1973). Textural features for image classifi-cation. IEEE Transactions on Systems, Man and Cybernetics, SMC-3(6):610–621.

[Haykin 2001] Haykin, S. (2001). Neural Networks: A Comprehensive Foundation.Prentice Hall, 2 edition.

[Otsu 1979] Otsu, N. (1979). A threshold selection method from gray-level histograms.IEEE transactions on systems, man, and cybernetics, 9(1):62–66.

[Pedrini 2007] Pedrini, H, S. W. R. (2007). Análise de Imagens Digitais: Princípios,Algoritmos e Aplicações. Editora Thomson Learning Edições Ltda, São Paulo, SãoPaulo, SP, BRA, 1 edition.

[Richards 2006] Richards, J., J. X. (2006). Remote Sensing Digital Image Analysis.Springer-Verlag Berlin Heidelberg., 4 edition.

[Sabino et al. 2004] Sabino, D. M. U., da Fontoura Costa, L., Rizzatti, E. G., and Zago,M. A. (2004). A texture approach to leukocyte recognition. Real-Time Imaging,10(4):205 – 216. Imaging in Bioinformatics: Part {III}.

[Silva et al. 2017] Silva, R. R. V. e., Aires, K. R. T., and Veras, R. d. M. S. (2017). De-tection of helmets on motorcyclists. Multimedia Tools and Applications, pages 1–25.

[Ushizima et al. 2014] Ushizima, D. et al. (2014). Structure recognition from high reso-lution images of ceramic composites. IEEE International Conference on Big Data.

A. Código-fonteO código abaixo reúne a etapas de segmentação, extração de atributos e classificação paraa base de dados de motociclistas com e sem capacete para uma base de dados. Alémdisso, adicionamos etapas para otimização de parâmetros dos classificados.

1 # Computer V i s i o n : s c i k i t −image + s c i k i t −l e a r n

3 ’ ’ ’ Problema : C l a s s i f i c a r Imagens de T r a n s i t o de M o t o c i c l i s t a s com e semc a p a c e t e ’ ’ ’

5 # b i b l i o t e c a s

7 i m p o r t numpy as npi m p o r t m a t p l o t l i b . p y p l o t a s p l t

9 from skimage . i o i m p o r t i m r e a d _ c o l l e c t i o n , imsavefrom s k l e a r n . m o d e l _ s e l e c t i o n i m p o r t t r a i n _ t e s t _ s p l i t

11 from g lob i m p o r t g lobfrom s c i p y . s t a t s i m p o r t r a n d i n t a s s p _ r a n d i n t

13 i m p o r t t imefrom skimage . c o l o r i m p o r t r g b 2 g r e y

15 from skimage . f i l t e r s i m p o r t t h r e s h o l d _ o t s ufrom skimage . measure i m p o r t l a b e l , r e g i o n p r o p s

17 from s k l e a r n . d e c o m p o s i t i o n i m p o r t PCAfrom skimage . f e a t u r e i m p o r t g r e y c o m a t r i x , g r e y c o p r o p s

19 from s k l e a r n . m o d e l _ s e l e c t i o n i m p o r t RandomizedSearchCVfrom s k l e a r n . ensemble i m p o r t R a n d o m F o r e s t C l a s s i f i e r

21 from s k l e a r n . m e t r i c s i m p o r t make_score r , a c c u r a c y _ s c o r efrom s k l e a r n . svm i m p o r t SVC

23

#Read images from d a t a b a s e25

p a t h = " / Use r s / romuere / Dropbox /MTAP/ d a t a b a s e s / d a t a b a s e 2 _ r a w _ d a t a / "

27 comcapace te = g lob ( p a t h + ’ comcapace te / * . png ’ )s e m c a p a c e t e = g lob ( p a t h + ’ s e m c a p a c e t e / * . png ’ )

29

images_cc = i m r e a d _ c o l l e c t i o n ( comcapace te )31 images_sc = i m r e a d _ c o l l e c t i o n ( s e m c a p a c e t e )

33 d e f s e g m e n t a t i o n ( im ) :’ ’ ’ Recebe uma imagem c a l c u l a l i m i a r de o t s u e f a z e r o

35 r e c o r t e obdecendo a r e g i a o r e s u l t a n t e d e s s e l i m i a r ’ ’ ’

37 grey_ image = r g b 2 g r e y ( im )o t s u = t h r e s h o l d _ o t s u ( grey_ image )

39 im_ = grey_ image < o t s un_branco = np . sum ( im_ == 1)

41 n _ p r e t o = np . sum ( im_ == 0)i f n_branco > n _ p r e t o :

43 im_ = 1−im_

45 l a b e l _ i m g = l a b e l ( im_ , c o n n e c t i v i t y = grey_ image . ndim ) # d e t e c t ar e g i o e s nao c o n e c t a d a sp r o p s = r e g i o n p r o p s ( l a b e l _ i m g ) # c a l c u l a p r o p r i e d a d e i m p o r t a n t e s de

cada r e g i a o e n c o n t r a d a ( ex . a r e a )47

# Conve r t t o d a s as r e g i o e s que possuem um v a l o r de a r e a menor que amaior a r e a em background da imagem

49 a r e a = np . a s a r r a y ( [ p r o p s [ i ] . a r e a f o r i i n r a n g e ( l e n ( p r o p s ) ) ] ) # a r e ade cada r e g i a o e n c o n t r a d amax_index = np . argmax ( a r e a ) # i n d e x da maior r e g i a o

51 f o r i i n r a n g e ( l e n ( p r o p s ) ) :i f ( p r o p s [ i ] . a r e a < p r o p s [ max_index ] . a r e a ) :

53 l a b e l _ i m g [ np . where ( l a b e l _ i m g == i +1) ] = 0# r e g i a o menor quea maior eh marcada como background

55 #−−−−−−−−−−−−−−−−r e c o r t e da r e g i a o de i n t e r e s s e −−−−−−−−−−−−−−−−## Obtendo os l i m i t e s v e r t i c a i s das imagens segmen tadas

57 ymin = np . min ( np . where ( l a b e l _ i m g != 0) [ 1 ] )ymax = np . max ( np . where ( l a b e l _ i m g != 0) [ 1 ] )

59 imagem_cor tada = imagem [ : , ymin : ymax , : ]r e t u r n imagem_cor tada

61

63 s t a r t = t ime . t ime ( )f o r id_im , imagem i n enumera t e ( images_cc ) :

65 im_name = images_cc . f i l e s [ id_ im ] . s p l i t ( ’ / ’ ) [−1]imagem_segmentada = s e g m e n t a t i o n ( imagem )

67 imsave ( p a t h + ’ segmen tacao / comcapace te / ’+im_name , imagem_segmentada )

69 # p r i n t ( im_name )f o r id_im , imagem i n enumera t e ( images_sc ) :

71 im_name = images_sc . f i l e s [ id_ im ] . s p l i t ( ’ / ’ ) [−1]imagem_segmentada = s e g m e n t a t i o n ( imagem )

73 imsave ( p a t h + ’ segmen tacao / s e m c a p a c e t e / ’+im_name , imagem_segmentada )# p r i n t ( im_name )

75

end = t ime . t ime ( )

77 p r i n t ( ’Tempo p a r a a segmentacao das imagens : ’ , end − s t a r t )

79 l a b e l s = np . c o n c a t e n a t e ( ( np . z e r o s ( l e n ( comcapace te ) ) , np . ones ( l e n (s e m c a p a c e t e ) ) ) )

81

# E x t r a c t i n g F e a t u r e s u s i n g GLCM83 p a t h _ s e g m e n t a d a = " / Use r s / romuere / Dropbox /MTAP/ d a t a b a s e s /

d a t a b a s e 2 _ r a w _ d a t a / segmen tacao / "comcapace te = g lob ( p a t h _ s e g m e n t a d a + ’ comcapace te / * . png ’ )

85 s e m c a p a c e t e = g lob ( p a t h _ s e g m e n t a d a + ’ s e m c a p a c e t e / * . png ’ )images = i m r e a d _ c o l l e c t i o n ( comcapace te + s e m c a p a c e t e )

87

d = 1589

f e a t u r e s = np . z e r o s ( ( l e n ( l a b e l s ) , 1 8 ) ) #6 f e a t u r e s x 3 c o l o r c h a n n e l s91 s t a r t = t ime . t ime ( )

93 f o r id_im , imagem i n enumera t e ( images ) :f o r i d _ c h i n r a n g e ( 3 ) :

95 m a t r i x 0 = g r e y c o m a t r i x ( imagem [ : , : , i d _ c h ] , [ d ] , [ 0 ] , normed=True )m a t r i x 1 = g r e y c o m a t r i x ( imagem [ : , : , i d _ c h ] , [ d ] , [ np . p i / 4 ] , normed

=True )97 m a t r i x 2 = g r e y c o m a t r i x ( imagem [ : , : , i d _ c h ] , [ d ] , [ np . p i / 2 ] , normed

=True )m a t r i x 3 = g r e y c o m a t r i x ( imagem [ : , : , i d _ c h ] , [ d ] , [3* np . p i / 4 ] ,

normed=True )99 m a t r i x = ( m a t r i x 0 + m a t r i x 1 + m a t r i x 2 + m a t r i x 3 ) / 4

p r o p s = np . z e r o s ( ( 6 ) )101 p r o p s [ 0 ] = g r e y c o p r o p s ( ma t r ix , ’ c o n t r a s t ’ )

p r o p s [ 1 ] = g r e y c o p r o p s ( ma t r ix , ’ d i s s i m i l a r i t y ’ )103 p r o p s [ 2 ] = g r e y c o p r o p s ( ma t r ix , ’ homogene i ty ’ )

p r o p s [ 3 ] = g r e y c o p r o p s ( ma t r ix , ’ e ne r gy ’ )105 p r o p s [ 4 ] = g r e y c o p r o p s ( ma t r ix , ’ c o r r e l a t i o n ’ )

p r o p s [ 5 ] = g r e y c o p r o p s ( ma t r ix , ’ASM’ )107 f e a t u r e s [ id_im , i d _ c h * 6 : ( i d _ c h +1) *6] = p r o p s

109 end = t ime . t ime ( )p r i n t ( ’Tempo p a r a e x t r a i r a t r i b u t o s usando GLCM: ’ , end − s t a r t )

111

113 # S p l i t Data

115 t r a i n = 0 . 5t e s t = 1− t r a i n

117 X _ t r a i n , X_ te s t , y _ t r a i n , y _ t e s t = t r a i n _ t e s t _ s p l i t ( f e a t u r e s , l a b e l s ,t e s t _ s i z e = t e s t )

119 #Random F o r e s t P a r a m e t e r E s t i m a t i o nd e f r f _ p a r a m e t e r _ e s t i m a t i o n ( xEst , yEs t ) :

121

c l f = R a n d o m F o r e s t C l a s s i f i e r ( n _ e s t i m a t o r s =20)123 # s p e c i f y p a r a m e t e r s and d i s t r i b u t i o n s t o sample from

h y p e r p a r a m e t e r s = { " n _ e s t i m a t o r s " : r a n g e ( 1 0 , 1 0 0 0 , 5 0 ) ,125 " max_depth " : r a n g e ( 1 , 1 0 0 ) ,

" m a x _ f e a t u r e s " : s p _ r a n d i n t ( 1 , xEs t . shape [ 1 ] ) ,127 " m i n _ s a m p l e s _ s p l i t " : s p _ r a n d i n t ( 1 , xEs t . shape [ 1 ] ) ,

" m i n _ s a m p l e s _ l e a f " : s p _ r a n d i n t ( 1 , xEs t . shape [ 1 ] ) ,129 " b o o t s t r a p " : [ True , F a l s e ] ,

" c r i t e r i o n " : [ " g i n i " , " e n t r o p y " ] }131

# run randomized s e a r c h133 n _ i t e r _ s e a r c h = 20

random_sea rch = RandomizedSearchCV ( c l f , p a r a m _ d i s t r i b u t i o n s =h y p e r p a r a m e t e r s , n _ i t e r = n _ i t e r _ s e a r c h , s c o r i n g = make_sco re r (a c c u r a c y _ s c o r e ) )

135 r andom_sea rch . f i t ( xEst , yEs t )r e p o r t ( r andom_sea rch . c v _ r e s u l t s _ )

137 r e t u r n random_sea rch . b e s t _ p a r a m s _

139 #SVM P a r a m e t e r E s t i m a t i o nd e f s v m _ p a r a m e t e r _ e s t i m a t i o n ( xEst , yEs t ) :

141

h y p e r p a r a m e t e r s = { ’gamma ’ : [1 e−1, 1e−2 ,1e−3, 1e−4] , ’C ’ : [ 1 , 10 ,100 , 1000]}

143

c l f = SVC( k e r n e l = ’ r b f ’ )145 n _ i t e r _ s e a r c h = 8

random_sea rch = RandomizedSearchCV ( c l f , p a r a m _ d i s t r i b u t i o n s =h y p e r p a r a m e t e r s , n _ i t e r = n _ i t e r _ s e a r c h , s c o r i n g = make_sco re r (a c c u r a c y _ s c o r e ) )

147 r andom_sea rch . f i t ( xEst , yEs t )r e p o r t ( r andom_sea rch . c v _ r e s u l t s _ )

149 r e t u r n random_sea rch . b e s t _ p a r a m s _

151 d e f r e p o r t ( r e s u l t s , n_ top =3) :f o r i i n r a n g e ( 1 , n_ top + 1) :

153 c a n d i d a t e s = np . f l a t n o n z e r o ( r e s u l t s [ ’ r a n k _ t e s t _ s c o r e ’ ] == i )f o r c a n d i d a t e i n c a n d i d a t e s :

155 p r i n t ( " Model w i th r ank : {0} " . f o r m a t ( i ) )p r i n t ( "Mean v a l i d a t i o n s c o r e : { 0 : . 3 f } ( s t d : { 1 : . 3 f } ) " .

f o r m a t (157 r e s u l t s [ ’ m e a n _ t e s t _ s c o r e ’ ] [ c a n d i d a t e ] ,

r e s u l t s [ ’ s t d _ t e s t _ s c o r e ’ ] [ c a n d i d a t e ] ) )159 p r i n t ( " P a r a m e t e r s : {0} " . f o r m a t ( r e s u l t s [ ’ params ’ ] [ c a n d i d a t e

] ) )

161

# C l a s s i f i c a t i o n u n s i n g a l l f e a t u r e s163

s t a r t = t ime . t ime ( )165 p a r a m e t e r s = r f _ p a r a m e t e r _ e s t i m a t i o n ( X _ t r a i n , y _ t r a i n )

c _ r f = R a n d o m F o r e s t C l a s s i f i e r (** p a r a m e t e r s )167 c _ r f . f i t ( X _ t r a i n , y _ t r a i n )

p red = c _ r f . p r e d i c t ( X _ t e s t )169 a c c _ r f = a c c u r a c y _ s c o r e ( y _ t e s t , p r ed )

171 end = t ime . t ime ( )p r i n t ( ’Tempo p a r a c l a s s i f i c a c a o usando Random F o r e s t : ’ , end − s t a r t )

173 p r i n t ( ’Random F o r e s t Accuracy : ’ , a c c _ r f )

175 s t a r t = t ime . t ime ( )p a r a m e t e r s = s v m _ p a r a m e t e r _ e s t i m a t i o n ( X _ t r a i n , y _ t r a i n )

177 c_svm = SVC(** p a r a m e t e r s )c_svm . f i t ( X _ t r a i n , y _ t r a i n )

179 p red = c_svm . p r e d i c t ( X _ t e s t )acc_svm = a c c u r a c y _ s c o r e ( y _ t e s t , p r ed )

181

end = t ime . t ime ( )183 p r i n t ( ’Tempo p a r a c l a s s i f i c a c a o usando Random F o r e s t : ’ , end − s t a r t )

p r i n t ( ’ S u p p o r t Ve c t o r Machine Accuracy : ’ , acc_svm )185

187 # C l a s s i f i c a t i o n u s i n g PCA

189 d e f pca ( X _ t r a i n , X_ te s t , y _ t r a i n , n_comp ) :" " "

191 PCA t r a n s f o r m a t i o n f o r u s i n g a ’ t r a i n i n g ’ s e t and a ’ t e s t i n g ’ s e t" " "

193 pca = PCA( n_components=n_comp )pca . f i t ( X _ t r a i n , y _ t r a i n )

195 t r a n s f o r m = pca . t r a n s f o r m ( X _ t e s t )r e t u r n t r a n s f o r m

197

components = [ 2 , 4 , 8 , 1 0 , 1 2 ]199 r e s u l t s _ r f = np . z e r o s ( 5 )

r e s u l t s _ s v m = np . z e r o s ( 5 )201

s t a r t = t ime . t ime ( )203 f o r id_comp , comp i n enumera t e ( components ) :

205 p r i n t ( ’−−−−−−−−−−−−−’ , ’ n comp . = ’ , comp , ’−−−−−−−−−−−−−’ )

207 X _ t r a i n _ p c a = pca ( X _ t r a i n , X _ t r a i n , y _ t r a i n , comp )X _ t e s t _ p c a = pca ( X _ t r a i n , X_ te s t , y _ t r a i n , comp )

209 #RFp a r a m e t e r s = r f _ p a r a m e t e r _ e s t i m a t i o n ( X _ t r a i n _ p c a , y _ t r a i n )

211 c _ r f = R a n d o m F o r e s t C l a s s i f i e r (** p a r a m e t e r s )c _ r f . f i t ( X _ t r a i n _ p c a , y _ t r a i n )

213 p red = c _ r f . p r e d i c t ( X _ t e s t _ p c a )acc = a c c u r a c y _ s c o r e ( y _ t e s t , p r ed )

215 r e s u l t s _ r f [ id_comp ] = acc

217 p r i n t ( ’−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−’ )

219 p a r a m e t e r s = s v m _ p a r a m e t e r _ e s t i m a t i o n ( X _ t r a i n _ p c a , y _ t r a i n )c_svm = SVC(** p a r a m e t e r s )

221 c_svm . f i t ( X _ t r a i n _ p c a , y _ t r a i n )p red = c_svm . p r e d i c t ( X _ t e s t _ p c a )

223 acc = a c c u r a c y _ s c o r e ( y _ t e s t , p r ed )r e s u l t s _ s v m [ id_comp ] = acc

225

end = t ime . t ime ( )227 p r i n t ( ’Tempo p a r a c l a s s i f i c a c a o usando PCA: ’ , end − s t a r t )

229 ’ ’ ’ P l o t do g r a f i c o com o r e s u l t a d o p a r a os c l a s s i f i c a d o r e s SVM e RandomF o r e s t ’ ’ ’

231 p l t . s t y l e . use ( ’ g g p l o t ’ )f i g = p l t . f i g u r e ( f i g s i z e = ( 1 0 , 5 ) , d p i =400)

233 ax = p l t . s u b p l o t ( 1 1 1 )ax . p l o t ( r a n g e ( 1 , 7 ) , np . c o n c a t e n a t e ( ( r e s u l t s _ r f , [ a c c _ r f ] ) , a x i s =0) , marker

= ’D’ , l i n e s t y l e = ’ : ’ , l a b e l = ’Random F o r e s t ’ )235 ax . p l o t ( r a n g e ( 1 , 7 ) , np . c o n c a t e n a t e ( ( r e s u l t s _ s v m , [ acc_svm ] ) , a x i s =0) ,

marker = ’D’ , l i n e s t y l e = ’ : ’ , l a b e l = ’SVM’ )ax . s e t _ x l i m ( [ 0 , 7 ] )

237 ax . s e t _ x l a b e l ( ’PCA Components ’ )ax . s e t _ y l a b e l ( ’ Accuracy ’ )

239 ax . s e t _ x t i c k s ( r a n g e ( 1 , 7 ) )ax . s e t _ x t i c k l a b e l s ( [ ’ 2 ’ , ’ 4 ’ , ’ 8 ’ , ’ 10 ’ , ’ 12 ’ , ’No PCA ’ ] )

241 ax . s e t _ y l i m ( [ 0 . 5 , 1 ] )ax . s e t _ t i t l e ( ’ Helmets ’ )

243 l e g e n d = ax . l e g e n d ( l o c = ’ uppe r c e n t e r ’ , shadow=True )

Código Fonte 8.5: Classificação de uma base de imagens utilizando o descritor GLCM eo classificador SVM.