FUNDAÇÃO EDUCACIONAL DE DUQUE DE CAXIAS

CURSO DE BACHARELADO EM SISTEMAS DE INFORMAÇÃO

PROJETO DE PESQUISA: UM EFICIENTE ALGORITMO DE CLUSTERIZAÇÃO KMEANS: ANÁLISE E IMPLEMENTAÇÃO

Alunos:

Emmanoel Jefferson dos Santos Jefferson Pita dos Santos Ícaro Figueira Martins de Oliveira

Coordenação: Prof. Renan Souza

Duque de Caxias, 01 de Junho de 2009

FUNDAÇÃO EDUCACIONAL DE DUQUE DE CAXIAS

CURSO DE BACHARELADO EM SISTEMAS DE INFORMAÇÃO

PROJETO DE PESQUISA: Um eficiente Algoritmo de Clusterização k-Means: Análise e Implementação

_______________________________________ Emmanoel Jefferson dos Santos
(Aluno)

_________________

_______________________________________ Jefferson Pita dos Santos
(Aluno)

_________________

_______________________________________ Ícaro Figueira Martins de Oliveira
(Aluno)

_________________

_______________________________________ Renan Souza
(Coordenador Responsável)

_________________

2

ÍNDICE
Resumo ...........................................................................................................................pág 4 Introdução .....................................................................................................................pág 4 O Algoritmo de Filtragem ............................................................................................pág 5 Análise Empírica ...........................................................................................................pág 6 Dados Sintéticos .................................................................................................pág 6 Anexos........ ....................................................................................................................pág 8 Bibliografia ..................................................................................................................pág 10

3

Um eficiente Algoritmo de Clusterização k-Means: Análise e Implementação
Resumo: Na clusterização com k-means, nos é dado um conjunto de n pontos de dados em um espaço dimensional Rd e um inteiro k e o problema é determinar um conjunto de k pontos em Rd, chamados centros, de modo a minimizar a distância média de cada ponto de dados para o seu centro mais próximo. Uma popular descoberta para o k-means é o algoritmo de Lloyd's. Nesta pesquisa, apresentamos uma implementação simples e eficiente do algoritmo de clusterização Lloyd's k-means, que nós chamamos de algoritmo de filtragem. Este algoritmo é de fácil implementação, exigindo uma kd-tree como única estrutura de dados importante.

1. Introdução
Problemas de clusterização surgem em muitas aplicações diferentes, como a mineração de dados e descoberta de conhecimento, a compressão de dados e quantização vetorial, e reconhecimento de padrões e classificação de padrões. A noção do que constitui um bom cluster depende da aplicação e existem muitos métodos para encontrar clusters sujeitos a vários critérios, como ad hoc e sistemática. Entre as formulações de clusterização que se baseiam na minimização dos dados, a mais amplamente utilizada e estudada é o k-means. Dado um conjunto de n pontos de dados no espaço real ddimensional, Rd, e um inteiro k, o problema é determinar um conjunto de pontos de k na Rd, chamadas de centros, de modo a minimizar a distância média do quadrado de cada ponto de dados para o seu centro mais próximo. Esta medida é muitas vezes chamada de distorção de erro-quadrado, e este tipo de agrupamento se insere na categoria geral de variância baseada em clusterização. Clusterização baseada em k-means está estreitamente relacionada com o número de clusters e outros problemas de localização. Estes incluem o k-means Euclidiano, em que o objetivo é minimizar a soma das distâncias para o próximo centro e o problema k-center geométrico em que o objetivo é minimizar a distância máxima de todos os pontos ao seu centro mais próximo. Não existem soluções eficientes conhecidas a qualquer um destes problemas e algumas formulações são NPhard. Uma aproximação eficiente para o problema de clusterização k-means foi apresentado pela Matousek, mas grande fatores constantes sugerem que não é um bom candidato para a aplicação prática. Uma das mais populares descobertas para resolver o problema do k-means é baseado em um esquema simples e iterativo para encontrar localmente uma solução mínima. Este algoritmo é freqüentemente chamado de algoritmo K-means. Há uma série de variantes para esse algoritmo, assim, para esclarecer qual a versão que estamos usando, nós iremos nos referir a ele como algoritmo de Lloyd's. Algoritmo de Lloyd's é baseado na observação simples que o melhor posicionamento de um centro está no baricentro dos clusters associados. Dado qualquer conjunto k de centros Z, para cada centro de z ϵ Z, deixe V(z) denotar sua vizinhança, isto é, o conjunto de pontos de dados para que Z é o vizinho mais próximo. Em terminologia geométrica, V(z) é o conjunto de pontos de dados situados na célula de Voronoi de z. Cada etapa do algoritmo de Lloyd's move cada ponto central em z para o baricentro de V(z) e em seguida atualiza V(z) recalculando a distância de cada ponto para seu centro mais próximo. Estes passos são repetidos até que alguma condição de convergência é satisfeita. Para os pontos em posições gerais (em particular, se nenhum ponto de dados é próximo dos dois centros), o algoritmo irá eventualmente convergir para um ponto que é um local mínimo para a distorção. No entanto, o resultado não é necessariamente um mínimo global. O algoritmo de Lloyd's pressupõe que os dados estão presentes na memória. Note que o algoritmo de Lloyd's não especifica o colocação inicial dos centros.

4

Devido à sua simplicidade e flexibilidade, o algoritmo de Lloyd's é muito popular na análise estatística. Em particular, dado qualquer outro algoritmo de clusterização, o algoritmo de Lloyd's pode ser aplicado como um estágio de pós-processamento para melhorar a distorção final. Como veremos em nossas experiências, isso pode resultar em significativas melhorias. No entanto, uma aplicação simples do algoritmo de Lloyd's pode ser bastante lento. Isto é principalmente devido ao custo de computação dos vizinhos mais próximos. Neste trabalho, apresentamos uma simples e eficiente execução do algoritmo de Lloyd's, a que chamamos algoritmo de filtragem. Este algoritmo começa por armazenar os dados pontos em uma kd-tree. Lembre-se que, em cada fase do algoritmo Lloyd's, o centro mais próximo a cada ponto de dados é computado e cada centro é movido para o centróide do vizinho associado. A idéia é manter, para cada nó da árvore, um subconjunto de centros de candidatos. Os candidatos para cada nó são podados, ou filtrados, eles são propagados para o filhos do nó. Desde que a kd-tree é computada para os pontos de dados em vez de para os centros, não há necessidade de atualizar esta estrutura, em cada etapa do algoritmo de Lloyd's. Além disso, uma vez que existem normalmente muitos mais pontos de dados que centros, há grande economia de escala a ser realizado. Note-se que este não é um método de agrupamento novo, mas simplesmente uma aplicação eficaz de Lloyd's k-means. O objetivo deste trabalho é apresentar uma análise mais detalhada deste algoritmo. Em particular, nós apresentamos um teorema que quantifica a eficiência do algoritmo quando os dados são agrupados e, naturalmente, nós apresentamos uma série detalhada de experimentos projetados para o avanço da compreensão do desempenho do algoritmo.

2. O Algoritmo de Filtragem
Nesta seção, descrevemos o algoritmo de filtragem. Como mencionado anteriormente, o algoritmo em baseado em armazenar o pontos de dados multidimensionais em uma kd-tree. Para completar, resumimos os elementos básicos desta estrutura de dados. Definir uma caixa a ser um eixo alinhado à hiper-retângulo. A caixa delimitadora de um conjunto de pontos é a menor caixa que contêm todos os pontos. Uma kd-tree é uma árvore binária, o que representa um subdivisão hierárquica do conjunto de pontos da caixa delimitadora com eixo alinhado a hiperplanos divididos. Cada nó da kd-tree está associado a uma caixa fechada, chamada de célula. A célula raiz é a caixa delimitadora do conjunto de pontos. Se a célula contém mais um ponto, então é declarada para ser uma folha. Caso contrário, ele é dividido em dois hiper-retângulos por um eixohiperplano ortogonal. Os pontos da célula são, então, particionadas para um lado ou para o outro deste hiperplano. As sub-células resultantes são filhas da célula original, conduzindo assim a uma estrutura de árvore binária. Há uma série de maneiras de selecionar a divisão do hiperplano. Uma maneira simples é dividir ortogonalmente ao lado mais longo da célula através da mediana coordenada dos pontos associados. Dado n pontos, isso produz uma árvore com O(n) nós e O(log n) profundidade. Começamos a calcular uma kd-tree para os pontos de dados. Para cada nó interno u na árvore, podemos calcular o número de pontos de dados associados u.count e ponderada ao centróide u.wgtCent, que é definido como a soma vetorial de todos os pontos associados. O centróide atual é apenas u.wgtCent/u.count. É fácil de modificar a construção da árvore kd-tree para calcular esta informação adicional no mesmo espaço e limites de tempo acima indicados. Os centros iniciais podem ser escolhidos por qualquer método desejado. (Algoritmo Lloyd's não especifica como eles deverão ser selecionados. Um método comum é a amostra ao acaso dos centros dos pontos de dados.) Lembre-se que, para cada fase do algoritmo Lloyd's, para cada um dos centros de k, temos que calcular o centróide do conjunto de pontos de dados para que este centro é mais próximo. Em seguida, mover este centro para o centróide calculado e avançar para a próxima fase. Para cada nó da kd-tree, mantemos um conjunto de centros candidatos. Isto é definido como um subconjunto dos pontos centrais que poderiam servir como o vizinho mais próximo de algum ponto inserido dentro da célula associada. Os centros candidatos para a raiz consistem de todos os centros k. Em seguida, devemos propagar os candidatos para baixo da árvore da seguinte forma: Para cada nó u, deixe C denotar sua célula e deixe Z denotar seu conjunto de candidatos. Primeiro, calcule o candidato z* ϵ Z que está mais próximo do

5

ponto médio de C. Então, para cada um dos restantes candidatos z* ϵ Z \{z*}, se nenhuma parte do C está mais perto de z do que é a z*, podemos inferir que z não é o mais próximo ao centro que qualquer ponto de dados associados com u e, portanto, podemos podar, ou filtrar, z da lista de candidatos. Se u é associado com uma único candidato (que deve ser z*), então z* é mais vizinho próximo de todos os seus pontos de dados. Podemos atribuí-los a z* e adicionar ao centróide associado e contar em z*. Caso contrário, se u é um nó interno, nós corremos seus filhos. Se u é um nó folha, vamos calcular as distâncias dos seus pontos de dados associados a todos os candidatos em Z e atribuir o dados apontam para o seu centro mais próximo. (Veja Fig. 1.) Ela continua a descrever como determinar se há qualquer parte da célula C, que está mais próximo do candidato z do que a z*. Permitindo H ser o hiperplano divide o segmento de linha ZZ. (Veja Fig. 2) H define dois halfspaces; um que esteja mais próximo a z e outro para z*. Se C está totalmente ao lado de H, então deve estar no lado que está mais próximo de z* (já que o ponto médio de C é próximo de z*) e assim z pode ser podada. Para determinar qual é o caso, considere o vetor u = z – z*, dirigido a partir de z* para z. Para v(H) denotar o vértice de C que é extrema neste direção, isto é, o vértice C que maximize o ponto produto (v(H)*u). Assim, z é podado se e somente se dist(z,v(H))>=dist(z*,v(H)). ( Distâncias quadradas podem ser usadas para evitar tomar raízes quadradas.) Para calcular v(H), vamos [C (min) i, C (max) i] denotando a projeção de C para o i-ésimo eixo de coordenadas. Nós tomamos a i-ésima coordenada de v(H) para ser de C (min) i se a i-ésima coordenada de u é negativa e C (max) i é o contrário. Este cálculo é implementado através do procedimento z.isFather(z*,C), que retorna verdadeiro se todas as partes C está mais longe de z que z*. A chamada inicial é Filter(r,Z0), onde r é a raiz da árvore e Z0 é o conjunto atual de centros. No fim, o centro z é movido para o centróide de seus pontos associados, isto é, z<-z.wgtCent/z.count. Nossa implementação difere um pouco das de Alsabti, Pelleg e Moore. A implementação do algoritmo de filtragem de Alsabti usa um método menos eficaz de poda baseado no cálculo das distâncias máximas e mínimas de cada célula, ao contrário do critério que atravessa o hiperplano. A implementação de Pelleg e Moore usa o hiperplano dividido, mas define z* (o chamado proprietário) para ser o candidato que minimiza a distância para o célula em vez do ponto médio da célula. Nossa abordagem tem a vantagem que, se dois candidatos encontram-se dentro da célula, ele selecionará o candidato que está mais próximo do ponto médio da célula.

3. Análise Empírica
Para estabelecer a eficiência prática do algoritmo de filtragem, temos implementado e testado o seu desempenho em um número de conjuntos de dados. Estes incluíram tanto dados gerados sinteticamente e os dados utilizados em aplicações reais. O algoritmo foi implementado em C + + utilizando o compilador Dev C++. A estrutura de dados implementada foi uma kd-tree, que foi construída a partir da biblioteca ANN usando a regra do ponto médio deslizante. Este método de decomposição foi escolhido porque os nossos estudos demonstraram que funciona melhor do que o padrão de decomposição kd-tree para os conjuntos de dados em cluster. Essencialmente, nós realizamos dois tipos diferentes de experiências. No primeiro tipo, comparamos o tempo de execução do algoritmo de filtragem contra duas diferentes implementações do algoritmo de Lloyd's. O segundo tipo de comparação de distorções de cluster são obtidos para o algoritmo de filtragem com aqueles obtidos para o esquema de clusterização BIRCH. O primeiro tipo de testes é apresentado neste trabalho, mas a segunda etapa de testes deverá ser especificada em outro documento. • Dados Sintéticos

Nós fizemos três experimentos para determinar as variações no tempo de duração em função da separação de cluster, conjunto de dados de tamanho, e dimensão. O primeiro experimento testou a validade do Teorema 1. Nós geramos n=10000 pontos de dados em R³. Estes pontos foram distribuídos uniformemente entre os 50 grupos da seguinte forma: Os 50 centros de cluster foram amostradas em um uniforme distribuição ao longo do hipercubo [-1,1]^d. A distribuição de Gaussiana foi gerada em torno de cada centro, onde cada coordenada foi gerada independentemente a partir de uma única variável Gaussiana com desvio-padrão. O desvio padrão variou de 0,01 (muito bem separadas) até 0,7 (virtualmente clusterizado). Porque a mesma distribuição foi utilizada para

6

os centros de cluster por toda parte, as distâncias esperadas entre os centros de cluster permaneceram constantes. Assim, o valor esperado do parâmetro p de separação cluster variou inversamente com o desviopadrão. Os centros iniciais foram escolhidos, tomando uma amostra aleatória de pontos de dados. Para cada desvio padrão, rodamos cada um dos algoritmos (brute-force, kd-center, e filter) três vezes. Para cada uma dos três testes, um novo conjunto de pontos de centro inicial foi gerada e todos os três algoritmos foram executados utilizando o mesmos dados e pontos de centro inicial. O algoritmo funcionou para um máximo de 30 estágios ou até de convergência. A média de tempo de CPU por etapa, para todos os três métodos, são mostrados para k=50 na fig. 2a e para k = 20 na fig. 3a. Os resultados destes experimentos mostram que o algoritmo de filtragem executa significativamente mais rápido que os outros dois algoritmos. Ignorando o viés introduzido pelo préprocessamento, seu funcionamento em tempo melhora quando os clusters são mais bem separados (para menores desvios-padrão). A melhoria em tempo de CPU previsto pelo Teorema 1 não é realmente evidente para desvios-padrão muito pequenos, pois a inicialização e os custos de pré-processamento dominam. No entanto, esta melhoria é indicada nas figuras 2b e 3b, que o enredo (inicialização independente) o número de nós candidatos pares. O número de nós pares candidatos para os outros dois métodos não são mostrados, mas variou de 4 a 10 vezes superiores às do algoritmo de filtragem. Nossa análise teórica não prevê que o algoritmo de filtragem será particularmente eficiente para conjuntos de dados não-clusterizados, mas não exclui essa possibilidade. No entanto, observa-se neste experimento que o algoritmo de filtragem funcionou muito mais rápido do que os algoritmos brute-force e kd-center, mesmo para grandes desvios-padrão. Isto pode ser atribuído, em parte, ao fato de que o algoritmo de filtragem simplesmente fazer um trabalho melhor em explorar as economias de escala por armazenar o conjunto muito maior de pontos de dados em uma kd-tree (ao invés de pontos de centro como de kd-center faz). O objetivo do segundo experimento foi estudar os efeitos do tamanho dos dados sobre o tempo de execução. Geramos conjuntos de pontos de dados, cujo tamanho variava de n=1000 a n=2000 e onde cada conjunto de dados consistiu de 50 clusters Gaussianos. O desvio-padrão foi fixado em 0,10 e os algoritmos foram funcionaram com k=50. Novamente, as buscas foram encerradas quando estabilidade foi conseguida, ou depois de 30 etapas. Como antes, rodamos cada caso, três vezes, com diferentes centros de partida e média dos resultados. Os tempos de CPU por estágio e número de nós pares candidatos para todos os três métodos são mostrados na figura 4. Os resultados deste experimento mostram que, para k fixo e grandes n, todos os três algoritmos têm executando vezes que variam linearmente com n, com o algoritmo de filtragem fazendo o melhor. Repetimos um experimento similar a um usado por Pelleg e por Moore. Para cada dimensão d, nós criamos um conjunto de dados aleatórios com 20.000 pontos. Os pontos foram amostra de uma distribuição Gaussiana agrupados com 72 grupos e um desvio padrão de 0,05 ao longo de cada coordenada. (O desvio padrão é o dobro da utilizada por Pelleg e Moore porque usaram um unidade hipercubo e o nossa hipercubo tem lado de comprimento 2.) Os três algoritmos k-means foram executados com um k=40 centros. Na figura 5, marcamos a média de vezes tomadas por estágio para os três algoritmos. Vimos que para esta configuração, o algoritmo de filtragem supera os algoritmos brute-force e kd-center em dimensões que variam até a 20s. Estes resultados confirmam a tendência geral, mas o desempenho do algoritmo de filtragem em moderadas dimensões 10-20 é consideravelmente melhor.

7

4. Anexos

Figura 1 – O Algoritmo de Filtragem

Figura 2 – Média de tempo de processamento e pares de nós candidatos por estágio versus desvio padrão de um cluster n=10000 e k=50.

8

Figura 3 - Média de tempo de processamento e pares de nós candidatos por estágio versus desvio padrão de um cluster n=10000 e k=20.

Figura 4 – Testando tempos e pares de nós candidatos versus tamanhos de dados para k=50 e ἀ=0,10

9

Figura 5 – Média de tempo de processamento por estágio versus dimensões para n=20000, ἀ=0,05, e k=40 5.

BIBLIOGRAFIA
• On Lloyd’s k-means Method – 2007 Sariel Har-Peled Bardia, Sariel Har-peled, Bardia Sadri http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.2480 K-Means Clustering Algorithms: Implementation and Comparison - 2007 The University of Iowa, Iowa City, Iowa, USA Gregory A. Wilkin, Xiuzhen Huang http://www2.computer.org/portal/web/csdl/doi/10.1109/IMSCCS.2007.51

10