DissertacaoMestrado LiciniaMonteiro 53160

Algoritmo Plug-in LVQ para Servidor SQL
Licnia Pedro Monteiro

Dissertao para obteno do Grau de Mestre em
Engenharia Informtica e de Computadores (MEIC)

Jri
Presidente: Prof. Doutora Ana Almeida e Paiva
Orientador: Prof. Doutor Andreas Miroslaus Wichert
Vogal: Prof. Doutor Diogo Ferreira

Setembro 2008

2

Agradecimentos
Foi possvel concretizar este trabalho devido ajuda de algumas pessoas que directa ou
indirectamente para ele contriburam, e s quais aqui agradeo.
Em primeiro lugar, agradeo pessoa que tornou este trabalho possvel e que foi uma enorme
ajuda durante todo o processo de execuo, o Professor Andreas Wichert que com a sua boa
vontade e esprito alegre, resolvia todos os pequenos problemas que iam surgindo e que me dava
nimo para continuar. A sua disponibilidade e pacincia foram interminveis e sem ele este trabalho
no teria sido possvel.
Seguidamente gostaria de agradecer minha famlia, pais e irmo, que sempre me apoiaram e
foram muito compreensivos quanto ao tempo que no lhes dava ateno para dedicar a este
trabalho. Obrigado pela compreenso e pelos sorrisos quando o trabalho no corria como gostava.
Gostaria tambm de agradecer ao meu namorado, que leu este trabalho vrias vezes e corrigiu
alguns erros, que sem ele ainda hoje c estariam. Agradeo-lhe a ateno demonstrada durante
todas as noites que lhe falava deste trabalho, e sem ser a sua rea, me tentava compreender.
Obrigado pela pacincia.
Agradeo aos companheiros de gabinete onde a maioria deste trabalho foi implementado e
escrito, foi bom ter algum to alegre e bem-disposto com quem partilhar os problemas e as
pequenas conquistas. Obrigado a todos pela companhia e pelo vosso apoio.
Gostaria de agradecer tambm a todos os meus amigos de quem estive um pouco mais afastada
para fazer frente a este desafio, todos os poucos minutos passados com eles neste ltimo ano foram
revitalizantes e davam-me novas foras para continuar este projecto. Desculpem pela pouca ateno
que vos dispensei, obrigado pela compreenso e pelo carinho.
Por ltimo, quero agradecer pessoa que tornou este trabalho fsico, dando-lhe vida para que o
leitor possa folhear as suas pginas. Obrigada amiga, foste incansvel quando imprimiste este
trabalho em tempo recorde.

3

Resumo
Este trabalho pretende descrever a nova funcionalidade desenvolvida no mbito do Data Mining.
Nos ltimos anos esta rea sofreu grandes modificaes, e a minerao de dados vista como uma
rea em expanso, muito importante em qualquer empresa, nomeadamente nas tarefas de
classificao e previso de dados. O objectivo deste projecto implementar um novo algoritmo para
realizar essas tarefas na ferramenta mais usada para as efectuar, o Microsoft SQL Server 2005 [16,
19].
Existem outras ferramentas utilizadas no mercado para Data Mining e integrao de novos
algoritmos, tais como as disponibilizadas pelo Oracle [11, 29] e SAS [7, 8]. Ambas as ferramentas
apresentam alguns inconvenientes no que trata de integrar novos algoritmos. Como exemplo, o SAS
oferece pouca informao no que respeita a esse tipo de desenvolvimento, o que iria tornar bastante
difcil este trabalho. Alm disso, visto que a ferramenta da Microsoft a mais procurada pelas
empresas e a mais utilizada, oferecendo alguma literatura e ajuda para a integrao de novos
algoritmos, revelou-se a escolha mais adequada para o desenvolvimento desta tese.
Nesta ferramenta j so disponibilizados vrios algoritmos, como o caso de rvores de Deciso
[6, 10, 17], Redes Neuronais Artificiais [6, 9, 10, 12, 17], Clustering [6, 10, 17], entre outros. O novo
algoritmo, Learning Vector Quantization [1, 2, 13, 15, 16], vem acrescentar valor a esta ferramenta,
pois um algoritmo fcil de perceber, simples, com tempos de execuo semelhantes aos algoritmos
referidos e cujos resultados de classificao so superiores. Como um caso especial de Redes
Neuronais Artificiais, este algoritmo tem uma aprendizagem supervisionada [17, 18], e uma das
grandes vantagens que a sua integrao com o Microsoft SQL Server 2005 [16, 19] oferece a
opo do utilizador poder ver os vectores de referncia que tero um papel importante na
classificao dos vectores de teste fornecidos pelo utilizador.

Palavras-chave
Data Mining, Data Warehouse, Aprendizagem Supervisionada, Aprendizagem No
Supervisionada, rvores de Deciso, Clustering, Nearest Neighbor, Redes Neuronais, Naive Bayes,
Microsoft SQL Server, ORACLE, SAS e Learning Vector Quantization, Integrao e Algoritmo Plug-In.

4

Abstract
In the last years Data Mining area underwent great changes. It is seen as an expanding area of the
greatest importance in every company in tasks like data classification and data prevision. The goal of
this work is to implement a new data mining algorithm in Microsoft SQL Server 2005, this way adding
to its functionality.
We considered other Tools in the data mining market in order to plug-in new algorithms, namely
Oracle and SAS. Both these tools developed present the same inconvenient: offers little information to
the programmer about this subject, and in SAS case, the new algorithm should be implemented in a
proper language. Besides that, the Tool offered by Microsoft is the most used by companies, and
offers tutorials and help for the integration, that?s why that was the chosen Tool.
In this Tool some of the most known algorithms are implemented, like Decision Trees, Artificial
Neural Networks and Clustering. The goal of this new algorithm, Learning Vector Quantization, is to
increase the value of the Tool. The algorithm has a simple structure and is very easy to understand.
His execution times are similar to the algorithms here referred, and the classification results are very
good. As this algorithm is a special case of Artificial Neural Networks, it has a supervised learning. His
big advantage is the possibility of the final codebook vectors being seen by the user. This way the
user can use that information to maximize the accuracy of the algorithm in the classification task.

Key Words
Data Mining, Data Warehouse, Supervised Learning, Unsupervised Learning, Decision Trees,
Clustering, Nearest Neighbour, Artificial Neural Networks, Nave Bayes, Microsoft SQL Server 2005,
Oracle, SAS, Learning Vector Quantization, Integration and Plug-in Algorithm.

5

ndice
Agradecimentos ....................................................................................................................................... 2
Resumo .................................................................................................................................................... 3
Abstract .................................................................................................................................................... 4
ndice........................................................................................................................................................ 5
Lista de Tabelas ....................................................................................................................................... 7
Lista de Figuras ....................................................................................................................................... 7
Lista de Matrizes ...................................................................................................................................... 9
Lista de Grficos .................................................................................................................................... 10
1 Introduo ......................................................................................................................................... 11
1.1 Data Mining ................................................................................................................................ 11
1.2 Objectivos ................................................................................................................................... 12
1.3 Estrutura ..................................................................................................................................... 12
2 Vista geral ......................................................................................................................................... 14
2.1 Tarefas de Data Mining .............................................................................................................. 15
2.1.1 Classificao ....................................................................................................................... 15
2.1.2 Previso ............................................................................................................................... 16
2.1.3 Regresso ........................................................................................................................... 16
2.1.4 Associao .......................................................................................................................... 16
2.1.5 Clustering............................................................................................................................. 16
2.2 Tcnicas de Data Mining ............................................................................................................ 17
2.2.1 rvores de deciso .............................................................................................................. 18
2.2.2 Nearest Neighbor ................................................................................................................ 20
2.2.3 Naive Bayes ........................................................................................................................ 22
2.2.4 Redes Neuronais Artificiais ................................................................................................. 24
2.2.5 Learning Vector Quantization .............................................................................................. 26
2.2.6 Clustering............................................................................................................................. 27
2.3 Ferramentas ............................................................................................................................... 32
2.3.1 Microsoft SQL Server .......................................................................................................... 32
2.3.2 SAS ...................................................................................................................................... 33
2.3.3 Oracle .................................................................................................................................. 34
2.3.4 Comparao das ferramentas ............................................................................................. 38
3 Learning Vector Quantization (LVQ)................................................................................................. 39
3.1 Deciso ptima .......................................................................................................................... 39
3.2 LVQ1 .......................................................................................................................................... 40
3.3 Optimized-Learning-Rate LVQ1 (OLVQ1) ................................................................................. 42
3.4 LVQ2 .......................................................................................................................................... 43

6

3.5 LVQ3 .......................................................................................................................................... 44
3.6 Diferenas entre LV1, LVQ2 e LVQ3 ......................................................................................... 44
3.7 Consideraes gerais ................................................................................................................ 45
3.7.1 Inicializao dos vectores de referncia ............................................................................. 45
3.7.2 Aprendizagem ..................................................................................................................... 46
3.7.3 Regra de paragem ............................................................................................................... 46
3.8 Vantagens .................................................................................................................................. 46
4 Microsoft SQL Server 2005 .............................................................................................................. 47
4.1 Interfaces .................................................................................................................................... 47
4.1.1 Interfaces do algoritmo usando C++ ................................................................................... 47
4.1.2 Interfaces do algoritmo usando C# ..................................................................................... 50
4.2 Plug-In ........................................................................................................................................ 53
4.2.1 O modelo: Learning Vector Quantization ............................................................................ 53
4.2.2 Construir um Algoritmo Plug-in............................................................................................ 54
4.2.3 Personalizar o algoritmo ...................................................................................................... 57
5 Microsoft SQL Server com LVQ ....................................................................................................... 61
5.1 Arquitectura do utilizador ........................................................................................................... 61
5.1.1 Criar uma fonte de dados .................................................................................................... 61
5.1.2 Criar uma vista sobre os dados ........................................................................................... 62
5.1.3 Construir o modelo .............................................................................................................. 63
5.1.4 Realizar previses sobre o modelo ..................................................................................... 65
5.1.5 Personalizar os parmetros................................................................................................. 66
5.2 Experincias ............................................................................................................................... 67
5.2.1 Teste bsico ........................................................................................................................ 67
5.2.2 Teste avanado ................................................................................................................... 71
5.2.3 Testes avanados: AdventureWorksDW ............................................................................. 74
5.2.4 Concluso das experincias................................................................................................ 83
6 Concluso ......................................................................................................................................... 85
7 Anexo: Arquitectura Microsoft SQL Server 2005 .............................................................................. 87
7.1.1 Arquitectura do servidor ...................................................................................................... 87
7.1.2 Arquitectura do cliente ......................................................................................................... 88
7.1.3 Fluxo de dados .................................................................................................................... 88
8 Glossrio ........................................................................................................................................... 91
9 Bibliografia ........................................................................................................................................ 93

7

Lista de Tabelas

5.1 Parmetros do primeiro teste bsico, com todos os valores por omisso dos parmetros
do algoritmo. ............................................................................................................................. 68
5.2 Parmetros do algoritmo para o segundo teste bsico. ........................................................... 69
5.3 Parmetros do algoritmo LVQ para o terceiro teste bsico. ..................................................... 70
5.4 Descrio das amostras de treino e de teste para o teste avanado. ...................................... 71
5.5 Parmetros do algoritmo LVQ para o primeiro teste avanado. .............................................. 72
5.6 Parmetros do algoritmo LVQ para o segundo teste avanado. .............................................. 73
5.7 Parmetros do algoritmo LVQ para o terceiro teste avanado. ............................................... 74
5.8 Parmetros da primeira experincia do algoritmo LVQ para o primeiro teste com
AdventureWorksDW onde os conjuntos de treino e de teste eram representados pela
mesma tabela, vTargetMail. ...................................................................................................... 76
5.9 Parmetros da segunda experincia do algoritmo LVQ para o primeiro teste com
mesma tabela. ........................................................................................................................... 77
5.10 Parmetros da terceira experincia do algoritmo LVQ para o primeiro teste com
mesma tabela. ........................................................................................................................... 78
5.11 Parmetros da primeira experincia do algoritmo LVQ para o segundo teste com
AdventureWorksDW onde o conjunto de treino representa 80% dos casos da tabela
vTargetMail e o conjunto de teste representado por 20% dessa mesma tabela. ................. 81

Lista de Figuras

2.1 O processo de classificao de dados: (a) Aprendizagem - os dados de Treino so
analisadas por um algoritmo de classificao. Aqui o atributo que representa a etiqueta
da classe credit_rating, e o modelo de aprendizagem representado na forma de
Classification Rules. (b) Classificao - os dados de teste so usadas para estimar a
exactido das regras de classificao . .................................................................................... 15
2.2 rvore de deciso para o conceito buys_computer (sim ou no), indicando se provvel
que um cliente da AllElectronics compre um computador. Cada n no folha representa
um teste a um atributo. Cada n folha representa uma classe . .............................................. 18
2.3 Uma rede neuronal feed-forward com mltiplas camadas: Uma amostra de treino,
= (x1, x2, ., x|) alimenta a camada de entrada. Ligaes pesadas existem entre cada
camada, onde w| denota o peso de uma unidade de uma camada para uma unidade |
da camada anterior. .................................................................................................................. 24

8

2.4 Uma camada escondida ou de sada : As entradas desta camada so sadas da
camada anterior. Estes so multiplicados pelo peso correspondente, de maneira a formar
uma soma pesada. Uma funo no linear de activao aplicada sada da rede. ............ 25
2.5 Clustering de um conjunto de objectos baseado no mtodo k-means (o meio de cada
cluster est marcado por um +) .............................................................................................. 30
3.1 (a) Pontos pequenos: sobreposio de duas funes de densidade Gaussiana
correspondente classe S1 e S2 com os seus centrides a serem mostrados pela cruz
branca e preta, respectivamente. Curva slida: fronteira de deciso de Bayes. (b) Pontos
pretos largos: vectores de referncia da classe S1. Crculos abertos: vectores de
referncia da classe S2. Curva slida: fronteira de deciso no LVQ. Curva partida:
fronteira de deciso de Bayes. ................................................................................................ 40
3.2 Ilustrao da janela do algoritmo LVQ2, onde | e so os vectores de referencia
mais prximos do vector de aprendizagem x, d|(x) e dx so as respectivas distancias
de x a | e . ......................................................................................................................... 44
4.4 Classes C++ que implementam as interfaces COM [5, 14] ...................................................... 48
4.5 Tratamento de chamadas a funes COM ............................................................................... 52
4.6 Lista dos algoritmos disponveis, mostrando o novo algoritmo, ainda sem nome; .................. 56
5.1 Janela para a criao de uma nova ligao base de dados que contm as tabelas com
os dados de aprendizagem e de classificao. ........................................................................ 61
5.2 Menu que oferece ao utilizador a escolha de uma fonte de dados j criada para realizar
uma vista sobre esses dados. .................................................................................................. 62
5.3 Janela onde o utilizador poder escolher as tabelas indicadas para aprendizagem e
classificao que iro fazer parte da estrutura de minerao. ................................................. 63
5.4 Lista de algoritmos disponveis, onde se destaca o novo algoritmo. ....................................... 63
5.5 Menu onde so especificadas as colunas (atributos) de entrada e sada................................ 64
5.6 Ilustrao do painel de previses com os campos Source, Field e Alias preenchidos. ........... 65
5.7 Lista apresentada com os valores previstos pelo modelo na coluna Previsto e os valores
reais na coluna Actual. .............................................................................................................. 65
5.8 Propriedades do modelo de minerao criado ao longo desta seco. ................................... 66
5.9 Menu onde so especificados os parmetros de entrada do algoritmo LVQ. .......................... 67
7.1 Arquitectura do servidor de Analysis Services ......................................................................... 87
7.2 Arquitectura do cliente do Analysis Services ............................................................................ 88
7.3 Fluxo de dados de um Algoritmo Plug-in ................................................................................. 89

9

Lista de Matrizes

5.1 Matriz de confuso do primeiro teste bsico do algoritmo LVQ, com um conjunto de
treino e de teste artificial contendo vectores de duas dimenses. ........................................... 69
5.2 Matriz de confuso do segundo teste bsico do algoritmo LVQ, com um conjunto de
treino e de teste artificial contendo vectores de duas dimenses. ........................................... 70
5.3 Matriz de confuso do terceiro teste bsico do algoritmo LVQ, com um conjunto de treino
e de teste artificial contendo vectores de duas dimenses. ..................................................... 70
5.4 Matriz de confuso do primeiro teste avanado do algoritmo LVQ. Estes resultados foram
obtidos atravs do conjunto de teste com 2000 casos, onde cada vector possua 36
dimenses. ................................................................................................................................ 72
5.5 Matriz de confuso do segundo teste avanado do algoritmo LVQ. Estes resultados
foram obtidos atravs do conjunto de teste com 2000 casos, onde cada vector possua
36 dimenses. ........................................................................................................................... 73
5.6 Matriz de confuso do terceiro teste avanado do algoritmo LVQ. Estes resultados foram
obtidos atravs do conjunto de teste com 2000 casos, onde cada vector possua 36
dimenses. ................................................................................................................................ 74
5.7 Matriz de confuso do primeiro teste do algoritmo rvores de Deciso cujos conjuntos de
treino e de teste partilham os mesmos dados residentes na tabela vTargetMail. ................... 75
5.8 Matriz de confuso do primeiro teste do algoritmo Clustering, cujos conjuntos de treino e
de teste partilham os mesmos dados residentes na tabela vTargetMail. ................................. 75
5.9 Matriz de confuso do primeiro teste do algoritmo Naive Bayes, cujos conjuntos de treino
e de teste partilham os mesmos dados residentes na tabela vTargetMail............................... 76
5.10 Matriz de confuso do primeiro teste do algoritmo Redes Neuronais, cujos conjuntos de
treino e de teste partilham os mesmos dados residentes na tabela vTargetMail. ................... 76
5.11 Matriz de confuso da primeira experincia do algoritmo LVQ, cujos conjuntos de treino e
5.12 Matriz de confuso da segunda experincia do algoritmo LVQ, cujos conjuntos de treino
e de teste partilham os mesmos dados residentes na tabela vTargetMail............................... 77
5.13 Matriz de confuso da terceira experincia do algoritmo LVQ, cujos conjuntos de treino e
5.14 Matriz de confuso do segundo teste do algoritmo rvores de Deciso, onde o conjunto
de treino composto por 80% dos casos da tabela vTargetMail e o conjunto de teste
representa os casos restantes dessa tabela. ........................................................................... 80
5.15 Matriz de confuso do segundo teste do algoritmo Clustering, onde o conjunto de treino
composto por 80% dos casos da tabela vTargetMail e o conjunto de teste representa os
casos restantes dessa tabela. .................................................................................................. 80
5.16 Matriz de confuso do segundo teste do algoritmo Redes Neuronais, onde o conjunto de
treino composto por 80% dos casos da tabela vTargetMail e o conjunto de teste
representa os casos restantes dessa tabela. ........................................................................... 80

10

5.17 Matriz de confuso da primeira experincia do segundo teste do algoritmo LVQ, onde o
conjunto de treino composto por 80% dos casos da tabela vTargetMail e o conjunto de
teste representa os casos restantes dessa tabela. .................................................................. 81
5.18 Matriz de confuso da segunda experincia do segundo teste do algoritmo LVQ, onde o
teste representa os casos restantes dessa tabela. .................................................................. 82

Lista de Grficos

5.1 Ilustrao dos vectores de referncia finais, onde se pode verificar a presena de trs
clusters de classes diferentes. .................................................................................................. 68
5.2 Ilustrao dos vectores de referncia finais, onde se pode ver a presena de dois
clusters distintos da classe 1 e da classe 3, enquanto a classe 2 apenas apresenta um
cluster. ....................................................................................................................................... 69
5.3 Ilustrao dos vectores de referncia finais, onde se pode ver a presena de dois
clusters distintos da classe 1 e da classe 3, enquanto a classe 2 apenas apresenta um
cluster bem definido com alguns vectores a sarem fora da sua rea. .................................... 71
5.4 Representao grfica da preciso parcial da classificao dos clientes sem casa
prpria do primeiro teste com AdventureWorksDW. ............................................................... 78
5.5 Representao grfica da preciso parcial da classificao dos clientes com casa
prpria do primeiro teste com AdventureWorksDW. ............................................................... 79
5.6 Representao grfica da preciso parcial da classificao dos clientes sem casa
prpria do segundo teste com AdventureWorksDW. .............................................................. 82
5.7 Representao grfica da preciso parcial da classificao dos clientes com casa
prpria do segundo teste com AdventureWorksDW. .............................................................. 83

11

1 Introduo

O Data Mining surge numa poca em que o problema de espao de armazenamento de dados j
no existe. A grande razo do seu aparecimento ter atrado muita ateno na indstria de informao
traduz-se disponibilidade de grandes quantidades de dados e na necessidade eminente de tornar
esses dados em informao til e em conhecimento [11].
A abundncia de dados conjugada com a necessidade de ferramentas de anlise de dados
poderosas, tem sido descrita como uma situao de riqueza de dados mas pobreza de informao
[11]. O crescimento do nmero de dados recolhidos e guardados em grandes e numerosas bases de
dados excedeu a nossa habilidade humana de compreenso sem poderosas ferramentas. Como
resultado, dados recolhidos em grandes bases de dados tornaram-se tmulos de dados arquivos de
dados raramente visitados. Consequentemente, decises importantes so frequentemente tomadas,
no baseadas na informao guardada nas bases de dados, mas baseadas na intuio de quem
toma a deciso, simplesmente porque essa pessoa no tem as ferramentas para extrair o
conhecimento valioso embebido nas grandes quantidades de dados [9, 11].
O Data Mining [9, 11] foi criado para trazer respostas aos problemas de organizao dos dados
num Data Warehouse [8, 9, 11], ou de organizao dos dados de maneira a obter conjuntos com
algumas semelhanas, para deles realizar algumas previses teis para a empresa.
O Data Mining usa vrios algoritmos ou tcnicas para encontrar padres entre os dados, os quais
sero depois usados para a previso pretendida. Existem duas abordagens ou categorias por onde
se dividem os mais famosos algoritmos de Data Mining, dependendo do tipo de aprendizagem que
pode ser supervisionada ou direccionada e no supervisionada ou no direccionada.
Nesta ir focar a aprendizagem supervisionada, dado que o algoritmo Learning Vector
Quantization inclui-se nesse grupo.
1.1 Data Mining
O Data Mining [9, 11] pode ser visto como um resultado da evoluo natural das tecnologias de
informao. O fantstico progresso da tecnologia hardware dos computadores levou a uma
quantidade enorme de computadores poderosos, equipamento para recolha de dados e meios de
armazenamento. Esta tecnologia fornece um grande avano s indstrias de bases de dados e de
informao, e torna disponvel um grande nmero de bases de dados e repositrios de informao
para a gesto de transaces, retorno de informao e anlise de dados.
Os dados podem ser agora guardados em diferentes tipos de bases de dados. Uma arquitectura
de base de dados que recentemente emergiu foi o Data Warehouse [8, 9, 11], um repositrio de
mltiplas e heterogneas fontes de dados, organizados sobre um esquema unificado num nico stio,
de modo a facilitar tomadas de decises de gesto. A tecnologia de Data Warehouse inclui limpeza
de dados, integrao de dados e On-Line Analytical Processing (OLAP) [9, 11], que so tcnicas de
anlise com funcionalidades (sumarizao, consolidao e agregao). Apesar das ferramentas
OLAP suportarem anlise multidimensional e tomadas de deciso, ferramentas de anlise de dados

12

adicionais so requeridas para anlises mais profundas, tais como classificao de dados, clustering
e a caracterizao das mudanas dos dados ao longo do tempo.
O Data Mining [9, 11] refere-se extraco ou minerao de conhecimento de largas quantidades
de dados. Data Mining apenas um passo simples na descoberta do conhecimento nas bases de
dados, pois o processo de descobrir conhecimento interessante de largas quantidades de dados
guardados quer em base de dados ou em Data Warehouses.
Data Mining [9, 11] consegue encontrar informao descritiva e preditiva. Qual o tipo de
informao a escolher depende do que se quer fazer com os resultados. Quando se escolhe obter
informao preditiva o objectivo derivar informao que oferece pistas sobre um evento futuro. A
informao descritiva descreve eventos passados duma maneira que se tornaria difcil ver atravs de
meios normais, oferecendo-nos a oportunidade de tomar decises baseado em novas relaes
descobertas [9].
As ferramentas de Data Mining efectuam anlise de dados e podem esconder padres de dados
importantes, contribuindo em larga escala para as estratgias de negcio, bases de conhecimento,
pesquisa cientfica e mdica.
1.2 Objectivos
A finalidade desta tese adicionar funcionalidade ferramenta disponibilizada pela Microsoft,
Microsoft SQL Server 2005 [11], no campo do Data Mining. Esta nova funcionalidade consiste no
desenvolvimento de uma nova tcnica [9] de Data Mining j existente mais ainda no incorporada na
ferramenta mencionada.
A tcnica baseia-se na tarefa de classificao e d pelo nome de Learning Vector Quantization [1,
2], um algoritmo desenvolvido por Kohonen do qual existem vrias verses. O facto de ser uma
tcnica de classificao pressupe que o algoritmo faa primeiro a sua aprendizagem da rede atravs
de um conjunto inicial de dados, e aps essa aprendizagem ir tentar prever o campo que o utilizador
nomear para previso.
Esta tese vem contribuir para um aumento do nmero de tcnicas de Data Mining [9, 11]
disponveis pela ferramenta oferecida pela Microsoft. Sendo um algoritmo muito fcil de perceber, e
que se baseia em algumas tcnicas j existentes, como o caso de Nearest Neighboor [3, 5, 9, 11],
torna-se mais rpido e simples. Uma das grandes vantagens que oferece ao utilizador a
possibilidade deste observar os vectores de referncia finais, que iro ser usados para a classificao
de dados. Atravs desta visualizao dos vectores de referncia finais o utilizador consegue tirar
concluses sobre como esto dispostos esses vectores em clusters, ou quais os novos valores
tomados por eles, e da tirar informao necessria para encontrar os melhores valores para os
parmetros de entrada do algoritmo.
1.3 Estrutura
Seguidamente ser apresentada a estrutura desta tese, bem como o contedo de cada um dos
seus captulos.

13

O captulo 2 fornece uma vista geral das tarefas de Data Mining [9] bem como uma descrio mais
detalhada de todo o processo e uma arquitectura de um sistema tpico de Data Mining [9, 11]. Ainda
neste captulo estaro descritas algumas tcnicas de Data Mining mais utilizadas tais como rvores
de Deciso [3, 5, 9, 11, 18], Naive Bayes [3, 5, 9, 11, 18], Redes Neuronais [3, 4, 5, 6, 9, 11, 18] e
Clustering [3, 5, 9, 11, 18].
O captulo 3 prope uma visita ao algoritmo central desta tese, onde se ir viajar atravs da sua
histria, oferendo uma descrio precisa sobre cada uma das actualizaes do algoritmo.
O captulo 4 ser dedicado ferramenta de integrao do algoritmo LVQ, o Microsoft SQL Server
2005, d detalhes sobre a sua arquitectura, oferece uma descrio do mtodo de integrao do
algoritmo e tambm uma pequena explicao da sua interface com o algoritmo recorrendo a duas
linguagens de programao mais utilizadas em integrao de algoritmos: C++
1
, linguagem na qual foi
desenvolvido o trabalho desta tese e C# [13].
O captulo 5 descreve a arquitectura de interaco com o utilizador com recurso a imagens reais
da integrao do algoritmo. Neste captulo consta tambm a descrio das experincias mais
relevantes realizadas ao trabalho. O captulo 6 faz as concluses finais e no captulo 7 encontra-se
um glossrio de termos, com as descries dos termos mais utilizados nesta tese.

1
SQL Server Data Mining. http://www.sqlserverdatamining.com. [Online] [Cited: Novembro 20, 2007.]
http://www.sqlserverdatamining.com/ssdm/Home/Tutorials/tabid/57/id/163/Default.aspx.

14

2 Vista geral

O Data Mining [9, 11] foi criado para responder s necessidades das grandes organizaes que,
com o passar do tempo foram armazenando grandes quantidades de dados nas suas bases de dados
e posteriormente no seu Data Warehouse [8].
Hoje em dia todas as grandes empresas tm o seu Data Warehouse [8, 11], um armazm central
de dados, com estruturas de armazenamento desenhadas para guardar grandes quantidades de
informao e que oferecem uma rpida resposta ao processamento de transaces eficientes.
Alm dos problemas de dados inconsistentes e invlidos, as grandes organizaes vem-se
perante um problema maior: o de tratamento dos dados, ou seja, de distribuio e organizao dos
dados para futura utilizao.
A essa necessidade o Data Mining oferece um conjunto de tcnicas [3, 4, 5, 6, 9, 11] para
organizar os dados de acordo com padres [4] semelhantes encontrados, para posterior utilizao em
previses. Estes padres no so mais do que um conjunto de eventos que ocorrem com frequncia
suficiente no conjunto de dados considerado e que revelam relaes entre si [11].
Para encontrar estes padres, o processo de Data Mining necessita de um algoritmo matemtico e
estatstico que transforma o caso (cada item de dados utilizado como fonte para um modelo) de
dados originais no modelo de Data Mining.
Quando um algoritmo associado a uma estrutura de dados, a estrutura populada com dados
de uma maneira que reflecte a existncia de relaes e padres do conjunto original, permitindo
predio baseada nesses dados [9, 11].
Um modelo de Data Mining [11] no mais do que uma estrutura fsica de um subconjunto de
dados compilados num algoritmo de Data Mining, juntamente com a descrio do conjunto original.
Esta estrutura contm os padres presentes nas bases de dados e usada como base a partir da
qual se faz previses. Por juntar informao dos conjuntos de dados originais, a aplicao de Data
Mining constri um subconjunto de dados que so compilados usando um algoritmo Data Mining.
Este conjunto de resultados pode ento ser usado para fazer previses contra os dados da amostra
[9, 11].
Podemos ento concluir que o Data Mining apresenta-se como sendo um processo assistido por
computador para encontrar e analisar enormes conjuntos de dados, encontrar padres
desconhecidos e relaes, e retirar deles algum significado, fazendo a classificao dos dados
existentes num Data Warehouse. Data Mining envolve descrever o passado para poder prever o
futuro [9, 11].
O Data Mining pode encontrar informao descritiva e preditiva. O objectivo da informao
descritiva descrever eventos passados, oferecendo a oportunidade de tomar decises baseado em
novas relaes descobertas, enquanto o objectivo da informao preditiva derivar a informao que
oferece pistas sobre um evento futuro [11].
As tarefas e tcnicas disponibilizadas so o ncleo de um sistema de Data Mining. Alguns
sistemas oferecem apenas uma tarefa como, por exemplo, a classificao. Outros acabam por
oferecer maior variedade como tarefas de previso, associao ou clustering.

2.1 Tarefas de Data Mining
Em Data Mining uma tarefa corresponde a um tipo de problema de descoberta de conhecimento
para o qual se pretende arranjar um
Classificao e Previso.
No entanto, consideram-se aqu
num ou noutro grupo, apresentam algumas propriedades interessantes que lhes faz merecer esta
diferenciao.
2.1.1 Classificao
A tarefa de classificao consiste em construir um modelo
visando categoriz-los em classes.
O objectivo encontrar frmulas, regras ou padres a partir de um conjunto de dados de treino, de
modo a organizar esses dados em classes. Um registo examinado e classificado de acordo com
uma classe predefinida. Essas frmulas ou regras iro depois ser aplicadas num conjunto de dados
de teste.
A classificao de dados um processo de dois passos [Figura 2.1]. No primei
construdo descrevendo um conjunto predeterminado de classes de dados
tuplos da base de dados descritos por atributos
Figura 2.1 O processo de classifica
analisadas por um algoritmo de classificao. Aqui o atributo que representa a etiqueta da classe
credit_rating, e o modelo de aprendiza
Classificao - os dados de teste so usadas
Cada tuplo assumido como pertencendo a uma classe predefinida, representada por um dos
atributos e chamada de etiqueta da classe. Os tuplos de dados analisados para construir o mod
formam o conjunto de dados de treino. Como a etiqueta da classe de cada amostra retirada da base
de dados fornecida, este passo tambm conhecido c
aprendizagem do modelo supervisionada na medida em que dito qua
amostra de treino pertence). No segundo passo, o modelo usado para classificao da classe de
Data Mining
uma tarefa corresponde a um tipo de problema de descoberta de conhecimento
para o qual se pretende arranjar uma soluo. Conseguimos distribu-las por dois grandes grupos:
se aqui outras tarefas de Data Mining que apesar de se poderem incluir
A tarefa de classificao consiste em construir um modelo aplicvel a dados no classificados
em classes. Esta tarefa prev etiquetas de classes, ou seja
rmulas, regras ou padres a partir de um conjunto de dados de treino, de
dados em classes. Um registo examinado e classificado de acordo com
A classificao de dados um processo de dois passos [Figura 2.1]. No primei
construdo descrevendo um conjunto predeterminado de classes de dados, atravs d
tuplos da base de dados descritos por atributos.
O processo de classificao de dados: (a) Aprendizagem - os dados de Treino so
por um algoritmo de classificao. Aqui o atributo que representa a etiqueta da classe
, e o modelo de aprendizagem representado na forma de Classification Rules
este so usadas para estimar a exactido das regras de
atributos e chamada de etiqueta da classe. Os tuplos de dados analisados para construir o mod
de dados fornecida, este passo tambm conhecido como aprendizagem supervisionada (a
aprendizagem do modelo supervisionada na medida em que dito qual a classe a que cada
15
uma tarefa corresponde a um tipo de problema de descoberta de conhecimento
las por dois grandes grupos:
que apesar de se poderem incluir
a dados no classificados
Esta tarefa prev etiquetas de classes, ou seja variveis discretas.
rmulas, regras ou padres a partir de um conjunto de dados de treino, de
dados em classes. Um registo examinado e classificado de acordo com
A classificao de dados um processo de dois passos [Figura 2.1]. No primeiro passo o modelo
, atravs da anlise de
.
os dados de Treino so
por um algoritmo de classificao. Aqui o atributo que representa a etiqueta da classe
Classification Rules. (b)
para estimar a exactido das regras de classificao [9].
atributos e chamada de etiqueta da classe. Os tuplos de dados analisados para construir o modelo
omo aprendizagem supervisionada (a
l a classe a que cada

16

uma nova amostra, a amostra de teste, onde a percentagem de classificao certa para cada amostra
calculada.
Como exemplo de tarefas de classificao temos a classificao de um pedido de crdito como
sendo de baixo, mdio ou alto risco. [9, 11]
2.1.2 Previso
Na Previso as operaes so efectuadas sobre um conjunto de dados contnuos e ordenados, de
modo a extrair um modelo preditivo que consiga prever valores futuros de outras variveis de
interesse.
A previso usada para definir um valor para uma varivel continua desconhecida. Dado um item
e um dado modelo de previso, pretende-se com esta tarefa prever o valor de um atributo especfico
do item, usando valores contnuos ou ordenados. Esta tarefa tem tambm as mesmas duas fases
consideradas na tarefa de Classificao.
Muitas vezes a tarefa de Previso vista como a construo e uso de um modelo para prever a
classe de uma amostra sem etiqueta. Nesta viso, a Classificao um dos tipos de problemas de
previso, usada para prever valores discretos, sendo que a Previso usada para prever valores
contnuos.
Como exemplo de uma tarefa de previso temos o caso, dado um modelo de previso e um
conjunto de transaces de um carto de crdito dever ser possvel prever se uma transaco
especfica ou no fraudulenta. [9, 11]
2.1.3 Regresso
A regresso a anlise de dependncia de valores de certos atributos em relao a valores de
outros atributos constantes no mesmo item e a posterior produo de um modelo que possa prever
os valores destes atributos para futuros registos.
Dado que a regresso opera sobre valores contnuos, normalmente inserida nas tarefas de
previso, apesar de poder tambm ser usada em tarefas de classificao. [9]
2.1.4 Associao
Esta tarefa consiste em identificar associaes entre atributos no mesmo item ou associaes
entre itens diferentes.
Um exemplo clssico determinar quais os produtos que costumam ser colocados juntos num
carrinho de compras. [9]
2.1.5 Clustering
A tarefa de Clustering consiste no agrupamento de um conjunto de dados em subconjuntos de
classes com caractersticas semelhantes. No Clustering, no existem partida classes predefinidas e
os itens so agrupados de acordo com a semelhana, o que a diferencia da tarefa de classificao.

17

Esta tarefa tambm conhecida por ter uma aprendizagem no supervisionada, pois a etiqueta da
classe de cada amostra de treino no conhecida, e o nmero ou conjunto de classes a serem
aprendidas podem no ser conhecidas previamente.
Um exemplo poder ser dado um conjunto de clientes de uma loja, identificar aqueles que
compram o mesmo tipo de produtos. [9]
2.2 Tcnicas de Data Mining
Organizaes aplicam as tecnologias Data Mining aos seus armazns de dados por dois motivos:
Para registar o passado dos dados (guardar histrico)
Para prever o futuro atravs dos dados
Ultimamente usam a informao tirada dos computadores para fazer decises sobre o futuro dos
dados. O tipo de informao que uma organizao quer, determina o tipo de modelo construdo e os
algoritmos aplicados estrutura de dados.
O objectivo do Data Mining [9, 11] encontrar regras compreensveis e relaes em conjuntos de
casos. Essas regras podem ento ser usadas para prevenir ameaas futuras, para salvaguardar os
perfis dos clientes, para controlo de riscos, ou apenas para descrever e explicar os contedos de uma
dada base de dados.
Devido preparao exigida, Data Mining no um processo completamente automatizado. O
processo requer que tomemos uma srie de factores em conta sobre os dados e o seu uso
pretendido para depois aplicar os melhores mtodos de Data Mining. [11]
No existe tal coisa como um mtodo superior de Data Mining, no mundo do Data Mining
geralmente aceite que independentemente do mtodo escolhido, vo existir trade-offs. Nenhum
mtodo simples resulta para todas as pessoas.
Existem dois tipos de Data Mining que separam os vrios algoritmos ou mtodos existentes, que
seguidamente sero explorados e definidos.
Data Mining direccionado ou supervisionado
De forma a realizar operaes de Data Mining Direccionado [9, 11], todos os factores conhecidos,
ou variveis de entrada, necessitam de ser dadas para que o engenho do Data Mining possa
encontrar as melhores relaes entre esses atributos e para que uma regra seja construda dentro do
modelo de Data Mining. A previso baseada em valores desconhecidos ou variveis alvo,
significando isto que o engenho de Data Mining ir encontrar o valor mais provvel para esses
valores desconhecidos baseado nos valores conhecidos fornecidos com as variveis de entrada.
O Data Mining supervisionado usa as mais populares tcnicas de Data Mining e algoritmos, tais
como rvores de Deciso [3, 5, 9, 11, 18] e Redes Neuronais [3, 4, 5, 6, 9, 11, 18], classifica os
dados para realizar previses ou estimativas com o objectivo de derivar valores alvo, ou a etiqueta da
classe alias, a necessidade dos valores alvo que d ao Data Mining direccionado a sua direco.
Uma larga variedade de negcios usam-no, tais como bancos, cadeias de retalho, empresas
farmacuticas. [11]

2.2.1 rvores de deciso
um algoritmo muito conhecido usado por todas as ferramentas de
comercializadas. Este termo descreve um nmero de algoritmos especficos, tal como
Automated Interaction Detector (CHAID) e o C4.5 e o processo do algoritmo que eles partilham, o que
resulta em modelos que parecem
Os algoritmos de rvores de
que requerem um modelo de classificao orientado e
que se resolvem segregando casos em grupos discretos. Por exemplo, as
frequentemente utilizadas para prever quais os clientes mais
e-mail e os mais provveis de serem aprovados para emprstimos.
Uma rvore de Deciso [3, 5,
um teste ou deciso sobre o item considerado, cada ramo representa o resultado do teste, e os ns
folha representam a classe ou classes de distribuio.
O objectivo principal separar as classes em que os dados esto agrupados. Tuplos de classes
diferentes tendem a ser colocadas em subconjuntos diferentes, cada um descrito por regra simples
[Figura 2.2]. Essas regras podem ser expressas como declaraes lgicas, numa linguagem como
SQL, de modo a que possam ser aplicadas directamente a novos tuplos.
Uma vantagem deste mtodo
Contudo perceber o significado de uma reg
aproximao por rvores de Deciso. O probl
expande para baixo os seus nveis, existe
de classificao que est a ser construda.
Figura 2.2 rvore de deciso para o conceito
provvel que um cliente da
representa um teste a um atributo. Cada n folha representa uma classe
Uma rvore de deciso separa os dados num nmero largo de conjun
pequenos medida que se tornam mais especficos. Quanto mais largo o nmero de diferentes
casos a examinar, mais pequeno cada prximo conjunto separado de exemplos de treino, o que
devido aos nmeros encolhidos,
pode ser executada exactamente.
Se a rvore se torna demasiado grande devido ao largo nmero de pequenos ramos, ento existe
uma boa hiptese de que as regras dentro desses ns no se apliquem a n
um algoritmo muito conhecido usado por todas as ferramentas de Data Mining
as. Este termo descreve um nmero de algoritmos especficos, tal como
(CHAID) e o C4.5 e o processo do algoritmo que eles partilham, o que
resulta em modelos que parecem rvores. [9, 11]
e Deciso [6, 5, 9, 11, 18] so recomendados para tarefas preditivas
que requerem um modelo de classificao orientado e, como tal, so desenhados para problemas
que se resolvem segregando casos em grupos discretos. Por exemplo, as rvores
requentemente utilizadas para prever quais os clientes mais provveis de responder a marketing por
de serem aprovados para emprstimos.
, 9, 11, 18, 19], uma rvore onde cada n no terminal represen
folha representam a classe ou classes de distribuio.
ntes tendem a ser colocadas em subconjuntos diferentes, cada um descrito por regra simples
. Essas regras podem ser expressas como declaraes lgicas, numa linguagem como
SQL, de modo a que possam ser aplicadas directamente a novos tuplos.
vantagem deste mtodo a maneira intuitiva de descrever ns com regras
Contudo perceber o significado de uma regra com fundamento pode ser um s
eciso. O problema originado do facto de med
expande para baixo os seus nveis, existe poucos registos deixados nos ns desses nveis da
a ser construda. [9, 11]
de deciso para o conceito buys_computer (sim ou no), indicando se
que um cliente da AllElectronics compre um computador. Cada n no folha
representa um teste a um atributo. Cada n folha representa uma classe
de deciso separa os dados num nmero largo de conjuntos que se tornam mais
medida que se tornam mais especficos. Quanto mais largo o nmero de diferentes
casos a examinar, mais pequeno cada prximo conjunto separado de exemplos de treino, o que
, inspira menos confiana que a classificao adicional correcta
pode ser executada exactamente. [9, 11]
se torna demasiado grande devido ao largo nmero de pequenos ramos, ento existe
uma boa hiptese de que as regras dentro desses ns no se apliquem a nenhum estudo estatstico
18
Data Mining disponveis
as. Este termo descreve um nmero de algoritmos especficos, tal como Chi-squared
(CHAID) e o C4.5 e o processo do algoritmo que eles partilham, o que
so recomendados para tarefas preditivas
so desenhados para problemas
rvores de deciso so
de responder a marketing por
onde cada n no terminal representa
ntes tendem a ser colocadas em subconjuntos diferentes, cada um descrito por regra simples
. Essas regras podem ser expressas como declaraes lgicas, numa linguagem como
a intuitiva de descrever ns com regras [Figura 2.2].
ra com fundamento pode ser um srio problema para a
medida que a rvore
poucos registos deixados nos ns desses nveis da rvore

(sim ou no), indicando se
compre um computador. Cada n no folha
representa um teste a um atributo. Cada n folha representa uma classe [9].
tos que se tornam mais
medida que se tornam mais especficos. Quanto mais largo o nmero de diferentes
casos a examinar, mais pequeno cada prximo conjunto separado de exemplos de treino, o que,
onfiana que a classificao adicional correcta que
se torna demasiado grande devido ao largo nmero de pequenos ramos, ento existe
enhum estudo estatstico

19

justificvel, sobretudo porque cada um dos ns desses ramos geralmente contm uma pequena
percentagem suspeita de todos os casos. [9, 11]
2.2.1.1 CART, CHAID e C4.5
Quando um algoritmo de rvores de Deciso aplicado a um problema de Data Mining o seu
resultado parece-se com uma rvore. Vamos agora olhar para alguns dos algoritmos de rvores de
deciso mais usados no mundo [11]:
Classification and regression tree (CART): o algoritmo mais usado no mundo devido ao seu
eficiente sistema de classificao. Os seus atributos que tm valores preditivos so escolhidos
assim que se determina que eles introduzem ordem ao conjunto de dados. So usados para
separar a piscina de dados existente em dois ns, e seguintes ramos ou folhas que sejam
posteriormente criados.
Uma das caractersticas mais teis do CART a habilidade de lidar com dados desaparecidos
aquando da construo da rvore. Ele saber quando no usar um determinado valor para
saber se uma diviso de ramo deve de ser feita.
Uma caracterstica nica do CART a restrio da diviso binria. Esta causa a diviso dos
ns apenas em dois ns filhos, o que produz uma rvore mais profunda que as outras. Uma
rvore mais profunda considerada mais econmica com os dados e como resultado capaz
de detectar mais estruturas antes de poucos dados serem deixados para anlise. Cada n
numa hierarquia divide os seus registos pelos ns abaixo de si. Se um n tem poucos registos
cessa a diviso, enquanto os outros ns continuam. [11]
Chi-Squared Automatic Interaction Detector (CHAID): este algoritmo usa os testes de anlise
Chi-Squared para validar a rvore. Devido a este tipo de anlise focar-se num grupo de tabelas
para determinar a distribuio de um dado valor, os atributos do conjunto de dados devem ser
forados em grupos que possam ser testados;
2.2.1.2 Como so determinadas as divises
As rvores de deciso usam um algoritmo de induo para decidir a ordem pela qual as divises
ocorrem [9, 11]. O algoritmo indutivo desenha concluses baseado em instncias repetidas de um
evento.
As divises so determinadas aplicando anlises estatsticas sobre os atributos de dados que
fazem os casos. O objectivo geral construir rvores que sejam o mais desequilibradas possvel, em
termos de distribuio desses atributos. Em outras palavras, o algoritmo procura colocar mais que um
tipo de atributos num dado n. Quando for possvel o algoritmo vai tentar ter todos os ns puros, o
que significa que o n contm apenas casos com 100% de um dado tipo de variveis [11].
As rvores de deciso tambm criam regras. Cada n pode ser escrito como um conjunto de
regras que fornece uma descrio da funo daquele n em particular na rvore, tal como dos ns
que levam a ele [11].

20

2.2.1.3 Como so derivadas as previses
Uma vez a rvore construda pode ser usada para um dos seus propsitos mais importantes,
prever os valores desaparecidos para novos casos. Existem duas aproximaes para realizar
previses [11]:
Pode escolher-se um caso e seguir os seus caminhos, que so determinados pelos seus
atributos, para ver em que folha acaba;
Pode usar-se cada n folha para derivar uma nova regra.
2.2.1.4 Navegar pela rvore
Uma vez que a rvore est preenchida, pode ser usada para prever novos casos comeando pelo
n raiz da rvore e continuando o caminho para os ramos, que so baseados nos atributos do novo
caso, antes de chegar ao n folha. O caminho que o novo caso segue baseado nos valores que
causaram a diviso e no nas variveis independentes na nova instncia. Um problema que poder
ocorrer est relacionado com as possibilidades presentes num dado n terem aproximadamente a
mesma oportunidade de ocorrerem. O melhor mtodo permitir ao operador decidir o que fazer em
casos como este. [11]
2.2.1.5 Problemas das rvores de Deciso
Se, por acaso, for gerada uma rvore pura, ento as previses baseadas nos casos usados para
construir o modelo iro sempre mostrar os resultados 100% exactos. Contudo, uma vez que se
comea a fazer previses baseadas em casos que so independentes do conjunto de treino, a rvore
100% pura ser pssima a fazer previses, porque as regras suportadas pela rvore so demasiado
restritas para reflectir o mundo real [3, 5, 11, 18].
2.2.1.6 Quando usar rvores de deciso
Quando for aplicado confiantemente o esquema de segmentao a um conjunto de dados que
reflecte um grupo de potenciais clientes [11];
Quando se identificar possveis relaes interactivas entre variveis duma maneira que levar a
perceber como mudar uma varivel pode afectar outra [11];
Quando se fornecer uma representao visual das relaes entre variveis na forma de uma
rvore [11];
Quando for simplificada a mistura de atributos e categorias para ficar com os essenciais
necessrios para fazer previses [11];
Quando forem explorados os dados para identificar variveis importantes num conjunto que pode
ser usado eventualmente como alvo [11];
2.2.2 Nearest Neighbor
Este mtodo menos utilizado que o descrito na seco anterior ou que o mtodo de Naive
Bayes, para classificao em sistemas comerciais de Data Mining. [9]

21

Numa descrio breve, pode-se dizer que a classificao Nearest Neighbor guarda todos as
amostras de treino que podem apresentar dificuldades quando aprendidas de largos e variados
conjuntos de dados. [9, 11]
Este algoritmo baseado na aprendizagem por analogia. As amostras de treino so descritas por
atributos numricos com n dimenses. Cada amostra representa um ponto num espao com n
dimenses. Desta forma, todas as amostras de treino so guardadas num espao padro. Quando
dada uma amostra desconhecida, este algoritmo procura o espao padro para as k amostras de
treino que esto prximas da amostra desconhecida. Assim, o espao partido em clulas,
colocando as amostras escolhidas como pertencendo mesma classe [2]. Estas k amostras de treino
so os k vizinhos mais prximos [18] da amostra desconhecida. A proximidade definida em termos
de distncia Euclidiana entre vectores. A distncia Euclidiana entre dois pontos, X = (
1
,
2
, .,
n
) e
= (
1
,
2
, .,
n
), definida como se segue:
(X, ) = _n ( - ) (2.1)
a amostra desconhecida atribuda classe mais comum entre os seus k vizinhos mais prximos.
Quando o k = 1, a amostra desconhecida atribuda classe da amostra de treino que est mais
prxima dela no espao padro.
Neste algoritmo, as amostras de treino so guardadas e no constroem um classificador at que
uma nova amostra necessite de ser classificada. Este mtodo contrasta com o mtodo de rvores de
Deciso na medida em que nesse algoritmo construdo um modelo antes de receber novas
amostras para classificar.
O algoritmo de Nearest Neighbor [18] atribui um peso igual a cada atributo, o que pode causar
confuso quando existem muitos atributos irrelevantes nos dados.
Pode tambm ser uma tcnica usada para previso, ou seja, retornar um valor real previsto para
uma dada amostra desconhecida. Neste caso, o classificador retorna o valor mdio dos valores reais
associados com o vizinho mais prximo k da amostra desconhecida. [9]
2.2.2.1 Como determinar um bom valor para k
Comeando com k = 1 e usando um conjunto de teste para validar a proporo de erro do
classificador. Repetir a operao usando k = k + 2. Aps estas experincias, um bom valor de k ser
aquele cuja proporo de erro seja menor. As experincias devem ser realizadas com valores de k
pares para evitar ligaes e dependncias. [9]
2.2.2.2 Quando usar Nearest Neighbor
Esta tcnica deve ser usada quando existem largas quantidades de dados de treino, ou quando
existem menos de 20 atributos por instncia. As vantagens deste algoritmo so:
O treino de grandes quantidades de dados bastante rpido;
Aprende facilmente funes alvo complexas;
No perde informao; [9]
Esta tcnica apresenta porm algumas desvantagens, tais como:
Bastante lento em termos do tempo que demora a realizar querys;

22

Facilmente enganado por atributos irrelevantes;
2.2.3 Naive Bayes
As Redes Bayesianas fornecem distribuies probabilsticas derivadas da contagem da ocorrncia
dos dados num dado conjunto. Fornecem um modelo grfico de relaes causais, sobre as quais a
aprendizagem se pode processar.
Estas redes baseiam-se no teorema de Bayes e consistem em grafos acclicos dirigidos onde os
ns representam os atributos, e as ligaes representam as dependncias probabilsticas entre os
atributos. Associada a cada n (atributo) da rede existe uma Tabela de Probabilidades Condicionais,
que descreve a relao entre o n e os seus ns pai. [9]
2.2.3.1 Teorema de Bayes
A classificao de Naive Bayes [3, 5, 9] baseada no teorema de Bayes [9], que dado uma
amostra de dados X cuja etiqueta da classe desconhecida, e sendo E as hipteses da amostra de
dados X pertencer a uma classe especifica . Para problemas de classificao queremos determinar
(E|X), a probabilidade de a hiptese E ser real dada a amostra de dados observada X. [9]
(E|X) a probabilidade posterior da condio de E a X. (E) a probabilidade prvia. A
probabilidade posterior (E|X) baseada em mais informao que a probabilidade prvia, (E) que
independente de X. Similarmente, (X|E) a probabilidade posterior de X condicionado a E, ou
seja, a probabilidade de que X vermelho e redondo dado o que sabemos, que X uma ma.
(X) a probabilidade prvia de X.
Estas probabilidades ((E), (X) e (X|E)) so estimadas atravs dos dados.O teorema de
Bayes bastante til porque fornece uma maneira de calcular a probabilidade posterior, (E|X)
atravs de (E), (X) e (X|E), como a seguir mostrado:
(E|X) =
P(X|H)P(H)
P(X)
(2.2)
2.2.3.2 Classificao de Naive Bayes
Nesta seco mostrado como pode ser usado o teorema de Bayes na classificao Naive
Bayes. O algoritmo de Naive Bayes [3, 5, 9] funciona da seguinte forma:
1. Cada amostra de dados representada por um vector caracterstico com n dimenses. X =
(
1
,
2
, . ,
n
);
2. Supondo que existem classes,
1
,
2
, .,
m
. Dado uma amostra de dados desconhecida, X, o
classificador ir prever que X pertence classe que tiver a mais alta probabilidade posterior,
condicionada em X. Isto , o classificador Naive Bayes atribui uma amostra desconhecida X
classe
, se e apenas se (|X) > (|X) para , = .

Assim, maximizamos (
|X). Atravs do teorema de Bayes conclui-se que:

(
|X) =
P(X|C
i
)P(C
i
)
P(X)
(2.3)
3. Enquanto que (X) constante para todas as classes, apenas (X|
)(
) necessrio
maximizar. Se a classe de probabilidades prvias no conhecida, ento facilmente assumido

23

que as classes so iguais, ou seja, (
1
) = (
2
) = . = (
m
), e ento maximizava-se
(X|
). Caso contrrio maximizava-se (X|
)(
).
4. Tendo em conta conjuntos de dados com muitos atributos, seria muito dispendioso a nvel
computacional, calcular (X|
). De forma a reduzir o clculo na avaliao (X|
)., a suposio
ingnua da independncia da classe condicional realizada. Isto presume que os valores dos
atributos so condicionalmente independentes uns dos outros, dado a etiqueta da classe da
amostra, ou seja, no existem relaes de dependncia entre os atributos. Assim,
(X|
) = [ (
k
|
)
n
k=1
(2.4)
As probabilidades (
1
|
), (
2
|
), ., (
n
|
) podem ser estimadas atravs das amostras de

treino, onde
a. Se
k
categrico, ento (
k
|
=
s
ik
s
i
), onde s
k
o nmero de amostras de treino da classe
, tendo o valor de
k
para
k
, e sendo o valor de s
o nmero de amostras de treino que

pertencem a
.
b. Se
k
um valor contnuo, ento o atributo tipicamente assumido como tendo uma
distribuio de Gauss, ento:
(
k
|
) = (
k
, p
C
i
, 0
C
i
) =
1
_
2nc
C
i
-
x
k
-
C
i
1
2
2o
C
I
2
(2.5)
Onde (
k
, p
C
i
, 0
C
i
) a densidade Gaussiana funcional para o atributo
k
, enquanto p
C
i
e
o
C
i
so o desvio mdio e padro, respectivamente, dado os valores para o atributo
k
para
amostras de treino da classe
.
5. De maneira a classificar uma amostra desconhecida X, (X|
)(
) avaliado para cada classe
. A amostra X atribuda classe
se e apenas se (X|
) > (X|
]
) para , = .
Noutras palavras, atribuda classe
, onde (X|
)(
) o mximo.
Esta classificao poder ser usada quando existem conjuntos de treino moderados e disponveis.
Estes classificadores tm uma percentagem de erro muito menor em comparao com outros
classificadores. A classificao Bayesiana til na medida que fornece uma justificao terica para
outros classificadores que no usam o teorema de Bayes explicitamente. [9]
2.2.3.3 Vantagens e Desvantagens
As vantagens da classificao Naive Bayes [9] so:
Fcil de implementar;
Na maioria dos casos so obtidos bons resultados;
Desvantagens desta classificao [9]:
Assumpo: independncia das classes condicionais, o que pode gerar perda de exactido;
A existncia de dependncias entre as suas variveis;

24

2.2.4 Redes Neuronais Artificiais
Uma rede neuronal artificial [3, 4, 5,6, 9, 11] um conjunto de unidades de input/output ligadas
entre si, onde cada ligao tem um peso associado.
O campo das redes neuronais foi originalmente usado por psiclogos e neurologistas que queriam
desenvolver e testar analogias computacionais a neurnios.
As redes neuronais artificiais [3, 4, 5,6, 9, 11] so uma classe especial de sistemas modelados
seguindo a analogia com o funcionamento do crebro humano. So formadas por neurnios artificiais
interligados. A intensidade das interligaes neuronais pode alterar-se como resposta a um estmulo,
o que permite rede aprender.
Durante a fase de aprendizagem, a rede aprende ajustando os pesos para que possa prever a
etiqueta da classe correcta das amostras de entrada.
Uma das principais vantagens das redes neuronais a sua variedade de aplicaes. No entanto
encontra-se dificuldade na formatao dos dados de entrada e os modelos produzidos por esta
tcnica podem ser difceis de entender.
A tcnica de redes neuronais apropriada s tarefas de classificao, previso e clustering.
O algoritmo de redes neuronais mais famoso o algoritmo de Backpropagation [4, 6, 9], proposto
nos anos 80, que iremos ver com mais detalhe nas seces seguintes.
2.2.4.1 Algoritmo Backpropagation
O algoritmo de Backpropagation [9, 6, 9] realiza a aprendizagem atravs de uma rede neuronal
feed-forward de mltiplas camadas [Figura 2.3].

Figura 2.3 Uma rede neuronal feed-forward com mltiplas camadas: Uma amostra de treino,
= (x
1
, x
2
, ., x
|
) alimenta a camada de entrada. Ligaes pesadas existem entre cada camada,
onde w
|
denota o peso de uma unidade de uma camada para uma unidade | da camada anterior.
As entradas correspondem aos atributos medidos para cada amostra de treino. As entradas so
introduzidas simultaneamente numa camada de unidades fazendo a camada de entrada. As sadas
pesadas dessas unidades so introduzidas simultaneamente para uma segunda camada de
unidades, conhecida como camada escondida. As sadas pesadas da camada escondida podem ser
entradas para outra camada escondida e assim por diante. As sadas pesadas da ltima camada
escondida so entradas de unidades fazendo a camada de sada, que emite a previso da rede para
uma dada amostra. A rede feed-forward no sentido dos ciclos dos pesos voltarem para uma
unidade de entrada ou para uma unidade de sada de uma camada de previso. completamente
ligada na medida em que cada unidade fornece entrada a cada unidade da prxima camada. [9]

25

Antes do treino poder comear, o utilizador tem de decidir sobre a topologia de rede especificando
o nmero de unidades da camada de entrada, o nmero de camadas escondidas, o nmero de
unidades em cada camada escondida e o nmero de unidades na camada de sada.
Tipicamente os valores de entrada so normalizados para terem valores entre 0,0 e 1,0.
No existem regras quanto ao melhor nmero de unidades na camada escondida. O desenho da
rede um processo de tentativa e erro e pode afectar a exactido da rede de treino resultante. Os
valores iniciais dos pesos podem tambm afectar a exactido do resultado. Uma vez que a rede foi
treinada e a sua exactido no considerada aceitvel, comum repetir o processo de treino com
uma topologia de rede diferente, ou com um conjunto diferente de pesos iniciais. [9]
O algoritmo de Backpropagation [4, 6, 9] aprende atravs de processar iterativamente um conjunto
de amostras de treino, comparando a previso da rede para cada amostra com a etiqueta da classe
conhecida. Para cada amostra da rede, os pesos so modificados para minimizar erros entre a
previso da rede e a classe actual. Estas modificaes so feitas da camada de sada, atravs de
cada camada escondida at chegar primeira camada escondida. Apesar de tudo, no garantido
que os pesos eventualmente iro convergir, e o processo de aprendizagem pra.

Figura 2.4 Uma camada escondida ou de sada : As entradas desta camada so sadas da
camada anterior. Estes so multiplicados pelo peso correspondente, de maneira a formar uma
soma pesada. Uma funo no linear de activao aplicada sada da rede.
Seguidamente ser apresentado o modo como o algoritmo funciona:
Inicializar os pesos: os pesos na rede so inicializados com nmeros pequenos e aleatrios. Cada
unidade tem uma polarizao associada. Estas polarizaes so tambm inicializadas com
nmeros aleatrios pequenos. Cada amostra de treino X processada atravs dos passos
seguintes [9, 11];
Propagar as entradas: as entradas e as sadas da rede de cada unidade na camada escondida e
na camada de sada so calculadas. Primeiro a amostra de treino alimentada camada de
entrada da rede. de notar que para a unidade na camada de entrada, a sua sada igual sua
entrada, isto ,
]
= I
]
. As entradas da unidade na camada escondida, so de facto sadas das
unidades ligadas na camada anterior. Para calcular a entrada da rede para a unidade , cada
entrada I
]
ligada unidade multiplicada pelo seu peso correspondente, e tudo isto somado:
I
]
= _
]

+ 0
]
(2.6)

26

Onde
]
o peso da ligao desde a unidade na camada anterior, unidade ;
a sada da
unidade desde a camada anterior; 0
]
a polarizao da unidade. Esta polarizao funciona como
threshold, na medida em que serve para variar a actividade da unidade.
Cada unidade nas camadas escondidas e de sada tomam as entradas da rede e aplicam uma
funo de activao (simboliza a activao do neurnio representado pela unidade), como
ilustrado na Figura 2.4, em que dada uma entrada da rede I
]
da unidade , ento
]
, a sada da
unidade calculado da seguinte maneira:
]
=
1
1+ c
-1
(2.7)
Propagao do erro: o erro propagado ao contrrio, fazendo a actualizao dos pesos e
polarizaes para reflectir o erro da previso da rede. Para uma unidade na camada de sada, o
erro
]
calculado da seguinte forma:
]
=
]
( -
]
)(
]
-
]
) (2.8)
Onde
]
a sada actual para a unidade , e
]
a verdadeira sada, baseada na classe conhecida
da amostra de treino fornecida.
Para calcular o erro de uma unidade da camada escondida , a soma dos pesos dos erros das
unidades ligadas unidade da prxima camada so considerados. O erro de uma unidade da
camada escondida dado pela equao 2.9.
]
=
]
( -
]
) _
k
k

]k
(2.9)
Onde
]k
o peso da ligao da unidade at unidade da prxima camada, e onde
k
o
erro da unidade . [9, 11]
2.2.5 Learning Vector Quantization
O algoritmo LVQ [1, 2, 12, 13, 15, 16, 17] pode considerar-se um tipo de rede neuronal artificial.
um algoritmo usado para classificao, o que subentende dois conjuntos de dados distintos, um para
treino e outro para teste.
Inicialmente, este algoritmo necessita de criar vectores de referncia, aleatoriamente distribudos
pelo espao [7]. Estes vectores de referncia sero treinados tendo em conta o conjunto de treino
fornecido pelo utilizador, para que os seus valores se possam ajustar. Para isso o algoritmo procede
da seguinte forma:
Percorre a lista de vectores de aprendizagem carregados a partir da base de dados e para cada
vector de aprendizagem, procura o vector de referncia que lhe est mais prximo, usando a
distncia Euclidiana, tal como o algoritmo de Nearest Neighboor.
Quando encontra o vector de referncia mais prximo do vector de aprendizagem seleccionado,
aplica a seguinte formula:
c
( +) =
c
() + o()|() -
c
()] Se
s
=
c
( +) =
c
() - o()|() -
c
()] Se
s
=
( + ) =
() Para = c (2.10)

27

Nesta equao o algoritmo pune os vectores de referncia com uma classe diferente da classe do
vector de aprendizagem, levando-os para longe desse vector e recompensado o vector de
referncia caso este seja da mesma classe, trazendo-o para mais perto do vector de
aprendizagem em questo.
A primeira equao da frmula acima calcula o novo vector de referncia, tendo em conta o vector
de referncia
c
que pertence classe
s
mais perto do vector de aprendizagem escolhido ()
pertencente classe
. Esta equao recompensa o vector de referncia com a mesma classe.

A segunda equao pune o vector de referncia se a classe for diferente do vector de
aprendizagem, ou de treino [1, 2].
O algoritmo aplica esta equao a todos os vectores de treino. Quando chega ao fim da lista dos
vectores de treino, o algoritmo pode ainda voltar a fazer o mesmo processo, consoante o nmero
de iteraes pretendidas pelo utilizador [1, 2].
Quando o processo de aprendizagem termina, o algoritmo classifica o conjunto de teste fornecido.
Neste processo de classificao, o LVQ usa os vectores de referncia finais, calculados no
processo de treino. Para isso, procura de novo o vector de referncia mais prximo, usando a
distncia Euclidiana, do vector de teste seleccionado. A classe do vector de referncia mais
prximo do vector de teste ser atribuda a este ltimo.
Este algoritmo oferece ptimos tempos de execuo, que dependem do nmero de iteraes
pretendidas e da extenso dos dados de treino. Mais detalhes sobre o algoritmo podem ser
encontrados no Capitulo 4 desta tese.
Data Mining no direccionado ou no supervisionado
O Data Mining no direccionado [9, 11] no usado para realizar previses, logo os valores alvo
no so requeridos. Em vez disso, os dados so colocados num formato que torna mais fcil para
ns que eles faam sentido. Por exemplo: uma venda de livros online pode organizar os dados das
vendas passadas para descobrir as caractersticas comuns do gnero de leitores dos Estados
Unidos.
Um dos algoritmos mais usados por este tipo de Data Mining o Clustering [3, 5, 9, 11], este
algoritmo rene os dados em grupos, baseados em caractersticas comuns.
Outra maneira de tratar estes dados usar um destes clusters derivados e aplicar-lhe o algoritmo
de rvores de Deciso [3, 5, 9, 11, 18]. Isto permite focar num segmento particular do cluster. [9, 11]
De facto, Clustering apenas o primeiro passo no processo de definir grupos. Uma vez que os
grupos esto estabelecidos, o Data Mining direccionado usado em grupos que so de particular
interesse para a empresa. [9, 11]
2.2.6 Clustering
O algoritmo Clustering [3, 5, 9, 11, 18] trabalha de maneira a facilitar o Data Mining no
direccionado. No direccionado significa que no existem variveis dependentes usadas para
encontrar um resultado especfico. Em outras palavras, quando se prepara o modelo de Data Mining
[9, 11], no se sabe bem o que se procura ou o que ser encontrado. A aplicao do Clustering como

28

uma tcnica requer que seja despejado o cesto de dados no sistema e deixemos que ele
magicamente arranje os dados em pilhas semelhantes. O que o algoritmo faz encontrar registos e
atribuir esses registos aos grupos que ele define. Falando geralmente, este algoritmo usado
raramente para derivar informao que possa ser usada directamente para algum tipo de tomada de
deciso especfica. Mais frequentemente usado para identificar os grupos de registos que possam
ser estudados mais tarde com qualquer outro mtodo, tal como rvores de deciso.
Clustering um mtodo no supervisionado de Data Mining designado para descobrir
classificaes bsicas inerentes s bases de dados. No foi construdo para prever valores
desconhecidos, mas oferece uma maneira de descobrir registos que so similares o suficiente para
serem consideradas partes de um dado grupo que o algoritmo identifica [9, 11].
O alvo deste tipo de Data Mining ganhar e perceber as similaridades naturais entre grupos de
registos. Este conhecimento pode levar a um estudo posterior do comportamento destes grupos para
se conseguir fazer algumas generalizaes.
Existe um largo nmero de algoritmos de Clustering [3, 5, 9, 11, 18]. A escolha do algoritmo de
Clustering depende do tipo de dados disponveis e do propsito da aplicao. Se a anlise de clusters
usada como sendo uma ferramenta descritiva ou exploratria, possvel usar vrios algoritmos nos
mesmos dados para ver o que os dados podem revelar.
No geral, os mtodos de clustering podem ser divididos nas seguintes categorias [9, 11]:
Mtodos de partio: dada uma base de dados de n objectos, este mtodo constri parties
de dados, onde cada partio representa um cluster e n. Isto , classifica os dados em
grupos, onde cada grupo tem de preencher os seguintes requisitos
1. Cada grupo deve conter pelo menos um objecto;
2. Cada objecto deve pertencer a apenas um grupo;
Neste grupo insere-se o algoritmo k-means [5, 9, 11] onde cada cluster representado pelo
valor mdio dos objectos no cluster e o algoritmo k-medoids [5, 11], onde cada cluster
representado por um dos objectos localizados perto do centro do cluster. Estes so os
algoritmos mais utilizados quando falamos de clustering.
Mtodos hierrquicos: criam uma composio hierrquica do conjunto de objectos dado.
Podem ser classificados como sendo mtodos de aglomerao ou de diviso, baseado na
maneira como a composio hierrquica formada.
Mtodos baseados na densidade: a maioria das parties dos objectos por clusters baseada
na distncia entre objectos. Estes mtodos apenas conseguem encontrar clusters com formas
esfricas e tm dificuldades em encontrar clusters de formas diferentes. A ideia geral
continuar a crescer o cluster dado enquanto a densidade da vizinhana no exceder o limite,
ou seja, para cada ponto de dados dentro de um cluster, a sua vizinhana num dado raio tem
de conter pelo menos um nmero mnimo de pontos
Mtodos baseados em Grid: quotizam o espao do objecto num nmero finito de clulas que
forma a estrutura grid. Todas as operaes de clustering so realizadas nessa estrutura.
Mtodos baseados nos modelos: realizam um modelo para cada cluster e encontram os dados
que melhor encaixam num dado modelo. Um algoritmo baseado em modelos pode localizar

29

clusters construindo uma funo de densidade que reflecte a distribuio espacial dos pontos
de dados.
Alguns algoritmos de clustering integram ideias de vrios mtodos, o que faz que, s vezes, seja
difcil classificar um dado algoritmo como pertencendo unicamente a uma categoria de mtodo de
clustering.
2.2.6.1 Como funciona o Clustering k-means
Este algoritmo [5, 9, 11] um processo interactivo que procura identificar grupos e membros
desses grupos e criar valores que representam pontos no espao. Estes pontos permitem ao
processo medir os registos em termos da sua proximidade uns com os outros.
Os clusters tm limites que rodeiam os registos que residem dentro do cluster. Para conhecer a
sociedade de um dado registo, chega apenas saber qual o cluster a que ele pertence. O modelo
gerado por este algoritmo tambm contm referncias para coordenadas que localizaro o registo
num ponto no espao.
Dado uma base de dados com n objectos, e sendo o nmero de clusters pretendidos, um
algoritmo de partio organiza os objectos em parties ( n), onde cada partio representa um
cluster. Os clusters so formados para optimizar um critrio da partio, chamado funo de
similaridade, como a distncia, para que os objectos dentro de um cluster sejam similares, assim
como os objectos de diferentes clusters so dissimilares em termos de atributos da base de dados.
A caracterstica principal do Clustering k-Means [5, 9, 11] a varivel que predeterminada, e
cujo valor o nmero de clusters pretendidos.
Clustering [3, 5, 9, 11, 18] pode produzir dois resultados extremos dependendo do valor que
escolhemos para .
Se = ir produzir um resultado insignificante porque todos os dados esto agrupados
apenas num n;
Se for igual ao nmero de conjuntos de casos, produzir um resultado insignificante porque o
agrupamento j ocorreu.
O nmero de clusters por omisso sempre 10.
O algoritmo k-means funciona da seguinte maneira: primeiro selecciona dos objectos, cada um
representa no incio um cluster ou o seu centro [Figura 2.5]. Para cada objecto restante, um objecto
associado ao cluster que mais similar, baseado na distncia entre os objectos e o centro do cluster.
Aps cada novo objecto associado, o centro do cluster recalculado. Este processo iterado at que
a funo de critrio convirja. Este critrio tenta fazer com que os clusters resultantes sejam o mais
compactos e separados possvel.

Figura 2.5 Clustering de um conjunto de objectos baseado no mtodo
cada cluster
2.2.6.2 Encontrar os clusters
Quando os dados so apresentados, o algoritmo tem de decidir sobre os possveis clusters
existam. [11]
Um dos mtodos para encontrar os clusters identificar todos os valores distintos para um dado
atributo, seleccionar todos os quartos e quintos registos, e oferecer esses valores como valores
possveis de um conjunto. Um m
determinar os conjuntos baseados no nmero de valores que esto separados por uma maior
distncia.
2.2.6.3 Encontrar o centro do cluster
Os valores iniciais do cluster so amostras determinadas alea
inicial. Assim, se for escolhido o valor de
escolhidos e temporariamente atribudo o estado do centro do cluster.
Uma vez que os valores iniciais do cluster esto determinados, ento o ciclo do algoritmo atravs
dos registos, coloca cada registo
registos que mais perto correspondem aos pontos centro de todos os outros registos e recoloca
Isto feito calculando uma simples mdia dos valores do cluster e agarrando os pontos que se
encontram perto da mdia. [11]
Enquanto os centros dos clusters esto continuamente a ser ajustados, os limites entre clusters
esto tambm a mudar. Estes limites esto definidos como o ponto a meio caminho entre os valores
de centro de cada um dos clusters
a um cluster, podem estar agora associados a outro.
2.2.6.4 Validao dos clusters
O processo de avaliar os resultados do algoritmo de
validao de clusters. [3, 5, 9, 11
Existem trs aproximaes [11
Baseado em critrios externos: implica que
Clustering baseados numa
reflecte a intuio sobre a estrutura do
de um conjunto de objectos baseado no mtodo k-means
cada cluster est marcado por um +)
Encontrar os clusters
Quando os dados so apresentados, o algoritmo tem de decidir sobre os possveis clusters
possveis de um conjunto. Um mtodo alternativo recupera uma amostra de registos e tenta
Encontrar o centro do cluster e os seus limites
Os valores iniciais do cluster so amostras determinadas aleatoriamente que fornecem um ponto
for escolhido o valor de , ento dez pontos iro ser aleatoriamente
escolhidos e temporariamente atribudo o estado do centro do cluster. [11]
dos registos, coloca cada registo num dos clusters. Ao fazer isto, ele continuamente procura os
registos que mais perto correspondem aos pontos centro de todos os outros registos e recoloca
de centro de cada um dos clusters. Os limites tambm se movem, registos que uma vez pertenceram
a um cluster, podem estar agora associados a outro. [11]
Validao dos clusters
O processo de avaliar os resultados do algoritmo de Clustering conhecido sobre o termo de
11, 18]
11] para investigar a validao dos clusters:
Baseado em critrios externos: implica que uma avaliao dos resultados do algoritmo de
baseados numa estrutura pr-especfica, imposta num conjunto de dados
reflecte a intuio sobre a estrutura do clustering do conjunto de dados;
30

means (o meio de
Quando os dados so apresentados, o algoritmo tem de decidir sobre os possveis clusters que
upera uma amostra de registos e tenta
toriamente que fornecem um ponto
, ento dez pontos iro ser aleatoriamente
num dos clusters. Ao fazer isto, ele continuamente procura os
registos que mais perto correspondem aos pontos centro de todos os outros registos e recoloca-os.
. Os limites tambm se movem, registos que uma vez pertenceram
conhecido sobre o termo de
os resultados do algoritmo de
njunto de dados que

31

Baseado em critrios internos: os resultados de um algoritmo de Clustering so avaliados em
termos de quantidades que envolvem os prprios vectores do conjunto de dados;
Baseado em critrios relativos: neste mtodo a ideia base a avaliao de uma estrutura de
clustering comparando-a a outros esquemas de clustering, resultando no mesmo algoritmo mas
com valores dos parmetros diferentes.
Existem dois critrios propostos [11] para a avaliao de clustering e seleco de um esquema de
clustering ptimo:
Compacidade: os membros de cada cluster devem estar o mais perto possvel uns dos outros.
Uma comum medida de compacidade a varincia, que deve ser minimizada;
Separao: os clusters devem ser largamente espaados;
2.2.6.5 Distncia entre dois clusters
Existem trs diferentes abordagens que medem a distncia entre dois clusters [9, 11]:
nico sistema de ligao: mede a distncia entre os membros mais perto do cluster;
Sistema de ligao completo: mede a distncia dos membros mais distantes do cluster;
Comparao de centrides: mede a distncia entre os centros dos clusters.
2.2.6.6 Encontrar o melhor esquema de clustering
Como j foi referido atrs, a ideia fundamental desta abordagem escolher o melhor esquema de
clustering de um conjunto de esquemas definidos de acordo com um critrio pr-especfico.
De entre os esquemas de clustering
, = , ., definido por um algoritmo especfico, para

diferentes valores dos parmetros, escolher o que melhor serve o conjunto de dados. O processo de
identificar o melhor esquema de clustering baseado na validade do ndex q. Escolhendo um ndex
q, podemos proceder com os seguintes passos [9, 11]:
Correr o algoritmo de Clustering para todos os valores de entre um mnimo
mn
e um
mximo
mx
(o valor mximo e mnimo foram definidos previamente pelo utilizador);
Para cada valor de , correr o algoritmo r vezes, usando diferentes conjuntos de valores para
os outros parmetros do algoritmo;
Traar os melhores valores do ndex q obtido por cada em funo de .
Baseado neste traado pode-se identificar o melhor esquema de clustering. Existem duas
abordagens para definir o melhor clustering dependendo do comportamento de q a respeito de .
Se a validade do ndex no exibe uma inclinao ascendente ou descendente, conforme o
incrementa, procura-se o mximo (mnimo) do traado.
Para ndices que incrementam (ou decrementam) enquanto o nmero de clusters aumenta
procura-se os valores de onde ocorre uma significante mudana nos valores do ndice. Esta
mudana aparece como um joelho, no traado, e uma indicao do nmero de clusters subjacentes
ao conjunto de dados. A ausncia de joelho pode ser uma indicao que o conjunto de dados no
possui uma estrutura de clustering.

32

2.2.6.7 Quando usar Clustering
a melhor escolha de algoritmos quando existe uma grande quantidade de dados que tm um
alto nvel de estruturas lgicas e muitas variveis. Os resultados do Clustering tambm permitem [11]:
Visualizar relaes: facilidade ao mostrar um modelo gerado a partir de um ponto ou grfico;
Destacar as anomalias;
Criar amostras para outros esforos de Data Mining.
2.2.6.8 Fraquezas do Clustering
No facilmente interpretado e frequentemente necessrio alguma experincia para obter
clusters significativos. As principais fraquezas deste algoritmo [11] so:
Os resultados so difceis de perceber;
Tipos de dados difceis de comparar: porque o cluster confia em dados numricos para traar
pontos no espao, comparar nmeros que medem diferentes tipos de coisas torna-se um
desafio.
2.3 Ferramentas
Como j foi visto em seces anteriores, para realizar previses com base nos dados existentes
no Data Warehouse [8, 9, 11] necessrio aplicar um algoritmo aos dados de entrada. A estrutura
que guarda o resultado de aplicar o algoritmo aos dados de entrada, chamada de Modelo de Dados
e guarda tambm os dados originais bem como os padres descobertos.
O primeiro passo em qualquer operao de Data Mining (caso seja escolhido realizar previses
com um dos algoritmos j integrado) criar um modelo. O modelo de Data Mining gerado de casos
contidos numa fonte de dados. Qualquer fonte de dados que possa ser ligada atravs de uma ligao
OLE DB pode ser usada para criar um modelo. Estas fontes incluem bases de dados relacionais,
cubos OLAP (On-Line Analytical Processing), ficheiros de texto, ou at folhas de texto do Microsoft
Excel. [11]
Seguidamente sero apresentadas trs tcnicas diferentes de relacionar Data Mining a uma base
de dados, sendo elas Microsoft SQL, SAS e Oracle.
2.3.1 Microsoft SQL Server
O Microsoft SQL Server Analysis Services 2000 Service Pack 1 permite a agregao de ligaes
OLE DB para fornecedores de Data Mining no Analysis Server. Devido a esta agregao ser ao nvel
do OLE DB, programadores de novos algoritmos que usam SQL Server 2000 SP1 tm de
implementar todas as funes de tratamento de dados, parsing, gesto de metadados, gesto de
sesso, e cdigo de produo de conjuntos de linhas em cima do ncleo da implementao do novo
algoritmo de minerao de dados.
Por contrates, SQL Server 2005 Data Mining permite a agregao directamente ao nvel do
algoritmo. Apesar de isto restringir o que o programador do novo algoritmo pode realizar em termos
de linguagem e tipos de dados, liberta o programador de implementar todas as camadas adicionais

33

descritas acima
1
. Tambm permite uma integrao mais profunda com o Analysis Services, incluindo
a capacidade de construir modelos de minerao OLAP.
O Analysis Server comunica com o novo algoritmo atravs de um conjunto de interfaces COM
1

descritas em detalhes no capitulo 4. Estas interfaces esto divididas em dois grupos:
Aquelas que necessrio implementar pelo programador do novo algoritmo;
Aquelas que so implementadas pelos objectos do Analysis Server e consumidos pelo
algoritmo.
O Microsoft SQL Server 2005 simplifica a integrao de novos algoritmos, podendo o programador
separar as vrias fases do processo
2
em:
Criao do projecto com a definio das interfaces;
Registar o algoritmo no Analysis Services;
A partir de agora o algoritmo ir fazer parte da lista de algoritmos apresentados pelo Wizard do
Analysis Manager, apesar de ainda no haver qualquer cdigo do algoritmo desenvolvido.
Neste passo apenas esto criadas as interfaces necessrias interaco do algoritmo com a
ferramenta.
Implementao do algoritmo no projecto;
Personalizao das interfaces tendo em conta o algoritmo;
Criao de um modelo de dados para previses com o novo algoritmo.
Esta ferramenta para alm da grande simplicidade demonstrada ao integrar novos algoritmos,
apresenta tambm muita documentao relativa a este assunto, bem como um frum com
especialistas de Data Mining prontos para responderem a qualquer dvida que o programador possa
ter.
Aps a integrao do cdigo do novo algoritmo no projecto onde j esto definidas as interfaces, e
aps serem personalizadas tendo em conta o algoritmo, o novo algoritmo estar pronto a ser utilizado
dentro de um modelo de dados, que pode ser concretizado facilmente com a ajuda do Wizard, cujos
passos esto descritos no Capitulo 5.
2.3.2 SAS
SAS fornece produtos de Data Mining baseados em Java, que suportam todos os passos
necessrios para enderear os problemas de negcio numa nica e integrada soluo
3
.
As interfaces SAS eliminaram a necessidade de programao manual, diminuindo dramaticamente
o tempo de desenvolvimento de modelos e a sua manuteno. Apesar de tudo, ainda no so
solues de caixa preta. Com SAS pode-se adicionar facilmente os cenrios de negcio e integrar o
cdigo normal do SAS com os modelos de fluxo.

1
Microsoft. SQL Server Data Mining: Plug-In Algorithms. [Online] [Cited: 08 05, 2008.]
http://msdn.microsoft.com/en-us/library/ms345133.aspx#ssd_topic3.
2
3
SAS. http://www.sas.com. [Online] [Citao: 28 de Novembro de 2007.]
http://www.sas.com/technologies/analytics/datamining/brochure.pdf.

34

As ferramentas do SAS fornecem algoritmos de anlise tal como rvores de deciso e redes
neuronais.
O projecto SAS Enterprise Miner suporta a partilha de resultados de modelos entre analistas. Os
modelos podem tambm ser importados para dentro do repositrio SAS Model Manager para partilha.
Scoring o processo de aplicar um modelo a novos dados e a aco resultante de muitos
esforos sobre o Data Mining. SAS Enterprise Miner guia o utilizador atravs do processo de Data
Mining e produz cdigo para todos os estgios de desenvolvimento do modelo. Guia o utilizador
atravs de um processo repetitivo de registar, testar e validar os modelos
1

2
.
Na viso do programador, esta ferramenta oferece uma soluo menos vivel que a abordada no
tpico anterior, dado que para adaptar um novo algoritmo ao SAS Enterprise Miner necessrio que
esse algoritmo esteja construdo na linguagem utilizada, prpria do SAS.
Quanto ligao do novo plug-in, aps a construo do algoritmo, ferramenta SAS Enterprise
Miner
2
, no existe informao suficiente disponvel para aqui ser explicado esse passo, pelo que se
torna numa desvantagem desta ferramenta a falta de informao de ajuda disponvel.
Devido a existir uma linguagem prpria, esta ferramenta no utilizada para a criao de novos
plug-in excepto por programadores que esto familiarizados com a linguagem, e que utilizam esta
ferramenta dentro das suas empresas.
2.3.3 Oracle
O Oracle Data Mining junta o Data Mining com a base de dados Oracle. No necessrio mover
os dados da base de dados para os ficheiros para anlise e depois de volta dos ficheiros para a base
de dados. Os dados nunca saem da base de dados, os dados, a preparao dos dados, e os
resultados dos modelos permanecem sempre na base de dados
3
.
Os dados utilizados pelo Oracle Data Mining consistem em tabelas guardadas nas bases de dados
Oracle. As linhas de uma tabela so referidas como casos, registos ou exemplos. As colunas da
tabela so referidas como atributos. Cada atributo num registo tem um item de informao. Os nomes
dos atributos so constantes de registo para registo, os valores nos atributos podem variar de registo
para registo
3
.
Para ligar os algoritmos base de dados Oracle, e us-los para fazer previses, necessrio
construir um modelo. Depois de ser construdo, fica na base de dados podendo ser acedido pelo seu
nome nico especificado pelo utilizador que o criou. Aps um modelo ter sido criado existe apenas
um utilizador por cada sesso a aceder ao modelo [29]
3
.
A seguir so apresentados os passos requeridos para executar algumas tarefas de Data Mining
usando o Oracle Data Mining (ODM):

1
http://www.sas.com/technologies/analytics/datamining/miner/factsheet.pdf.
2
http://www.sas.com/technologies/analytics/datamining/brochure.pdf.
3
ORACLE. http://www.oracle.com. [Online] [Citao: 25 de Novembro de 2007.] http://download-
east.oracle.com/docs/cd/B14117_01/datamine.101/b10699/preface.htm.

35

1. Recolher e pr-processar os dados (este passo opcional dado que os algoritmos ODM
podem automaticamente preparar os dados);
2. Construir um modelo:
3. Testar o modelo e calcular a elevao (apenas para problemas de classificao);
4. Aplicar o modelo a novos dados.
Apesar de ser disponibilizada muita informao sobre Data Mining, a Oracle no oferece um guia
detalhado de integrao de novos algoritmos com a sua ferramenta, pelo que apenas aqui descrito
em traos gerais quais seriam os passos para a criao de um modelo de Data Mining com o Oracle
Data Mining.
2.3.3.1 Construir um modelo de minerao com Interface Java
Esta seco ira descrever como usar uma Interface Java num Oracle Data Mining para escrever
uma aplicao Data Mining em Java.
1. Estabelecer uma ligao ao Data Mining Server [29]
1

Para executar qualquer operao de Data Mining na base de dados, necessrio criar uma
ligao atravs da criao de uma instncia da classe oracle.dmt.odm.DataMiningServer. Esta
instncia usada como proxy para criar ligaes a um Data Mining Server (DMS) e para manter a
ligao. O DMS o lado do servidor, nos componentes de base de dados que executam as
actuais operaes de Data Mining com ODM. O DMS tambm fornece um repositrio de
metadados que consiste em objectos de entrada para Data Mining e objectos resultantes,
juntamente com os namespaces dentro do qual estes objectos so guardados e armazenados.
2. Descrever os dados do Data Mining [29]
1

Na Interface Java do ODM, as classes: oracle.dmt.odm.data.LocationAccessData (LAD) e
oracle.dmt.odm.PhysicalDataSpecification (PDS) so usadas para descrever o conjunto de dados
de entrada (tabela/vista no esquema de utilizador). Para representar um conjunto de dados no
formato de registo nico, deve-se usar uma instncia da classe
NonTransactionalDataSpecification, e para representar os conjuntos de dados num formato de
mltiplo registo, necessrio usar a instncia da classe TransactionalDataSpecification.
3. Objecto MiningFunctionSettings [29]
1

A classe oracle.dmt.odm.settings.function.MiningFunctionSettings (MFS) a super classe comum
para todos os tipos de classes de configurao de funes de minerao. Encapsula os detalhes
das funes e as configuraes do algoritmo, os dados lgicos, e as especificaes dos dados
que iro ser usados.
Um objecto MFS um objecto que pode ser guardado no DMS. Se nenhum algoritmo for
especificado para ser usado no processo de Data Mining, o DMS selecciona o algoritmo por
omisso e as suas configuraes para essa funo.

1

36

A classe oracle.dmt.odm.settings.algorithm.MiningAlgorithmSettings a super classe comum para
todas as configuraes do algoritmo. Encapsula todas as configuraes que podem ser ajustadas
baseadas no problema e nos dados.
4. Objecto MiningTask [29]
1

A classe oracle.dmt.odm.task.MiningTask a mais comum super classe para todas as tarefas de
Data Mining. Esta classe fornece a execuo assncrona de operaes de Data Mining na base de
dados. Para cada execuo da tarefa um objecto oracle.dmt.odm.task.ExecutionHandle criado.
Este objecto fornece aos mtodos o estado da execuo.
5. Construir um modelo [29]
1

Para construir um modelo, usado o objecto MiningBuildTask. Encapsula os detalhes de entrada
e de sada da operao de construo do modelo. A seguir so apresentados os passos
requeridos para construir um modelo:
a. Pr processar e preparar os dados de entrada requeridos
b. Construir e guardar os objectos MiningFunctionSettings e MiningBuildTask;
c. Chamar o mtodo execute, que ir manter o trabalho numa fila para uma execuo assncrona;
d. Periodicamente chamar o mtodo getCurrentStatus para obter o estado da tarefa.
Aps a execuo destes passos, um objecto modelo ir ser criado na base de dados.
6. Objecto MiningModel [29]
1

A classe oracle.dmt.odm.model.MiningModel uma classe que envolve o modelo actual guardado
no DMS. Cada classe MiningModel fornece mtodos para recuperar detalhes dos modelos.
7. Testar o modelo [29]
1

Para testar o modelo construdo necessrio efectuar os seguintes passos:
a. Descrever o conjunto de dados de entrada;
b. Testar o modelo: Antes de executar uma tarefa, esta deve ser guardada no DMS. Depois de
invocar execute na tarefa, a tarefa submetida para uma execuo assncrona no DMS.
c. Obter os resultados do teste;
2.3.3.2 Construir um modelo com Interface PL/SQL
A metodologia de desenvolvimento utilizada para Data Mining usando a API
DBMS_DATA_MINING est dividida em duas fases
1
:
A primeira fase inclui a aplicao, a anlise dos dados e o desenho, onde se realizam os dois
seguintes passos:
1. Analisar o problema e escolher a funo de minerao e o algoritmo;
2. Analisar os dados a serem usados para construir o modelo de Data Mining, testar os modelos
preditivos e os novos dados aos quais o modelo vai ser aplicado.

1

37

A segunda fase envolve desenvolver uma aplicao de minerao de dados usando os pacotes
DSMS_DATA_MINING e DBMS_DATA_MINING_TRANSFORM;
3. Preparar a construo, teste e contagem dos dados usando o pacote
DBMS_DATA_MINING_TRANSFORM ou outra utilidade directa como scripts em SQL ou
PL/SQL, duma maneira apropriada para o algoritmo ou funo previamente escolhidos.
4. Preparar uma tabela de configuraes que reescreva o algoritmo definido por omisso para
uma dada funo de minerao de dados e as configuraes desse algoritmo.
5. Construir um modelo de minerao para treinar o conjunto de dados.
6. Para modelos preditivos (de classificao e regresso), testar o modelo a nvel de exactido e
de outros atributos. Isto requer que se aplique o modelo aos dados de teste.
7. Recuperar a assinatura do modelo para determinar os atributos requeridos por um dado
modelo. Esta informao ir ajudar a perceber se determinados dados so apropriados para
um modelo.
8. Aplicar uma classificao, regresso, clustering ou um modelo com uma caracterstica de
extraco a novos dados para gerar previses ou descrever padres em torno dos dados.
9. Recuperar os detalhes do modelo, para perceber porque que um modelo marca os dados de
uma maneira particular.
10. Repetir os passos 3 a 9 at obter resultados satisfatrios.
O pacote DBMS_DATA_MINING cria um modelo de minerao para uma funo usando um
algoritmo de minerao especfico que suporta a funo
1
.
Um modelo identificado pelo seu nome e, tal como as tabelas, tem armazenado dados
associados. Mas ao contrrio de uma tabela, a forma e o contedo desses dados armazenados
opaco ao utilizador. Contudo, um utilizador pode ver os contedos de um modelo, isto quer dizer, os
padres e as regras que constituem um modelo, usando uma funo
1
especfica
GET_MODEL_DETAILS.
O pacote acima referido suporta funes de Classificao, Regresso, Associao de Regras,
Clustering e Extraco de caractersticas. Pode-se especificar a escolha da funo atravs de um
parmetro no procedimento CREATE_MODEL.
Cada funo de minerao de dados pode ser implementada usando um ou mais algoritmos. ODM
assume um algoritmo por omisso [29]
1
para cada uma das funes que pode ser alterado.
Para ligar um outro algoritmo que no sejam os algoritmos por omisso do ODM, necessrio
criar uma nova tabela de configurao para esse algoritmo. Esta nova tabela tem vrias colunas que
devem ser preenchidas com informao sobre o algoritmo. A tabela criada atravs de uma
instruo SQL e guardada na base de dados com os valores dados. Aps esta operao existe mais
um algoritmo que poder ser aplicado para calcular valores preditivos num determinado modelo.
1

Cada algoritmo tem um ou mais parmetros que influenciam a maneira como construdo o
modelo, o ODM assume um conjunto de configuraes por omisso para cada algoritmo. [29]
1

1

38

Para construir resultados necessrio construir primeiro o modelo atravs da operao
CREATE_MODEL. Os contedos do modelo so fornecidos pela funo GET_MODEL_DETAILS
para cada algoritmo suportado. Em adio a isso, as funes GET_MODEL_SIGNATURE e
GET_MODEL_SETTINGS fornecem informao descritiva sobre o modelo.
1

A operao APPLY cria e preenche um esquema de uma tabela com um dado nome. O esquema
dessa tabela varia, baseado na funo particular de minerao, no algoritmo e no tipo de atributos
alvo.
1

Por fim, os dados de entrada das operaes de minerao devem ser inseridos atravs de tabelas
relacionais, onde cada linha representa um caso, e cada coluna na tabela unicamente representa um
atributo (formato caso de registo nico).
1

2.3.4 Comparao das ferramentas
Das trs ferramentas descritas nas seces anteriores, apenas o SAS apresenta uma linguagem
prpria e , portanto, pouco utilizado para desenvolvimento de algoritmos plug-in. A ferramenta
apresentada pelo SAS para minerao normalmente utilizada por empresas, e oferece ao utilizador
uma interface bastante intuitiva no que diz respeito a construo de modelos de Data Mining.
A ferramenta oferecida pelo Oracle mais acessvel aos programadores, na medida em que os
algoritmos podem ser desenvolvidos em linguagens conhecidas como PL/SQL ou Java. A nvel da
integrao de novos algoritmos plug-in com a ferramenta no oferece um mtodo simples, pois
necessrio realizar cdigo, chamar classes e dar instrues para ligar o algoritmo ao Oracle Data
Mining e criar um modelo de minerao de dados. O problema no seria o nmero de instrues de
cdigo, mas sim a falta de informao descritiva sobre como integrar um novo algoritmo Plug-in.
Quanto ao Microsoft SQL Server 2005, este parece oferecer o mtodo mais intuitivo e menos
trabalhoso de integrar o novo algoritmo plug-in sua base de dados. Existe um Wizard que guia o
programador atravs dos passos de construo do modelo de minerao, e alguns tutoriais
disponveis em duas linguagens de programao (C++ e C#) para ajudar o programador na tarefa de
integrao do algoritmo plug-in na ferramenta. Estes tutoriais vm tambm acompanhados com
algum cdigo, o que permite ao programador analisar a personalizao das interfaces e a definio
de funes necessrias.
A ferramenta oferecida pela Microsoft de facto a soluo mais procurada e utilizada para
integrao de novos algoritmos plug-in, pois facilita o trabalho do programador, no sendo necessrio
aprender novas linguagens de programao nem escrever longas instrues de cdigo, poupando
assim tempo em importaes e exportaes de pacotes, classes e objectos.

1

39

3 Learning Vector Quantization (LVQ)

O algoritmo Learning Vector Quantization [1, 2, 12, 13, 14, 15, 16, 17] o precursor do j
conhecido self-organizing maps [1] (tambm conhecido por Kohonen feature maps) e, como ele, pode
ser visto como um tipo especial de redes neuronais artificiais. Ambos os tipos de redes representam
um conjunto de vectores de referncia, e as posies onde vai ser optimizado um dado conjunto de
dados.
Learning Vector Quantization [1, 2, 12, 13, 14, 15, 16, 17] representa uma classe de algoritmos
relacionados com este nome, tais como LVQ1, LVQ2, LVQ3 e OLVQ1. LVQ descreve uma
aprendizagem supervisionada, ou seja, necessrio fornecer um conjunto de valores sobre os quais
se realizaro as classificaes (dados de teste).
Como o LVQ depende de uma classificao estatstica ou de um mtodo de reconhecimento, o
seu nico propsito definir regies de classes no espao de dados de entrada, semelhana do
algoritmo de Clustering [3, 5, 9, 11, 18]. Para este fim um subconjunto de vectores de referncia
etiquetados colocado na regio.
Este mtodo aparentemente um mtodo de Nearest Neighbor, devido a ser necessrio calcular a
mais pequena distncia dos vectores desconhecidos, ou vectores de treino com um conjunto de
vectores de referncia. Temos de seleccionar um nmero fixo de vectores de referncia para cada
classe. Os valores desses vectores vo sendo optimizados no processo de aprendizagem.
No treino, apenas o vector de referncia mais prximo actualizado. A actualizao do vector de
referncia realizada para ambas as classificaes, correcta e incorrecta. O processo de correco
metricamente compatvel com o critrio usado para a classificao.
Como resultado, os vectores de referncia so aproximados por funes de densidade
probabilsticas dos padres das classes. Para serem mais precisos, os vizinhos mais prximos
definem superfcies de deciso entre os padres das classes, os quais parecem aproximar-se do
classificador de Bayes e, na classificao, as fronteiras das classes so de maior importncia.
As seces seguintes descrevem o modo de funcionamento de cada um dos algoritmos da classe
Learning Vector Quantization.
3.1 Deciso ptima
O problema da deciso ptima [1] ou do reconhecimento de padres estatsticos normalmente
discutido na Framework da teoria de probabilidades de Bayes. Assumindo que todas as amostras de
, sendo um dos vectores de entrada ou vectores de treino, so derivados de um conjunto finito de
classes {
k
] , cujas distribuies esto normalmente sobrepostas. Seja (
k
) a probabilidade priori
da classe
k
, e seja p(| e
k
) a funo da probabilidade condicional de em
k
, respectivamente.
Define-se as funes discriminantes:
o
k
() = p(| e
k
)(
k
) (3.1)

40

de relembrar que na mdia, as amostras desconhecidas so classificadas optimamente (por
exemplo, a taxa das classificaes erradas mnimo), se uma amostra determinada como
pertencendo classe
c
de acordo com a deciso
o
c
() = max
k
{o
k
()] (3.2)
Relembremos tambm que o mtodo tradicional na prtica de reconhecimento de padres
estatsticos, era primeiramente desenvolver aproximaes a p(| e
k
)(
k
) e depois us-las para
a primeira equao. A aproximao LVQ, por outro lado baseada numa filosofia completamente
diferente. Considere-se a Figura 3.1.

Figura 3.1 - (a) Pontos pequenos: sobreposio de duas funes de densidade Gaussiana
correspondente classe S1 e S2 com os seus centrides a serem mostrados pela cruz branca
e preta, respectivamente. Curva slida: fronteira de deciso de Bayes. (b) Pontos pretos largos:
vectores de referncia da classe S1. Crculos abertos: vectores de referncia da classe S2.
Curva slida: fronteira de deciso no LVQ. Curva partida: fronteira de deciso de Bayes. [1]
Primeiro atribui-se um subconjunto de vectores de referncia a cada classe
k
e depois procura-se
o vector de referncia
que tem a distncia Euclidiana mais pequena de . suposto a amostra

pertencer mesma classe do vector mais perto
. Os vectores de referncia podem ser colocados

de maneira a que os que pertencem a classes diferentes no estejam misturados, apesar da
distribuio sobreposta de classes de . A partir de agora apenas os vectores de referncia que esto
perto das fronteiras de classes so importantes para ptimas decises, obviamente uma boa
aproximao de p(| e
k
) no necessrio em todo o lado. mais importante colocar o
no
espao de maneira a que a regra do vizinho mais perto usada para classificao minimize a mdia
esperada de probabilidades de ms classificaes. [1]
3.2 LVQ1
O mtodo utilizado por este algoritmo aparentemente o mesmo mtodo utilizado pelo algoritmo
Nearest Neighbour [3, 5, 9], devido pequena distncia do vector desconhecido at a um conjunto de
vectores de referncia procurados. No so usadas amostras estatsticas de vectores conhecidos,
mas so seleccionados num nmero fixo de vectores de referncia para cada classe os valores que
sero posteriormente optimizados num processo de aprendizagem. Algumas caractersticas deste
algoritmo so [2]:
No treino, apenas o vector de referncia mais prximo actualizado;
A actualizao do vector de referncia feita para ambas as classificaes, correctas e
incorrectas;
O processo correctivo metricamente compatvel com o critrio usado para identificao;

41

Este algoritmo usado na classificao estatstica ou no mtodo de reconhecimento, e o seu
nico propsito definir regies de classe nos dados de entrada [1].
O mtodo de aprendizagem do algoritmo LVQ1 [1, 2, 16] constantemente chamado de
aprendizagem competitiva porque funciona da seguinte maneira: para cada padro de treino o
vector de referncia que est prximo dele determinado. O neurnio de sada correspondente
tambm chamado de neurnio vencedor. Os pesos das ligaes a esse neurnio e apenas a esse
neurnio: o vencedor toma tudo so depois adaptados. A direco da adaptao depende se a
classe do padro de treino e a classe atribuda ao vector de referncia coincide ou no. Se
coincidem, o vector de referncia movido para mais perto do padro de treino, caso contrrio
movido para mais longe. Este movimento do vector de referncia controlado por um parmetro
chamado rcio de aprendizagem. Este parmetro muda conforme a distncia para onde o vector de
referncia movido. Normalmente o rcio de aprendizagem decrementado com o tempo, sendo
que as mudanas iniciais so maiores que mudanas posteriores do processo de treino. A
aprendizagem pode ser terminada quando as posies dos vectores de referncia raramente se
alterarem.
Consideremos um processo que aloca optimamente vectores de referncia
e
n
, = , , .,
no espao n-dimensional ou de padres de vectores e
n
.
Para valores iniciais do
, = , , ., , as primeiras amostras de podem ser escolhidas. As

prximas amostras de so ento usadas para treino. No caso de apenas um nmero limitado de
amostras estarem disponveis, elas devem ser aplicadas iterativamente no processo de
aprendizagem. Que
c
seja o vector entre o
com o qual tem a menor distancia -

c
. Este
vector depois actualizado de maneira a que -
c
seja decrementado. Por exemplo, se a norma
Euclidiana, a actualizao pode ser descrita num formalismo em tempo discreto ( =
,,, .) atravs de:
c
( + ) =
c
() + o()|() -
c
()],
( + ) =
() poro = c, (3.3)
Com os problemas de reconhecimento de padres, a superfcie de deciso entre classes de
padres e no o interior das distribuies das classes que deve ser descrito mais em pormenor.
O algoritmo LVQ [1, 2] descrito de seguida inicializado com os valores da primeira amostra de
que so identificados com
(). Estes vectores so etiquetados usando um conjunto de

amostras de treino de com a classificao conhecida. A distribuio das amostras de treino pelas
vrias classes, tal como os nmeros relativos dos
atribudos a essas classes devem cumprir com

as probabilidades a priori (
k
) das classes
k
. Cada amostra de treino atribuda ao
do qual se
encontra mais prximo. Cada
ento etiquetado de acordo com a maioria das classes

representadas entre essas amostras que foram atribudas a
.
Para continuar, ainda necessitamos de amostras do conjunto de treino com a classificao
conhecida, que aplicamos iterativamente durante os passos de aprendizagem. Estas amostras
podem ser usadas ciclicamente, ou os vectores de treino podem ser escolhidos aleatoriamente deste
conjunto.

42

Assumindo que vrios vectores de referncia so atribudos a cada classe de valores , e
ento determinado para pertencer mesma classe qual o mais perto mi pertence. Seja
c = aig min
{ -
] (3.4)
que define o ndice do
mais perto de .
Suponhamos que o vector de treino () pertence classe
. Assumindo que o vector de

referncia mais prximo
c
etiquetado de acordo com a classe
s
e que
() a representao
sequencial de valores de
no domnio do tempo discreto, = ,,, .. O algoritmo de aprendizagem

supervisionada [1, 2] que recompensa as classificaes correctas e pune as incorrectas definido
por:
c
( +) =
c
() + o()|() -
c
()] Se
s
=
c
( +) =
c
() - o()|() -
c
()] Se
s
=
( + ) =
() Para = c (3.5)
Onde < o() < o rcio de aprendizagem e normalmente decresce monotonamente com o
tempo. recomendado que alfa deva ser inicialmente pequeno, mais pequeno do que 0,1. A lei
exacta o = o() no crucial e o() pode at ser feito para decrescer linearmente para zero, sendo o
nmero de passos de aprendizagem suficiente. Se apenas um restrito conjunto de amostras de treino
est disponvel, elas podem ser aplicadas ciclicamente.
De novo, apenas o vector
mais perto modificado de cada vez, mas agora a direco da

correco depende da exactido da classificao.
O efeito primrio das regras acima descritas a diminuio das classificaes erradas. Ao mesmo
tempo os vectores de referncia
, so empurrados para fora das zonas onde a m classificao

ocorre.
3.3 Optimized-Learning-Rate LVQ1 (OLVQ1)
O algoritmo LVQ bsico ser modificado de maneira a que um factor de rcio de aprendizagem
individual o
() seja atribudo a cada
(vector de referncia), assim obtm-se o seguinte processo

de aprendizagem. Seja c definido pela equao (3.4). Ento assume-se que:
c
( +) =
c
() + o
c
()|() -
c
()] Caso seja classificado correctamente;
c
( +) =
c
() - o
c
()|() -
c
()] Caso seja classificado incorrectamente;
( + ) =
() Para = c (3.6)
O problema que o
() tem de ser determinado optimamente para uma rpida convergncia das

equaes anteriores. Expressamos as trs equaes na forma de:
c
( + ) = | - s()o
c
()]
c
() + s()o
c
()(), (3.7)
Onde s() = + caso a classificao seja correcta, e s() = - se a classificao for incorrecta.
Pode ser bvio que a exactido estatstica dos valores aprendidos dos vectores de referncia
aproximadamente ptima se todas as amostras foram usadas com o mesmo peso, por exemplo, se
os efeitos das correces feitas em alturas diferentes, quando referidas ao fim do perodo de
aprendizagem, apresentam aproximadamente a mesma magnitude. Repare-se que
c
( + ) contm
um rasto de () atravs do ltimo termo da equao composta, e rastos de ('), ' = ,, ., -

43

em
c
(). Num passo de aprendizagem, a magnitude do ltimo rasto de () escalonado para baixo
pelo factor o
c
(), e por sua vez, durante o mesmo passo, o rasto de ( - ) tornou-se escalonado
para baixo por | - s()o
c
()]. o
c
( -). Primeiro deve-se estipular que esses dois escalonamentos
devem ser idnticos:
o
c
() = | - s()o
c
()]. o
c
( -) (3.8)
Se esta condio foi feita para aguentar para todos os , por induo pode ser mostrado que os
rastos recolhidos fora de tempo de todos os (') sero escalonados para baixo por uma quantidade
igual, no fim, e assim, o valor ptimo de o
() pode ser determinado pela recurso:

o
c
() =
u
c
(t-1)
1+s(t)u
c
(t)
. (3.9)
Contudo uma precauo necessria: desde que o
c
() pode tambm aumentar, especialmente
importante que no aumente acima do valor 1. Esta condio pode ser imposta no prprio algoritmo.
Para os valores iniciais do o
um pode tomar 0,5, mas bom comear com um valor como o
= 0,3.
Deve-se avisar que a equao (3.9) no deve ser aplicvel ao algoritmo LVQ2, pois o o
, na
mdia, no ir decrescer, e o processo no converge.
3.4 LVQ2
A deciso de classificao neste algoritmo idntica do LVQ1. Na aprendizagem, contudo, dois
vectores de referncia
e
]
, que so os vizinhos mais prximos de so agora actualizados
simultaneamente. Um deles deve pertencer classe correcta e o outro classe incorrecta,
respectivamente. Mais ainda, deve cair numa zona de valores chamada janela que definida em
volta do plano de
e
]
. Assuma que
e
]
so as distncias Euclidianas de a
e a
]
,
respectivamente; ento definido para cair na janela de uma largura se:
min(
d
i
d
]
,
d
]
d
i
) > s, onde s =
1-w
1+w
. (3.10)
Uma janela com largura relativa de 0,2 a 0,3 recomendada. A verso do LVQ2 chamada
LVQ2.1 [1, 2] descrita abaixo uma melhoria do algoritmo LVQ2 original, pois permite que
e
]

sejam os vizinhos mais prximos de , considerando que no LVQ2 original
tem de ser mais

prximo.
Considere-se a Figura 3.2 abaixo que ilustra as distribuies de uma dimenso (as mesmas
consideraes aplicam-se a casos multidimensionais). Assumindo que os vectores de referncia
vizinhos
e
]
esto inicialmente numa posio errada. A superfcie de discriminao sempre
definida como sendo o plano mdio entre
e
]
. Definindo uma janela simtrica com largura no
nula em volta do plano mdio e estipulando que as correces a
e
]
apenas devem ser
realizadas se cair nos valores da janela, do lado errado do plano mdio. Se as correces forem
feitas de acordo com a equao (3.11), ser fcil ver que para os vectores que caem na janela, as
correces de ambos
e
]
, em mdia, tm uma direco tal que o plano mdio move-se atravs
da superfcie de distribuio das classes, e assim coincide aproximadamente com a deciso de
fronteira de Bayes.

44

Figura 3.2 Ilustrao da janela do algoritmo LVQ2, onde
|
e
so os vectores de referencia mais

prximos do vector de aprendizagem x, d
|
(x) e d
(x) so as respectivas distancias de x a

|
e
. [2]
( + ) =
() - o()|() -
()]
]
( +) =
]
() + o()|() -
]
()] (3.11)
Se
a classe vizinha, mas pertence a

]
=
, onde
a segunda classe vizinha; alm

disso deve cair na janela, em todos os outros casos:

k
( + ) =
k
() (3.12)
Onde
e
]
so os dois vectores de referncia mais prximos de , sendo que e
]
pertencem
mesma classe, enquanto e
pertencem a classes diferentes, respectivamente, deve estar

ainda dentro dos valores definidos da janela [1, 2].
3.5 LVQ3
O algoritmo LVQ2 [1, 2] era baseado na ideia de deslocao diferencial nas fronteiras dos limites
Bayesianos, enquanto nenhuma ateno era prestada ao que podia acontecer localizao do
se
o processo continuasse. Assim, parece necessrio introduzir correces que garantam que o
se
continua a aproximar das distribuies de classe. Combinando as ideias anteriores, obtemos agora
um algoritmo melhorado, que pode ser chamado LVQ3 [1, 2], tendo em conta a equao (3.11) do
algoritmo LVQ2, onde
e
]
so os dois vectores de referncia vizinhos mais prximos de , sendo
que e
]
pertencem mesma classe, enquanto e
pertencem a classes diferentes,

respectivamente; e onde deve estar entre os valores definidos da janela;
k
( + ) =
k
() - eo()|() -
k
()], (3.13)
Para e {, ], se ,
e
]
pertencerem mesma classe.
Numa srie de experincias, foram encontrados valores aplicveis a e entre 0,1 e 0,5, no que toca
a os valores podem ser 0,2 ou 0,3. O valor ptimo de e parece depender do tamanho da janela,
sendo mais pequeno para janelas mais estreitas. Este algoritmo parece estabilizar-se a ele prprio,
por exemplo, o valor ptimo de
no muda com a aprendizagem contnua.

3.6 Diferenas entre LV1, LVQ2 e LVQ3
As trs opes para os algoritmos LVQ, chamadas LVQ1, LVQ2 e LVQ3 partilham as mesmas
exactides [17] na maioria das tarefas de padres de reconhecimento estatsticos, apesar de uma
filosofia diferente viver por debaixo de cada um deles. O LVQ1 e LVQ3 definem um processo mais
robusto, onde os vectores de referncia assumem valores estacionrios mesmo depois de perodos
de aprendizagem extensos. Para o LVQ1 [1, 2, 16] a taxa de aprendizagem pode ser optimizada
aproximadamente para uma rpida convergncia. No LVQ2, as distncias relativas dos vectores de

45

referncia das fronteiras das classes so optimizadas, considerando que no existe garantia dos
vectores de referncia serem colocados optimamente para descrever as formas da distribuio das
classes. Assim, o LVQ2 apenas deve ser utilizado numa forma diferencial, usando um valor muito
pequeno de taxa de aprendizagem e um nmero restrito de passos de aprendizagem [1].
3.7 Consideraes gerais
Nos algoritmos LVQ [1, 2, 12, 13, 14], a quantificao vectorial no usada para aproximar as
funes de densidade das amostras da classe, mas para definir directamente as fronteiras da classe
tendo em conta a regra do vizinho mais prximo. A exactido alcanada em qualquer tarefa de
classificao s quais os algoritmos LVQ so aplicados e o tempo necessrio para aprender
dependem dos seguintes factores:
Um nmero ptimo aproximado de vectores de referncia atribudos a cada classe e os seus
valores iniciais;
O algoritmo detalhado, uma taxa de aprendizagem apropriada aplicada durante os passos, e
um critrio prprio para parar a aprendizagem.
3.7.1 Inicializao dos vectores de referncia
Devido a formas desconhecidas da distribuio das classes, as coordenadas finais dos vectores
de referncia no so conhecidas at ao final do processo de aprendizagem, as suas distncias e
portanto os seus nmeros ptimos no podem ser determinados antes disso [1]. Este tipo de
atribuio dos vectores de referncia s vrias classes deve ser feito iterativamente.
Em muitas aplicaes prticas, tal como reconhecimento de voz, mesmo quando as
probabilidades realizadas priori para as amostras caem em classes diferentes, uma boa estratgia
comear com o mesmo nmero de vectores de referncia em cada classe. Um limite superior ao
nmero total de vectores de referncia definido pelo tempo de reconhecimento e pelo poder
computacional disponvel.
Para uma boa aproximao linear das fronteiras, as medianas das distncias mais curtas entre os
vectores de referncia podem tambm ser seleccionadas, mais pequenas que o desvio padro das
amostras de entrada em todas as classes respectivas. Este critrio pode ser usado para determinar o
nmero mnimo de vectores de referncia por classe.
Uma vez que o nmero de vectores de referncia por classe foi fixado, para os seus valores
iniciais alguns podem ter os valores das primeiras amostras dos dados de treino com as respectivas
classes. Como os vectores de referncia devem sempre manter-se dentro dos respectivos domnios
das classes, para os valores iniciais apenas se devem considerar valores cujas classes estejam bem
classificadas. Por outras palavras, uma amostra primeiramente classificada (tentativa de
classificao) contra todas as outras amostras no conjunto de treino, por exemplo atravs do mtodo
do Nearest-Neighbor, e aceite como um possvel valor inicial apenas se essa tentativa de
classificao o mesmo que o identificador de classe da amostra. [1]

46

3.7.2 Aprendizagem
recomendado que a aprendizagem comece sempre com o algoritmo OLVQ1 [1] que converge
bastante rpido, a sua exactido de reconhecimento ir ser alcanada aps um nmero de passos de
aprendizagem que 30 a 50 vezes o nmero total dos vectores de referncia.
Frequentemente a fase de aprendizagem do algoritmo OLVQ1 [1] pode ser suficiente para
aplicaes prticas, especialmente se o tempo de aprendizagem crtico. Apesar de tudo, numa
tentativa de melhorar a exactido de reconhecimento, podemos continuar com o bsico LVQ1, ou
LVQ2 ou at LVQ3, usando um valor baixo inicial de rcio de aprendizagem, o que o mesmo para
todas as classes.
3.7.3 Regra de paragem
Acontece frequentemente que os algoritmos de Neural Networks aprendem demais. Uma possvel
explicao disto no caso presente quando os vectores de referncia se tornam muito ligados
amostra de treino, a habilidade do algoritmo de generalizar para novos dados sofre. Torna-se pois,
necessrio parar o processo de aprendizagem depois de um nmero de passos ptimo, digamos 50 a
200 vezes o nmero total dos vectores de referncia. Esta regra de paragem apenas pode ser
encontrada por experincia, e tambm depende dos dados de entrada.
3.8 Vantagens
Este algoritmo tem vrias vantagens, motivos pelos quais se achou importante realizar este
trabalho e adicionar este algoritmo lista de algoritmos disponveis para tarefas de Data Mining no
Microsoft SQL Server 2005. Uma das suas vantagens a sua fcil compreenso. Como o seu cdigo
muito simples e fcil de perceber, a sua codificao tambm se torna fcil e por isso, torna-se mais
rpido e leve. Este algoritmo bebe um pouco os mtodos de dois algoritmos: Clustering e Nearest
Neighboor. Na fase de treino e de teste necessrio encontrar o vector de referncia mais prximo,
usando o mtodo do vizinho mais prximo do algoritmo Nearest Neighboor. Aps a fase de treino
podemos ver, nas experincias de vectores com duas dimenses, e por isso, representveis no
plano, que os vectores de referncia finais se dispem em clusters de uma determinada classe.
A grande vantagem deste algoritmo a visualizao dos vectores de referncia finais. A
integrao do algoritmo no Microsoft SQL Server 2005 est feita de maneira aos vectores de
referncia finais serem escritos num ficheiro, onde o utilizador pode observar como foram colocados
os vectores, se contm valores negativos ou demasiado grandes para a amostra de teste. Com esta
observao aos vectores de referncia finais o utilizador poder coordenar melhor os parmetros de
entrada do algoritmo para que a preciso seja maior. Esta uma vantagem, pois os parmetros
ideais variam de conjunto de dados para conjunto de dados. Os parmetros para uma amostra de
dados esparsa, com vectores distantes uns dos outros so diferentes dos de uma amostra de treino
densa, tal como amostras de treino grandes e pequenas tambm tm parmetros diferentes.
Conhecer o conjunto de dados de treino e poder ver como o comportamento dos vectores de
referncia finais so factores essenciais para uma preciso ptima com Learning Vector Quantization.

47

4 Microsoft SQL Server 2005

O Microsoft SQL Server 2005 (Analysis Services) um pacote de mecanismos de suporte
deciso e de ferramentas. [11]
O Analysis Services acedido atravs de uma interface grfica de utilizador que implementado
no Microsoft Management Console (MMC). Esta ferramenta deixa que o administrador facilmente gira
vrias tarefas de suporte deciso. O Analysis Services fornece acesso a duas formas de
mecanismos de suporte deciso: Data Mining e OLAP. [11]
O Microsoft SQL Server 2005 Data Mining, permite a agregao directa ao nvel do algoritmo.
Apesar de restringir as linguagens de programao disponveis para desenvolvimento de novos
algoritmos plug-in, esta ferramenta liberta os programadores de implementar todas as camadas
adicionais bem como a definio das interfaces
1
. Nas prximas seces sero descritas as interfaces
necessrias integrao do algoritmo e no Anexo: Arquitectura Microsoft SQL Server 2005 desta
tese est descrito a arquitectura desta ferramenta, bem como o fluxo de dados necessrio para as
chamadas s interfaces a seguir descritas.
4.1 Interfaces
Neste captulo sero descritas quais foram as interfaces implementadas para a integrao do novo
algoritmo na ferramenta Microsoft SQL Server 2005. Existem duas linguagens de programao
possveis, com instrues disponveis pela Microsoft para a integrao de novos algoritmos, so elas
o C++
1
e o C#
2
. Este projecto foi desenvolvido em C++ por ser a linguagem mais utilizada na
integrao de algoritmos, pois os guias em C# surgiram h relativamente pouco tempo. Apesar de
serem linguagens diferentes, ambas implementam as mesmas interfaces (pode acontecer que
tenham nomes diferentes, mas a funcionalidade a mesma), e seguem a mesma arquitectura.
4.1.1 Interfaces do algoritmo usando C++
Todos os algoritmos a serem ligados ao Microsoft SQL Server 2005 necessitam de fornecer uma
implementao de cinco interfaces COM
1
[14] principais, j mencionadas na seco anterior:
1. IDMAlgorithm: a interface do algoritmo. Tem dois objectivos:
- Implementar um modelo que produz a aprendizagem do algoritmo;
- Implementar as operaes de previso do modelo resultante.
2. IDMAlgorithmNavigation: A interface de navegao do algoritmo permite a browsers aceder ao
contedo do modelo.
3. IDMPersist: A interface de persistncia permite aos modelos aprendidos pelo novo algoritmo
serem guardados e carregados pelo Analysis Services.

1
2
Microsoft.com. [Online] [Citao: 06 de 08 de 2008.]
http://www.microsoft.com/downloads/details.aspx?FamilyID=50B97994-8453-4998-8226-
FA42EC403D17&displaylang=en#DMAPI .

48

4. IDMAlgorithmMetadata: a interface de metadados do algoritmo descreve as capacidades e os
parmetros de entrada do algoritmo em aprendizagem.
5. IDMAlgorithmFactory: esta interface tem duas funes:
- Criar instncias dos objectos que implementam a interface do algoritmo;
- Fornecer ao Analysis Services acesso interface de metadados do algoritmo.
O Analysis Services usa estas interfaces para realizar a aprendizagem de um modelo a partir dos
dados. Para comear, Analysis Services usa um ficheiro de inicializao (chamado msmdsrv.ini) que
determina quais os algoritmos de Data Mining disponveis. Este ficheiro inclui uma lista de todos os
algoritmos Microsoft disponibilizados no Analysis Services. Aps ser construda uma DLL que
implementa o algoritmo Plug-in, necessrio adicionar o novo algoritmo lista e especificar o campo
ProdID da CoClass que implementa a interface IDMAlgorithmFactory. Quando est perante uma
tarefa de Data Mining, o Analysis Services ir criar uma instncia do objecto factory e usar a interface
de metadados (obtido atravs da interface IDMAlgorithmFactory do algoritmo) para determinar se o
algoritmo apropriado para a tarefa dada. Seguidamente, o Analysis Services criar uma instncia do
novo algoritmo usando a interface IDMAlgorithmFactory. A interface do algoritmo resultante usada
para treinar o modelo e fornecer acesso interface persistente e interface de navegao do
algoritmo.
Na Figura 4.4, so mostradas as trs classes C++ que serviro para implementar essas
interfaces.

Figura 4.1 - Classes C++ que implementam as interfaces COM [5, 14]
A classe FACTORY implementa ambas as interfaces IDMAlgorithmFactory e
IDMAlgorithmMetadata. Isto a CoClass cujo ProgID fornecido no ficheiro de inicializao do
Analysis Services. A classe ALGORITHM implementa ambas as interfaces, do algoritmo e de
persistncia. Esta classe tambm tem funes com membros estticos que implementam a interface
IDMAlgorithmMetadata; a implementao de FACTORY de IDMAlgorithmMetadata apenas chama as
correspondentes funes de membros estticos de ALGORITHM. Esta arquitectura foi escolhida para
este trabalho para que as capacidades do algoritmo de Data Mining possam ser publicadas pela
mesma classe que implementa o algoritmo. Finalmente, a classe NAVIGATOR implementa a interface
IDMAlgorithmNavigation. Instncias destas classes tm um ponteiro para a classe ALGORITHM

49

correspondente para a qual existe um navegador. Esta classe foi a nica que no foi completamente
implementada neste projecto, dado que no estava dentro dos objectivos do trabalho.
As interfaces do algoritmo so responsveis por fornecerem ambas as interfaces de persistncia e
de navegao ao Analysis Services aps ter sido pedido; quando o Analysis Services pede uma
interface de navegao, a classe ALGORITHM em C++
1

2
ir criar novas instncias da classe
NAVIGATOR em C++ e retornar a interface correspondente.
Como o trabalho prtico desta tese est desenvolvido tendo em conta esta arquitectura COM e a
linguagem C++, no captulo 4.3 encontra-se descrito o contedo de cada interface bem como quais
os seus objectivos.
4.1.1.1 Ficheiro Dmalgo.h
O principal ficheiro de cabealho que descreve as interfaces e os tipos de dados utilizados pelos
algoritmos Plug-in o ficheiro dmalgo.h. Pode ser til para viajar pelas definies das cinco primeiras
interfaces para obter alguma familiaridade com os tipos de funes que estas interfaces suportam
1
.
4.1.1.2 Threading
O algoritmo Plug-in desenvolvido e o Analysis Services comunicam entre si atravs de interfaces
COM. Para evitar misturar as chamadas a estas interfaces, o que iria significativamente abrandar o
treino do modelo, deve-se usar o mesmo modelo de threading que as interfaces expostas pelo
Analysis Services.
O Analysis Services usa um modelo de free-threading, e portanto, importante usar tambm esse
modelo. Porm, garantido que as duas principais funes de treino do algoritmo,
IDMAlgorithm::Initialize() e IDMAlgorithm::InsertCases(), nunca sero chamadas por mltiplas threads
simultaneamente.
No geral, os algoritmos Plug-in devem evitar criar novas threads porque o servidor tem o seu
prprio sistema de gesto de threads. Threads Windows criadas no processo do servidor fora do
controlo da thread do servidor iro ter impacto na habilidade do servidor gerir as threads.
1

4.1.1.3 Gesto de memria
Todas as alocaes de memria realizadas pelo algoritmo Plug-in devem usar as interfaces de
gesto de memria disponibilizadas pelo Analysis Services.
A interface de gesto de memria (IDMMemoryAllocator) pode ser usada a qualquer altura
dependendo do tempo de vida da memria que se alocar. As duas escolhas so, alocar memria que
dure (a) o tamanho de uma chamada de funo ou (b) o tempo de vida de um modelo. Quase todas
as chamadas a funes realizadas pelas interfaces do algoritmo Plug-in, tomam como entrada uma
interface de contexto de servios (IDMContextServices). A partir dessa interface, pode-se obter uma
interface a ser usada para alocar memria que apenas dure o tempo de vida da chamada funo.

1
2

50

Quando o modelo criado pela interface IDMAlgorithmFactory, tem-se acesso a uma interface de
servios de modelo (IDMModelServices), que pode ser guardada com o modelo.
No mbito deste projecto, a gesto de memria estar a cargo da classe DMHALLOC, que contm
um ponteiro ATL inteligente para a interface de gesto de memria. O maior benefcio desta classe
poder ser inicializada quer com uma interface de contexto de servios, quer com uma interface de
modelo de servios, com uma interface de gesto de memria ou com outro DMHALLOC. A classe
ALGORITHM, sobre a qual se fala mais frente, deriva desta classe.
1

4.1.1.4 STL
Na implementao de um algoritmo Plug-in usando a linguagem C++, frequente o uso de
classes de vectores STL. Devido aos requerimentos da gesto de memria, existe uma classe
derivada dmh_vector que usa uma alocao STL especial (dmh_allocator). Esta alocao utiliza uma
classe DMHALLOC para alocar memria. Usa-se tambm uma classe DMHALLOC sobre a
construo de um dmh_vector, o que significa que qualquer classe que contenha vectores STL como
variveis membro devem ter acesso a DMHALLOC.
1

4.1.1.5 Tratamento de erros
Os algoritmos Plug-in passam os erros de volta ao servidor, usando ambos os resultados de
HRESULTS e levantando erros usando a funo global SetLastError. Os algoritmos Plug-in
desenvolvidos em C++ no devem mandar excepes que no consigam tratar eles mesmos. Devido
a algumas funes STL atirarem excepes quando no conseguem alocar espao, necessrio
envolver essas chamadas a funes dentro de um bloco try/catch para ter a certeza que a excepo
no passada para o Analysis Server. Na presente verso do Microsoft SQL Server 2005, os erros
levantados usando SetLastError no so reportados pelo Analysis Services, e consequentemente
apenas so reportados erros usando HRESULTS.
1

4.1.2 Interfaces do algoritmo usando C#
O algoritmo plug-in desenvolvido nesta linguagem necessita de efectuar trs grandes tarefas:
Descrever as caractersticas;
Lidar com os padres nos dados;
Expor os padres detectados.
Estas tarefas esto associadas a algumas interfaces COM dentro desta arquitectura, tais como:
Descrio das caractersticas tratada pela interface IDMAlgorithmMetadata;
Os padres so detectados e usados pela interface IDMAlgorithm e guardados
persistentemente na interface IDMPersist.
A navegao nos padres efectuada atravs da interface IDMAlgorithmNavigation.

1

51

Tipicamente, a classe que implementa IDMAlgorithmMetadata tambm implementa
IDMAlgorithmFactory, que pode ser usada para instanciar a implementao de IDMAlgorithm, o que
por sua vez pode ser usada para instanciar uma implementao de IDMAlgorithmNavigator.
semelhana da arquitectura COM utilizada na implementao de algoritmos Plug-in em C++ [5,
14], em C#, um programar de um novo algoritmo Plug-in tem de implementar trs classes, uma para
cada tarefa abaixo:
A classe Metadata expe as caractersticas do algoritmo e cria objectos do algoritmo.
A classe Algorithm detecta, guarda persistentemente e usa padres encontrados nos dados.
A classe Navigator expe os padres encontrados pela classe Algorithm.
Um Plug-in desenvolvido em C#
1
uma biblioteca de classes que implementa, minimamente, as
trs classes descritas acima. Implementaes parciais destas classes esto j definidas na biblioteca
primria DMPluginWrapper.dll.
Quando se implementa as classes num Plug-in, deve-se derivar as seguintes classes das trs
implementaes parciais fornecidas pelo assembly DMPluginWrapper:
A classe Metadata deve derivar de AlgorithmMetadataBase;
A classe Algorithm deve derivar de AlgorithmBase;
A classe Navigator deve derivar de AlgorithmNavigationBase.
Dentro do assembly DMPluginWrapper, todos os tipos so definidos como parte do namespace
Microsoft.SqlServer.DataMining.PluginAlgorithms. Se nenhum namespace for especificado para um
tipo, deve-se assumir que o tipo parte deste namespace.
As classes DMPluginWrapper implementam as interfaces COM que so requeridas para o Plug-in.
Para projectos deste tipo desenvolvidos em C#
1
, o Analysis Services usa as interfaces COM
1

2

implementadas pelo DMPluginWrapper para aprender um modelo de dados. No inicio, o Analysis
Services usa o ficheiro de inicializao, chamado msmdsrv.ini para determinar quais os algoritmos de
minerao de dados que esto disponveis. Depois da biblioteca de classes que implementa o novo
algoritmo Plug-in ser construda, necessrio adicionar o algoritmo lista de algoritmos disponveis,
tal como ir ser descrito na seco seguinte com a linguagem C++
2
.
Quando existe uma tarefa de minerao de dados, o Analysis Services cria uma instncia do
objecto factory e usa a interface metadata do algoritmo (obtida atravs da interface factory do
algoritmo) para determinar se o algoritmo apropriado para a tarefa dada.
Seguidamente o Analysis Services cria uma instncia do novo algoritmo usando a interface factory
do algoritmo. A interface resultante do algoritmo usada para treinar o modelo e para fornecer
acesso interface de persistncia e interface de navegao do algoritmo.
A Figura ilustra como so tratadas as chamadas dentro de um algoritmo Plug-in.

1
Microsoft.com. [Online] [Citao: 06 de 08 de 2008.]
http://www.microsoft.com/downloads/details.aspx?FamilyID=50B97994-8453-4998-8226-
FA42EC403D17&displaylang=en#DMAPI .
2

52

Figura 4.2 - Tratamento de chamadas a funes COM
Considerando o exemplo de IDMAlgorithmFactory::CreateAlgorithm. Esta funo da interface
invocada pelo servidor para instanciar uma implementao IDMAlgorithm. Num Plug-in com interfaces
COM em C++, esta funo invocada directamente sobre o objecto e deve retornar um ponteiro
IDMAlgorithm. Num Plug-in em C#, a funo exposta pela classe AlgorithmMetadataBase e
invocada pelo servidor. A implementao de AlgorithmMetadataBase mapeia os parmetros dos
respectivos invlucros, depois invoca o mtodo CreateAlgorithm para requerer uma derivao de
AlgorithmBase. A derivada AlgorithmBase j a implementao de um objecto COM IDMAlgorithm e
retornado ao servidor.
4.1.2.1 Aspectos gerais de algoritmos Plug-in
Todos os comportamentos especficos das funes COM esto escondidos pela interoperabilidade
do assembly primrio. Isto significa que o cdigo do algoritmo pode focar-se na tarefa em mos sem
muitas preocupaes com a alocao de memria e tratamento de variveis. Contudo, existem certas
regras para a interoperabilidade trabalhar sem problemas. Muito mais importante, evita invlucros de
armazenamento para os objectos do servidor. Tais objectos podem ser expostos como argumentos
das funes ou propriedades das classes AlgorithmMetadataBase, AlgorithmBase ou
AlgorithmNavigationBase.
4.1.2.2 Tratamento de erros
O tratamento de excepes em algoritmos Plug-in desenvolvidos em C# segue o mesmo lema que
os desenvolvidos em C++: no apanhar excepes que no foram atiradas usando o algoritmo. O
tratamento de erros implementado usando excepes. Certas chamadas ao servidor podem
retornar falhas. Estas falhas so convertidas em excepes e devem ser passadas pelo cdigo do
algoritmo ao assembly primrio, que as converter de novo em cdigo de erros do servidor.
Sempre que uma situao de erro detectada pelo cdigo do algoritmo, atira uma excepo. A
Framework apanhar essa excepo e convert-la- para um erro de servidor. A mensagem de texto
da excepo ser anexa como o texto do erro.
Alguns erros no resultam em excepes. Uma excepo lanada quando os metadados so
inicializados ir prevenir a gesto do Plug-in de o carregar e no existe maneira para o programador
detectar a causa desse erro. Por essa razo, certos erros nos metadados podem ser detectados

53

inspeccionando o esquema de conjunto de linhas exposto pelo servidor de Analysis Services. Tais
erros incluem erros de minerao de parmetros e erros de funes personalizadas.
4.1.2.3 Threading
No caso dos algoritmos Plug-in implementados em C#, a nvel de threading, usa-se os mesmos
pressupostos que nos algoritmos implementados em C++, ver seco 4.2.1.2.
4.2 Plug-In
Este captulo dedicado explicao do mtodo de implementao das interfaces e de toda a
integrao do algoritmo na ferramenta Microsoft. No basta apenas definir as interfaces, necessrio
personaliz-las de acordo com o que se pretende para o modelo, neste caso o modelo pretendido usa
o algoritmo Learning Vector Quantization [1, 2, 12, 13, 14]. Cada interface tem as suas funes com
caractersticas e finalidades diferentes que aqui sero abordadas em detalhe.
4.2.1 O modelo: Learning Vector Quantization
O modelo usado pretende construir um algoritmo Plug-in [11] que aprende atravs da
aproximao ou distanciamento de vectores de referncia, gerados aleatoriamente, aos vectores de
aprendizagem. Sendo assim, existem trs tipos de vectores associados a este algoritmo, dois deles
na fase de aprendizagem. Atravs do clculo da distncia Euclidiana bsica, entre cada um dos
vectores de referncia e um dos vectores de aprendizagem de cada vez, encontra-se o vector de
referncia que est mais perto do vector de aprendizagem escolhido. Aps ter sido descoberto o
vector de referncia mais prximo do vector de aprendizagem, necessrio verificar se ambos os
vectores so ou no da mesma classe. Caso as classes dos dois vectores se verifiquem iguais, o
algoritmo comportar-se- de maneira compensadora, ou seja, ir mover o vector de referncia para
um ponto mais perto do vector de aprendizagem, caso contrrio, o algoritmo oferece uma punio ao
vector de referncia, alocando-o para um ponto mais afastado do vector de aprendizagem.
Sendo
c
o vector de referncia mais perto do vector de aprendizagem a tratar, o nmero de
iteraes realizadas ao algoritmo,
o vector de aprendizagem e o() uma funo linear que vai

decrescendo em cada iterao e cujos valores esto compreendidos entre 0 e 1, e
s
e
as classes
do vector de aprendizagem e de referencia, tem-se que [1, 2]:
c
( + ) =
c
() + o() |
() -
c
()], Se
s
=
c
( + ) =
c
() - o() |
() -
c
()], Se
s
=
(4.1)
A funo o() serve para ter a certeza de que no se est a recolocar o mesmo vector para o stio
anterior em cada iterao [1, 2]. Aplicando estas frmulas a todos os vectores de referncia, e
percorrendo todos os vectores de aprendizagem vezes obtemos novos valores para os vectores de
referncia iniciais.
Este modelo tem como objectivo prever as etiquetas das classes de determinados vectores de
entrada fornecidos e que, partida no sero apresentados com a informao da classe a que
pertencem. Esta fase a fase de classificao dos vectores fornecidos, em que o algoritmo apenas

54

calcula a distncia Euclidiana entre cada um dos vectores de classificao e os vectores de
referncia, para que seja atribuda a etiqueta da classe do vector de referncia mais prximo do
vector de classificao.
4.2.2 Construir um Algoritmo Plug-in
Para a construo de algoritmo Plug-in, implementado na linguagem C++, foi seguido um Tutorial
[5] desenvolvido pela equipa de Data Mining da Microsoft.
Nesta seco, sero descritos alguns passos do tutorial, com algumas modificaes necessrias a
uma melhor interpretao, para guiar atravs da criao de um algoritmo Plug-in que integre no
Analysis Services.
Para a implementao do algoritmo foi utilizado Microsoft Visual Studio 2005, juntamente com o
Microsoft SQL Server 2005.
4.2.2.1 Criar o projecto
Tal como referido acima, este projecto foi desenvolvido em Microsoft SQL Server Business
Intelligence Development Studio na linguagem C++, como tal, foi criado um novo projecto nessa
ferramenta, ao qual foram acrescentados alguns ficheiros disponibilizados com o tutorial, descritos de
seguida:
DmhMemory.h e DmhMemory.cpp
Estes ficheiros declaram e implementam a classe do ajudante do gestor de memria
DMHALLOC e as operaes correspondentes.
DmhLocalization.h e DmhLocalization.cpp
Declaram e implementam as funes globais LoadStringFromID(), que permitem ao algoritmo
Plug-in recuperar strings localizveis. A implementao por omisso desta funo retorna
simplesmente a verso da string do ID.
ParamHandler.h e ParamHandler.cpp
Estes ficheiros fornecem implementao livre das funes do IDMAlgorithmMetadata.
StaticAlgorithmMetadata.h adicionado ao centro da directoria onde reside o projecto.
Este ficheiro tem dois propsitos: manter as funes a descrever o algoritmo na mesma
localizao que o prprio algoritmo e oferecer implementaes livres das funes
IDMAlgorithmMetadata.
4.2.2.2 Criar a classe ALGORITHM
Esta classe implementa as interfaces IDMAlgorithm e IDMPersit, logo necessrio que esta
classe herde de IDMPersist e DMHALLOC e que seja acrescentado classe as declaraes do
cabealho das interfaces IDMAlgorithm e IDMPersist. Nesta fase necessrio criar dois novos
ficheiros ALGORITHM.IDMAlgorithm.cpp e ALGORITHM.IDMPersist.cpp. O primeiro ir ter os
mtodos principais usados no processo de treino e de previso. Ambos os ficheiros, iro conter a
definio das funes e o programador apenas tem de implement-las de acordo com o algoritmo.

55

4.2.2.3 Criar a classe FACTORY
Este passo muito similar ao passo anterior. Aqui ir ser criada a classe FACTORY [10] para
implementar ambas as interfaces IDMAlgorithmFactory e IDMAlgorithmMetadata. necessrio
especificar que esta classe herda de IDMAlgorithmMetadata. Na classe FACTORY apenas
necessrio copiar o contedo de um outro ficheiro disponibilizado, onde alguns dos principais
mtodos genricos j foram desenvolvidos, e acrescentar algumas macros especficas. A prxima
etapa ser implementar a interface de IDMAlgorithmMetadata usando funes com membros
estticos na classe ALGORITHM. criado um novo ficheiro ALGORITHM.IDMAlgorithmMetadata.cpp
onde se deve colar o cdigo de implementao para as funes IDMAlgorithmMetadata tambm j
desenvolvido. neste passo que se inserem as duas linhas de cdigo em ALGORITHM.cpp entre as
quais mais tarde se ir definir os parmetros especficos do algoritmo, inserindo instncias da macro
DECLARE_PARAMETER. Estas macros juntas iro implementar as nove funes de tratamentos de
parmetros IDMAlgorithmMetadata automaticamente.
4.2.2.4 Criar a classe NAVIGATOR
Neste passo ser criada a classe NAVIGATOR que implementa IDMAlgorithmNavigation [5]. Todo
o cdigo existente nesta classe e no seu ficheiro de cabealho, por agora ser copiado de um ficheiro
disponibilizado juntamente com o Tutorial.
Aps a criao desta classe necessrio compilar o projecto para corrigir algum erro que possa
existir, ou copiar algum cdigo ainda em falta.
4.2.2.5 Registar o algoritmo no Analysis Services
Este passo permite ao algoritmo ser chamado pelo Analysis Services. Primeiro necessrio definir
o nome do servio do algoritmo, que ser o nome que o Analysis Services usa internamente para se
referir ao algoritmo. No ficheiro ALGORITHM.IDMAlgorithmMetadata.cpp existe um mtodo
GetServiceName(), onde necessrio definir o nome do algoritmo na varivel szName, que neste
caso ser "Learning_Vector_Quantization".
Caso ainda no tenha sido iniciado o Analysis Services, necessrio faz-lo nesta fase para
popular os ficheiros de inicializao. No ficheiro msmdsrv.ini, um documento XML, inclumos o novo
algoritmo na lista de algoritmos disponveis no servidor. Para isso, necessrio criar outro n filho de
<Algorithms> que ir ter o mesmo nome que o nome do servio do algoritmo especificado
anteriormente.
necessrio inserir um elemento ao filho, chamado <ProgID>. Este elemento contm o ProgID
dos objectos COM que implementam a interface IDMAlgorithmFactory. Este campo ir ter o valor da
varivel ProgID localizada no ficheiro FACTORY.rgs presente no projecto aps a sua compilao.
Para finalizar, necessrio um segundo elemento ao n filho, chamado <Enabled>, o contedo deste
elemento deve ser 1 ou 0, significando 1 que o servidor est apto a usar o algoritmo.
Para que o Analysis Services incorpore as mudanas realizadas no ficheiro de inicializao
necessrio reiniciar o servio SQL Server Analysis Services. A partir desta altura, sempre que se

56

recompilar o projecto necessrio parar primeiro o servio, sendo este iniciado depois da compilao
do projecto.
Neste ponto tem-se o esqueleto do algoritmo implementado e integrado no Analysis Services.
4.2.2.6 Testar a integrao do algoritmo
Apesar do algoritmo neste momento no fazer nada de til, pois o seu cdigo ainda no est
integrado, pode-se verificar que as interfaces esto a ser chamadas. Para isso, necessrio criar um
projecto Analysis Services Project no Business Intelligence Development Studio.
Primeiro, para ligar fonte de dados, necessrio escolher as propriedades da ligao aos dados,
onde neste projecto se seleccionar Microsoft Jet 4.0 OLEDB Provider, aps o que deve-se indicar
qual a base de dados, tendo em conta o mbito do projecto, essa base de dados dever ter duas
tabelas, uma para a primeira fase do algoritmo, ou seja, o treino, e outra tabela para previso.
Seguidamente, neste processo, define-se uma vista dos dados, onde se ir seleccionar as tabelas
que esto presentes na base de dados escolhida acima, com as quais se quer trabalhar, deve-se
escolher as tabelas de treino e de teste necessrias.
Neste momento, pode-se testar o esqueleto do algoritmo construdo, construindo uma nova Mining
Structure (estrutura de minerao). O primeiro passo para a construo dessa estrutura est na
escolha de uma tcnica de Data Mining de entre a lista de tcnicas disponibilizadas pelo Analysis
Services. Neste momento, o algoritmo a implementar aparecer como o ltimo membro da lista, tendo
como nome Undefined Localized String, como indicado na Figura 4.6.

Figura 4.3 - Lista dos algoritmos disponveis, mostrando o novo algoritmo, ainda sem nome;
Pode-se cancelar esta caixa de dilogo, pois apenas permitia ver se o Analysis Services detectava
o novo algoritmo. Caso Undefined Localized String no aparea, pode apenas ser devido ao
Analysis Services estar a correr quando o projecto foi compilado. Nesse caso, deve-se guardar este
projecto, parar o servio do Analysis Services, recompilar o projecto e iniciar o Analysis Services,
aps o que se deve abrir de novo o projecto e tentar novamente.
Para obter uma lista dos algoritmos disponveis, o Analysis Services usou o ficheiro de
inicializao para criar uma instncia da classe FACTORY e guardou tambm as instncias
correspondentes das interfaces IDMAlgorithmFactory e IDMAlgorithmMetadata. Para extrair a

57

descrio do novo algoritmo para a lista, o Analysis Services chama a funo
IDMAlgorithmMetadata::GetDisplayName(). Esta funo preenche uma descrio, que uma string
localizvel. Devido a ainda no se ter definido essa string, a descrio por omisso aparece:
Undefined Localized String.
4.2.3 Personalizar o algoritmo
Nesta etapa personaliza-se o esqueleto do algoritmo construdo no passo anterior para abrigar o
algoritmo Linear Vector Quantization.
Primeiro necessrio copiar alguns ficheiros, fornecidos juntamente com o Tutorial, para o
Projecto:
DmhVector.h e DmhAllocator.h: estes ficheiros permitem usar vectores STL com as interfaces
de gesto de memria fornecidos pelo Analysis Services.
DataValues.cpp e DataValues.h: estes ficheiros so utilizados para fazer a translao de tipos
usados pelo Analysis Services e o tipo simples double.
caseprocessor.cpp e caseprocessor.h: usados para implementar a interface do case processor.
Hierarchies.h: este ficheiro contm a estrutura que implementa as duas diferentes hierarquias
para modelos que so necessrios para a interface de navegao (no abordado neste
projecto);
lrsstatreader.cpp e lrsstatreader.h: estes ficheiros contm a classe LRSSTATREADER, que
deriva do case processor e recolhe os valores necessrios para cada caso para o processo de
aprendizagem do modelo;
lvqmodel.cpp e lvqmodel.h: estes ficheiros implementam a classe LVQMODEL, ou seja, a
classe usada para representar o modelo aprendido pelo novo algoritmo.
Nos prximos passos sero personalizadas as funes das cinco interfaces principais para
implementar o modelo LVQ.
4.2.3.1 Personalizar os mtodos de IDMAlgorithmMetadata
Nesta seco sero abordadas as funes mais importantes deste ficheiro:
GetServiceType: Descreve o tipo de servio fornecido pelo novo algoritmo. O algoritmo
Learning Vector Quantization usa a classificao e previso, dois dos servios de minerao
disponveis, assim deve-se preencher a varivel presente na funo com:
DM_SERVICETYPE_CLASSIFICATION, dado que a classificao apenas um tipo especifico
da previso [9].
GetServiceName: Guarda o nome do algoritmo, que num dos passos acima j foi definido
como LINEAR_VECTOR_QUANTIZATION;
GetDisplayName: necessrio ter um ID para cada string, e uma maneira correspondente de
mapear esse ID numa string. Este mtodo garante estes dois requisitos. Neste momento
existem duas strings localizveis (o nome do algoritmo, e a sua descrio), mas quando forem
definidos os parmetros, existiro mais strings. No ficheiro resource.h necessrio adicionar
para cada string uma declarao que contenha uma varivel com o nome da string e o seu ID.

58

Assim, necessrio incrementar o valor de _APS_NEXT_SYMED_VALUE para o ID seguinte
ao definido nas strings. Para finalizar, fundamental substituir o corpo inteiro da funo
LoadStringFromID() presente em DmhLocalization.cpp por cdigo onde estar definida cada
string. Para que o nome do algoritmo seja visvel, essencial mudar nesta funo o valor de
iIDStrAlgorithm de -1 para IDS_SERVICE_DISPLAY_NAME, a constante definida com o nome
do novo algoritmo.
GetDescription: Esta a segunda string localizvel. Similar a GetDisplayName(), o valor de
iDStrDescription alterado de -1 para IDS_SERVICE_DESCRIPTION, a constante que se
definiu no ficheiro resource.h com a descrio do algoritmo.
GetSupInputContentTypes: O modelo LVQ apenas suporta variveis de entrada contnuas, e
necessita sempre de suportar as colunas chave. Assim tem de se descomentar as linhas
relativas a esses dois aspectos.
GetSupPredictContentTypes: O modelo LVQ apenas suporta variveis de sada contnuas.
Assim, necessrio comentar a linha que se refere s variveis discretas e descomentar a
linha referente s variveis contnuas.
GetTrainingComplexity: Esta funo refere-se com o nmero de vezes que os dados de
treino so iterados. Assim, a varivel presente nesta funo ir ser preenchida com uma macro
definida para o tempo de execuo ser proporcional aos parmetros de entrada, e ser
relativamente curto.
GetPredictionComplexity: Semelhante funo acima mas, na previso o modelo LVQ tem o
seu tempo de previso proporcional ao nmero de variveis de entrada.
Aps a definio destas funes, as prximas linhas esto directamente relacionadas com os
parmetros de entrada necessrios execuo do algoritmo. Cada parmetro especfico do
algoritmo, tem um dado nmero de propriedades:
O nome do parmetro.
Uma descrio do parmetro, que uma string localizvel, e como tal tem associado um ID.
Um tipo especfico representado por uma string. A string para um tipo combina com o nome da
enumerao DBTYPEENUM do ficheiro oledb.h. Exemplos incluem DBTYPE_I8, um inteiro
com tamanho 8 e DBTYPE_R4 que representa um float.
Uma flag que indica se o valor requerido ou no.
Uma flag que indica se o valor exposto (visvel ao utilizador) ou no. Para o modelo LVQ
melhor expor todos os parmetros referentes a informao dada pelo utilizador.
Um valor de omisso, representado por uma string.
Uma enumerao, que uma string amiga do utilizador (no localizvel) e que descreve o
alcance do parmetro. Se o parmetro permite qualquer nmero, iremos usar (-, +).
Neste projecto iremos usar o tratamento de parmetros esttico, logo todos os parmetros da
funo sero implementados automaticamente, sendo apenas necessrio especificar as sete
propriedades de cada um no ficheiro ALGORITHM.cpp.
Neste momento o projecto dever ser compilado e no obter erros.

59

4.2.3.2 Personalizar IDMAlgorithmFactory
necessrio que no se faa nenhuma mudana interface IDMAlgorithmFactory, mas til
rever o cdigo para ver como que a nica funo CreateAlgorithm permite ao novo algoritmo usar a
interface IDMModelService.
Se for necessrio alocar memria com o novo algoritmo, que dure mais do que o tempo de vida de
uma chamada funo, deve-se guardar uma interface especial de modelos de servio,
IDMModelServices, juntamente com o nosso algoritmo. IDMModelServices est disponvel apenas
quando o modelo criado com IDMAlgorithmFactory::CreateAlgorithm(). Neste projecto (com o
modelo LVQ), resolvemos este problema derivando ALGORITHM da classe de alocao de memria
DMHALLOC; depois, em CreateAlgorithm, inicializamos a classe base para se referir interface do
alocador de memria passando-lhe a interface IDMModelService.
4.2.3.3 Personalizar IDMAlgorithm
Esta seco aborda a personalizao das funes da interface IDMAlgorithm do ficheiro
ALGORITHM.IDMAlgorithm.cpp. Esta interface bastante importante e a interface principal do
algoritmo, visto que aqui que se encontram as funes de treino e de previso do algoritmo. nesta
fase que a integrao do novo algoritmo realizada.
Initialize: Esta funo fornece a inicializao do algoritmo. Todas as alocaes so realizadas
na interface IDMAttributeSet passada. Para isso necessrio adicionar a varivel membro
publico, _spidmattributeset, classe ALGORITHM declarada em ALGORITHM.h. Esta varivel
ir armazenar o conjunto de atributos (as propriedades de cada coluna na tabela da base de
dados).
InsertCases: Esta a funo que treina o modelo com os dados e pode ser dividida em trs
etapas: anlise dos parmetros fornecidos, extraco dos dados de aprendizagem e popular o
modelo de minerao de dados criado (ou seja, realizar a aprendizagem).
Na primeira fase, necessrio analisar os parmetros de entrada fornecidos, apesar de nem
todos os parmetros de entrada serem utilizados no processo de treino. No caso do modelo
LVQ, usar uma varivel local para guardar os seus valores suficiente. Para isso necessrio
criar uma varivel local para cada parmetro no ficheiro ALGORITHM.h, tendo em conta o tipo
do parmetro. Essas variveis sero inicializadas no construtor com os valores por omisso,
aps o que se deve adicionar o cdigo, cuja estrutura fornecida, para cada parmetro para
realizar o parse de todos os parmetros na varivel _dmhparamhandler.
O objectivo da segunda fase desta funo a captura dos dados de entrada para a extraco
dos valores necessrios. Existe uma classe de processamento de casos genrica que
simplifica o acesso a dados chamada CASEPROCESSOR, e pode ser encontrada em
caseprocessor.h. No ficheiro lrsstatreader.h fornecida uma implementao da classe
LRSSTATREADER que recolhe os atributos disponibilizados por caso, ou seja, por cada linha
da tabela e os coloca em vectores ou outras estruturas definidas pelo programador, que
posteriormente sero utilizados. Todo o cdigo de invocao de funes presentes noutros

60

ficheiros est j desenvolvido, sendo apenas necessrio adaptar. Agora LRSSTATREADER
contm todos os atributos necessrios para fornecer classe que contm o algoritmo. nesta
fase que fundamental incluir um ficheiro chamado lvqmodel.c ao projecto. Este ficheiro
contm o cdigo do novo algoritmo desenvolvido anteriormente num ambiente livre de
integrao e previamente testado. Finalmente necessrio adicionar a ALGORITHM uma
varivel membro _lvqmodel do tipo LVQMODEL para acesso a funes do modelo LVQ.
A ltima fase desta funo visa popular o modelo, e realizar a sua aprendizagem. Para isso
essencial invocar a funo PopulateModel, residente no ficheiro lvqmodel.cpp, com o objecto
lrsstatreader e todos os parmetros necessrios aprendizagem do algoritmo como
parmetros de entrada da funo.
Predict: Esta funo usada para extrair previses do novo modelo. O cdigo dever ler os
casos de entrada a serem previstos e dever chamar a funo que estar no ficheiro
lvqmodel.c, _lvqmodel. CreateClassification(), que ir realizar a classificao dos vectores.
GetNavigator: Esta funo cria uma instncia da classe NAVIGATOR e passa-a interface
IDMAlgorithmNavigation correspondente. O cdigo apropriado encontra-se entre o cdigo
fornecido. Porque a classe NAVIGATOR deriva de DMHALLOC, necessrio criar novas
instncias usando o template estendido ATL de DmhMemory.h (isto , usar o template
CComObjectDM em vez do template CComObject e passar uma referncia DMHALLOC
funo CreateInstance). Assim, essencial chamar a funo NAVIGATOR::Initialize que foi
definida anteriormente.
GetTrainingParameterActualValue: Esta funo retorna o valor actual usado no treino para
cada parmetro do algoritmo. O valor actual pode ser diferente do que era requerido pelo
utilizador nas seguintes situaes:
o O valor especificado pelo utilizador indica algum mecanismo de auto-deteco, que calcula
um valor optimizado baseado nos dados de entrada.
o O utilizador no especifica nada e um valor de omisso usado.
4.2.3.4 Personalizar IDMPersist
Neste passo implementada a interface IDMPersist na classe ALGORITHM. Esta interface
consiste em duas funes: Load e Save. Estas duas funes carregam e salvam o modelo criado
pelo algoritmo usando as interfaces IDMPersistenceReader e IDMPersistenceWriter. Todo este
cdigo ir estar dentro do ficheiro ALGORITHM.IDMPersist.cpp.
de se notar que as funes Load e Save esto a guardar persistentemente as variveis
membros que contm os valores actuais dos parmetros de treino.

Aps estes passos, e a implementao do novo algoritmo Learning Vector Quantization nos ficheiro
lvqmode.cpp e lvqmodel.h o projecto pode ser usado como um novo algoritmo na ferramenta

61

5 Microsoft SQL Server com LVQ
Este captulo pretende oferecer ao leitor, em primeiro lugar uma visita ferramenta oferecida pela
Microsoft j com o novo algoritmo integrado, ajudando o utilizador a construir um modelo de
minerao de dados com o algoritmo LVQ [1, 2, 12, 13, 15, 17], e a conhecer os seus parmetros.
Em segundo lugar, este captulo oferece um conjunto de experincias realizadas ao algoritmo,
focando a sua preciso com vrios conjuntos de treino, e posteriormente comparando o LVQ com
outros algoritmos descritos no capitulo 2.
5.1 Arquitectura do utilizador
Nesta seco, irei mostrar como o utilizador poder usar o algoritmo Plug-in desenvolvido dentro
da aplicao Business Intelligence Development Studio.
O ponto inicial para criar um modelo de Data Mining numa base de dados Microsoft SQL utilizar
o Analysis Manager includo no pacote do Analysis Services Installation.
O segundo passo iniciar ou reiniciar o Analysis Services. Aps o que se deve abrir o projecto
criado na seco 4.3.2.6
Atravs do Analysis Manager, so apresentados ao utilizador alguns passos para a construo de
um modelo de maneira fcil e intuitiva, que seguidamente so especificados:
5.1.1 Criar uma fonte de dados
O primeiro passo que o utilizador ter de efectuar, ser especificar qual a base de dados a utilizar
pelo algoritmo. Normalmente essas bases de dados encontram-se implementadas em Microsoft
Access ou Microsoft SQL Server.

Figura 5.1 Janela para a criao de uma nova ligao base de dados que
contm as tabelas com os dados de aprendizagem e de classificao. [5]
No Solution Explorer, o utilizador dever criar uma nova fonte de dados, carregando sobre Data
Sources e depois escolhendo New Data Source, aps o que aparecer o Data Source Wizard,
onde o utilizador dever carregar Next. A janela How to Define the connection aparecer, e o

62

utilizador dever escolher New para criar uma nova ligao. Uma janela semelhante Figura 5.1 ser
mostrada.
O utilizador dever escolher na lista de Fornecedores, Native OLE DB\Microsoft Jet 4.0 OLE DB
Provider, caso a base de dados esteja implementada em Microsoft Access ou Native OLE
DB\Microsoft OLE DB Provider for SQL Server caso a base de dados a utilizar esteja implementada
em Microsoft SQL Server 2005, aps o que dever indicar a localizao da base de dados e os dados
de acesso base de dados, caso seja necessrio. importante que a ligao base de dados seja
testada, para garantir que no existem falhas na conexo.
Depois de seleccionar OK neste menu, o utilizador volta ao anterior, onde deve escolher Next, e o
menu Impersonation Information mostrado. Neste o utilizador tem de fornecer todos os dados
necessrios sua autenticao. Fornecer a autenticao que est presente no Windows pode ser
perigoso, pois faz com que erros futuros sejam difceis de detectar, devido ao sistema de segurana
estar associado s credenciais do utilizador autenticado no Windows e posteriormente ao utilizador
que est autenticado no servidor onde reside o Analysis Services. Para este caso porm o utilizador
poder seleccionar Default e avanar para o prximo menu, onde apenas ter de modificar o nome
da fonte de dados caso necessrio. E a criao de uma nova ligao fonte de dados estar
completa.
5.1.2 Criar uma vista sobre os dados
Aps criar a ligao fonte de dados o utilizador dever criar uma vista sobre os dados existentes
nessa base de dados. Para isso, dever ainda no Solution Explorer, carregar em cima de Data
Source Views e escolher New Data Source View, onde ir aparecer o Data Source View Wizard.
Escolhendo Next, ser apresentado ao utilizador o menu Select Data Source, como ilustrado a
seguir pela Figura 5.2.

Figura 5.2 Menu que oferece ao utilizador a escolha de uma fonte de
dados j criada para realizar uma vista sobre esses dados. [5]
Neste menu, j est seleccionada a fonte de dados criada no passo anterior. Com todas as
informaes sobre a ligao criada, o utilizador apenas deve confirmar todos os dados e escolher
Next, onde ser apresentado o menu Select Tables and Views que seguidamente apresentado
[Figura 5.3].

63

Figura 5.3 Janela onde o utilizador poder escolher as tabelas indicadas para
aprendizagem e classificao que iro fazer parte da estrutura de minerao.
O utilizador dever escolher quais as tabelas pretendidas. Sero necessrias duas tabelas, uma
para treino do modelo e outra para a fase de teste, onde iro ser comparados resultados de
classificao. Aps ter carregado no boto com a seta para passar para a coluna da direita as tabelas
pretendidas, o utilizador dever passar ao menu seguinte, onde ter de mudar o nome vista.
5.1.3 Construir o modelo
Para construir o modelo necessrio criar uma nova estrutura de minerao de dados e, para
isso, ambas as subseces anteriores devem ter sido realizadas.
1. Em Solution Explorer, carregar em Mining Structures e depois seleccionar New Mining
Structure, onde um Data Mining Wizard ser mostrado.

Figura 5.4 - Lista de algoritmos disponveis, onde se destaca o novo algoritmo.
2. No menu seguinte ser dada a escolha de mtodos para definir a estrutura de minerao: com
cubos OLAP ou atravs de uma base de dados existente, o utilizador dever escolher esta
ultima hiptese.
3. Na pgina seguinte Select the Data Mining Technique o utilizador deve seleccionar o
algoritmo que pretende utilizar para realizar as previses. Existe uma lista de algoritmos

64

disponveis para usar, e o utilizador poder escolher o algoritmo que foi ligado ao Analysis
Services no incio deste captulo, Learning Vector Quantization [Figura 5.4].
4. Na prxima pgina Select Data Source View and Specify Table Types, seleccionar Next sem
fazer qualquer alterao. No menu, Specify Table Types, o utilizador dever especificar qual o
tipo de tabela. Neste projecto no usaremos nested tables, assim o utilizador dever colocar
um visto na caixa da linha da tabela de treino do algoritmo, na coluna Case.
5. A prxima janela permite criar e editar junes: caso o utilizador tenha escolhido mais do que
uma tabela no penltimo passo, ir aparecer este passo no Wizard, para dar a possibilidade ao
utilizador de realizar a juno das tabelas graficamente, arrastando as colunas chave das
tabelas pai para a tabela filho. Caso tenha apenas sido escolhida uma tabela este passo ser
suprimido.
6. No prximo menu Specify the Training Data [Figura 5.6], o utilizador poder escolher quais as
colunas da tabela (atributos) que iro entrar no processo de treino e de previso do algoritmo.
aconselhvel escolher pelo menos uma coluna de entrada para o Mining Model da lista de
colunas disponveis. As colunas de entrada representam os dados actuais que so usados
para treinar o modelo. necessrio escolher colunas previsveis, dependendo do algoritmo
seleccionado. Estas colunas so campos usados para fornecer a sada prevista do modelo.
Aps o utilizador especificar o tipo de cada atributo, onde os atributos de entrada entraro no
processo de treino do algoritmo e o atributo de sada ser aquele sobre o qual vo ser
realizadas previses, o utilizador poder ento dar um nome ao seu modelo de minerao,
terminando esta tarefa.

Figura 5.5 - Menu onde so especificadas as colunas (atributos) de entrada e sada [5].
7. Neste passo o utilizador estar apto para construir o modelo, seleccionando Deploy Solution
no menu de Build. medida que o modelo treinado, os vrios passos de treino so
detalhados aquando do seu acontecimento. O tempo inicial do processo registado, e uma
barra de progresso ir reflectir o estado do processo durante as vrias fases.

65

5.1.4 Realizar previses sobre o modelo
Para efectuar previses com o modelo, necessrio seleccionar o cone de Mining Model
Prediction no painel View. O utilizador poder comparar as previses do modelo com os valores
contidos nos dados de teste.
Na caixa de dialogo Select Input Table(s), o utilizador deve seleccionar Select case table,
expandir o n inicial e seleccionar a tabela de previso.
Para comparar resultados, necessrio arrastar o atributo a comparar da caixa de dilogo Mining
Model at coluna Source na linha do topo da tabela [Figura 5.6]. No campo Alias dessa linha, o
utilizador dever escrever algumas palavras que identifiquem aquela linha como sendo os valores
obtidos do modelo. Agora dever arrastar o mesmo atributo a comparar da caixa de dialogo Select
Input Table(s) at coluna Source na segunda linha da tabela, e colocar no campo Alias
correspondente algumas palavras que identifiquem os valores provenientes daquela linha como
sendo os valores reais, ou seja, os valores contra os quais se vai prever. A lista dever parecer como
a seguinte:

Figura 5.6 Ilustrao do painel de previses com os campos Source, Field e Alias preenchidos.

Figura 5.7 Lista apresentada com os valores previstos pelo modelo na coluna
Previsto e os valores reais na coluna Actual.

66

Para o utilizador poder ver a exactido das previses do algoritmo, necessrio seleccionar o
cone em forma de tabela por cima da caixa de dilogo, e poder observar uma tabela semelhante
exibida pela Figura 5.7.
A primeira coluna desta tabela obtida chamando a funo ALGORITHM::Predict implementada
neste trabalho.
5.1.5 Personalizar os parmetros
Caso o utilizador queira testar o modelo dando vrios valores aos parmetros de entrada do
algoritmo, poder faz-lo tendo em ateno que as previses podero melhorar ou piorar consoante
os parmetros que forem modificados.
Para iniciar o processo de mudana dos valores dos parmetros, o utilizador ter de seleccionar o
cone Mining Models na lista View, deve carregar duas vezes sobre a coluna com o nome do
modelo, e seleccionar Properties. A janela de propriedades ser semelhante Figura 5.8.

Figura 5.8 Propriedades do modelo de minerao criado ao longo desta seco.
Agora o utilizador pode especificar os parmetros do modelo seleccionando a caixa Set Algorithm
Parameters. A caixa de dilogo ilustrada na Figura 5.9 mostra os parmetros disponveis.
O algoritmo Learning Vector Quantization [1, 2, 12, 13, 15, 16] recebe seis parmetros [Figura 5.9],
todos eles necessrios apenas na fase de treino. Os parmetros ALFA_FUNCTION_INITIAL_VALUE
e ALFA_FUNCTION_ FINAL_VALUE, contm o valor inicial e final da funo linear o(), que pode
variar entre o valor inicial 1 e o valor final 0. Testes anteriormente realizados com o algoritmo
revelaram que o valor ptimo inicial seria abaixo de 0.1, que o valor por omisso. Nas ltimas
iteraes do algoritmo existe a tendncia para a rede desaprender, ou seja, os vectores passarem de
um valor para outro, voltando ao inicial e assim sucessivamente, at que o nmero de iteraes limite
seja alcanado. Estes parmetros fazem com que o vector no alterne de valores, mas continue
sempre no mesmo quando o() inicial se aproxima ou tende para zero.
O valor de CODEBOOK_VECTORS_PER_CLASS deve ser tambm dependente do nmero de
vectores na tabela de treino. Mais uma vez o valor por omisso apenas representativo, devendo o
utilizador modific-lo para o que for mais indicado. Para classes muito extensas deve existir maior
nmero de vectores de referncia. Uma das limitaes deste trabalho consiste exactamente nisso, o
utilizador no pode definir um nmero de vectores de referncia para cada classe, mas tem de definir
um valor nico para todas as classes.

67

Figura 5.9 Menu onde so especificados os parmetros de entrada do algoritmo LVQ.
Os parmetros HIGH_VALUE e LOW_VALUE so os valores entre os quais iro ser criados os
valores aleatrios dos vectores de referncia iniciais. Tendencialmente, estes valores devero estar
de acordo tambm com o valor mnimo e mximo dos valores nos vectores de aprendizagem.
Finalmente, ITERATIONS_NUMBER contm o nmero de iteraes pretendidas para a
aprendizagem do algoritmo.
5.2 Experincias
Neste captulo sero apresentadas as experincias efectuadas ao algoritmo e ao modelo com ele
construdo. Para isso foi necessrio considerar trs tipos de experincias: o primeiro mais bsico
seria realizado com um conjunto de treino e de teste com vectores de duas dimenses, ou seja
vectores que podero ser representados no plano. A segunda experincia foi realizada com vectores
de 36 dimenses, e cujos resultados apenas se encontram disponveis sob a forma de uma matriz de
confuso. Finalmente a terceira e mais importante experincia foi realizada com a base de dados
disponvel pelo Microsoft SQL Server 2005, AdventureWorks, onde houve a possibilidade de testar
estes dados com alguns algoritmos j disponveis nesta verso da aplicao, tais como Microsoft
Decision Trees [5, 9, 11, 18], Neural Networks [4, 5, 6, 9, 11, 18], Naive Bayes [5, 9, 11, 18] e Nearest
Neigbor [5, 9, 11, 18].
5.2.1 Teste bsico
Para este teste foram apenas considerados vectores com duas dimenses, representveis no
plano, para que desta forma se conseguisse observar a distribuio dos vectores de referncia finais.
A amostra de treino consistia em 100 vectores de aprendizagem, e o tamanho da amostra de teste
era metade, os vectores tinham valores entre 0 e 300.
5.2.1.1 Primeiro teste
O primeiro teste com as amostras mencionadas foi realizado tendo em conta os valores por
omisso dos parmetros do algoritmo. Para que este algoritmo apresente bons resultados

68

necessrio que o utilizador conhea as suas amostras de treino e de teste, pois nem sempre os
parmetros por omisso so os adequados para as amostras em questo. Como o valor de alfa final
por omisso o recomendado por Kohonen (0,1) e assim bastante baixo tendo em conta o intervalo
em que este valor se pode encontrar (entre 0 e 1), usando este valor, a exactido das previses era
muito baixa, rondando os 65%, e testes posteriores com valores como 0.5 e 0.75 obtiveram
exactides nas previses de 77% e 75% respectivamente, valores de alfa final muito mais baixos
como 0.05, obtiveram percentagens de exactido perto de 58%, pelo que o valor 1 ser ptimo para
este conjunto de dados.
Parmetros
Nmero de vectores = 25
Iteraes = 50
Valor Mnimo = 0
Valor Mximo = 150
Alfa inicial = 1
Alfa final = 0
Tabela 5.1 Parmetros do primeiro teste bsico, com todos os valores por
omisso dos parmetros do algoritmo.
Assim, no teste seguinte realizado, apenas se modificou o alfa final para 1, como se pode ver na
Tabela 5.1, sendo os resultados obtidos seguidamente ilustrados pelo Grfico 5.1:

Grfico 5.1 Ilustrao dos vectores de referencia finais, onde se pode verificar a presena de trs
clusters de classes diferentes.
Como se pode verificar, na representao dos vectores de referncia finais (os vectores que
posteriormente iro ser usados na classificao do vectores de teste) podemos encontrar dois
clusters distintos e um terceiro, representado pela classe 1, que se encontra com alguns vectores das
outras classes. Este facto deve-se ao valor mximo por omisso com que os vectores de referncia
iniciais so gerados ser apenas de 150, enquanto o intervalo que estamos a considerar para as
amostras de treino e de teste tem o seu valor mximo em 300. Assim, os vectores de referncia

69

raramente so relocados para valores acima de 200. Apesar deste pequeno problema na afinao
dos parmetros, a matriz de confuso mostra uma grande exactido nas previses:
Classe 1 2 3 Preciso
1 14 3 3 70%
2 1 19 0 95%
3 0 2 8 80%
Preciso Total

82%
Matriz 5.1 - Matriz de confuso do primeiro teste bsico do algoritmo LVQ, com um conjunto de treino e
de teste artificial contendo vectores de duas dimenses.
5.2.1.2 Segundo teste
No segundo teste realizado, alguns dos parmetros foram alterados, como est descrito na tabela
seguinte:
Parmetros
Iteraes = 50
Valor Mnimo = 0
Valor Mximo = 300
Alfa inicial = 1
Alfa final = 0
Tabela 5.2 - Parmetros do algoritmo para o segundo teste bsico.
As alteraes realizadas ocorreram ao nvel do valor mximo para os valores existentes nos
vectores de referncia, o que permite que os vectores de referncia iniciais possam ser criados num
plano em que o eixo dos xx v at 300 tal como o eixo dos yy. Outro dos parmetros modificado foi o
nmero de vectores de cada classe, para melhor se visualizar os vectores de referncia no plano e
para o novo valor se adaptar melhor ao nmero de vectores de aprendizagem e de treino das
classes.

Grfico 5.2 - Ilustrao dos vectores de referncia finais, onde se pode ver a presena de dois
clusters distintos da classe 1 e da classe 3, enquanto a classe 2 apenas apresenta um cluster.

70

Como se pode ver neste grfico os clusters identificados esto mais distintos e no existe mistura
de vectores de referncia de classes diferentes. O problema agora com estes parmetros est no
alcance dos vectores de referncia finais: neste referencial aparecem vectores em zonas negativas
do grfico, bem como em valores muito acima de onde o ltimo vector de teste poder estar. Estes
dois factores fazem com que a matriz de confuso obtenha uma exactido de previso mais baixa.
Assim, apesar de os clusters estarem mais definidos, os vectores de referncia finais so mandados
para fora da zona onde os vectores de teste podero estar.
1 15 2 3 75%
2 3 16 1 80%
3 2 0 8 80%
Preciso Total

78%
Matriz 5.2 - Matriz de confuso do segundo teste bsico do algoritmo LVQ, com um conjunto de treino e
de teste artificial contendo vectores de duas dimenses.
5.2.1.3 Terceiro teste
Para corrigir o facto dos vectores de referncia se distanciarem da rea pretendida, mais uma vez
o valor mximo dos vectores de referncia foi modificado, desta vez para 250. E para garantir que o
algoritmo iterado as vezes suficientes para a relocao dos vectores de referncia, modificou-se
esse valor como a seguir mostrado na Tabela 5.3.
Parmetros
Iteraes = 100
Valor Mnimo = 0
Valor Mximo = 250
Alfa inicial = 1
Alfa final = 0
Tabela 5.3 - Parmetros do algoritmo LVQ para o terceiro teste bsico.
Estes valores permitiram obter clusters bem definidos, sem misturas de vectores de referncia de
classes diferentes, dentro dos limites da amostra de treino e de teste, como poderemos ver no
referencial representado no Grfico 5.3.
Como foi referido, este teste foi o que apresentou melhores resultados de previso, sendo que a
matriz de confuso apresenta uma exactido de previso de 87%.
1 15 2 3 75%
2 0 19 1 95%
3 1 0 9 90%
Preciso Total

87%
Matriz 5.3 - Matriz de confuso do terceiro teste bsico do algoritmo LVQ, com um conjunto de treino e de
teste artificial contendo vectores de duas dimenses.

71

Grfico 5.3 - Ilustrao dos vectores de referncia finais, onde se pode ver a presena de dois
clusters distintos da classe 1 e da classe 3, enquanto a classe 2 apenas apresenta um cluster bem
definido com alguns vectores a sarem fora da sua rea.
Podemos concluir que os parmetros usados neste teste, so parmetros ptimos para as
amostras de dados de treino e de teste. O facto de a matriz de confuso apresentar uma
percentagem menor de exactido para a classe 1, devido ao conjunto de treino, em que os vectores
da classe 3 esto talvez demasiado prximos dos vectores do conjunto 1.
5.2.2 Teste avanado
Este teste foi realizado tendo em conta uma amostra de dados disponvel para este tipo de provas.
As amostras em questo continham vectores de 36 dimenses. A amostra de dados de treino
continha 4435 vectores e a amostra de dados de teste continha 2000 vectores. Nestas amostras
existiam 6 classes distintas, sendo elas etiquetadas com nmeros: 1, 2, 3, 4, 5 e 7. Os
atributos so numricos, definidos num intervalo entre 0 e 140. A descrio detalhada do nmero de
vectores por classe quer de treino quer de teste est descrita na Tabela 5.4.
Classe Treino Teste
1 1072 (24%) 461 (23%)
2 479 (11%) 224 (11%)
3 961 (22%) 397 (20%)
4 415 (9%) 211 (11%)
5 470 (11%) 237 (12%)
7 1038 (23%) 470 (23%)
Tabela 5.4 - Descrio das amostras de treino e de teste para o teste avanado.
Antes mesmo de iniciar os testes que iriam ser relevantes para esta tese, foi realizado um conjunto
de testes para perceber como se comportariam estas amostras com o algoritmo Learning Vector
Quantization. Como foi referido na seco anterior, o valor ideal de alfa final para este algoritmo seria
de 0,1, o que no teste descrito em 5.2.1 no se verificou, pela amostra ser bastante pequena, e por
isso os dados se tornarem mais escassos. Com estas amostras os testes primrios realizados com
valor superior a 0,75 davam uma percentagem de exactido na previso de menos de 50%. Assim,
foi-se diminuindo esse valor at chegarmos a um valor ptimo para o parmetro alfa final, que ser
em todos os testes aqui descritos de 0,05.

72

5.2.2.1 Primeiro teste
Para este teste, foram usados os parmetros descritos na Figura 5.5. Optou-se por definir um
baixo nmero de vectores de referncia por cada classe, bem como um pequeno intervalo onde
esses vectores de referncia se poderiam iniciar para ser mais fcil perceber o que se passara com
os vectores de referncia finais. Esse intervalo foi definido como sendo um intervalo que incidisse
sobre os valores centrais da gama de valores oferecida pelas amostras.

Parmetros
Iteraes = 100
Valor Mnimo = 90
Valor Mximo = 110
Alfa inicial = 0,05
Alfa final = 0
Tabela 5.5 - Parmetros do algoritmo LVQ para o primeiro teste avanado.
Dado que a amostra relativamente grande optou-se por aumentar as iteraes para 100, apesar
de que dado a pequena quantidade definida de vectores de referncia no seria necessrio, pois a
determinada altura esses vectores no se iriam mover, por j estarem bem posicionados. Quanto ao
valor 0,05 definido para o alfa final, experincias anteriores, como j foi referido atrs, mostraram que
valores abaixo de 0,1 obtm ptimos resultados com estas amostras.
Para ilustrar os resultados obtidos com estes parmetros aps a fase de aprendizagem com o
conjunto de treino, foi elaborada uma matriz de confuso com as devidas percentagens [Matriz 5.4].
Classe 1 2 3 4 5 7 Preciso
1 394 0 14 0 24 29 86%
2 16 198 0 1 7 2 88%
3 4 0 371 19 0 3 94%
4 5 0 37 123 0 46 58%
5 40 4 0 6 140 47 59%
7 3 0 13 81 8 365 78%
Preciso Total

79%
Matriz 5.4 - Matriz de confuso do primeiro teste avanado do algoritmo LVQ. Estes resultados foram
obtidos atravs do conjunto de teste com 2000 casos, onde cada vector possua 36 dimenses.
Na matriz de confuso acima, nos quadrados a preto podemos observar a quantidade de classes
previstas com exactido. Podemos calcular a preciso do algoritmo, que neste teste de 79%,
atravs da diagonal seleccionada.
5.2.2.2 Segundo teste
Neste teste mantivemos alguns parmetros como se pode ver na Tabela 5.6. Um dos parmetros
modificado foi o nmero de vectores de referncia por classe, que foi o principal problema encontrado
na seco 5.2.2.1. Esse valor foi modificado para 50, valor que, devido ao nmero de vectores de
referncia mostrado na Tabela 5.5, ainda assim se considera pequeno.

73

Parmetros
Iteraes = 200
Valor Mnimo = 90
Valor Mximo = 110
Alfa inicial = 0,05
Alfa final = 0
Tabela 5.6 - Parmetros do algoritmo LVQ para o segundo teste avanado.
O nmero de iteraes tambm aumentou, devido ao nmero de vectores de referncia por classe
tambm ter aumentado. Caso o nmero de iteraes seja realmente demasiado elevado, isso no
interfere na exactido das previses realizadas pelo algoritmo, dado que o valor de alfa final est
muito baixo, o que permite aos vectores de referncia no se deslocarem para o stio anterior de
onde acabaram de ser transportados e assim sucessivamente. Os resultados conseguidos com o
conjunto de teste, aps a aprendizagem do algoritmo com o conjunto de treino so apresentados na
matriz de confuso ilustrada na Matriz 5.5.
1 445 0 9 0 7 0 97%
2 14 204 1 1 3 1 91%
3 1 0 383 11 0 2 97%
4 4 0 41 121 0 45 57%
5 42 6 5 4 127 53 54%
7 2 0 19 69 5 375 80%
Preciso Total

82%
Matriz 5.5 - Matriz de confuso do segundo teste avanado do algoritmo LVQ. Estes resultados foram
Calculando a preciso do algoritmo com esta amostra de dados atravs da diagonal da matriz,
obtemos 82% de preciso. Apesar de a preciso ter aumentado, podemos ver que aumentou o
nmero de previses bem sucedidas para as trs primeiras classes e para a ltima, mas que para as
classes 4 e 5 o nmero de previses certas desceu um pouco, o que se poder dever ao facto dos
vectores de referncia serem inicializados aleatoriamente dentro de um intervalo central muito
pequeno.
5.2.2.3 Terceiro teste
Este teste o mais exigente a nvel de tempo de execuo pois foi alterado o parmetro relativo
ao nmero de iteraes do algoritmo, desta vez para um nmero bastante mais elevado, 1000
iteraes. Esta alterao permite-nos ver como funciona o algoritmo com um grande nmero de
iteraes. Outros parmetros tambm foram alterados, tais como o nmero de vectores que mais
uma vez aumentou para um valor ainda mais alto, e que achamos ser o mnimo indicado dado o
grande nmero de vectores de aprendizagem, e o valor mximo e mnimo dos vectores de referncia
iniciais, este intervalo passou a ser um pouco maior, Tabela 5.7.

74

Parmetros
Iteraes = 1000
Valor Mnimo = 50
Valor Mximo = 100
Alfa inicial = 0,05
Alfa final = 0
Tabela 5.7 - Parmetros do algoritmo LVQ para o terceiro teste avanado.
Com a alterao nestes parmetros, principalmente no Valor mximo e Valor mnimo, que se
referem aos valores entre os quais os vectores de referncia vo ser inicializados, pretendemos
aumentar a preciso do algoritmo, diminuindo as previses erradas nas classes 4 e 5.
Na Matriz 5.6 pode-se observar cada preciso parcial, de cada classe, obtida pelo algoritmo aps
a aprendizagem com o conjunto de treino. A classificao do conjunto de teste mostra que a preciso
do algoritmo de 85%. Assim, com as modificaes realizadas conseguimos que a classe 5 fosse
classificada com maior preciso, bem como a classe 4, apesar de nesta ltima classe o aumento de
preciso ter sido muito ligeiro.
1 442 1 4 0 12 2 96%
2 2 212 0 1 6 3 95%
3 2 0 376 15 0 4 95%
4 1 0 39 129 4 42 61%
5 26 3 5 7 154 42 65%
7 2 0 13 64 7 384 82%
Preciso Total

85%
Matriz 5.6 - Matriz de confuso do terceiro teste avanado do algoritmo LVQ. Estes resultados foram
Podemos concluir que para esta amostra no so necessrias demasiadas iteraes, ou seja, as
100 iteraes dos outros dois testes adaptam-se perfeitamente a esta amostra, sendo que os
vectores no se modificam nas ltimas iteraes. Neste teste o que realmente fez a diferena foi o
maior nmero de vectores de referncia e um intervalo mais aberto, com uma maior gama de valores
para os vectores de referncia iniciais.
5.2.3 Testes avanados: AdventureWorksDW
A finalidade deste teste a comparao do algoritmo implementado com outros algoritmos j
existentes na ferramenta Microsoft SQL Server 2005, tais como, rvores de Deciso [3, 5, 9, 11],
Naive Bayes [3, 5, 9, 11], Clustering [3, 5, 9, 11] e Redes Neuronais [3, 4, 5, 6, 9, 11]. Sero
apresentados dois testes com a base de dados AdventureWorksDW, uma base de dados j fornecida
pela ferramenta utilizada, e que ir permitir comparar o desempenho dos algoritmos j nela existentes
e integrados, com o algoritmo LVQ. No primeiro teste com esta base de dados, comparmos todos os
algoritmos aqui mencionados com o LVQ tendo como conjunto de dados de treino e de teste a
mesma tabela da base de dados. No segundo teste, realizou-se uma partio dessa tabela, onde
80% da tabela funcionou como tabela de treino e 20% como tabela de teste.

75

5.2.3.1 Primeiro teste com AdventureWorksDW
Para executar este teste foi seguido um dos tutoriais [20] disponveis pela Microsoft na rea de
Data Mining. A base de dados utilizada, AdventureWorksDW, foi disponibilizada juntamente com a
ferramenta acima referida. Como a documentao oferecida pela Microsoft [20] que acompanha a
base de dados aqui em questo no menciona um conjunto de dados para comparao de
resultados, aps a classificao do conjunto de teste, optou-se por comparar os dados classificados
do modelo, cuja aprendizagem foi realizada atravs da tabela vTargetMail, com os dados dessa
mesma tabela, sendo o conjunto de treino e de teste o mesmo.
Neste tutorial uma das coisas modificadas foi o atributo a ser classificado, assim sendo iremos
classificar o atributo House Owner que permite, baseado nos atributos de entrada, perceber quais os
clientes com casa prpria e quais os clientes sem casa prpria.
O conjunto de dados de sada considerado apresentava aproximadamente 18000 casos, pelo que
para estas estatsticas apenas foram considerados 2000, desses casos 1481 seriam clientes com
casa prpria, e 519 seriam clientes com casa arrendada ou a viver em casa de outrem.
Seguidamente sero apresentadas as matrizes de confuso obtidas da execuo de cada algoritmo
j fornecido pelo Microsoft SQL Server 2005 usando os parmetros por omisso de cada algoritmo. O
primeiro algoritmo a ser considerado foi o algoritmo de rvores de Deciso, cuja matriz se apresenta
de seguida, Matriz 5.7.
Classe 0 1 Preciso
0 243 276 47%
1 117 1364 92%
Preciso Total

80,4%
Matriz 5.7 - Matriz de confuso do primeiro teste do algoritmo rvores de Deciso cujos conjuntos
de treino e de teste partilham os mesmos dados residentes na tabela vTargetMail.
Como pode ser visto na matriz acima o algoritmo classificou correctamente 92% dos clientes com
casa prpria e menos de metade dos clientes sem casa prpria o que significa que o algoritmo
tende a identificar de maneira errada os clientes sem casa.
O algoritmo de Clustering obteve resultados inferiores ao algoritmo rvores de Deciso,
mostrando resultados igualmente desequilibrados na classificao de clientes, Matriz 5.8.
Classe 0 1 Preciso
0 184 335 36%
1 119 1362 92%
Preciso Total

77,3%
Matriz 5.8 - Matriz de confuso do primeiro teste do algoritmo Clustering, cujos conjuntos
Neste algoritmo observa-se um decrscimo na preciso da classificao de clientes sem casa
prpria, tendo tendncia a prever erradamente estes clientes como tendo casa. No que diz respeito
aos clientes cuja classificao correcta , clientes com casa prpria a preciso correspondente
semelhante obtida com o algoritmo rvores de Deciso.
O algoritmo que se segue, Naive Bayes [Matriz 5.9], obteve uma preciso de classificao
ligeiramente inferior ao algoritmo rvores de Deciso [Matriz 5.7]. Apesar do algoritmo Naive Bayes

76

classificar um pouco melhor os clientes sem casa prpria, tambm classifica erradamente num
maior nmero os clientes com casa prpria, o que se traduz num equilbrio quanto ao nmero de
classificaes correctas das pessoas sem casa prpria.
Classe 0 1 Preciso
0 257 262 50%
1 162 1319 89%
Preciso Total

78,8%
Matriz 5.9 - Matriz de confuso do primeiro teste do algoritmo Naive Bayes, cujos conjuntos de
treino e de teste partilham os mesmos dados residentes na tabela vTargetMail.
Apesar desse pequeno equilbrio o algoritmo mostra uma preciso total inferior ao algoritmo
rvores de Deciso [Matriz 5.7] o que significa que na generalidade classificou mais clientes com
casa prpria como clientes sem casa prpria.
O algoritmo Redes Neuronais, do qual descende o algoritmo proposto nesta tese, apresenta
resultados inferiores a qualquer algoritmo aqui apresentado, como mostrado na Matriz 5.10.
Classe 0 1 Preciso
0 160 359 31%
1 104 1377 93%
Preciso Total

76,9%
Matriz 5.10 - Matriz de confuso do primeiro teste do algoritmo Redes Neuronais, cujos
conjuntos de treino e de teste partilham os mesmos dados residentes na tabela vTargetMail.
Redes Neuronais apresenta uma preciso total inferior a todos os outros algoritmos aqui
apresentados, apesar de ser o algoritmo que classifica melhor os clientes com casa prpria,
apresenta resultados muito inferiores no que diz respeito a classificar clientes sem casa prpria.
Tendendo a classificar erradamente os clientes sem casa prpria como clientes com casa prpria.
Seguidamente sero apresentados todos os resultados efectuados com o algoritmo LVQ, bem
como os parmetros usados para cada experincia.
A primeira experincia efectuada com este algoritmo, cujos resultados no sero detalhadamente
aqui expostos, realizou-se com os parmetros por omisso apresentados na ferramenta da Microsoft,
o resultado traduziu-se na classificao de todos os clientes em clientes com casa prpria. Este
resultado nada satisfatrio foi influenciado pelos valores dos vectores de referncia finais, que
estavam a tomar valores infinitos e at negativos. Concluiu-se ser melhor baixar o valor mximo
permitido para os valores dos vectores de referncia iniciais, bem como o nmero de iteraes e o
valor de alfa inicial. Na experincia seguinte, os parmetros utilizados foram os seguintes:
Parmetros
Iteraes = 5
Valor Mnimo = 0
Valor Mximo = 20
Alfa inicial = 0,05
Alfa final = 0
Tabela 5.8 - Parmetros da primeira experincia do algoritmo LVQ para o primeiro teste com
AdventureWorksDW onde os conjuntos de treino e de teste eram representados pela mesma
tabela, vTargetMail.

77

Dado que os valores existentes nos dados de entrada na tabela vTargetMail usada para estes
testes encontravam-se entre 0 e 60, aproximadamente, optou-se por um Valor Mximo intermdio
para os valores dos vectores de referncia iniciais, para evitar que esses vectores possam ser
relocados para valores negativos ou infinitos.
Na Matriz 5.11 pode-se observar os resultados obtidos nesta experincia, a preciso total obtida
com este algoritmo nestas circunstncias inferior a qualquer um dos algoritmos apresentados
anteriormente, o que nos leva alterao dos parmetros do algoritmo, Tabela 5.9.
Classe 0 1 Preciso
0 190 329 37%
1 161 1320 89%
Preciso Total

75,5%
Matriz 5.11 - Matriz de confuso da primeira experincia do algoritmo LVQ, cujos conjuntos
Tendo em conta os resultados frgeis obtidos, repetiu-se a experincia, desta vez com outros
parmetros.
Parmetros
Iteraes = 5
Valor Mnimo = 0
Valor Mximo = 20
Alfa inicial = 0,025
Alfa final = 0
Tabela 5.9 - Parmetros da segunda experincia do algoritmo LVQ para o primeiro teste com
AdventureWorksDW onde os conjuntos de treino e de teste eram representados pela mesma tabela.
Desta vez alterou-se apenas valor de Alfa inicial, para que todos os vectores de referncia que
foram relocados e que ainda se encontravam longe dos limites pudessem ser relocados de maneira
correcta. Os resultados com estes parmetros foram ligeiramente melhores que os efectuados
anteriormente, Matriz 5.12.
Classe 0 1 Preciso
0 198 321 38%
1 156 1325 90%
Preciso Total

76,2%
Matriz 5.12 - Matriz de confuso da segunda experincia do algoritmo LVQ, cujos conjuntos
A preciso total desta experincia assemelha-se com a obtida com o algoritmo Redes Neuronais.
Esta experincia conseguiu uma preciso parcial dos clientes com casa prpria bastante elevada e
uma preciso parcial dos clientes sem casa prpria diminuta, o que tem sido conseguido em todos
os testes realizados quer com este algoritmo quer com os algoritmos j disponibilizados pelo
O prximo teste apresenta menor discrepncia nestas duas precises parciais de maneira a que
exista uma preciso total elevada e um maior equilbrio entre as classificaes. Quanto aos
parmetros, apenas o valor de alfa inicial sofreu uma alterao para 0.01. Apesar de ser um valor
bastante reduzido em relao ao valor ptimo para este parmetro (0,1), dependendo da quantidade

e das estruturas dos dados de treino e de teste, este parmetro pode ter valores muit
seguir so apresentados os parmetros para
Tabela 5.10 - Parmetros da terceira experincia do algoritmo LVQ para o primeiro teste com
AdventureWorksDW onde os conjuntos de treino e de teste eram representados pela mesma tabela.
Os resultados obtidos neste teste, so apresentados de segu
verificar que a preciso total a mais elevada conseguida com o algoritmo LVQ, podemos comparar
estes resultados com os obtidos com o algoritmo rvores de Deciso, a preciso total semelhante,
com uma nica diferena, estes resultados mostram um maior equilbrio no que diz respeito s
precises parciais, sendo que o algoritmo que at agora mostrou maior preciso parcial na
classificao dos clientes sem casa prpria.
Classe
Preciso Total
Matriz 5.13 - Matriz de confuso da terceira experincia do algoritmo LVQ, cujos conjuntos
de treino e de teste partilham os mesmos dados residentes na tabela
Atravs da observao dos res
Microsoft e dos resultados obtidos n
concluir que Learning Vector Quantization
equilibrados que algoritmos como Redes Neuronais,
aproximados, mas mais equilibrados que os apresentados pelo algoritmo rvores de Deciso.
Os Grficos 5.4 e 5.5 mostram o panorama das precises parciais obtidas por
pelo algoritmo LVQ na ltima experincia
Grfico 5.4 - Representao grfica da preciso parcial da classificao dos clientes sem
casa prpria do primeiro teste com
0
50
100
150
200
250
300
350
rvores de
Deciso
dos dados de treino e de teste, este parmetro pode ter valores muit
seguir so apresentados os parmetros para a terceira experincia deste teste com o algoritmo LVQ
Parmetros
Iteraes = 5
Valor Mnimo = 0
Valor Mximo = 15
Alfa inicial = 0,01
Alfa final = 0
Parmetros da terceira experincia do algoritmo LVQ para o primeiro teste com
onde os conjuntos de treino e de teste eram representados pela mesma tabela.
Os resultados obtidos neste teste, so apresentados de seguida na Matriz 5.13, onde podemos
tes resultados mostram um maior equilbrio no que diz respeito s
classificao dos clientes sem casa prpria.
Classe 0 1 Preciso
0 287 232 55%
1 160 1321 89%
Preciso Total

80,4%
Matriz de confuso da terceira experincia do algoritmo LVQ, cujos conjuntos
Atravs da observao dos resultados obtidos com os algoritmos presentes na ferramenta da
Microsoft e dos resultados obtidos na ltima experincia realizada com o algoritmo LVQ, pode
Learning Vector Quantization um algoritmo que obtm resultados melhores e mais
ibrados que algoritmos como Redes Neuronais, Clustering ou Naive Bayes
Os Grficos 5.4 e 5.5 mostram o panorama das precises parciais obtidas por
experincia aqui apresentada.
Representao grfica da preciso parcial da classificao dos clientes sem
casa prpria do primeiro teste com AdventureWorksDW.
Clustering Naive Bayes Redes
Neuronais
Learning
Vector
Quantization
0 ou Clientes
sem casa
prpria
78
dos dados de treino e de teste, este parmetro pode ter valores muito baixos. A
com o algoritmo LVQ.
Parmetros da terceira experincia do algoritmo LVQ para o primeiro teste com
onde os conjuntos de treino e de teste eram representados pela mesma tabela.
ida na Matriz 5.13, onde podemos
tes resultados mostram um maior equilbrio no que diz respeito s
Matriz de confuso da terceira experincia do algoritmo LVQ, cujos conjuntos
vTargetMail.
ultados obtidos com os algoritmos presentes na ferramenta da
com o algoritmo LVQ, pode-se
um algoritmo que obtm resultados melhores e mais
Naive Bayes, e resultados muito
Os Grficos 5.4 e 5.5 mostram o panorama das precises parciais obtidas por cada algoritmo e

Representao grfica da preciso parcial da classificao dos clientes sem
0 ou Clientes
sem casa

Grfico 5.5 - Representao grfica da preciso parcial da classificao dos clientes com
casa prpria do primeiro teste com
Pelo Grfico 5.5 pode observar
resultados, ou seja, maior exactido na classificao de
implementado nesta tese, Learning Vector Quantization
LVQ encontra-se em penltimo na classificao de c
casos o separarem do algoritmo rvores de Deciso.
apresenta uma preciso total superior apresentada pelos algoritmos
Redes Neuronais, mostrando uma preciso total semelhante obtida pelo algoritmo rvores de
Deciso, com resultados mais equilibrados a nvel de preciso parcial.
5.2.3.2 Segundo teste com AdventureWorksDW
Tal como no teste anterior, este teste seguiu as linhas de orienta
Microsoft [20], cuja diferena entre a execuo do tutorial e a execuo aqui realizada reside no
atributo a classificar, House Owner
Este teste utiliza apenas uma tabela de treino, mas ao c
treino no so iguais aos dados de teste. Seguindo o guia de partio de tabelas [30] para
Mining fornecido pela Microsoft, separou
treino do modelo, e outra para teste. Assim sendo, 80% da tabela (14877 casos) foi designada para
dados de treino e os restantes 20% (3607 casos) para dados de teste
apresentados contemplam uma amostra de 2000 casos tendo em conta o universo dos dados de
teste.
Tal como no teste anterior a execuo deste teste com algoritmos j oferecidos pela Microsoft
pressupe o uso de parmetros de omisso nesses algoritmos.
O algoritmo rvores de Deciso
de separao da tabela. Os resultados obtidos podem ser observados na matriz de confuso que se
segue, Matriz 5.14.

1290
1300
1310
1320
1330
1340
1350
1360
1370
1380
1390
rvores de
Deciso
Representao grfica da preciso parcial da classificao dos clientes com
casa prpria do primeiro teste com AdventureWorksDW.
observar-se que o algoritmo que consegue obter maior prec
resultados, ou seja, maior exactido na classificao de clientes sem casa prpria
Learning Vector Quantization, em compensao, no Grfico 5.5 o algoritmo
se em penltimo na classificao de clientes com casa prpria, apesar de apenas 40
casos o separarem do algoritmo rvores de Deciso. Apesar deste ltimo resultado o algoritmo LVQ
apresenta uma preciso total superior apresentada pelos algoritmos Clustering
ostrando uma preciso total semelhante obtida pelo algoritmo rvores de
Deciso, com resultados mais equilibrados a nvel de preciso parcial.
AdventureWorksDW
Tal como no teste anterior, este teste seguiu as linhas de orientao do tutorial oferecido pela
House Owner e no nmero de tabelas utilizadas.
Este teste utiliza apenas uma tabela de treino, mas ao contrrio do teste anterior os dados de
treino no so iguais aos dados de teste. Seguindo o guia de partio de tabelas [30] para
fornecido pela Microsoft, separou-se a tabela vTargetMail em duas vistas distintas, uma para
utra para teste. Assim sendo, 80% da tabela (14877 casos) foi designada para
dados de treino e os restantes 20% (3607 casos) para dados de teste.
pressupe o uso de parmetros de omisso nesses algoritmos.
O algoritmo rvores de Deciso foi dos primeiros algoritmos a serem testados com este mtodo
eparao da tabela. Os resultados obtidos podem ser observados na matriz de confuso que se
Clustering Naive Bayes Redes
Neuronais
Learning
Vector
Quantization
1 ou Clientes
com casa
prpria
79

Representao grfica da preciso parcial da classificao dos clientes com
que o algoritmo que consegue obter maior preciso nos
clientes sem casa prpria o algoritmo
, em compensao, no Grfico 5.5 o algoritmo
lientes com casa prpria, apesar de apenas 40
Apesar deste ltimo resultado o algoritmo LVQ
Clustering, Naive Bayes e
ostrando uma preciso total semelhante obtida pelo algoritmo rvores de
o do tutorial oferecido pela
ontrrio do teste anterior os dados de
treino no so iguais aos dados de teste. Seguindo o guia de partio de tabelas [30] para Data
em duas vistas distintas, uma para
utra para teste. Assim sendo, 80% da tabela (14877 casos) foi designada para
Os resultados aqui
foi dos primeiros algoritmos a serem testados com este mtodo
eparao da tabela. Os resultados obtidos podem ser observados na matriz de confuso que se
1 ou Clientes
com casa

80

Classe 0 1 Preciso
0 256 216 54%
1 196 1332 87%
Preciso Total

79,4%
Matriz 5.14 - Matriz de confuso do segundo teste do algoritmo rvores de Deciso, onde o
teste representa os casos restantes dessa tabela.
Apesar da preciso total ser ligeiramente inferior conseguida no primeiro teste [Matriz 5.7]
realizado com este algoritmo, as suas precises parciais esto melhor distribudas, mais equilibradas,
sendo que a preciso parcial dos clientes sem casa prpria aumentou em comparao com o teste
anterior.
Tal como a experincia realizada com o algoritmo de rvores de Deciso, a experincia efectuada
com o algoritmo de Clustering revela tambm resultados semelhantes [Matriz 5.15].
Classe 0 1 Preciso
0 248 226 52%
1 281 1245 82%
Preciso Total

74,7%
Matriz 5.15 - Matriz de confuso do segundo teste do algoritmo Clustering, onde o conjunto
de treino composto por 80% dos casos da tabela vTargetMail e o conjunto de teste
representa os casos restantes dessa tabela.
Tambm este algoritmo apresenta uma preciso total inferior preciso exibida no teste anterior
[Matriz 5.8], mas em contrapartida oferece precises parciais mais estveis, por exemplo, a preciso
parcial da correcta classificao dos clientes sem casa prpria no primeiro teste [Matriz 5.8] de
36%, enquanto neste teste esta mesma preciso subiu para 52%, o que aumentou em 16% os casos
de clientes sem casa prpria classificados correctamente. Quanto aos casos de clientes com casa
prpria, a preciso neste teste situa-se nos 82%, o que representa uma descida de 10% em relao
ao teste anterior [Matriz 5.8]. Pode-se concluir que as precises parciais apesar de mais equilibradas,
reflectem uma preciso total inferior devido classificao errada de clientes com casa prpria.
Em relao ao algoritmo de Naive Bayes, no foi possvel efectuar este teste com um modelo
construdo com este algoritmo, pois os resultados apresentados mostravam que todos os clientes
foram classificados como sendo clientes sem casa prpria o que mostra uma m classificao visto
que a grande maioria dos clientes devem ser classificados como clientes com casa prpria, assim
sendo este algoritmo ignorado para este teste.
O prximo algoritmo, Redes Neuronais, apresenta resultados ligeiramente superiores aos
conseguidos no teste anterior [Matriz 5.10], com um total de casos relativos aos clientes com casa
prpria muito superior, como se pode observar pela Matriz 5.16.
Classe 0 1 Preciso
0 143 331 30%
1 126 1400 92%
Preciso Total

77,2%
Matriz 5.16 - Matriz de confuso do segundo teste do algoritmo Redes Neuronais, onde o
teste representa os casos restantes dessa tabela.

81

Tendo em conta que a amostra sobre a qual estamos a realizar estas estatsticas difere do
primeiro para o segundo teste deste captulo, este algoritmo na subseco anterior [Matriz 5.10]
apresentou bons resultados com pouco equilbrio entre as suas precises parciais, o que acontece de
novo neste teste, desta vez a preciso total foi ligeiramente superior, mas continua a existir uma
grande discrepncia entre as precises parciais, sendo que Redes Neuronais tende a classificar
correctamente os clientes com casa prpria, e a classificar de forma errada os clientes sem casa
prpria. Apesar desta discrepncia este algoritmo consegue obter resultados, em termos de preciso
total, semelhantes ao algoritmo rvores de Deciso [Matriz 5.14].
Seguidamente sero apresentados os resultados obtidos com o algoritmo Learning Vector
Quantization. Foram realizadas duas experincias para este teste, a primeira delas efectuada com os
parmetros descritos pela Tabela 5.11.
Parmetros
Iteraes = 5
Valor Mnimo = 0
Valor Mximo = 20
Alfa inicial = 0,05
Alfa final = 0
Tabela 5.11 - Parmetros da primeira experincia do algoritmo LVQ para o segundo teste com
AdventureWorksDW onde o conjunto de treino representa 80% dos casos da tabela vTargetMail
e o conjunto de teste representado por 20% dessa mesma tabela.
Para esta primeira experincia deu-se como valor de Alfa Inicial, 0,05 dado que com o valor
definido por omisso o algoritmo classificava erradamente muitos dos clientes com casa prpria. Os
valores descritos nesta tabela so semelhantes aos valores utilizados na primeira experincia do
primeiro teste [Tabela 5.8]. Os resultados esto descritos na seguinte matriz de confuso [Matriz
5.17].
Classe 0 1 Preciso
0 98 376 21%
1 100 1426 94%
Preciso Total

76,2%
Matriz 5.17 - Matriz de confuso da primeira experincia do segundo teste do algoritmo LVQ,
onde o conjunto de treino composto por 80% dos casos da tabela vTargetMail e o
conjunto de teste representa os casos restantes dessa tabela.
Como est representado, este algoritmo com os parmetros referidos obteve resultados menos
significativos que qualquer outro neste teste. Comparando os resultados com os obtidos com o
algoritmo Redes Neuronais neste teste [Matriz 5.16], pode-se perceber que a discrepncia entre a
percentagem sobre a correcta classificao de clientes com e sem casa prpria continua a ser
elevada, mais elevada com o algoritmo LVQ. Com este algoritmo existe menor quantidade de clientes
classificados como clientes sem casa prpria, o que leva a um aumento dos clientes bem
classificados como clientes com casa prpria, valor este que superior ao obtido pelo algoritmo
Redes Neuronais.
Comparando esta experincia com a primeira experincia efectuada no primeiro teste desta
subseco [Matriz 5.11], em que os valores dos parmetros do algoritmo LVQ so semelhantes,
pode-se perceber que as precises parciais so um pouco diferentes, a correcta classificao de

clientes sem casa prpria neste teste desce para 21%, menos 16% que no teste anterior [Matriz
5.11], enquanto a correcta classificao de
mais 5% que no anterior teste. Pode
para o algoritmo classificar melhor os
A finalidade da prxima experincia diminuir a discrepncia encontrada anterior
os parmetros de entrada utilizados no algoritmo LVQ sero os mesmos utilizados
experincia do teste passado [Tabela
LVQ so exibidos na Matriz 5.18.
Classe
Preciso Total
Matriz 5.18 - Matriz de confuso da segunda experincia do segundo teste do algoritmo
LVQ, onde o conjunto de treino composto por 80% dos casos da tabela
Como apresentado na matriz acima, os resultados do algoritmo LVQ com os parmetros da
Tabela 5.10 so muito semelhantes aos resultados apresentados na ltima experincia do teste
anterior [Matriz 5.13], onde apenas existe uma pequena diminuio dos client
correctamente como clientes com
correctamente como clientes sem
existia na experincia anterior foi reduzida em cer
classificao tanto de clientes com casa prpria
estes resultados com os obtidos neste teste pelo algoritmo rvores de Deciso, pode
o algoritmo LVQ obteve uma preciso total maior, devido sua exactido na classificao de
sem casa prpria.
Nos grficos que se seguem esto representados os resultados obtidos por estes quatro
algoritmos, apenas tendo em conta a ltima experincia r
destes grficos obteremos uma viso global do desempenho de cada algoritmo.
Grfico 5.6 - Representao grfica da preciso parcial da classificao dos clientes sem casa
prpria do s
No Grfico 5.6 esto representados os resultados apenas para a classificao correcta dos
clientes sem casa prpria. Como visvel, o algoritmo que melhor prev estes clientes e que
mantm por isso menor discrepncia e
0
50
100
150
200
250
300
rvores de
Deciso
neste teste desce para 21%, menos 16% que no teste anterior [Matriz
5.11], enquanto a correcta classificao de clientes com casa prpria neste teste sobe para 94%,
mais 5% que no anterior teste. Pode-se concluir que com estes parmetros existe um
para o algoritmo classificar melhor os clientes com casa prpria.
A finalidade da prxima experincia diminuir a discrepncia encontrada anterior
os parmetros de entrada utilizados no algoritmo LVQ sero os mesmos utilizados
Tabela 5.10]. Os resultados obtidos com estes parmetros no algoritmo
LVQ so exibidos na Matriz 5.18.
Classe 0 1 Preciso
0 268 206 57%
1 195 1331 87%
Preciso Total

80%
Matriz de confuso da segunda experincia do segundo teste do algoritmo
LVQ, onde o conjunto de treino composto por 80% dos casos da tabela vTargetMail
omo apresentado na matriz acima, os resultados do algoritmo LVQ com os parmetros da
so muito semelhantes aos resultados apresentados na ltima experincia do teste
anterior [Matriz 5.13], onde apenas existe uma pequena diminuio dos client
clientes com casa prpria, e um aumento dos clientes classificados
clientes sem casa prpria. A discrepncia entre as duas precises parciais que
existia na experincia anterior foi reduzida em cerca de 40%, o que torna o algoritmo mais exacto na
clientes com casa prpria como de clientes sem casa prpria
estes resultados com os obtidos neste teste pelo algoritmo rvores de Deciso, pode
itmo LVQ obteve uma preciso total maior, devido sua exactido na classificao de
algoritmos, apenas tendo em conta a ltima experincia realizada com o algoritmo LVQ. Atravs
destes grficos obteremos uma viso global do desempenho de cada algoritmo.
Representao grfica da preciso parcial da classificao dos clientes sem casa
prpria do segundo teste com AdventureWorksDW.
rfico 5.6 esto representados os resultados apenas para a classificao correcta dos
. Como visvel, o algoritmo que melhor prev estes clientes e que
mantm por isso menor discrepncia entre estes dados e os representados no Grfico 5.7 o
rvores de
Deciso
Clustering Redes
Neuronais
Learning Vector
Quantization
0 ou Clientes
sem casa
prpria
82
neste teste desce para 21%, menos 16% que no teste anterior [Matriz
neste teste sobe para 94%,
se concluir que com estes parmetros existe uma propenso
A finalidade da prxima experincia diminuir a discrepncia encontrada anteriormente, pelo que
os parmetros de entrada utilizados no algoritmo LVQ sero os mesmos utilizados na ltima
Os resultados obtidos com estes parmetros no algoritmo
Matriz de confuso da segunda experincia do segundo teste do algoritmo
vTargetMail e o

omo apresentado na matriz acima, os resultados do algoritmo LVQ com os parmetros da
so muito semelhantes aos resultados apresentados na ltima experincia do teste
anterior [Matriz 5.13], onde apenas existe uma pequena diminuio dos clientes classificados
, e um aumento dos clientes classificados
. A discrepncia entre as duas precises parciais que
ca de 40%, o que torna o algoritmo mais exacto na
clientes sem casa prpria. Comparando
estes resultados com os obtidos neste teste pelo algoritmo rvores de Deciso, pode-se observar que
itmo LVQ obteve uma preciso total maior, devido sua exactido na classificao de clientes
ealizada com o algoritmo LVQ. Atravs

Representao grfica da preciso parcial da classificao dos clientes sem casa
rfico 5.6 esto representados os resultados apenas para a classificao correcta dos
. Como visvel, o algoritmo que melhor prev estes clientes e que
ntre estes dados e os representados no Grfico 5.7 o
0 ou Clientes

algoritmo LVQ, sendo que o algoritmo que mostra um valor inferior aos outros algoritmos Redes
Neuronais
Grfico 5.7 - Representao grfica da preciso parcial da cla
prpria do segundo teste com
Neste grfico pode observar-
casa prpria, mas sim o algoritmo de Redes Neuronais, sendo que
aparece em segundo lugar juntamente com rvores de Deciso. Apesar do algoritmo LVQ no ser o
algoritmo que melhor classifica correctamente os
atrs o algoritmo que em todo o conjunto de dad
classificao de clientes com casa prpria
5.2.4 Concluso das experincias
Estes testes foram fundamentais para apreender o desempenho conseguido pelo algoritmo
Learning Vector Quantization com os diferentes tipos de dados.
No teste bsico os dados de treino e de teste apenas consistiam em vectores de duas dimenses,
que eram facilmente representados num grfico, e onde se identificavam os clusters definidos pelos
vectores de referncia finais, aps a fase de treino. O conjunto de dados de treino e teste era
pequeno e por isso o valor de A
preciso de classificao igual a
vectores de referncia finais, aps o processo de aprendizagem do modelo.
Um conjunto de dados de treino e de teste mais complexo foi utilizado no teste avanado, onde
cada vector tinha 36 dimenses. Este teste foi importante
algoritmo na presena de dados de treino e teste com uma extenso considervel. Com
dados de grande extenso este algoritmo funciona correctamente com um valor d
baixo, 0,05. Nestas experincias o algoritmo obteve precises elevadas, em que a mais distinta foi
85%. Para este tipo de dados, onde existe um grande nmero de atributos a considerar, necessrio
que o nmero de iteraes tambm seja elevado, e que os valores Mnimo e Mximo par
dos vectores de referncia iniciais sejam adequados aos valores existentes no conjunto de treino.
O ltimo teste realizado com este algoritmo, e o mais importante, envolveu a base de dados j
existente no Microsoft SQL Server 2005 e teve como
1150
1200
1250
1300
1350
1400
1450
rvores de
Deciso
, sendo que o algoritmo que mostra um valor inferior aos outros algoritmos Redes
Representao grfica da preciso parcial da classificao dos clientes com casa
prpria do segundo teste com AdventureWorksDW.
-se que o algoritmo LVQ no o melhor a classificar
, mas sim o algoritmo de Redes Neuronais, sendo que Learning Vector
em segundo lugar juntamente com rvores de Deciso. Apesar do algoritmo LVQ no ser o
algoritmo que melhor classifica correctamente os clientes com casa prpria , como j foi referido
atrs o algoritmo que em todo o conjunto de dados se mantm mais estvel e equilibrado na
casa prpria e clientes sem casa prpria.
Concluso das experincias
com os diferentes tipos de dados.
ferncia finais, aps a fase de treino. O conjunto de dados de treino e teste era
Alfa inicial mantinha-se a 1, valor com o qual se conseguia obter uma
igual a 87%. Este valor ptimo conseguido atravs da observao dos
vectores de referncia finais, aps o processo de aprendizagem do modelo.
cada vector tinha 36 dimenses. Este teste foi importante para perceber qual era o comportamento do
algoritmo na presena de dados de treino e teste com uma extenso considervel. Com
este algoritmo funciona correctamente com um valor d
incias o algoritmo obteve precises elevadas, em que a mais distinta foi
que o nmero de iteraes tambm seja elevado, e que os valores Mnimo e Mximo par
ltimo teste realizado com este algoritmo, e o mais importante, envolveu a base de dados j
existente no Microsoft SQL Server 2005 e teve como principal objectivo comparar os algoritmos j
rvores de
Deciso
Clustering Redes
Neuronais
Learning Vector
Quantization
1 ou Clientes
com casa
prpria
83
, sendo que o algoritmo que mostra um valor inferior aos outros algoritmos Redes

ssificao dos clientes com casa
no o melhor a classificar clientes com
Learning Vector Quantization
em segundo lugar juntamente com rvores de Deciso. Apesar do algoritmo LVQ no ser o
, como j foi referido
os se mantm mais estvel e equilibrado na
ferncia finais, aps a fase de treino. O conjunto de dados de treino e teste era
1, valor com o qual se conseguia obter uma
ravs da observao dos
qual era o comportamento do
algoritmo na presena de dados de treino e teste com uma extenso considervel. Com conjuntos de
este algoritmo funciona correctamente com um valor de alfa inicial muito
incias o algoritmo obteve precises elevadas, em que a mais distinta foi
que o nmero de iteraes tambm seja elevado, e que os valores Mnimo e Mximo para os valores
ltimo teste realizado com este algoritmo, e o mais importante, envolveu a base de dados j
principal objectivo comparar os algoritmos j
1 ou Clientes
com casa

84

existentes nesta ferramenta com o algoritmo LVQ. No primeiro teste realizado, onde os dados de
treino eram iguais aos dados de teste, observou-se que o algoritmo LVQ conseguia obter melhores
resultados com valores de Alfa inicial muito baixos (0,01) dado a extenso dos dados. Em
comparao com outros algoritmos, o algoritmo LVQ teve uma preciso semelhante obtida pelo
algoritmo rvores de Deciso e superior obtida pelos algoritmos Clustering, Naive Bayes e Redes
Neuronais. A nica diferena a nvel de classificaes correctas entre os algoritmos LVQ e rvores de
Deciso verificou-se ao nvel do equilbrio das classificaes, os resultados do algoritmo LVQ
mostraram uma discrepncia inferior entre as classificaes correctas dos clientes com casa prpria
e dos clientes sem casa prpria. No segundo teste realizado, dividiu-se o conjunto de dados de uma
tabela em dados de treino e de teste, ou seja, 80% dos casos da tabela faziam parte da vista com a
qual o modelo foi treinado, e os restantes casos foram introduzidos na vista para testar o modelo. Os
resultados de todos os algoritmos mostraram que houve uma pequena descida na preciso total.
Apesar dessa descida, o algoritmo LVQ manteve a uma boa preciso de 80%, com os mesmos
parmetros referidos no teste anterior, e obteve resultados semelhantes ao algoritmo rvores de
Deciso que neste teste conseguiu resultados mais equilibrados das precises parciais.
Para concluir e comparando todos os algoritmos aqui estudados, atravs da observao dos
vectores de referncia finais aps o processo de aprendizagem do modelo, consegue-se prever os
parmetros de entrada adequados para os conjuntos de dados de treino e de teste. Com os
parmetros correctos o algoritmo LVQ consegue obter resultados melhores e mais equilibrados que
os obtidos com os algoritmos Clustering, Redes Neuronais e Naive Bayes, e resultados equiparados
aos obtidos com o algoritmo rvores de Deciso, sendo que em alguns conjuntos de dados o
algoritmo Learning Vector Quantization consegue obter resultados mais equilibrados que o algoritmo
rvores de Deciso.

85

6 Concluso

Um novo algoritmo desenvolvido por Kohonen, foi proposto para ser integrado na ferramenta da
Microsoft para Data Mining, o Microsoft SQL Server 2005. Learning Vector Quantization [1, 2, 12, 13,
14, 15, 16, 17] um tipo de Redes Neuronais Artificiais [3, 4, 5, 6, 9, 11] e, como tal partilha algumas
das suas caractersticas, como o facto de fazer parte da lista de algoritmos supervisionados, tais
como rvores de Deciso [3, 5, 9, 11], Nearest Neighbor [3, 5, 9, 11] e Naive Bayes [3, 5, 9, 11].
Neste tipo de algoritmos, todos os factores conhecidos ou variveis de entrada necessitam de ser
fornecidos para que se consiga encontrar as melhores relaes entre eles. A previso baseada em
valores conhecidos ou variveis alvo, atravs das quais o engenho de Data Mining ir encontrar o
valor mais provvel para os valores desconhecidos. Outro tipo de Data Mining abordado foi o Data
Mining no supervisionado, no qual podemos ver inserido o algoritmo Clustering [3, 5, 9, 11]. Este tipo
de Data Mining no usado para fazer previses, logo as variveis alvo no so requeridas. Os
dados so colocados num formato que torna mais fcil a sua interpretao. O algoritmo Clustering [3,
5, 9, 11] tem a caracterstica de agrupar os dados em grupos baseados em caractersticas comuns,
para depois poderem ser interpretados.
O algoritmo de Redes Neuronais Artificias, do qual deriva o algoritmo Learning Vector
Quantization, baseia-se numa rede que representa um conjunto de unidades de entrada/sada ligadas
entre si, onde cada ligao tem um peso associado. Durante a fase de aprendizagem, a rede
aprende, ajustando os pesos para que possa prever a etiqueta da classe correcta das amostras de
entrada. O algoritmo LVQ utiliza o mtodo do algoritmo Nearest Neighbor, na fase de treino para
encontrar o vector de referncia mais perto do vector de aprendizagem retirado do conjunto de
entrada. Os pesos das ligaes do neurnio de sada, ou vector de referncia, so depois adaptados,
dependendo da classe do vector de referncia e do padro de treino coincidirem ou no. Se
coincidem, o vector de referncia movido para mais perto do padro de treino, caso contrrio
movido para mais longe.
Existem algumas ferramentas especializadas na integrao de algoritmos para as tarefas de
Data Mining [9, 11], tais as ferramentas disponveis pelo Oracle [11, 29], SAS [7, 8] e Microsoft [3, 4,
5]. Destas trs ferramentas foi escolhido o Microsoft SQL Server 2005 para a integrao do algoritmo
LVQ, por ser o mais utilizado, e por ter disponvel uma equipa especializada em desenvolvimento
Data Mining que oferece documentao para esta tarefa, bem como a possibilidade de
desenvolvimento do algoritmo e de todo o cdigo de integrao, o que inclui as interfaces aqui
referidas, em duas linguagens: C++ e C#. A ferramenta oferecida pelo SAS, SAS Data Miner era
praticamente invivel, pois no s oferece pouca informao sobre como integrar novos algoritmos
como tem uma linguagem prpria com a qual necessrio que o programador se familiarize. A
ferramenta oferecida pelo Oracle tambm era uma boa opo, mas tem desvantagens, tais como no
ter um grupo de apoio de Data Mining que possa ajudar o programador na tarefa de integrao do
novo algoritmo e o modelo de minerao ser construdo ainda com cdigo desenvolvido pelo
programador, o que torna o processo de construo do modelo mais moroso e menos intuitivo que no

86

Aps a integrao do algoritmo desenvolvido com a ferramenta da Microsoft, verificaram-se as
vantagens que o algoritmo apresentava. Para alm de ser um algoritmo de fcil compreenso, por ser
muito simples e, portanto, simples de programar, gerando prottipos fceis de perceber, o LVQ1 um
algoritmo que faz parte da colectnea de algoritmos desenvolvidos que possui tempos de treino
semelhantes aos algoritmos rvores de Deciso, Naive Bayes e Clustering, dependendo do tamanho
da amostra de treino, e tempos de treino inferiores ao algoritmo Redes Neuronais. Mas a grande
vantagem deste algoritmo encontra-se na observao dos vectores de referncia finais, ou seja, aps
o treino, o utilizador poder consult-los para redefinir os parmetros do algoritmo, de maneira a obter
um maior nmero de classificaes correctas.
A ideia de conseguir integrar um algoritmo simples, fcil de compreender e de programar, rpido e
robusto no reportrio de algoritmos j disponibilizados pela Microsoft foi o que impulsionou este
trabalho, de maneira a oferecer rea de Data Mining mais uma tcnica para previso de variveis e
eventos.

87

7 Anexo: Arquitectura Microsoft SQL Server 2005

A arquitectura Analysis Services [11] pode ser dividida em arquitectura do cliente, usada para
fornecer interfaces a aplicaes de front-end, e arquitectura do servidor, que guarda o mecanismo
que fornece a funcionalidade e o poder desses servios. As arquitecturas do cliente e do servidor tm
componentes separados que so acedidos de maneira diferente. Por exemplo, os servios do cliente
fornecem a funcionalidade necessria para criar componentes locais que so subconjuntos dos
componentes do servidor. Os componentes do servidor fornecem os dados do ncleo e os servios
necessrios para suportar as tarefas do Analysis Services.
7.1.1 Arquitectura do servidor
A arquitectura
1
do Analysis Services [11] do lado do servidor fornece facilidades para criar e
manipular cubos OLAP (que esto fora do mbito desta tese) e modelos de minerao de dados.
Ligaes s fontes de dados, tal como o acesso local segurana, so tambm geridos pelo
servidor. O servidor gere a mecnica do armazenamento de dados medida que os cubos e os
modelos esto a ser processados.
A interface utilizador fornecida pelo Analysis Manager contm Data Transformation Services
(DTS), um servio do Microsoft SQL Server 2005 que limpa e transfere dados, enquanto eles se
movem entre fontes de dados. O Analysis Manager a principal interface utilizador para o Analysis
Services, mas existem outras interfaces de programao que possibilitam as aplicaes
personalizadas de front-end interagir com modelos de objectos COM que controlam a interface do
servidor. Apesar do Analysis Services ter muitas funes que so usadas para minerao de dados,
como mostra a Figura 4.1, algumas das caractersticas do servidor so especialmente desenhadas
para minerao.

Figura 7.1 Arquitectura do servidor de Analysis Services [11]

1

7.1.2 Arquitectura do cliente
O lado do cliente
1
[11] primeiro desenhado para fornecer uma ponte, ou interface, entre as
funes do servidor e as aplicaes personalizadas.
interaces e tambm fornece interfaces ao OLE DB para
conectividade directa a aplicaes Microsoft Visual C++ ou a
Figura 7.2
7.1.3 Fluxo de dados
Esta seco explica o fluxo d
algoritmos. Todos os passos na
encontram dentro dos quadrados ou crculos:
Inicio do servidor
Ao incio, o Analysis Server ir in
ligados, e ir guardar em cache os seus ponteiros da interface
Informao dos algoritmos de minerao
Em resposta aos pedidos de descoberta dos MINING_SERVICES, o servid
fornecedores de algoritmos do Gestor de Algoritmos (representada pela sua interface da cache
correspondente IDMAlgorithmFactory
Criao do modelo de minerao
Quando um modelo de minerao de dados criado, um objecto de metadados instanciado para
ele no servidor e guardado no disco. Neste ponto, ele no tem uma instncia de algoritmo associada.
Contudo, ser validada contra informao obtida da int
de algoritmo correspondente.

1
Microsoft. SQL Server Data Mining: Plug
7.1.2 Arquitectura do cliente
] primeiro desenhado para fornecer uma ponte, ou interface, entre as
funes do servidor e as aplicaes personalizadas. PivotTable Service gere o ponto crucial destas
interaces e tambm fornece interfaces ao OLE DB para Data Mining, o qual
conectividade directa a aplicaes Microsoft Visual C++ ou a ActiveX Data Objects
Arquitectura do cliente do Analysis Services [11]
de dados e o controlo entre o Analysis Server e os fornecedores de
algoritmos. Todos os passos na Figura 4.1 sero descritos, tendo em conta as aces que se
encontram dentro dos quadrados ou crculos:
instanciar todos os fornecedores de algoritmos Plug
ligados, e ir guardar em cache os seus ponteiros da interface IDMAlgorithmFactory
minerao
Em resposta aos pedidos de descoberta dos MINING_SERVICES, o servidor ir iterar pela lista de
IDMAlgorithmFactory) e ir obter a informao relevante atravs da interface
erao
Contudo, ser validada contra informao obtida da interface IDMAlgorithmMetadata

SQL Server Data Mining: Plug-In Algorithms. [Online] [Cited: 08 05, 2008.]
us/library/ms345133.aspx#ssd_topic3.
88
] primeiro desenhado para fornecer uma ponte, ou interface, entre as
gere o ponto crucial destas
, o qual por sua vez fornece
ActiveX Data Objects (ADO).

e os fornecedores de
sero descritos, tendo em conta as aces que se
stanciar todos os fornecedores de algoritmos Plug-in registados e
IDMAlgorithmFactory.
or ir iterar pela lista de
) e ir obter a informao relevante atravs da interface
IDMAlgorithmMetadata do fornecedor

89

Figura 7.3 - Fluxo de dados de um Algoritmo Plug-in [14]
Processamento da estrutura de minerao
Aps um pai do modelo de minerao da estrutura ser processado, o objecto AttributeSet criado
pelo servidor validado contra cada fornecedor do modelo de algoritmo filho para confirmar que o
AttributeSet est numa forma que pode ser consumida pelo algoritmo. Isto levado a cabo invocando
o mtodo ValidateAttributeSet na interface do fornecedor de algoritmo IDMAlgorithmMetadata.
Treino do modelo de minerao
Quando um pedido de processamento levado pelo servidor para um modelo de minerao de
dados, o mtodo CreateAlgorithm no fornecedor do algoritmo correspondente IDMAlgorithmFactory
invocado para criar uma nova instncia do algoritmo associada com o modelo. A interface
IDMAlgorithm na instncia do algoritmo e interfaces relacionadas obtidas dele so usadas pelo
servidor para passar casos, treinar a instncia do algoritmo, e salvar os seus contedos, como
detalhados a seguir:

90

1. A instncia do algoritmo primeiramente inicializada com um objecto AttributeSet
(IDMAttributeSet) que pode ser acedido pelos algoritmos durante o treino para obter
informao sobre os atributos.
2. Depois, o servidor inicia o treino chamando IDMAlgorithm::InsertCases com um parmetro
IDMPushCaseSet. O fornecedor do algoritmo na verdade requerido para implementar um
objecto que expe a interface IDMCaseProcessor que passada ao Analysis Server, em
resposta ao pedido InsertCases, via IDMPushCaseSet::StartCases.
3. Depois do servidor receber o objecto do algoritmo CaseProcessor, empurra casos para ele,
para processamento, invocando o mtodo ProcessCase para cada caso.
Previso do modelo de minerao
Em resposta a uma query de previso, o processador de querys do Analysis Server avalia a
previso usando o mtodo Predict na interface do modelo (IDMAlgorithm::Predict). Chamadas a
funes so avaliadas usando os metadados obtidos atravs da interface do fornecedor do algoritmo
Procura no modelo de minerao
Em resposta aos pedidos de descoberta para MINING_MODEL_CONTENT, o servidor usa uma
chamada interface do correspondente modelo IDMAlgorithm para pedir uma navegao de
contedo de objectos que expe a interface IDMAlgorithmNavigation.
Persistncia do modelo de minerao
A interface ncleo numa instncia do algoritmo IDMAlgorithm pode ser interrogada usando
COM para a interface IDMPersist. Esta interface usada para carregar e guardar os contedos do
algoritmo de e para o espao de armazenamento do objecto do modelo de minerao de dados que
tem a instncia do algoritmo.
Drillthrough do modelo de minerao
Enquanto se percorre o contedo de um modelo de minerao visualizado, um utilizador pode
pedir para ver os casos por debaixo que pertencem a um n particular no grfico de contedos. Se o
algoritmo suporta operaes Drillthrough, o Analysis Server constri uma estrutura de dados interna
associada com o modelo que mapeia casos de treino para corresponderem a ns no contedo do
grfico. De modo a construir esta estrutura para usar durante a procura, o servidor usa o mtodo
IDMAlgorithm::GetNodeIDs para cada caso at ao fim do treino.
Dimenses de minerao de dados
O Analysis Server permite aos utilizadores construir uma dimenso de minerao de dados
baseada no contedo de um modelo de dados. Esta dimenso pode ser includa num cubo OLAP que
usa as mesmas dimenses que o modelo onde foi construdo, e a sua hierarquia descoberta pode ser
usada para deslizar os dados de facto em maneiras interessantes.
Tratamento de erros
Os fornecedores de algoritmos devem fornecer erros padro e popular objectos, IErrorInfo.

91

8 Glossrio

Algoritmos de Data Mining: um algoritmo de data mining um algoritmo matemtico e estatstico
que transforma os casos presentes no conjunto de dados original no modelo de data mining. O visual
do modelo depende do algoritmo de data mining aplicado aos dados.

Aprendizagem Supervisionada: nas tcnicas de Data Mining que usam uma aprendizagem
supervisionada, todos os factores conhecidos, ou variveis de entrada, necessitam de ser dadas para
que o engenho do Data Mining possa encontrar as melhores relaes entre esses atributos para que
uma regra seja construda dentro do modelo de minerao. A previso baseada em valores
desconhecidos ou variveis alvo, significando que o engenho de Data Mining ir encontrar o valor
mais provvel para esses valores desconhecidos, baseado nos valores conhecidos fornecidos com as
variveis de entrada.

Aprendizagem No Supervisionada: as tcnicas que utilizam este tipo de aprendizagem no so
usadas para realizar previses, logo os valores desconhecidos para classificao no so requeridos.
Em vez disso, os dados so colocados num formato que torna mais fcil para ns que eles faam
sentido.

Casos: cada item de dados histricos que usado como fonte para um modelo de minerao de
dados um caso.

Data Mining: o processo de descoberta de padres e relaes importantes atravs da anlise
automatizada e a classificao de largas quantidades de dados histricos guardados nas bases de
dados ou data warehouses.

Data Warehouse: armazm central que guarda os dados que foram extrados dos dados
operacionais.

Matriz de confuso: uma ferramenta de visualizao especialmente utilizada na aprendizagem
supervisionada, para representar os dados conseguidos nas tarefas de previso e classificao. Cada
coluna da matriz representa as instncias numa classe prevista, enquanto que cada linha representa
as instncias numa classe actual. Um dos benefcios da matriz de confuso que se torna fcil ver se
o sistema est a confundir duas classes.

Modelos de Minerao: uma estrutura fsica de um subconjunto de dados compilados de um
algoritmo minerao de dados, juntamente com a descrio do conjunto de dados original. Data
Mining precisa de uma estrutura que contenha os padres presentes nas bases de dadas envolvidas.
Esta estrutura , ento, usada como base para realizar previses baseadas em novos dados para
preencher os espaos em branco deixados pelos valores em falta. Juntando informao do conjunto

92

de dados original, a aplicao de Data Mining constri um subconjunto de dados que compilado
usando um algoritmo de Data Mining. Este conjunto resultado pode ento ser usado para fazer
previses contra o conjunto de dados inicial.

Padres: um padro um conjunto de eventos que ocorre com frequncia suficiente no conjunto de
dados para revelar uma relao entre eles.

Tcnicas de Data Mining: Considera-se uma tcnica de Data Mining cada algoritmo desenvolvido
para esse propsito que execute as tarefas consagradas pelo Data Mining. Existem algumas tcnicas
mais conhecidas e utilizadas como o caso de rvores de Deciso, Nearest Neighbor, Naive Bayes,
Redes Neuronais e Clustering.

Tarefas de Data Mining: Em Data Mining, uma tarefa corresponde a um tipo de problema de
descoberta de conhecimento, para o qual se pretende arranjar uma soluo. Existem vrios tipos de
tarefas, tais como Previso, Classificao, Regresso, Clustering entre outras.

93

9 Bibliografia

[1]. Kohonen, Teuvo. Self-Organizing Maps. s.l. : Springer-Verlag, 1995.
[2]. Kohonen, Teuvo. SelF-Organization and Associative Memory. s.l. : Springer-Verlag, 1989.
[3]. Cortes, Bruno. Sistemas de Suporte Deciso. s.l. : FCA, 2005.
[4]. Marques, Jorge Salvador. Reconhecimento de padres mtodos estatsticos e neuronais. s.l. :
IST-press, 1999.
[5]. S, J.P. Marques de. Pattern Recognition. s.l. : Springer, 2001.
[6]. Haykin, Simon. Neural Networks, A Comprehensive Foundation. s.l. : Prentice Hall, 1999.
[7]. Mitchell, Tom M. Machine Learning. s.l. : McGraw Hill.
[8]. Kimball, Ralph e Ross, Margy. The Data Warehouse Toolkit. Second Edition. s.l. : John Wiley &
Sons, 2002.
[9]. Han, J. and M., Kamber. Data Mining: Concepts and Techniques. s.l. : Morgan Kaufmann, 2001.
[10]. Gamma, Erich, et al. Design Patterns, Elements of Reusable Object-Oriented Software. s.l. :
Addison-Wesley, 1995.
[11]. Seidman, Claude. Data Mining with Microsoft SQL Server 2000. s.l. : Microsoft Press, 2001.
[12]. Application of LVQ to novelty detection using outlier training data. Lee, H. J. e Cho, S. Z. 13,
October de 2006, PRL, Vol. 27, pp. 1572-1579.
[13]. One-dimensional kohonen LVQ nets for multidimensional pattern recognition. Skubalska
Rafajlowicz, E. 2000, International Journal of Applied Mathematics and Computer Science, Vol. 10,
pp. 767-778.
[14]. Comparison of FA LVQ and modified backpropagation in artificial odor discrimination system.
Kusumoputro, B. s.l. : ACTA Press, 1999, In Proceedings of the Eighteenth IASTED International
Conference Modelling, Identification and Control, pp. 434-437.
[15]. Bill classification by using the LVQ method. Kosaka, T., Omatu, S. e Fujinaka, T. s.l. : LTD
Himeji, In Proceedings of the IEEE International Conference on Systems, Man and Cybernetics, Vol.
3, pp. 1430-1435.
[16]. Finite-sample convergence properties of the LVQ1 algorithm and the batch LVQ1 algorithm.
Bermejo, S. e Cobertany, J. 2001, Neural Processing Letters, Vol. 13, pp. 135-157.
[17]. Performance analysis of LVQ algorithms: a statistical physics approach. Ghosh, Anarta, Biehl,
Michael e Hammer, Barbara. July de 2006, Neural Networks archive, Vol. 19, pp. 817-829.
[18]. Russel, S. e Norvig, P. Artificial Intelligence - A Modern Approach. Second Edition. s.l. : Prentice
Hall, 2003.
[19]. Luger, G. L. e Stubblefield, W. A. Artificial Intelligence - Structures and Strategies for Complex
Problem Solving. Second Edition. s.l. : Benjamin/Cummings Publishing, 1993.

DissertacaoMestrado LiciniaMonteiro 53160

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

DissertacaoMestrado LiciniaMonteiro 53160

Загружено:

Авторское право:

Доступные форматы

Algoritmo Plug-in LVQ para Servidor SQL

Licnia Pedro Monteiro

, se e apenas se (|X) > (|X) para , = .

|X). Atravs do teorema de Bayes conclui-se que:

). Caso contrrio maximizava-se (X|

). De forma a reduzir o clculo na avaliao (X|

) podem ser estimadas atravs das amostras de

o nmero de amostras de treino que

) avaliado para cada classe

. A amostra X atribuda classe

. Esta equao recompensa o vector de referncia com a mesma classe.

, = , ., definido por um algoritmo especfico, para

que tem a distncia Euclidiana mais pequena de . suposto a amostra

. Os vectores de referncia podem ser colocados

, = , , ., , as primeiras amostras de podem ser escolhidas. As

com o qual tem a menor distancia -

(). Estes vectores so etiquetados usando um conjunto de

atribudos a essas classes devem cumprir com

ento etiquetado de acordo com a maioria das classes

. Assumindo que o vector de

no domnio do tempo discreto, = ,,, .. O algoritmo de aprendizagem

mais perto modificado de cada vez, mas agora a direco da

, so empurrados para fora das zonas onde a m classificao

() seja atribudo a cada

(vector de referncia), assim obtm-se o seguinte processo

() tem de ser determinado optimamente para uma rpida convergncia das

() pode ser determinado pela recurso:

um pode tomar 0,5, mas bom comear com um valor como o

tem de ser mais

so os vectores de referencia mais

(x) so as respectivas distancias de x a

a classe vizinha, mas pertence a

a segunda classe vizinha; alm

pertencem a classes diferentes, respectivamente, deve estar

pertencem a classes diferentes,

no muda com a aprendizagem contnua.

o vector de aprendizagem e o() uma funo linear que vai

Вам также может понравиться