Aprendizagem de Máquina para Projetar Filtros

Nesta aula, vamos estudar alguns usos básicos de aprendizagem de máquina em processamento deimagens e visão computacional. Uma possível definição de aprendizagem de máquina é:

Aprendizagem de máquina é o estudo de algoritmos que executam uma certa tarefa baseando-se em exemplos, sem usar instruções explícitas. (definição de [WikiML] simplificada)

Uma outra definição é:

“Diz-se que um programa computacional aprende com a experiência E no que diz respeito auma tarefa T e medida de desempenho P, se o seu desempenho na tarefa T, medida por P,aumenta com a experiência E.” [Mitchell1997]

A aprendizagem de máquina divide-se em duas categorias principais:

Aprendizagem supervisionada Aprendizagem não-supervisionada

Nesta aula, veremos somente a aprendizagem supervisionada.http://anaturalissima.com.br/o-guia-da-fruta-de-epoca/

1. Aprendizagem supervisionada:

Na aprendizagem supervisionada, um “professor” ou “oráculo” fornece amostras ou exemplos detreinamento de entrada/saída (ax, ay). O “aprendiz” ou “algoritmo de aprendizagem” M classificauma nova instância de entrada qx baseado nos exemplos fornecidos pelo professor, gerando aclassificação qp. Para cada instância de entrada qx existe uma classificação correta ou verdadeiraqy, desconhecida pelo aprendiz. Se a classificação do aprendiz qp=M(qx) for igual à classificaçãoverdadeira qy então o aprendiz acertou a classificação.

1

(ax,ay)

M

qx

qp

qy

iguais?

Exemplo: O aprendiz ou o algoritmo de aprendizagem de máquina M é alimentada com a tabela 1,com conjunto de pares (exemplo de entrada, exemplo de saída) ou (ax, ay): { (4,B), (15,C), (65,A),(5,B), (18,C), e (70,A) }. Este conjunto indica o peso em kg de indivíduos e a sua classificação em“Adulto”, “Bebê” ou “Criança”, mas o aprendiz M não sabe disso. Por exemplo (4,B) indica que háum indivíduo de 4 kg e sua classificação é “Bebê”. Depois, pede-se ao aprendiz M que classifiqueqx=16. O aprendiz pode adotar diferentes técnicas para classificar o indivíduo com característicaqx=16, mas uma técnica “razoável” seria procurar na tabela aquela instância mais parecida a 16.Fazendo isto, M encontra ax=15 cuja classificação é “C”. Então, M atribui rótulo “C” a 16, isto é,M(16) = “C”. Este método de aprendizagem chama-se busca do vizinho mais próximo.

Aplicando a aprendizagem do vizinho mais próximo a outras instâncias a classificar, obtemos:(a) M(3) = “B”, pois o exemplo de treino com característica de entrada mais próxima de 3 é

(4,B). (b) M(75) = “A”, pois o exemplo de treino com característica de entrada mais próxima de 75 é

(70,A).

Tabela 1: Amostra de treinamento (ax, ay):ax (features, características, entradas) ay (labels, rótulos, saídas, classificações)4 B15 C65 A5 B18 C70 A

Tabela 2: Instâncias a classificar (qx), classificação verdadeira (qy) e classificação do aprendiz (qp).A processar ou a classificar(qx):

Classificação ideal ouverdadeira desconhecida (qy):

Classificação pelo aprendiz(qp):

16 C C3 B B75 A A

2

2. Projetar filtro 3x3 binário pela aprendizagem de máquina

2.1 Busca do vizinho mais próximo “força bruta”

Agora, vamos considerar um exemplo simples de uso de aprendizagem de máquina emprocessamento de imagens. Considere a figura 1 que mostra a detecção de pontas de retas pelaaprendizagem de máquina.

As imagens AX e AY (figuras 1a e 1b) são respectivamente exemplos de entrada e saída, isto é,estamos informando ao aprendiz M que, se a entrada do sistema for uma imagem com segmentos dereta como AX (figura 1a), queremos obter a saída AY (figura 1b) onde todas as pontas das retasestão marcadas de preto. Depois de alimentar o algoritmo de aprendizagem com as imagens-exemplos, fornecemos ao aprendiz M a imagem a processar com segmentos de retas QX (figura 1c).Existe uma imagem de saída ideal QY (figura 1d), mas esta imagem é desconhecida. O aprendiz Mdeve processar QX da “melhor forma possível”, gerando uma imagem processada QP (figura 1e) talque esta seja o mais parecido possível da saída ideal desconhecida QY (figura 1d). Aqui, a medidade desempenho poderia ser: (a) A diferença média absoluta entre QY e QP, isto é, MAE(QY, QP).(b) A distância de Hamming entre QY e QP, isto é, o número de pixels diferentes entre as duasimagens.

O que seria razoável fazer aqui? Em vez de pensar em escrever um programa que gera a imagem desaída QP para uma imagem de entrada QX qualquer (o que é uma tarefa difícil), podemos pensarem projetar um filtro F que usa janela 3x3 (uma tarefa bem mais simples, figura 2, [Kim2000]). Jáestudamos filtros várias vezes nas aulas passadas. Na figura 2, o filtro F olha a vizinhança 3x3 dopixel p na imagem de entrada A para escolher a cor de saída B(p). Assim, precisamos projetarsomente uma função f :{0,1}9→{0,1} que caracteriza o filtro F (que chamaremos de funçãocaracterística). Note que coube a nós, seres humanos, escolher o tamanho de janela adequada pararesolver este problema. A janela adequada é a janela de menor tamanho possível que permitepredizer corretamente a saída (neste caso, se é ou não ponta de reta).

Usando o algoritmo de vizinho mais próximo “força bruta” (isto é, sem nenhum truque para aceleraro processamento), dadas as imagens AX, AY e QX, uma janela 3x3 percorre a imagem QX. Paracada pixel p de QX, vamos denotar o conteúdo da janela 3x3 de QX centrada em p de qx(p). Paracada qx(p), devemos procurar um pixel q de AX tal que ax(q), isto é, o conteúdo da janela 3x3 deAX centrada em q, seja o mais semelhante possível à qx(p). Esta semelhança pode ser medida emnúmero de pixels diferentes, isto é, distância de Hamming. Aí, copiamos o valor AY(q) em QP(p).

3

(a) AX - exemplo de entrada (b) AY - exemplo de saída

(c) QX - instância a processar (d) QY - saída ideal desconhecida

(e) QP - saída processada (f) saída processada sobreposta à imagem deentrada

Figura 1: Detecção de ponta de reta em imagens binárias pela aprendizagem de máquina.

4

A B

W(p) B(p)

Figura 2: Filtro ou operador “restrito à janela” 3x3. A transformação é caracterizada pela funçãocaracterística f :{0,1}9→{0,1} .

Este algoritmo “força bruta” está implementado no programa nn (algoritmo 1). As linhas 24-27lêem as imagens AX, AY e QX. A linha 28 cria a imagem de saída QP e a preenche de pixelsbrancos. As linhas 30-32 geram índices p=(l,c) que percorrem a imagem QX. Na linha 33, para cadaíndice p=(l,c), calcula-se o conteúdo da janela qx(p) usando a função “vizinhanca33”.

Para cada índice p=(l,c), as linhas 37-38 geram índices q=(l2,c2) que percorrem a imagem AX,procurando o conteúdo da janela ax(q) que seja mais semelhante à qx(p), usando função“hamming”. Nas linhas 42-43, armazena-se a menor distância de Hamming encontrada “mindist” ea saída AY(q) no pixel q que deu a menor distância “minsai”. Este valor de saída é armazenada naimagem de saída QP na linha 46. Por fim, a linha 49 imprime a imagem de saída obtida.

A saída do programa nn (figura 1d) é exatamente igual à saída ideal (figura 1e). O único problema éque este processo “força bruta” demora 250s (mais de 4 minutos)1! De um modo geral, o problemada busca do vizinho mais próximo é o tempo de processamento.

Exercício: Você consegue imaginar uma forma de acelerar o programa nn “força bruta” (algoritmo1) fazendo somente duas pequenas alterações? Com estas alterações, o tempo de processamento caipara algo como 4s.

1 Os tempos de processamento desta apostila são medidos num computador com Intel i7 2.6 GHz.

5

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950

//nn.cpp#include <cekeikon.h>

Mat_<GRY> vizinhanca33(Mat_<GRY> a, int lc, int cc) { Mat_<GRY> d(1,9); int i=0; for (int l=-1; l<=1; l++) for (int c=-1; c<=1; c++) { d(i)=a(lc+l,cc+c); i++; } return d;}

int hamming(Mat_<GRY> a, Mat_<GRY> b) { if (a.total()!=b.total()) erro("Erro hamming"); int soma=0; for (int i=0; i<a.total() ; i++) if (a(i)!=b(i)) soma++; return soma;}

int main() { Mat_<GRY> AX,AY,QX; le(AX,"ax.bmp"); le(AY,"ay.bmp"); le(QX,"qx.bmp"); Mat_<GRY> QP(QX.size(),255); //#pragma omp parallel for for (int l=1; l<QP.rows-1; l++) { fprintf(stderr,"%d\r",l); for (int c=1; c<QP.cols-1; c++) { Mat_<GRY> qx=vizinhanca33(QX,l,c); //acha vizinho mais proximo de qx em AX int mindist=INT_MAX; GRY minsai=0; for (int l2=1; l2<AX.rows-1; l2++) for (int c2=1; c2<AX.cols-1; c2++) { Mat_<GRY> ax=vizinhanca33(AX,l2,c2); int dist=hamming(qx,ax); if (dist<mindist) { mindist=dist; minsai=AY(l2,c2); } } QP(l,c)=minsai; } } imp(QP,"qpnn.pgm");}

Algoritmo 1 - nn: Detecção de pontas de reta pelo busca do vizinho mais próximo “força bruta”.

6

2.2 Busca do vizinho mais próximo usando tabela

O tempo de processamento de 4s é melhor que 4 minutos, mas ainda é lento, longe de poder serusado em aplicações de tempo real (algo como processar 30 quadros por segundo). É possívelacelerar ainda mais a busca do vizinho mais próximo, fazendo com que o tempo de processamentocaia para algo como 0,04s (aproximadamente 6000 vezes mais rápido que o algoritmo original).

A ideia é construir uma tabela com as saídas para cada uma das 512 entradas possíveis(representando as 29 = 512 configurações binárias dentro da janela 3x3). Com isso, para cada qx(p)basta fazer um único acesso à tabela, em vez de percorrer a imagem AX procurando a instânciamais parecida.

Veja a figura 3, onde tem algumas configurações da janela 3x3. Para cada uma delas, faz-se buscana imagem AX, procurando a janela ax(q) com o conteúdo mais parecido. O resultado desta procurairá indicar se é ou não ponta de reta. Depois, copia-se a saída AY(q) na tabela (figura 4).

1 1 11 0 01 1 1

111100111 0487

(a) É ponta de reta

1 0 10 0 01 0 1

101000101 1325

(b) Não é ponta de reta

1 1 11 1 11 1 1

111111111 1511

(c) Não é ponta de reta1 1 01 0 11 1 1

110101111 0431

(d) É ponta de reta

0 1 01 0 10 1 0

010101010 1170

(e) Não é ponta de retaFigura 3: Exemplos de alguns conteúdos da janela e as respectivas saídas.

índice decimal índice binário conteúdo da tabela0 000000000 1... ... ...

170 010101010 1... ... ...

325 101000101 1... ... ...

431 110101111 0... ... ...

487 111100111 0... ... ...

511 111111111 1Figura 4: Tabela que representa a função f que caracteriza o filtro F.

7

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970

//tabelann.cpp pos2020#include <cekeikon.h>

int hamming(int a, int b) { assert(0<=a && a<512); assert(0<=b && b<512); int soma=0; int bit=1; for (int i=0; i<9; i++) { if ( (a & bit) != (b & bit) ) soma++; i = i*2; } return soma;}

int main(int argc, char** argv) { if (argc!=5) erro("tabelann ax.pgm ay.pgm qx.pgm qp.pgm"); Mat_<GRY> AX; le(AX,argv[1]); Mat_<GRY> AY; le(AY,argv[2]); vector<BYTE> tabela(512, 128); // Padrao nao visto vira cinza

//Percorre imagem AX e AY, preenchendo tabela for (int l=1; l<AX.rows-1; l++) for (int c=1; c<AX.cols-1; c++) { int indice=0; for (int l2=-1; l2<=1; l2++) for (int c2=-1; c2<=1; c2++) { int t=1; if (AX(l+l2,c+c2)==0) t=0; indice = 2*indice+t; } //Aqui, indice vai ser um numero entre 0 e 511 tabela[indice]=AY(l,c); }

//Processa as entradas cinza (padroes nao vistos) da tabela. for (int indice=0; indice<512; indice++) { if (tabela[indice]==128) { //procura vizinho mais proximo na tabela int mindist=INT_MAX; GRY minsai=0; for (int j=0; j<512; j++) { if (tabela[j]!=128) { int dist=hamming(indice,j); if (dist<mindist) { mindist=dist; minsai=tabela[j]; } } } tabela[indice]=minsai; } }

Mat_<GRY> QX; le(QX,argv[3]); Mat_<GRY> QP(QX.size(),255); for (int l=1; l<QX.rows-1; l++) for (int c=1; c<QX.cols-1; c++) { int indice=0; for (int l2=-1; l2<=1; l2++) for (int c2=-1; c2<=1; c2++) { int t=1; if (QX(l+l2,c+c2)==0) t=0; indice = 2*indice+t; } //Aqui, indice vai ser um numero entre 0 e 511 QP(l,c)=tabela[indice]; } imp(QP,argv[4]);}

Algoritmo 2- tabelann: Projeto de filtro binário 3x3 usando vizinho mais próximo e tabela.

Este processo está implementado no programa tabelann (algoritmo 2). Não explico linha a linha estaimplementação pois tem alguns “truques” que são “chatos” para explicar. Programa tabelanndemora aproximadamente 0,04s para construir a tabela e processar a imagem QX obtendo QP. Asaída obtida é exatamente igual à saída do nn “força bruta” (algoritmo 1).

O mesmo programa pode executar outras tarefas se fornecer exemplos de treinamento diferentes.Por exemplo, a figura 5 mostra esse mesmo programa detectando as bordas de imagens binárias,quando treinadas com imagens exemplos apropriadas. A figura 6 mostra o programa tabelann

8

(algoritmo 2) emulando operadores morfológicos erosão 3x3 e abertura 2x2 a partir de imagensexemplos de entrada e saída.

Exemplo de treino de entrada AXmickey_reduz.bmp

Exemplo de treino de saída AY borda.png

Imagem a processar QX persuasion.png Imagem processada QP

Imagem a processar QX pers.bmp Imagem processada QPFigura 5: O programa tabelann (algoritmo 2) pode executar outras tarefas quando alimentado comimagens exemplos apropriados. Detecção de bordas.

9

Exemplo de entrada AX (120160) Exemplo de saída AY (erosão 33)

Imagem a processar QX (120160) Erosão 3x3 emulado QP (erro zero)

Exemplo de entrada AX Exemplo de saída AY (abertura 2x2)

Imagem a processar QX Abertura 2x2 emulado QP (erro zero)Figura 6: O programa tabelann (algoritmo 2) pode emular filtros 3x3 a partir de exemplos.

10

3. Árvore

3.1 O problema

Agora que já vimos como construir filtros 3x3 para imagens binárias usando aprendizagem demáquina, vamos tentar fazer o mesmo para filtros com janelas maiores. A figura 7 mostra detecçãode caracteres “a” e “A”, onde esses caracteres são mantidos intactos na saída e os outros caracteressão todos apagados. Para fazer esta tarefa, precisa usar uma janela suficientemente grande parapoder reconhecer a letra “a” ou “A” olhando só o conteúdo dentro da janela. Experimentalmente,constata-se que janela 7x7 é uma escolha adequada. Aí, a função característica seriaf :{0,1}7×7→{0,1}

Exemplo de entrada AX (lax.bmp) Exemplo de saída AY (lay.bmp)

Imagem a processar QX (lqx.bmp) Imagem processada QP (lqp.bmp)Figura 7: Detecção de letras “A” com aprendizagem de máquina.

Podemos fazer busca do vizinho mais próximo “força bruta”, semelhante ao programa nn(algoritmo 1), só que é muito lento.

Exercício: Resolva o problema de detectar letras “A” e “a”, ilustrada na figura 7, usando busca dovizinho mais próximo “força bruta” semelhante ao algoritmo 1 e verifique quanto tempo demora oprocessamento.

Por outro lado, não é possível usar tabela como no programa tabelann (algoritmo 2), pois aqui otamanho da tabela seria 249 = 562.949.953.421.312! Não dá mais para usar tabela, pois:

(a) A tabela não cabe na memória do computador; (b) É impossível conseguir exemplos suficientes para preencher toda a tabela (ou uma parte

considerável dela); (c) O tempo para preencher a tabela é astronômico.

Podemos usar uma árvore em vez de tabela [Kim2004]. O uso da árvore para acelerar busca dovizinho mais próximo é conhecido como árvore k-dimensional (kd-tree) [wikiKD, Bentley1975]. Ouso da árvore como algoritmo de aprendizagem de máquina é conhecido como árvore de decisão(decision-tree) [wikiDecision, Mitchell1997]. Os dois conceitos estão inter-relacionados.

11

3.2 Árvore de decisão

Mostro abaixo um exemplo gráfico de construção de árvore de decisão para representar um filtro1x3 para imagens binárias. Escolhi uma janela pequena para facilitar a ilustração mas a construçãode árvore só faz sentido quando o tamanho da janela é maior. Neste exemplo, a função característicaé f :{0,1}3→{0,1} .

Suponha que, a partir das imagens-exemplos AX e AY, foram coletados os exemplos abaixopercorrendo-as com uma janela 1x3:

Exemplos = { [000, 0], [000, 0], [000, 1], [001, 1], [100, 1], [100, 1], [011, 1], [111, 0] }[ax, ay] = [000, 0] indica uma amostra de treinamento com entrada ax=[000] e saída ay=[0].

Podemos representar o espaço das características {0,1}3 como um cubo. Na figura 8, as amostras detreinamento acima estão colocadas num cubo, com eixos w1, w2 e w3. Para construir a árvore dedecisão, vamos “cortar” recursivamente o cubo em sub-cubos cada vez menores, até que cada sub-cubo satisfaça alguma condição de parada.

Neste caso, escolheu-se (usando algum critério) o eixo w1 para fazer o primeiro corte, dividindo ocubo original em 2 sub-cubos: vermelho e azul (figura 9). Este corte gera o primeiro nó na árvore(nó W1 da figura 10), indicando que deve andar para a sub-árvore esquerda (azul) ou direita(vermelha) de acordo com o valor de w1 da instância qx.

Depois, o sub-cubo vermelho é subdividido no eixo w2 em dois sub-cubos menores (figura 9).Agora, cada um dos dois sub-cubos vermelhos obtidos possui um único valor de saída ay: 0 no sub-cubo superior e 1 no sub-cubo inferior (figura 8). Portanto, não há necessidade de fazer maissubdivisões. Chegamos às folhas da sub-árvore vermelha (figura 10).

O sub-cubo azul é subdividido no eixo w3 em dois sub-cubos menores. Agora, o sub-cubo azul dadireita possui só os valores de saída ay=1 (folha com valor 1 da sub-árvore azul). O sub-cubo azulesquerda contém o padrão ax=[000] que possui três valores de saída ay={0, 0, 1}, isto é, há umconflito nas amostras de treino. Neste caso, o razoável é escolher a saída mais numerosa, isto é, 0(folha esquerda da sub-árvore azul).

Agora, digamos que queremos achar o valor de saída para instância a classificar qx=[011], isto écalcular M([011]). No primeiro nó da árvore, vai para sub-árvore esquerda (azul), pois w1=0. No nóda sub-árvore azul, vai para direita, pois w3=1. Assim, chega-se ao nó cujo valor é 1. Portanto,M([011])=1.

12

Figura 8: Os exemplos de treinamentorepresentados num cubo.

Figura 9: Cortes no espaço dos atributos paraconstruir árvore (decision-tree ou kd-tree).

Figura 10: Árvore construída.

Todo algoritmo de aprendizagem de máquina deve ter estratégia para lidar com dois “problemas”:

(a) Generalização: Como classificar uma instância qx que nunca apareceu nos exemplos detreinamento? Por exemplo, qx=[110], qx=[101] e qx=[010] não aparecem nos exemplos detreinamento. Já vimos que “vizinho mais próximo” é uma estratégia de generalização:procura-se o exemplo conhecido mais parecido. A árvore de decisão fornece uma outraestratégia de generalização: a instância qx sem exemplo é classificada de acordo com o valorde saída da folha a que se chega percorrendo a árvore de decisão.

(b) Amostras com conflito ou ruído: O que fazer quando uma amostra de entrada ax possuiamostras de saída ay com valores diferentes (conflitantes)? Por exemplo, a entrada ax=[000]tem 3 saídas ay=0, 0, 1. Neste caso, o razoável é escolher a saída mais popular ou numerosa,isto é, 0.

13

Note que o tamanho da tabela depende da cardinalidade do espaço das características (que“explode” com o crescimento da janela). Por outro lado, o tamanho da árvore de decisão dependedo número de amostras de treinamento (portanto não “explode”), pois o número de folhas será nomáximo igual ao número de amostras de treinamento.

3.3 Kd-tree

É possível usar a árvore para acelerar a busca do vizinho próximo. Neste caso, somente os exemplosde entrada AX são levadas em consideração na construção da árvore. Para buscar um vizinhopróximo de uma instância qx, percorre-se a árvore até chegar a uma folha. Na folha, há umaamostra ax que é um vizinho de qx (não é necessariamente o vizinho mais próximo). Paraminimizar a possibilidade de que kd-tree devolva um vizinho ax distante da instância buscada qx, oalgoritmo pode usar duas estratégias:

(b1) O algoritmo cria várias árvores t1, t2, ..., tn escolhendo, para cada uma, uma sequênciadiferente de cortes. Para buscar um vizinho próximo de qx, o algoritmo percorre todas as nárvores, obtendo n candidatos a vizinho próximo de qx. Dentre eles, o algoritmo escolheaquele que for o mais próximo de qx.

(b2) Ao buscar um vizinho qp próximo de qx numa árvore ti, o algoritmo faz “backtracking”. Istoé, ao chegar a uma folha s da árvore (um sub-cubo sem mais subdivisões), o algoritmo fazbuscas nos sub-cubos vizinhos de s para verificar se há um vizinho mais próximo de qx doque aquele encontrado no sub-cubo s.

14

4. Segmentação pela cor

4.1 O problema

Vamos considerar uma outra aplicação de aprendizagem de máquina em processamento de imagens:segmentar uma imagem pela cor dos pixels. Considere a figura 11c com feijões sobre cartolinabranca. Gostaríamos de pintar os feijões de preto e o fundo de branco. Se você tentar resolver esteproblema escrevendo manualmente um programa, irá constatar que é mais difícil do que podeparecer à primeira vista. Feijão possui várias tonalidades e há reflexos de luz. A cartolina temsombras de feijões.

A figura 12 mostra as projeções de todos os pixels da figura 11c (f1.jpg) nos planos de cores RG,RB e GB. Pode-se observar que não há uma separação nítida entre as cores dos feijões (marrom) eas cores da cartolina (cinza) no espaço RGB. Isto dificulta separar feijão do fundo.

Para resolver este problema usando aprendizagem de máquina, podemos pegar uma sub-imagem def1.jpg (AX figura 11a) e pintar manualmente de preto o feijão e de branco o fundo (imagem AY,figura 11b). Aí, fornecemos este par de imagens AX, AY como exemplos de treinamento paraprojetar um filtro F. Aplicamos este filtro F à imagem QX e esperamos que gere uma imagem desaída QP onde os feijões estão pintados de preto e o fundo de branco (figura 11d).

Pergunta: Qual é o tamanho de janela adequada para este filtro? A resposta correta é 1x1, pois ovalor de um pixel de saída depende exclusivamente da cor do pixel de entrada. Não depende de umavizinhança. A função característica deste filtro é f : [0, 255]3→{0,1} e o seu domínio (espaço dascaracterísticas) é o espaço das cores RGB com 2563 = 16.777.216 elementos.

Vimos quatro métodos até agora: (a) busca do vizinho mais próximo “força bruta”; (b) vizinho maispróximo usando tabela; (c) árvore de decisão; e (d) vizinho mais próximo aproximado usando kd-árvore.

Exercício: Resolva este problema usando vizinho mais próximo força bruta. Levaaproximadamente 8 minutos para resolver.

Seria difícil usar tabela (método b) neste caso, pelo tamanho do domínio. É possível usar árvore dedecisão (método c) e vizinho mais próximo aproximado usando kd-árvore (método d). Vamos usarimplementações prontas de OpenCV de decision-tree e kd-tree.

15

(a) AX amostra de entrada (b) AY amostra de saída

(c) QX (f1.jpg) imagem a processar

(d) QP imagem processadaFigura 11: Segmentação de uma imagem pela cor dos pixels.

16

rg.tga rb.tga gb.tgaFigura 12: Projeções do conjunto de pixels da imagem f1.jpg nos planos RG, RB e GB do cuboRGB.

4.2 Kd-árvore da OpenCV 2.X

Nota: As rotinas de aprendizagem de máquina sofreram grandes mudanças de OpenCV2 paraOpenCV3 e OpenCV4. Vários métodos de aprendizagem de máquina que funcionavamcorretamente na OpenCV2 não funcionam mais em OpenCV3/4, mesmo fazendo as adaptaçõesnecessárias. Nesta apostila, a maioria dos exemplos é para versão 2 (default no Cekeikon 5.2X).Usando Cekeikon, é possível especificar qual versão de OpenCV quer usar, com as opções -v2 ou-v3.

>compila programa -c -v2 (ou >compila programa -cek -ver2)>compila programa -c -v3 (ou >compila programa -cek -ver3)

FlaNN (Fast Library for Approximate Nearest Neighbors) é uma sub-biblioteca da OpenCV quepermite fazer busca rápida (mas aproximada) do vizinho mais próximo. FlaNN implementa kd-tree(entre outros métodos) para acelerar a busca do vizinho mais próximo.

17

123456789101112131415161718192021222324252627282930313233343536373839404142

//grad-2017 flann.cpp//segmentacao de feijao usando FlaNN//Usa OpenCV2#include <cekeikon.h>

int main() { Mat_<COR> ax; le(ax,"ax.png"); Mat_<GRY> ay; le(ay,"ay.png"); Mat_<COR> qx; le(qx,"f1.jpg"); if (ax.size()!=ay.size()) erro("Erro dimensao"); Mat_<GRY> qp(qx.rows,qx.cols);

//Cria as estruturas de dados para alimentar OpenCV Mat_<FLT> features(ax.rows*ax.cols,3); Mat_<FLT> saidas(ax.rows*ax.cols,1); int i=0; for (int l=0; l<ax.rows; l++) for (int c=0; c<ax.cols; c++) { features(i,0)=ax(l,c)[0]/255.0; features(i,1)=ax(l,c)[1]/255.0; features(i,2)=ax(l,c)[2]/255.0; saidas(i)=ay(l,c)/255.0; i=i+1; } flann::Index ind(features,flann::KDTreeIndexParams(4)); // Aqui, as 4 arvores estao criadas

Mat_<FLT> query(1,3); vector<int> indices(1); vector<FLT> dists(1); for (int l=0; l<qp.rows; l++) for (int c=0; c<qp.cols; c++) { query(0)=qx(l,c)[0]/255.0; query(1)=qx(l,c)[1]/255.0; query(2)=qx(l,c)[2]/255.0; // Zero indica sem backtracking ind.knnSearch(query,indices,dists,1,flann::SearchParams(0)); // Saida e' um numero entre 0 e 255 qp(l,c)=255*saidas(indices[0]); } imp(qp,"f1-flann.png");}

Algoritmo 3 - flann: Uso de FlaNN (vizinho mais próximo usando kd-tree) para segmentar feijões.

O algoritmo 3 mostra o uso de FlaNN (de OpenCV2) para segmentar feijões. Linhas 7-11 lêem asimagens AX, AY, QX e cria a imagem de saída QP.

A maioria das rotinas de aprendizagem de máquina de OpenCV exigem que as amostras detreinamento sejam colocados em duas matrizes tipo “float”:

Mat_<FLT> features(namostras,nfeatures); Mat_<FLT> saidas(namostras,1);

onde cada amostra (ax, ay) deve ser colocada numa linha da matriz. As linhas 14-24 do algoritmo 3fazem a conversão das imagens AX, AY para o formato desejado por OpenCV. Matriz features tem3 colunas, para armazenar as cores BGR. Estou adotando a convenção de que cores BGR em uint8(0 a 255) são convertidas para intervalo [0,1] quando forem armazenadas como float32.

Features ax Saidas ay

B G R Saida (0 ou 1)

...

18

A linha 25 cria 4 kd-árvores para buscar o vizinho próximo. As buscas serão feitas nas 4 árvores eserá escolhido o exemplo mais parecido com a instância de busca qx.

A rotina que faz busca na kd-árvore está na linha 37: ind.knnSearch(query,indices,dists,1,flann::SearchParams(0));

Esta rotina deve ser alimentada com matriz query com 3 colunas BGR. Os vetores indices e distsdevolvem respectivamente o índice do vizinho mais próximo na matriz features e a distância entreqx e o vizinho devolvido. Este método pode devolver mais de um vizinho mais próximo e portantoindices e dists são vetores.

Este programa demora 4s para processar e a saída obtida está na figura 13.

4.2 Árvore de decisão da OpenCV 2.X

12345678910111213141516171819202122232425262728293031323334

//dtree.cpp grad2017//Usa OpenCV2#include <cekeikon.h>

int main() { Mat_<COR> ax; le(ax,"ax.ppm"); Mat_<GRY> ay; le(ay,"ay.ppm"); if (ax.size()!=ay.size()) erro("Erro: Dimensoes diferentes");

Mat_<FLT> features(ax.total(),3); Mat_<FLT> saidas(ay.total(),1); for (unsigned i=0; i<ax.total(); i++) { features(i,0)=ax(i)[0]/255.0; features(i,1)=ax(i)[1]/255.0; features(i,2)=ax(i)[2]/255.0; saidas(i,0)=ay(i)/255.0; }

CvDTree arvore; arvore.train(features,CV_ROW_SAMPLE,saidas);

Mat_<COR> qx; le(qx,"f1.jpg"); Mat_<GRY> qp(qx.rows,qx.cols); for (unsigned i=0; i<qx.total(); i++) { Mat_<FLT> query(1,3); query(0)=qx(i)[0]/255.0; query(1)=qx(i)[1]/255.0; query(2)=qx(i)[2]/255.0; CvDTreeNode* no=arvore.predict(query); int r=255*(*no).value; qp(i)=r; } imp(qp,"f1-dtree.png");}

Algoritmo 4 - dtree: Uso de árvore de decisão para segmentar feijões.

O mesmo problema pode ser resolvido usando árvore de decisão (algoritmo 4). As linhas 19-20criam a árvore de decisão. As linhas 29-30 percorrem a árvore e devolvem o valor de saída.

Este programa demorou 0,2s para processar e a saída está na figura 13.

19

FlaNN com 4 árvores (4s) Decision-tree do OpenCV (0,2s)Figura 13: Saídas de flann (kd-tree) e decision-tree do OpenCV na segmentação de feijões.

4.3 Generalização vizinho mais próximo versus árvore de decisão

Olhando a figura 13, vemos que árvore de decisão é bem mais rápida que kd-árvore. Por outro lado,árvore de decisão errou na classificação dos pixels com reflexos dentro dos feijões. Podemos pensarque sempre a generalização do vizinho mais próximo será melhor que a da árvore de decisão, pois ésempre melhor aproximar a instância desconhecida pelo exemplo conhecido mais parecido. Istonem sempre é verdade.

Considere novamente classificar um indivíduo como “Adulto”, “Bebê” ou “Criança”, mas desta vezsão dados como entrada o peso em kg e a cor da pele (0 = escuro, 100 = claro). Evidentemente, acor da pele não tem nada a ver com a classificação A, B ou C, mas o algoritmo de aprendizagemnão sabe disso.

ax ay peso cor da pele

4 6 B15 50 C65 70 A5 7 B18 70 C70 80 A

Se classificar o indivíduo (20, 6) pelo vizinho mais próximo, o indivíduo será classificado comobebê, quando na verdade é criança. É possível descobrir automaticamente que a segundacaracterística é irrelevante? A árvore de decisão consegue descobrir. Veja o anexo A para maisdetalhes.

4.4 Exemplo gráfico da diferença entre vizinho mais próximo e árvore de decisão:

Considere classificar os pontos com 2 features f0 e f1 em “X” ou “O”, onde a classificação sódepende do valor f0 (figura 14).

Usando o vizinho mais próximo, “□” será classificada erradamente como “X”.

Usando a árvore de decisão, provavelmente “□” será classificada corretamente como “O”.

20

Figura 14: Vizinho mais próximo irá classificar “□” erradamente como “X”. Árvore de decisãoprovavelmente irá classificar “□” corretamente como “O”.

4.5 Boosting

Boosting calcula a média ponderada das saídas de muitos classificadores “fracos” para construir umclassificador “forte”. Os classificadores “fracos” são tipicamente árvores de decisão e os seus pesossão calculados a partir das suas taxas de erro. Algoritmo 5 usa boost do OpenCV 2.X parasegmentar feijões. Há mais explicações sobre boosting no anexo B.

123456789

10111213141516171819202122232425262728293031

//boost.cpp pos2017 OpenCV2#include <cekeikon.h>

int main() { Mat_<COR> ax; le(ax,"ax.ppm"); Mat_<GRY> ay; le(ay,"ay.ppm"); if (ax.size()!=ay.size()) erro("Erro: Dimensoes diferentes");

Mat_<FLT> features(ax.total(),3); Mat_<FLT> saidas(ay.total(),1); for (unsigned i=0; i<ax.total(); i++) { features(i,0)=ax(i)[0]/255.0; features(i,1)=ax(i)[1]/255.0; features(i,2)=ax(i)[2]/255.0; saidas(i,0)=ay(i)/255.0; }

CvBoost ind(features,CV_ROW_SAMPLE,saidas); Mat_<COR> qx; le(qx,"f1.jpg"); Mat_<GRY> qp(qx.rows,qx.cols);

for (unsigned i=0; i<qx.total(); i++) { Mat_<FLT> query(1,3); query(0)=qx(i)[0]/255.0; query(1)=qx(i)[1]/255.0; query(2)=qx(i)[2]/255.0; int pred=saturate_cast<GRY>(255.0*ind.predict(query,Mat(),Range::all(),false,true)); qp(i)=pred; } imp(qp,"f1-boost.png");}

Algoritmo 5 - boost: Uso de boosting para segmentar feijões.

21

4.6 Classificador de Bayes

Classificador de Bayes assume que os vetores de características de cada classe são distribuiçõesnormais. Assim, assume que a distribuição total dos dados é uma mistura de gaussianas, umcomponente por classe. O algoritmo treino estima a média vetorial e a matriz de covariância paracada classe e depois usa-as para fazer predição.

Figura 15: Classificação em grilo, gafanhoto e formiga usando classificador de Bayes.

Digamos que um pesquisador mediu duas características (digamos, peso e comprimento) de muitosgrilos, gafanhotos e formigas. A partir dos dados, o classificador de Bayes calcula as médiasvetoriais e as matrizes de covariância das três classes, que modelam as 3 distribuições normais.Plotando os três modelos obtidos num gráfico 2D, obtém gráfico como mostrado na figura 15-superior. Com isso, é possível dividir o espaço das características em regiões onde é mais provávelque o inseto seja de uma certa classe (figura 15-inferior). Com isso, dado peso e comprimento deum inseto, é possível escolher a classe de inseto mais provável com essas características.

A figura 16 mostra algumas distribuções de classes adequadas e inadequadas para serem resolvidasusando classificador de Bayes. Diremos que um algoritmo de aprendizagem é inadequado pararesolver um determinado problema se a sua taxa de erro esperada é alta, mesmo usando parâmetrosadequados e um número grande de amostras de treinamento.

A figura 17 mostra as saídas obtidas e os tempos de processamento para segmentar feijões usandoBoosting e Bayes.

22

Adequado para Bayes. Adequado para Bayes.

Adequado para Bayes. Inadequado para Bayes. Figura 16: Algumas distribuições de classes adequadas e inadequadas para serem classificadasusando Bayes.

boost (1.9s) qp-bayes (1,16s) Bayes

Figura 17: Segmentação de feijão usando Boosting e Bayes.

23

Lição de casa: Você pode escolher um dos dois exercícios para resolver: “lição de casa 1” ou “liçãode casa 2”. Os dois são semelhantes, mas o primeiro é um pouco mais fácil do que o segundo.

Lição de casa 1: Faça um programa que resolve o problema da figura 1, isto é, que detecta aspontas das retas, usando uma das funções de aprendizagem de máquina do OpenCV vista nestaaula. Depois, verifique que o seu programa também consegue detectar as bordas das imagensalimentando-o com os exemplos de treinamento da figura 5.

OU

Lição de casa 2: Implemente um programa que resolve o problema da figura 7, isto é, que mantémas letras “a” e “A” e apaga as outras letras da imagem, usando uma das técnicas de aprendizagemdescritas nesta aula. Pode usar as funções do OpenCV. Note que o seu programa só precisafuncionar para o tipo de fonte das imagens fornecidas (lax.bmp, lay.bmp e lqx.bmp).

24

Referências

[Mitchell1997] Tom. M Mitchell, Machine Learning, WCB/McGraw-Hill, 1997

[WikiML] https://en.wikipedia.org/wiki/Machine_learning, acessado em 3 de abril de 2020.

[WikiKD] https://en.wikipedia.org/wiki/K-d_tree, acessado em 8 de abril de 2020.

[Bentley1975] Bentley, J. L. (1975). "Multidimensional binary search trees used for associativesearching". Communications of the ACM. 18 (9): 509–517. doi:10.1145/361002.361007.

[wikiDecision] https://en.wikipedia.org/wiki/Decision_tree, acessado em 8 de abril de 2020.

[Kim2004] H. Y. Kim, “Binary Halftone Image Resolution Increasing by Decision-Tree Learning,” IEEE Trans. on Image Processing, vol. 13, no. 8, pp. 1136-1146, Aug. 2004.

[Kim2000] H. Y. Kim, “Binary Operator Design by k-Nearest Neighbor Learning with Application to Image Resolution Increasing,” Int. J. Imaging Systems, vol. 11, no. 5, pp. 331-339, 2000.

25

Anexo A: Ganho de informação

Como escolher o eixo de corte e o valor de corte da árvore de decisão? Como descobrir que umatributo é ruído? Como descobrir a importância de um atributo para resolver o problema declassificação?

Usarei o conceito de "ganho de informação" ou "redução de entropia", seguindo o livro[Mitchell, 1997].

Definição de entropiaã "the entropa of a phasical sastem is the minimum number of bits aouneed to fulla describe the detailed state of the sastem"[httpã//www.science20.com/hammock_phasicist/what_entropa-89730]

A entropia de um conjunto de amostras S contendo amostras positivas e negativas nasproporções p⊕ e p⊖ éã

Entropy (S)=−p⊕ log2 p⊕−p⊖log2 p⊖

A entropia assume valor 1 se p⊕=p⊖=0.5 (precisa de um bit para informar se um exemplo épositivo ou negativo). Assume valor 0 se p⊕=0 ou p⊖=0 (não precisa de nenhum bitpara informar se um exemplo é positivo ou negativo, pois só há exemplos de um único tipo).Assume valores entre 0 e 1 para as outras proporções.

O ganho de informação ou a redução de entropia ao dividir o conjunto de amostras usando umcerto atributo A éã

Gain(S , A)=Entropy (S)− ∑Sv ⊂Divisao (A, S )

[|Sv||S|

Entropy (Sv)]onde Divisao(S,A) é o conjunto de todos os subconjuntos de S obtido ao dividir o conjunto Susando o atributo A.

Exemploã Considere as seguintes amostras de treinamentoãatributos rótulos

peso cor da pele classifcação

baixo escura bebê

baixo clara bebê

alto clara adulto

alto escura adulto

Evidentemente, é melhor usar o atributo "peso" pois o atributo "cor" não ajuda em nada aclassificar os indivíduos em bebê ou adulto. Vamos verificar se é possível descobrir isto usandoganho de informação. A entropia da amostra de treinamento éã

Entropy (S)=−p⊕log2 p⊕−p⊖log2 p⊖=−0.5 log20.5−0.5 log20.5=0.5+0.5=1

Se escolher o atributo "peso" para dividir as amostras, o ganho de informação é um bit.

Gain(S , peso)=Entropy (S)− ∑v∈Values (A )

[|Sv||S|

Entropy (Sv)]=1− 24×0−2

4×0=1

Se escolher o atributo "cor da pele" para dividir as amostras, o ganho de informação é zero bit.

Gain(S , cor )=Entropy (S)− ∑v∈Values (A )

[|Sv||S|

Entropy (Sv )]=1− 24×1−2

4×1=0

26

Portanto, não se ganha nada ao escolher o atributo cor para dividir as amostras. Por outrolado, escolhendo o atributo peso para dividir a amostra, os indivíduos ficam perfeitamenteclassificados em bebê ou adulto.

Anexo B: Boosting

Copio o trecho abaixo sobre boosting do manual do OpenCV. Para maiores detalhes, veja o própriomanual do OpenCV e artigos referenciados.

Boosting is a powerful learning concept that provides a solution to the supervised classificationlearning task. It combines the performance of many “weak” classifiers to produce a powerfulcommittee [HTF01]. A weak classifier is only required to be better than chance, and thus can bevery simple and computationally inexpensive. (...) Decision trees are the most popular weakclassifiers used in boosting schemes. (...) The desired two-class output is encoded as -1 and +1.Different variants of boosting are known as Discrete Adaboost, Real AdaBoost, LogitBoost, andGentle AdaBoost [FHT98]. (...) This chapter focuses only on the standard two-class DiscreteAdaBoost algorithm, outlined below.

Initially the same weight is assigned to each sample (step 2). Then, a weak classifier fm(x) istrained on the weighted training data (step 3.1). Its weighted training error and scaling factor c m iscomputed (step 3.2). The weights are increased for training samples that have been misclassified(step 3.3). All weights are then normalized, and the process of finding the next weak classifiercontinues for another M -1 times. The final classifier F(x) is the sign of the weighted sum over theindividual weak classifiers (step 4).

Algoritmo AdaBoost escrito de forma informal (extraído de Wikipedia):

Form a large set of simple features Initialize weights for training images For T rounds

1. Normalize the weights 2. For available features from the set, train a classifier using a single feature and

evaluate the training error 3. Choose the classifier with the lowest error 4. Update the weights of the training imagesã increase if classified wrongla ba this

classifier, decrease if correctla Form the final strong classifier as the linear combination of the T classifiers (coeficient largerif training error is small)

Two-class Discrete AdaBoost Algorithm (do manual do OpenCV):

Step 1. Set N examples (xi, yi)i = 1, ..., N, with xi R∈ K, yi −1, +1 .∈Step 2. Assign weights as wi = 1/N, i = 1, ..., N.Step 3. Repeat for m = 1, 2, ..., M : 3.1. Fit the classifier fm (x) −1, 1, using weights w∈ i on the training data. 3.2. Compute errm = Ew[1(y≠fm (x))], cm = log( (1 − errm )/errm ) . 3.3. Set wi w⇐ i exp[cm 1(yi≠fm (xi)) ], i = 1, 2, ..., N, and renormalize so that Σi wi = 1 .Step 4. Classify new samples x using the formula: sign(Σm = 1

M cm fm (x)) .

27