Cla 2003 Ufrj DSC Tese

INTEGRAÇÃO DE RECURSOS DE DATA MINING COM
GERENCIADORES DE BANCOS DE DADOS RELACIONAIS
Claudio Luiz Curotto
TESE SUBMETIDA AO CORPO DOCENTE DA COORDENAÇÃO DOS PROGRAMAS DE PÓS-

GRADUAÇÃO DE ENGENHARIA DA UNIVERSIDADE FEDERAL DO RIO DE JANEIRO COMO
PARTE DOS REQUISITOS NECESSÁRIOS PARA A OBTENÇÃO DO GRAU DE DOUTOR EM
CIÊNCIAS EM ENGENHARIA CIVIL.
Aprovada por:
___________________________________________________
Prof. Nelson Francisco Favilla Ebecken, D.Sc.
___________________________________________________
Prof. Alexandre Gonçalves Evsukoff, Dr.
___________________________________________________
Prof. Alvaro Luiz Gayoso de Azeredo Coutinho, D.Sc.
___________________________________________________
Profa. Marta Lima de Queirós Mattoso, D.Sc.
___________________________________________________
Prof. Sérgio Scheer, D.Sc.
RIO DE JANEIRO, RJ – BRASIL

MAIO DE 2003
CUROTTO, CLAUDIO LUIZ
Integração de Recursos de Data
Mining com Gerenciadores de Bancos de
Dados Relacionais [Rio de Janeiro] 2003
XV, 217 p. 29,7 cm (COPPE/UFRJ,
D.Sc., Engenharia Civil, 2003)
Tese – Universidade Federal do Rio
de Janeiro, COPPE
1. Mineração de Dados
2. Bancos de Dados Relacionais
3. Classificador Incremental Bayesiano
I. COPPE/UFRJ II. Título (série)
ii
Resumo da Tese apresentada à COPPE/UFRJ como parte dos requisitos necessários
para a obtenção do grau de Doutor em Ciências (D.Sc.)

Maio / 2003
Orientador: Nelson Francisco Favilla Ebecken

Programa: Engenharia Civil
O processo de descoberta de conhecimento em bancos de dados é abordado

sob a ótica da integração com um sistema gerenciador de banco de dados
relacional de uso comercial. As etapas que compõem este processo, ou seja, a
consolidação de dados, a preparação e seleção de dados, a mineração de dados, a
avaliação e a interpretação do conhecimento obtido, são delineadas. A etapa de
mineração de dados é realizada através de um classificador incremental Bayesiano.
Este classificador é formulado para considerar problemas com atributos de dados
contínuos e múltiplos atributos de predição discretos com atualização incremental dos
dados de treinamento. A implementação deste classificador, como um provedor de
recursos de mineração de dados, é apresentada em detalhes. As árvores de decisão
produzidas pelo classificador são visualizadas graficamente através de um Browser
desenvolvido especialmente para esta finalidade. Experimentos computacionais são
realizados para avaliar o comportamento e o desempenho da implementação em
comparação com outros classificadores.
iii
Abstract of Thesis presented to COPPE/UFRJ as a partial fulfillment of the requirements
for the degree of Doctor of Science (D.Sc.)
INTEGRATION OF DATA MINING RESOURCES WITH RELATIONAL

DATABASE MANAGEMENT SYSTEMS
May / 2003
Advisor: Nelson Francisco Favilla Ebecken

Department: Civil Engineering
The process of knowledge discovery in databases is approached from the

perspective of the integration with a commercial relational database management
system. The steps that compose this process: consolidation of data, preparation and
selection of data, data mining, evaluation and interpretation of the achieved
knowledge, are outlined. The data mining step is carried out by an incremental
Bayesian classifier. This classifier is formulated to deal with problems with continuous
input attributes and multiple discrete prediction attributes using incremental update of
the training data set. The implementation of this classifier, as a data mining provider, is
shown in details. The decision trees produced by the classifier are visualized graphically
through a Browser developed specially for this purpose. Computational experiments are
made to evaluate the behavior and the performance of the implementation in
comparison with other classifiers.
iv
DEDICATÓRIA
À minha esposa, Adevanilde, e aos meus filhos, Sandra e Marcio, pelo incentivo
e compreensão pelas incontáveis horas extras, dedicadas a esta tese, que foram
suprimidas do convívio familiar.
v
AGRADECIMENTOS
Ao professor Nelson Francisco Favilla Ebecken pela amizade, incentivo e

orientação precisa e objetiva.
À CAPES – Coordenação de Aperfeiçoamento de Pessoal de Nível Superior e a
UFPR – Universidade Federal do Paraná pelo indispensável suporte financeiro.
A Kris Ganjam, Claude Seidman, Raman Iyer, Peter Kim, Jamie MacLennan e
ZhaoHui Tang, pela valiosa ajuda na elucidação das dúvidas surgidas durante as fases
de implementação computacional e de execução dos experimentos de
desempenho.
A Gary Perlman pelo fornecimento do código fonte do seu sistema |STAT,
utilizado nos experimentos computacionais.
Aos funcionários do CESEC - Centro de Estudos de Engenharia Civil Professor
Inaldo Ayres Vieira da UFPR, Athys Palú da Silva, Elizeu dos Santos e Maristela Bandil
pelo atendimento sempre gentil e eficiente.
À funcionária do Programa de Engenharia Civil da COPPE/UFRJ, Estela Sampaio,
pelo valioso apoio burocrático.
Aos colegas professores do Departamento de Construção Civil da UFPR, Sérgio
Scheer e Ricardo Mendes Jr., pelo apoio e incentivo incondicionais.
Aos amigos Roberto Dalledone Machado e Jorge Luis Milek, companheiros
desde a época do curso de mestrado na COPPE/UFPRJ, no período de 1978 a 1981,
pelo permanente incentivo.
vi
CONTEÚDO
I. Introdução_______________________________________________________________________________ 1
II. Trabalhos Correlatos à Integração da Tecnologia de DM com SGBDs _______________________ 5
II.1 Projeto Quest________________________________________________________________________ 5
II.2 Projeto dbMiner _____________________________________________________________________ 5
II.3 Outros Trabalhos_____________________________________________________________________ 6
II.4 Tecnologia OLE DB DM_______________________________________________________________ 6
III. Processo de KDD ________________________________________________________________________ 8
IV. Classificador SNBi ______________________________________________________________________ 11
IV.1 Formulação do Classificador SNBi ___________________________________________________ 12
IV.2 Algoritmos de Treinamento e Predição do Classificador SNBi__________________________ 15
V. Provedor de Recursos de Mineração de Dados DMclcMine _______________________________ 18
V.1 Sistemas de Integração com SGBDs _________________________________________________ 18
V.1.1 Sistemas Externos ______________________________________________________________ 18
V.1.2 Sistemas Internos ______________________________________________________________ 19
V.1.3 Sistemas Acoplados ___________________________________________________________ 19
V.1.3.1 Sistemas de Acoplamento Íntimo __________________________________________ 19
V.1.3.2 Sistemas de Acoplamento por API _________________________________________ 20
V.2 Tecnologia OLE DB DM _____________________________________________________________ 20
V.3 Arquitetura de Acesso Universal de Dados ___________________________________________ 22
V.4 Ferramentas _______________________________________________________________________ 23
V.5 Implementação do Provedor DMclcMine____________________________________________ 23
V.5.1 Exemplo AllElet ________________________________________________________________ 24
V.5.2 Operações Fundamentais de um Provedor de Recursos de DM __________________ 25
V.5.3 Criando o Modelo de DM ______________________________________________________ 25
V.5.4 Povoando o Modelo de DM ___________________________________________________ 26
V.5.5 Predizendo Atributos___________________________________________________________ 30
V.5.6 Expondo o Modelo de DM _____________________________________________________ 30
VI. Experimentos Computacionais__________________________________________________________ 34
VI.1 Waveform - Reconhecimento de Formas de Onda __________________________________ 35
VI.2 Meteo - Previsão de Tempo ________________________________________________________ 39
VI.3 Insurance - Dados de Seguro de Vida _______________________________________________ 41
VI.3.1 Dados Preparados ____________________________________________________________ 42
VI.3.2 Dados Originais _______________________________________________________________ 44
VI.4 Estudo de Desempenho____________________________________________________________ 45
VI.4.1 Variação do Número de Atributos de Dados ___________________________________ 45
VI.4.2 Variação do Número de Casos ________________________________________________ 46
VI.4.3 Variação do Número de Estados dos Atributos de Dados________________________ 51
VI.4.4 Variação do Número de Atributos de Predição _________________________________ 52
vii
VII. Conclusão ____________________________________________________________________________ 53
VIII. Trabalhos Futuros______________________________________________________________________ 54
Referências_______________________________________________________________________________ 55
Referências Complementares _____________________________________________________________ 65
Apêndice A. Classificador Bayesiano Simples _______________________________________________ 78
Apêndice B. Tecnologia OLE DB ___________________________________________________________ 82
Apêndice C. Detalhes da Implementação _________________________________________________ 84
C.1 Preparando o Ambiente de Desenvolvimento _______________________________________ 84
C.2 Kit de Recursos OLE DB DM _________________________________________________________ 85
C.3 Implementando o Provedor Exemplo________________________________________________ 86
C.4 Nomeando Variáveis_______________________________________________________________ 88
C.5 Implementando o Modo de Funcionamento Isolado _________________________________ 89
C.6 Criando um Novo Provedor_________________________________________________________ 91
C.7 Modificando o Nome de um Algoritmo______________________________________________ 93
C.8 Corrigindo os Arquivos de Análise de Comandos_____________________________________ 94
C.9 Implementando um Novo Algoritmo ________________________________________________ 94
C.10 Inserindo Suporte para uma Nova Propriedade _____________________________________ 96
C.11 Inserindo Códigos de Erros_________________________________________________________ 96
C.12 Armazenando e Recuperando Arquivos XML _______________________________________ 97
C.13 Corrigindo Erros de Programação __________________________________________________ 98
C.13.1 Executando _________________________________________________________________ 99
C.13.2 Removendo Arquivos Indesejados ____________________________________________ 99
C.14 Construindo a Versão Final _______________________________________________________ 100
C.15 Arquivos Modificados ____________________________________________________________ 101
C.16 Listagens ________________________________________________________________________ 104
Apêndice D. Parâmetros do Classificador MSDT____________________________________________ 152
D.1 COMPLEXITY_PENALTY _____________________________________________________________ 152
D.2 MINIMUM_LEAF_CASES ____________________________________________________________ 152
D.3 SCORE_METHOD __________________________________________________________________ 152
D.4 SPLIT_METHOD ____________________________________________________________________ 153
Apêndice E. Detalhes dos Experimentos Computacionais __________________________________ 154
E.1 Utilitários DTS ______________________________________________________________________ 154
E.2 Waveform - Reconhecimento de Formas de Onda __________________________________ 155
E.2.1 Geração de Dados ___________________________________________________________ 158
E.2.2 Criação do Banco de Dados __________________________________________________ 161
E.2.3 Utilitários DTS__________________________________________________________________ 165
E.2.4 Comandos SQL DM ___________________________________________________________ 168
E.3 Meteo - Previsão de Tempo ________________________________________________________ 169
E.3.3 Comandos SQL DM ___________________________________________________________ 178
E.4 Insurance - Dados de Seguro de Vida_______________________________________________ 180
viii
E.4.3 Comandos SQL DM ___________________________________________________________ 203
E.5 Estudo de Desempenho ___________________________________________________________ 206
E.5.1 Geração de Dados ___________________________________________________________ 206
E.5.4 Comandos SQL DM ___________________________________________________________ 215
ix
FIGURAS
Figura III.1. Etapas do processo de KDD............................................................................................................................ 8

Figura III.2. O Processo de KDD no contexto de solução de um problema ............................................................ 10
Figura V.1. Arquitetura de acesso universal de dados................................................................................................. 22
Figura V.2. AllElet - Árvores do modelo para os atributos de predição..................................................................... 31
Figura V.3. AllElet - Árvore do atributo de predição BuysComputer.......................................................................... 32
Figura V.4. AllElet - Conteúdo da tabela virtual do modelo de DM .......................................................................... 33
Figura V.5. AllElet – Árvore do atributo de predição BuysComputer exibida pelo Internet Explorer.................... 33
Figura VI.1. Waveform - Tempo de treinamento x Número de casos........................................................................ 38
Figura VI.2. Desempenho - Tempo de treinamento x Número de atributos de dados .......................................... 46
Figura VI.3. Desempenho - Tempo de treinamento x Número de casos .................................................................. 48
Figura VI.4. Desempenho - Tempo de predição x Número de casos........................................................................ 49
Figura VI.5. Desempenho – Incremental - Tempo de treinamento x Número de casos......................................... 50
Figura VI.6. Desempenho - Tempo de treinamento x Número de estados dos atributos de dados .................... 51
Figura VI.7. Desempenho - Tempo de treinamento x Número de atributos de predição ..................................... 52
Figura B.1. Arquitetura OLE DB .......................................................................................................................................... 82
Figura E.1. Meteo – DTS – Importação de dados......................................................................................................... 154
Figura E.2. Forma de onda 1 ........................................................................................................................................... 155
Figura E.5. Waveform – Primeiros 3 casos da classe 0................................................................................................. 157
Figura E.8. Waveform – Processamento completo do primeiro procedimento..................................................... 165
Figura E.9. Waveform – Importação de dados............................................................................................................ 166
Figura E.10. Waveform – Processamento do treinamento e predição do classificador MSDT1........................... 167
Figura E.11. Waveform – Processamento da validação cruzada ............................................................................ 168
Figura E.12. Waveform – Importação de dados em blocos...................................................................................... 168
Figura E.13. Meteo – Processamento completo do primeiro procedimento.......................................................... 176
Figura E.14. Meteo – DTS – Importação de dados ...................................................................................................... 176
Figura E.15. Insurance - Diagrama de relacionamentos entre as tabelas originais............................................... 180
Figura E.16. Insurance – DTS – Dados Originais - Importação de dados.................................................................. 202
Figura E.17. Insurance – DTS – Dados Originais - Montagem dos dados ................................................................. 202
Figura E.18. VarNumCases – Tarefa de predição por partes do classificador SNBi ............................................... 213
Figura E.19. VarNumCases – Processamento das tarefas de predição por partes do classificador SNBi .......... 213
Figura E.20. VarNumCases – Tarefa de treinamento do classificador SNBi ............................................................. 215
x
TABELAS
Tabela V.1. AllElet - Dados de treinamento.................................................................................................................... 24

Tabela V.2. AllElet - Estatísticas do modelo marginal.................................................................................................... 25
Tabela VI.1. Waveform - Parâmetros dos classificadores utilizados ........................................................................... 36
Tabela VI.2. Waveform - Tempos de processamento (s) ............................................................................................. 37
Tabela VI.3. Waveform - Acurácia (%) ............................................................................................................................ 38
Tabela VI.4. Waveform - Tempos de processamento (s) da validação cruzada.................................................... 39
Tabela VI.5. Waveform - Acurácia (%) da validação cruzada................................................................................... 39
Tabela VI.6. Meteo - Parâmetros dos classificadores utilizados .................................................................................. 40
Tabela VI.7. Meteo - Tempos de processamento (s) .................................................................................................... 40
Tabela VI.8. Meteo - Acurácia (%) ................................................................................................................................... 40
Tabela VI.9. Meteo - Tempos de processamento (s) da validação cruzada........................................................... 41
Tabela VI.10. Meteo - Acurácia (%) da validação cruzada ....................................................................................... 41
Tabela VI.11. Insurance - Parâmetros dos classificadores utilizados .......................................................................... 42
Tabela VI.12. Insurance - dados preparados - Tempos de processamento (s)........................................................ 42
Tabela VI.13. Insurance – dados preparados - Acurácia (%)...................................................................................... 42
Tabela VI.14. Insurance – dados preparados - Tempos de processamento (s) da validação cruzada ............. 43
Tabela VI.15. Insurance – dados preparados - Acurácia (%) da validação cruzada ............................................ 43
Tabela VI.16. Insurance - dados originais - Tempos de Processamento (s)............................................................... 44
Tabela VI.17. Insurance - dados originais - Acurácia (%) ............................................................................................. 44
Tabela VI.18. Insurance – dados originais - Tempos de Processamento (s) da validação cruzada .................... 44
Tabela VI.19. Insurance – dados originais - Acurácia (%) da validação cruzada................................................... 44
Tabela VI.20. Desempenho - Parâmetros dos classificadores utilizados.................................................................... 45
Tabela B.1. Componentes OLE DB ................................................................................................................................... 83
Tabela C.1. Prefixos de alguns tipos de variáveis.......................................................................................................... 89
Tabela C-2 – Relação de Arquivos Modificados ......................................................................................................... 101
Tabela E.1. Waveform - Comandos SQL DM para criação do modelo de DM..................................................... 169
Tabela E.2. Meteo - Descrição dos atributos dos dados meteorológicos .............................................................. 170
Tabela E.3. Meteo - Comandos SQL DM para criação do modelo de DM............................................................ 178
Tabela E.4. Insurance - Descrição dos atributos .......................................................................................................... 181
Tabela E.5. Insurance - dados preparados - Comandos SQL DM para criação do modelo de DM ................. 203
Tabela E.6. Insurance - dados originais - Comandos SQL DM para criação do modelo de DM........................ 204
Tabela E.7. Parâmetros para o programa DATGEN .................................................................................................... 206
Tabela E.8. VarInpAtt - Comandos SQL DM para criação do modelo de DM com 12 atributos de dados..... 215
Tabela E.9. VarNumCases - Comandos SQL DM para criação do modelo de DM .............................................. 215
Tabela E.10. VarStates - Comandos SQL DM para criação do modelo de DM..................................................... 216
Tabela E.11. VarPredAtt - Comandos SQL DM para criação do modelo de DM com 32 atributos de predição
.................................................................................................................................................................................... 217
xi
LISTAGENS
Listagem IV.1. Algoritmo de treinamento do classificador SNBi .................................................................................. 15

Listagem IV.2. Algoritmo de predição do classificador SNBi ....................................................................................... 16
Listagem V.1. AllElet - Arquivo XML de criação do modelo de DM ........................................................................... 26
Listagem V.2. AllElet - Arquivo XML do modelo completo de DM.............................................................................. 27
Listagem C.1. Arquivo DMMStatistics.h.......................................................................................................................... 104
Listagem C.2. Arquivo SNaiveBayes.cpp ...................................................................................................................... 106
Listagem C.3. Arquivo SNaiveBayes.hpp ...................................................................................................................... 145
Listagem E.1. Waveform - Programa gerador de dados ........................................................................................... 158
Listagem E.2. Waveform - Script gerador do banco de dados ................................................................................ 161
Listagem E.3. Script de inicialização do contador de registros................................................................................. 166
Listagem E.4. Waveform - Importação de dados do arquivo texto ........................................................................ 167
Listagem E.5. Waveform - Script de repetição das tarefas da validação cruzada .............................................. 168
Listagem E.6. Waveform - Comando SQL DM para predição dos dados de teste, classificador SNBi .............. 169
Listagem E.7. Meteo - Script gerador do banco de dados....................................................................................... 171
Listagem E.8. Meteo - Importação de dados do arquivo texto ............................................................................... 177
Listagem E.9. Meteo - Comando SQL DM para predição dos dados de teste, classificador SNBi1.................... 179
Listagem E.10. Insurance - Script gerador do banco de dados preparados ......................................................... 187
Listagem E.11. Insurance - Script gerador do banco de dados original ................................................................. 192
Listagem E.12. Insurance - dados preparados - Comando SQL DM para predição dos dados de teste,
classificador SNBi ...................................................................................................................................................... 204
Listagem E.13. Insurance - dados originais - Comando SQL DM para predição dos dados de teste,
classificador SNBi ...................................................................................................................................................... 205
Listagem E.14. Funções para o programa DATGEN.................................................................................................... 206
Listagem E.15. VarInpAtt - Script gerador do banco de dados................................................................................ 207
Listagem E.16. VarNumCases - Script gerador do banco de dados ....................................................................... 208
Listagem E.17. VarStates - Script gerador do banco de dados................................................................................ 210
Listagem E.18. VarPredAtt - Script gerador do banco de dados ............................................................................. 212
Listagem E.19. Script de inicialização de repetição de tarefas................................................................................ 214
Listagem E.20. Script de repetição de tarefas ............................................................................................................. 214
Listagem E.21. VarNumCases - Comando SQL DM para predição dos dados de teste, classificador SNBi ..... 216
xii
CONVENÇÕES
Exemplo Descrição
Internet Textos em itálico indicam palavras de outros idiomas.

Quando necessário, se o texto não for de uso comum, a
explicação em português é incluída entre parênteses ou
vice-versa. Também utilizado nas referências
bibliográficas de acordo com as normas vigentes da
COPPE.
DMclcMine Fonte utilizada para representar hyperlinks (vínculos de

hipertexto) que apontam para um endereço da Internet;
para uma descrição de símbolo ou sigla; ou para uma
referência bibliográfica.
API (interface de programação As siglas (acrônimos) são descritas entre parênteses na

entre aplicativos) primeira vez que aparecem. Além disso contêm hyperlinks
para a descrição correspondente na tabela de símbolos
e siglas.
1 Fonte utilizada para representar valores constantes de

fórmulas.
n Fonte utilizada para representar variáveis de fórmulas.
clcMine Fonte utilizada para nomes em geral, incluindo nomes de

arquivos, funções, opções de compilação, etc.
void initialize() Fonte utilizada para listagem de programas em geral,

{ comandos e scripts SQL, procedimentos armazenados e
int i,j; scripts Visual Basic®.
char command[100];
Para j = 0, mt Fonte utilizada para listagem de algoritmos.
Recupere s tj
xiii
SIGLAS
Sigla Descrição em inglês Descrição
ADO ActiveX Data Objects Interface de programação entre

aplicativos para manipulação de
dados através de objetos
API Application Programming Interface Interface de Programação entre

Aplicativos
C45 C4.5 Classifier Classificador de Árvores de Decisão

C4.5 (QUINLAN, 19932)
CRISP-DM CRoss-Industry Standard Process for Padrão interindustrial para o

Data Mining processamento de tarefas de
mineração de dados
DLL Dynamic Link Library Arquivo que contém funções que são
vinculadas ao aplicativo que as utiliza
em tempo de execução
DM Data Mining Mineração de Dados
DMclcMine clcMine OLE DB Data Mining Provider Provedor OLE DB de Recursos de

Mineração de Dados de Claudio Luiz
Curotto
DMQL Data Mining Query Language Linguagem Estruturada de Consultas

para Mineração de Dados
DTS Data Transformation Services Conjunto de ferramentas gráficas e

objetos programáveis para
transformação de dados no MSSQL
EOS Earth Observing System Sistema de Observação Terrestre
IIS Internet Information Services Servidor de Informações Internet
KDD Knowledge Discovery in Databases Descoberta de Conhecimento em

Bancos de Dados
MDAC Microsoft® Data Access Components Componentes de Acesso de Dados

da Microsoft®
MSDT Microsoft® Decision Trees Classificador de Árvores de Decisão

do Provedor MSDMine (CHICKERING,
GEIGER & HECKERMAN, 1994)
ML Machine Learning Aprendizado de Máquina
MOLAP Multidimensional OLAP Modo de armazenamento

multidimensional para dimensões de
cubos para OLAP
MSDMine Microsoft® OLE DB Provider for Data Provedor OLE DB de recursos de

Mining Services Mineração de Dados da Microsoft®
MSJet Microsoft® Jet OLE DB Provider Provedor OLE DB de dados do

Access®, Excel®, FoxPro® e outros
MSOLAP Microsoft® OLE DB Provider for Analysis Provedor OLE DB de serviços de

Services análise do MSSQL
MSSQL Microsoft® SQL Server™ Sistema Gerenciador de Banco de

Dados da Microsoft®
xiv
Sigla Descrição em inglês Descrição
NASA National Aeronautics & Space Instituto de Pesquisa Espacial e

Administration Aeronáutica dos EUA
OCI Oracle® Call Interface Interface de chamadas de

procedimentos da Oracle®
OLAP Online Analytical Processing Processamento Analítico em Tempo

Real
OLE Object Linking and Embedding Tecnologia de objeto de sistemas

extensíveis para integração de
recursos entre aplicativos com
arquitetura que suporta novos projetos
OLE DB Object Linking and Embedding Conjunto de interfaces que permite a

Database integração de recursos de bancos de
dados entre aplicativos
OLE DB DM Object Linking and Embedding Conjunto de interfaces que permite a

Database for Data Mining integração de recursos de mineração
de dados entre aplicativos
PL Programming Language Linguagem de Programação
PMML Predictive Model Markup Language Linguagem de marcação para

modelos estatísticos e de mineração
de dados baseada em XML
ROLAP Relational OLAP Modo de armazenamento relacional

para dimensões de cubos para OLAP
SNBi Simple Naïve Bayes Incremental Classificador Incremental Bayesiano

do Provedor DMclcMine
SGBD Database management system Sistema Gerenciador de Banco de

Dados
SQL Structured Query Language Linguagem Estruturada de Consultas
SQL DM Structured Query Language for Data Linguagem Estruturada de Consultas

Mining para Mineração de Dados da
especificação OLE DB DM
SQLOLEDB Microsoft® OLE DB Provider for SQL Provedor OLE DB de Dados do MSSQL
Server
UDA Universal Data Access Acesso Universal de Dados
XML Extensible Markup Language Linguagem de Marcação Extensível
WEKA Waikato Environment for Knowledge Ambiente de Análise de

Analysis Conhecimento da Universidade de
Waikato
xv
I. Introdução
O explosivo crescimento dos bancos de dados científicos e comerciais, bem

como a ampliação das áreas de aplicação (FAYYAD, PIATETSKY-SHAPIRO & SMYTH,
1995, 19961,2), motivam o desenvolvimento de tecnologia de KDD (Knowledge
Discovery in Databases) para a descoberta de conhecimento em bancos de dados.
Como áreas de aplicações comerciais podem ser citadas as seguintes:
• comercialização: segmentação, localização de consumidores, identificação
de hábitos de consumo (SFORNA, 2000);
• financeira: apoio para investimentos (BECERRA-FERNANDEZ, ZANAKIS &
WALCZAK, 2002), controle de carteira de ações (QUAH & SRINIVASAN, 1999);
• bancária: política de aprovação de crédito (BAESENS et alii, 2002);
• segurança: detecção de bombas, icebergs e fraudes (MAES et alii, 2002);
• manufatura: modelagem e controle de processos (ROUSU, ELOMAA & AARTS,
1999), controle de qualidade, alocação de recursos;
• Internet: ferramentas de busca, navegação, extração de dados (CRAVEN
et alii, 2000);
• gerencial: tomadas de decisão, gerenciamento de documentos (AGRAWAL,
BAYARDO JR. & SRIKANT, 1999; CHAKRABARTI et alii, 1997);
Entre os exemplos comerciais significativos podem ser citados: o da rede Wal-
Mart, que acumula dados de 20 milhões de transações diárias sendo um dos maiores
bancos de dados do gênero conhecidos; e o da Mobil Oil Corporation que possui um
banco de dados capaz de armazenar 100 terabytes de dados relacionados com a
exploração de petróleo.
Algumas áreas de aplicação científica são listadas a seguir:
• ciências e medicina: descoberta de hipóteses, predição, classificação
(QUINLAN, 19931; PARPINELLI, LOPES H.S. & FREITAS, 2001) e diagnóstico
(BOJARCZUK, LOPES & FREITAS, 1999, 2000);
• engenharia: simulação e análise, reconhecimento de padrões,
processamento de sinais, planejamento (VANIER & DANYLO, 19981,2; CHAU
et alii, 2003);
Entre os exemplos científicos, podem ser lembrados: o projeto do genoma
humano que já coletou gigabytes de dados do código genético humano; e o projeto
EOS (Earth Observing System) da NASA (National Aeronautics & Space Administration)
(KING & GREENSTONE, 1999), que produz a fabulosa quantia de 528 gigabytes de
dados por dia!
Por outro lado atualmente existem SGBDs (Sistemas Gerenciadores de Bancos de
Dados) comerciais, como o MSSQL (Microsoft® SQL (Structured Query Language)
1
Server™ 2000 Enterprise) (MICROSOFT, 20001), que possuem recursos para manipulação
de terabytes de dados com processamento paralelo de consultas (através de
múltiplos servidores com multiprocessadores) utilizando microcomputadores
(MICROSOFT, 19981).
Este SGBD pode ser utilizado em servidores equipados com até 32 processadores
e 64 gigabytes de memória. Aplicações que exigem o processamento de uma
quantidade muito elevada de dados podem fazer uso de uma federação de
servidores (agrupamento de servidores que trabalham em conjunto). Recursos de
OLAP (Online Analytical Processing) e de DM (Data Mining) são disponibilizados através
do módulo de Serviços de Análise (Analysis Services) do MSSQL.
Os recursos de DM são integrados internamente com as fontes de dados
relacionais e os cubos de dados de OLAP, sendo implementados com o uso da
tecnologia OLE DB DM (Object Linking and Embedding Database for Data Mining), que
são um conjunto de interfaces que permite a integração de recursos de DM entre
aplicativos (MICROSOFT, 20002, 2002; SEIDMAN, 2001; VILLE, 2001). Novos recursos de
DM podem ser implementados por pesquisadores e desenvolvedores de software
através desta tecnologia (NETZ et alii, 2000, 2001; FAYYAD, CHAUDHURI & BRADLEY,
2000; SETH, 2001).
Esta conjuntura sugere estudos sobre a integração de SGBDs com a tecnologia
de KDD com a finalidade de ampliar o alcance desta tecnologia mediante custos
acessíveis, através da utilização de microcomputadores.
Esta integração, realizada através do acoplamento de técnicas de DM e OLAP
em ambientes de desenvolvimento de aplicativos de bancos de dados, é assunto de
interesse atual, tendo sido abordado em trabalhos apresentados em vários congressos,
tais como:
• Data Mining 1998 (International Conference on Data Mining), ocorrido em
Setembro / 1998 no Rio de Janeiro – Brasil;
• Data Mining 2000 (Second International Conference on Data Mining Methods
and Databases for Engineering, Finance and other Fields), ocorrido em Julho /
2000 em Cambridge – Inglaterra;
• KDD-2001 (The Seventh ACM SIGKDD International Conference on Knowledge
Discovery and Data Mining) realizado em Agosto / 2001 em São Francisco -
Califórnia – EUA;
• ICDM'01 (The 2001 IEEE International Conference on Data Mining) realizado no
Vale do Silício, Califórnia, EUA em Novembro / 2001;
• KDD-2002 (The Eighth ACM SIGKDD International Conference on Knowledge
Discovery and Data Mining) realizado em Julho / 2002 em Edmonton - Alberta
– Canadá;
2
• Data Mining 2002 (Third International Conference on Data Mining Methods
and Databases for Engineering, Finance and Other Fields), ocorrido em
Setembro / 2002 em Bolonha – Itália;
• ICDM'02 (The 2002 IEEE International Conference on Data Mining) realizado em
Maebashi, Japão em Dezembro / 2002.
Este esforço para disponibilizar recursos agrupados de KDD com custo acessível,
também poder ser encontrado no trabalho realizado pela Universidade Waikato de
Hamilton, Nova Zelândia, que criou o sistema WEKA (Waikato Environment for
Knowledge Analysis), uma ferramenta que agrega vários algoritmos de DM
implementados em linguagem JAVA (WITTEN & FRANK, 2000). No entanto em
contraponto à grande vantagem proporcionada pela portabilidade, existe o baixo
desempenho introduzido pelo uso das Máquinas Virtuais JAVA.
Assim, o objetivo principal desta tese é conseguir uma forte integração de
recursos de DM com um SGBD relacional de uso comercial, desenvolvendo e
implementando um algoritmo de DM com recursos que possam ser utilizados de forma
direta e transparente por este SGBD e por outros aplicativos.
Os trabalhos correlatos à integração de recursos de DM com SGBDs são
discutidos no capítulo II.
As diversas etapas do processo de KDD e a inserção deste processo no contexto
da solução de um problema, são descritos no capítulo III.
Os algoritmos de treinamento e predição do classificador SNBi (Simple Naïve
Bayes Incremental), um classificador Bayesiano, com atributos de dados contínuos,
múltiplos atributos de predição e atualização incremental dos dados de treinamento,
são mostrados no capítulo IV.
A implementação deste classificador, normalizada por uma especificação
adequada, como um provedor de recursos de DM, que pode ser utilizado tanto por
um aplicativo isolado, como por um SGBD, como parte integrante do mesmo, é
apresentada em detalhes no capítulo V, juntamente com a lista das ferramentas
utilizadas para realizar esta implementação e os experimentos computacionais.
Também neste capítulo são apresentados procedimentos para visualização, através
da Internet, de múltiplas árvores de decisão produzidas por provedores de recursos de
DM.
Experimentos computacionais, realizados para avaliar o comportamento da
implementação em comparação com outros classificadores, são mostrados no
capítulo VI.
As conclusões são listadas no capítulo VII juntamente com o resumo das
contribuições desta tese.
3
Sugestões para o desenvolvimento de trabalhos futuros são encontradas no
capítulo VIII.
Encerrando, são incluídas todas as referências citadas ao longo do texto, bem
como as referências complementares que foram utilizadas como base de formação
para a composição desta tese.
Como complemento, vários apêndices são incluídos para descrever os detalhes:
da formulação do Classificador Bayesiano Simples (Apêndice A); da implementação
do provedor de recursos de DM com os respectivos códigos fonte (Apêndice C); e dos
dados e procedimentos dos experimentos computacionais (Apêndice E).
A documentação essencial da tecnologia OLE DB, que fundamenta a
tecnologia OLE DB DM é descrita no Apêndice B e os parâmetros do classificador MSDT
(Microsoft® Decision Trees) utilizados nos experimentos computacionais, são listados no
Apêndice D.
4
II. Trabalhos Correlatos à Integração da Tecnologia de DM
comVisando
SGBDsa escolha da abordagem mais adequada para a integração da
tecnologia de DM com SGBDs, foram estudadas as várias abordagens existentes,
conforme mostram as citações dos trabalhos mostradas a seguir. As vantagens e
desvantagens destas abordagens são destacadas no capítulo V.
II.1 Projeto Quest
Vários trabalhos foram desenvolvidos dentro do contexto do Projeto Quest

(AGRAWAL et alii, 19961), do centro de pesquisas da IBM®, visando a integração da
tecnologia de DM com SGBDs.
AGRAWAL et alii (1992), apresentaram um algoritmo de árvores de decisão para
problemas de classificação por intervalos. Este classificador foi projetado para possuir
uma interface eficiente com um SGBD através de consultas SQL.
AGRAWAL, IMIELINSKI & SWAMI (19931) e AGRAWAL & SRIKANT (19941) reportaram
a implementação de funcionalidades de processamento de consultas para
descoberta de regras de associação em bancos de dados de grande capacidade.
Outros trabalhos (AGRAWAL, FALOUTSOS & SWAMI, 1993; AGRAWAL & SRIKANT,
19942; AGRAWAL et alii, 19952) mostraram um método para buscas de similaridades em
seqüências cronológicas.
Os três tipos de problemas citados acima, classificação, associação e
seqüências, bem como uma abordagem para combinar estas operações visando a
integração com um SGBD, foram apresentados por AGRAWAL, IMIELINSKI & SWAMI
(19932).
AGRAWAL & SHIM (1995) apresentaram uma metodologia para acoplamento de
um aplicativo de DM com um SGBD relacional - IBM® DB2®/CS – baseada na
utilização de funções SQL criadas pelo usuário (user-defined functions) e
procedimentos armazenados (stored procedures).
Em um trabalho posterior (SARAWAGI, THOMAS & AGRAWAL, 1998) foram
consideradas várias alternativas de arquitetura para realizar esse acoplamento.
II.2 Projeto dbMiner
Um grupo de pesquisadores da Universidade Simon Fraser de Burnaby, British

Columbia, Canadá desenvolveu uma série de trabalhos de integração de técnicas de
DM com OLAP.
Um destes trabalhos (CHEN, HAN & YU, 1996) apresentou uma excelente resenha
de técnicas de DM desenvolvidas sob a perspectiva do interesse de uso em SGBDs.
5
Outro trabalho (HAN et alii, 19961) mostrou um anteprojeto da DMQL (Data
Mining Query Language), uma linguagem de consultas para DM.
Vários outros trabalhos (HAN, 1997; HAN, CHEE & CHIANG, 1998; STEFANOVIC,
1997; TAM, 1998; ZHU, 1998; CHEN, 1999) mostraram o uso de técnicas de OLAP
implementadas em um SGBD com recursos de DM.
Todos estes trabalhos foram desenvolvidos no contexto do sistema dbMiner (HAN
et alii, 199623; HAN & KAMBER, 2001), um projeto de pesquisa que evoluiu para um
produto comercial (DBMINER, 2002).
II.3 Outros Trabalhos
JOHN (1997) forneceu algumas sugestões relativas ao uso de SQL por algoritmos
de ML (Machine Learning), com a finalidade de integrar estes algoritmos com SGBDs.
FREITAS & LAVINGTON (19961,2,3,4) e FREITAS (19971,2,3) mostraram em vários
trabalhos pesquisas para definir primitivas de SQL adequadas ao uso por algoritmos de
DM.
SOUSA (1998) e SOUSA, MATTOSO & EBECKEN (19981,2,3) apresentaram uma
implementação de um algoritmo de classificação através de árvores de decisão,
utilizando um conjunto de procedimentos armazenados escritos na linguagem
proprietária PL/SQL, em um servidor de processamento paralelo da Oracle®.
BEZERRA & XEXÉO (1998, 1999) e BEZERRA (1999) mostraram trabalhos de
implementação de funcionalidades internas para extração e armazenamento de
regras em um SGBD de uso experimental.
II.4 Tecnologia OLE DB DM
Com a colaboração de dezenas de pesquisadores foi elaborada e publicada

em Julho de 2000 a especificação da tecnologia OLE DB DM (MICROSOFT, 20002). Esta
especificação define um padrão industrial para DM tal que diferentes algoritmos de
DM implementados por diversos desenvolvedores possam ser facilmente embutidos
em aplicativos de usuários, especificando a API (Application Programming Interface)
entre consumidores de DM (aplicativos que utilizam recursos de DM) e provedores de
recursos de DM (pacotes de software que fornecem algoritmos de DM).
Em Setembro de 2000, o MSSQL 2000 (MICROSOFT, 20001) foi lançado com um
importante componente: o módulo de Serviços de Análise. Incluso, o primeiro
provedor de recursos de DM, com dois algoritmos implementados: um para problemas
de classificação através de árvores de decisão (CHICKERING, GEIGER & HECKERMAN,
1994) e outro para problemas de clusterização (BRADLEY, FAYYAD & REINA, 1999).
6
Em Março de 2001, o recurso de agregação de provedores de recursos de DM
do MSSQL Analysis Services foi incluído no Service Pack 1 (pacote de atualização de
software) (SETH, 2001).
Completando o conjunto de ferramentas, o kit de recursos OLE DB DM
(MICROSOFT, 2002) foi lançado em Junho de 2001 e atualizado em Março de 2002.
Este kit inclui o código fonte de um provedor de recursos de DM que implementa o
Classificador Bayesiano Simples para atributos discretos.
NETZ et alii (2000, 2001) e FAYYAD, CHAUDHURI & BRADLEY (2000) apresentaram
trabalhos descrevendo a tecnologia OLE DB DM. SEIDMAN (2001) publicou um
excelente manual de referência para o uso desta tecnologia.
7
III. Processo de KDD
De acordo com FAYYAD, PIATETSKY-SHAPIRO & SMYTH (19961) a tecnologia de

KDD se refere ao processo global de descoberta de conhecimento útil de dados,
composto por várias etapas, enquanto que a tecnologia de DM se refere a apenas
uma destas etapas, na qual são utilizados os algoritmos de extração de padrões dos
dados. Outras etapas do processo de KDD (tais como a incorporação de
conhecimentos prévios e a interpretação dos resultados) são essenciais para garantir
que a informação útil (conhecimento) é deduzida a partir dos dados. Nesta tese será
adotada esta definição.
No entanto, conforme pode ser observado na literatura existente, vários autores,
principalmente de ambientes comerciais, utilizam o termo Data Mining em um sentido
mais amplo, representando todo o processo de KDD, ao invés de apenas uma etapa
deste processo.
Interpretação e Avaliação
Conhecimento
Mineração dos Dados
p(x)=0.02
Seleção e Pré-processamento
Padrões e Modelos
Consolidação de Dados
Warehouse Dados Preparados
Dados Consolidados
Fontes de Dados
Figura III.1. Etapas do processo de KDD (FAYYAD, PIATETSKY-SHAPIRO & SMYTH, 19961,2)
O processo de KDD com suas várias etapas pode ser visto na Figura III.1. Estas
etapas e as tarefas correspondentes são descritas sucintamente como segue:
1. Consolidação de Dados: A partir de fontes diversas, os dados são consolidados
em um repositório de dados (data warehouse) (SETH, GUATAM & BALINT, 2002).
a. Criar ou escolher um banco de dados de trabalho;
b. Definir o subconjunto de atributos;
c. Remover as exceções óbvias;
8
d. Definir a estratégia de abordagem de valores de atributos ausentes;
e. Determinar as probabilidades prévias de classes.
2. Seleção e Pré-processamento (PYLE, 1999).
a. Gerar uma amostragem de dados: escolher o método de amostragem;
considerar a complexidade da amostragem; tratar das questões dos erros
sistemáticos;
b. Reduzir a dimensionalidade de atributos: remover redundâncias e
correlações de atributos; combinar atributos (somar, multiplicar, subtrair);
c. Reduzir intervalo de atributos: agrupar valores de atributos discretos;
quantificar valores de atributos contínuos;
d. Transformar dados: descorrelacionar e normalizar valores, mapear séries
temporais para representações estáticas;
e. Codificar dados: organizar os dados de forma apropriada para o uso pela
ferramenta de DM; continuar o processo de redução de
dimensionalidade sem que haja perda de informação.
3. Mineração dos Dados (MENESES & GRINSTEIN, 1998).
a. Escolher a tarefa de mineração: classificação, regressão, agrupamento,
associação, sumarização;
b. Escolher o algoritmo de mineração: Redes Neurais Artificiais; Sistemas
Indutivos de Árvores de Decisão e Regras de Produção; Algoritmos
Genéticos; Algoritmos de Agrupamento do Vizinho Mais Próximo;
Algoritmos Estatísticos (Paramétricos e não paramétricos).
4. Interpretação e Avaliação (NAGAI, 2000).
a. Avaliação: Validação estatística e testes de significância; Revisão
qualitativa por especialistas; Pesquisas piloto para avaliar a acurácia do
modelo;
b. Interpretação: Modelos indutivos de árvores e de regras podem ser lidos
diretamente; Resultados de agrupamentos poder ser tabelados ou
representados graficamente; histogramas de distribuição de valores
podem ser plotados; Código fonte de programas pode ser
automaticamente gerado por alguns sistemas.
Recentemente foi proposto um padrão (CRISP-DM) que fornece um conjunto de
metodologias, práticas e definições das atividades que envolvem o processo de KDD
(CHAPMAN, 2000). O modelo do processo proposto por este padrão é bastante
parecido com o exposto neste capítulo, sendo obviamente muito mais completo e
abrangente.
9
O esquema mostrado pela Figura III.2 ilustra o posicionamento do processo de
KDD no contexto do ciclo de solução de um problema, destacando as características
de interatividade e iteratividade deste ciclo.
Processo de KDD
Problema Conhecimento
Identificação do O ciclo virtuoso Ação baseada no

problema conhecimento
Estratégia Mensuração do efeito Resultados

da ação
Figura III.2. O Processo de KDD no contexto de solução de um problema (SILVER 1998)
A identificação do problema inclui o desenvolvimento e o entendimento do

domínio da aplicação, os conhecimentos prévios relevantes e os objetivos do usuário
final. O processo de KDD atua sobre os dados do problema descobrindo
conhecimento, identificando padrões novos, precisos e úteis e obtendo um modelo
do mesmo. O conhecimento obtido permite a execução de ações produzindo
resultados. O efeito destas ações pode ser mensurado para criar uma estratégia que
redefine ou cria ou novo problema.
A quantidade, a complexidade e a interdependência das tarefas do processo
de KDD reforçam a necessidade da integração de recursos de DM através de SGBDs,
com o uso de interfaces padronizadas, visando a otimização na implementação de
procedimentos e aplicativos para a execução destas tarefas.
Nesta tese somente será abordada uma etapa deste processo, a etapa de
mineração de dados, sendo realizada a implementação de um algoritmo de
classificação, cuja formulação será descrita no capítulo seguinte.
10
IV. Classificador SNBi
Na maioria dos classificadores propostos, conforme mostra a literatura existente,

não ocorre aproveitamento de conhecimento anterior. A grande vantagem do
classificador incremental ocorre nos problemas em que aparecem novos dados após
o classificador ter sido construído. Esta é uma ocorrência comum em aplicações que
coletam dados continuamente. Um exemplo interessante de engenharia é o do
controle de deformações em barragens, que produz dados de deslocamentos em
regime contínuo (FAIRBAIRN et alii, 1999).
Uma versão incremental do classificador CART (Classification and Regression
Trees) (BREIMAN et alii, 1984) foi implementada por CRAWFORD (1989).
UTGOFF (1989, 1994), desenvolveu um classificador incremental que utiliza um
procedimento interessante, cujo resultado obtido a partir da árvore existente
modificada pelos novos dados é exatamente igual à árvore produzida pelo conjunto
total de dados de treinamento.
A partir deste classificador, KALLES (1994) desenvolveu um classificador
incremental para aplicações de reconhecimento de padrões utilizando uma árvore
de decisão para classificar caracteres que devem ser transformados de sua
representação gráfica para um código seqüencial tal como o código ASCII.
CRAVEN et alii (2000) apresentaram um interessante trabalho, baseado no
classificador Bayesiano, para formação de um banco de conhecimento a partir de
extração de dados textuais da Internet.
VAILAYA & JAIN (1999) utilizaram um classificador incremental Bayesiano para
classificar imagens.
O classificador SNBi, implementado nesta tese, é um classificador Bayesiano
simples, com recursos de atualização incremental dos dados de treinamento, com
consideração de atributos de dados contínuos e discretos e múltiplos atributos de
predição discretos.
Apesar de sua simplicidade, devido à premissa de independência entre
atributos, para vários exemplos práticos de classificação, ele apresenta resultados
melhores do que algoritmos mais sofisticados (FRANK et alii, 2000). DOMINGOS &
PAZZANI (1996, 1997) mostraram que mesmo para problemas com presença de forte
dependência entre atributos ele apresentou bons resultados. LANGLEY, IBA &
THOMPSON (1992) demonstraram através de uma análise formal o excelente
comportamento deste classificador em comparação com outros mais sofisticados e
frente a problemas complexos e com distúrbio de dados.
11
Existem abordagens que procuram traduzir a dependência entre atributos e são
conhecidas como Redes Bayesianas (HANSON, STUTZ & CHEESEMAN, 1991; CHEESEMAN
& STUTZ, 1995).
MADIGAN & RIDGEWAY (2002) apresentaram um trabalho ilustrando as
características dos algoritmos Bayesianos para aplicações de DM.
IV.1 Formulação do Classificador SNBi
A seguir é apresentada a formulação do classificador SNBi, para múltiplos

atributos de predição, cujas fórmulas são demonstradas no Apêndice A.
Seja um conjunto de dados de treinamento composto por:
v número total de casos (amostras) de treinamento
Xt = x it , i = 1, n vetor que representa cada caso, para o atributo de predição t,
composto por n valores de atributos do vetor At
At = ait , i = 1, n vetor dos atributos do conjunto de dados de treinamento, para
o atributo de predição t, composto por n valores
Ot = oit , i = 1, n vetor do número de atributos possíveis para cada atributo ait ,
para o atributo de predição t, composto por n valores. Para um

atributo contínuo o elemento do vetor tem valor igual a 2 (um
para valores presentes e outro para valores ausentes). Para um
atributo discreto o elemento do vetor tem valor igual ao
número de valores discretos possíveis + 1 (um para valores
ausentes)
Ct = c tj , j = 1, mt vetor das classes às quais cada caso pode pertencer, para o
atributo de predição t
p número total de atributos de predição
t = 1, p índice de atributo de predição
Seja um conjunto de dados, para o qual as classes são desconhecidas,
composto por:
u número total de casos desconhecidos
Yt = y it , i = 1, n vetor que representa cada caso, para o atributo de predição t,
composto por n valores de atributos do vetor At

Para um caso desconhecido deste conjunto, representado pelo vetor Yt, para o
atributo de predição t, o classificador SNBi selecionará a classe com a maior
probabilidade a posteriori, escolhendo aquela que satisfazer a fórmula seguinte (ver
fórmula A-2 do Apêndice A):
12
P(c tj | Y t ) > P(ckt | Y t ) para 1 ≤ k ≤ mt , k ≠ j (IV-1)
Sendo P( c t | Y t ) (probabilidade de que o caso Yt pertença a classe c tj ), para o

j
atributo de predição t, calculada pela expressão seguinte (ver fórmulas A-4 e A-5 do
Apêndice A):
s tj n
t t
P(c j | Y ) =
v ∏
P( yit | c tj ) (IV-2)
i=1
onde:
s tj número de casos de treinamento de classe c tj
v número total de casos de treinamento
P( yit | c tj ) probabilidade de que ocorra um valor y it para um atributo ait
de um caso desconhecido Yt pertencente a classe c tj
As probabilidades P( y t | c t ) , definidas pelas fórmulas A-5 a A-7 do Apêndice A,

i j
para o atributo de predição t, são calculadas a partir dos dados de treinamento pelas
fórmulas seguintes, dependendo do tipo do atributo ait . Se ait for discreto, então (ver
fórmula A-6 do Apêndice A):
rjith
t t
P( yi | c j ) = (IV-3)
s tj
onde:
rjith número de casos de treinamento de classe c tj tendo o valor
y it , de ordem h, para o atributo ait
s tj número de casos de treinamento de classe c tj
Se por outro lado, ait for um valor contínuo, então será utilizada a fórmula
seguinte (ver fórmula A-7 do Apêndice A):

2
1  y i − µ ji 
t t
− 
1 2  σ jit 
P( yit | c tj ) = e   (IV-4)
2πσ jit
onde:
y it valor y it para o atributo ait do caso desconhecido Yt
13
e número neperiano
µ t e σ jit respectivamente, média aritmética e desvio padrão dos

ji
valores x it para os atributos ait dos casos de treinamento de
classe c tj , calculadas pelas fórmulas seguintes
A média aritmética, para o atributo de predição t, é calculada por (ver fórmula

A-8 do Apêndice A):
rjit1
z tji
∑ xijtk
µ jit = = k =1 (IV-5)
rjit1 rjit1
onde:
z tji somatória dos valores x it para o atributo ait dos casos de
treinamento de classe c tj
rjit1 número de casos de treinamento de classe c tj tendo qualquer
valor presente de x it , de ordem h = 1 (h = 1 é utilizado para
valores presentes de atributos contínuos e h = 0 é utilizado para

valores ausentes de atributos contínuos e discretos), para o
atributo ait
x ijtk valores x it para o atributo ait dos casos de classe c tj
O desvio padrão, para o atributo de predição t, é calculado por (ver fórmula

A-14 do Apêndice A):
t2
t z ji
q ji −
rjit1
σ jit = (IV-6)
rjit1 −1
onde:
qtji somatória dos quadrados dos valores de x it para o atributo ait
dos casos de treinamento de classe c tj
z tji somatória dos valores x it para o atributo ait dos casos de
treinamento de classe c tj
14
rjit1 número de casos de treinamento de classe c tj tendo qualquer
valor presente de x it , de ordem h = 1 (h = 1 é utilizado para

valores ausentes de atributos contínuos e discretos), para o
atributo ait
Uma variante para o cálculo da probabilidade para atributos contínuos (fórmula

V-4) foi apresentada por JOHN & LANGLEY, (1995). Esta variante pretendia resolver
problemas em que a condição de normalidade assumida pela fórmula fosse violada.
Porém em contrapartida a alguns bons resultados, a necessidade de armazenamento
de todos os dados de treinamento dos atributos contínuos e a maior complexidade de
cálculo traz algumas desvantagens, em especial quando se deseja implementar um
classificador incremental.
IV.2 Algoritmos de Treinamento e Predição do Classificador SNBi
Para que o classificador Bayesiano descrito no item anterior possa funcionar com
atualização incremental dos dados de treinamento, é necessário o armazenamento
de alguns dados, recuperados quando novos dados de treinamento são inseridos. As
Listagens IV.1 e IV.2 descrevem, respectivamente, o algoritmo de treinamento de
dados e o algoritmo de predição de dados deste classificador.
Listagem IV.1. Algoritmo de treinamento do classificador SNBi
Se houver dados de treinamento anterior

Recupere v (número de casos de treinamento)
Recupere p (número de atributos de predição)
Para t = 1, p
Recupere mt (número de classes para o atributo de predição t)
Para j = 0, mt
Recupere s tj (número de casos de classe c tj , para o atributo de predição t)

Para i = 1, n
Recupere oit (número de atributos possíveis para cada atributo ait , para o atributo de
predição t
Para h = 1, oit Recupere rjith (número de casos de classe c tj tendo o valor x ij , de ordem
h, para o atributo ait , para o atributo de predição t)
Recupere z tji (somatória dos valores x ij para o atributo ait dos casos de classe c tj , para
o atributo de predição t)
15
Recupere qtji (somatória dos quadrados dos valores x ij para o atributo ait dos casos de
classe c tj , para o atributo de predição t)

Fim de Para i = 1, n
Fim de Para j = 0, mt
Fim de Para t = 1, p
Fim de Se houver dados de treinamento anterior
Para cada caso de treinamento novo
Incremente vn (número de casos de treinamento novos)
Para t = 1 ate p
Defina j da classe c tj do caso atual (j = 0 para classe ausente)
Incremente s tj
Para i = 1, n (número de atributos de dados)
Defina a ordem h do atributo atual (h = 0 para atributo ausente)
Incremente rjith
Se o atributo for contínuo
Adicione x ij a z tji
Adicione ( x ij )2 a qtji
Fim de Se o atributo for contínuo
Fim de Para t = 1 ate p
Fim de Para cada caso de treinamento novo
Adicione vn a v
Listagem IV.2. Algoritmo de predição do classificador SNBi
Para t = 1, p (número de atributos de predição)

Para j = 0, mt (número de classes para o atributo de predição t)
s tj
t
Faça P = (probabilidade a priori das classes)
j v
Para i = 1, n (número de atributos de dados)
Defina a ordem h do atributo atual (h = 0 para atributo ausente)
Se o atributo for discreto
rjith
t
Multiplique P por
j
s tj
Senão (o atributo é contínuo)
t ztji
Faça µ ji = t1 (fórmula IV-5)
rji
16
ztji2
qtji −
rjit1
Faça σ t = (fórmula IV-6)
ji rjit1 −1
2
1  y i − µ ji 
t t
− 
1 2  σ jit 
Multiplique P t por e   (fórmula IV-4)
j
2πσ jit
Fim de Se o atributo for discreto

Escolha o maior valor entre os valores de P t para j = 0, mt definindo o valor de j

j
Defina a classe do caso desconhecido Yt como sendo a de índice j
O procedimento de escolha do maior valor entre os valores calculados das

probabilidades das classes, mostrado na Listagem IV.2, pode acarretar enormes
tempos de processamento em situações que envolvem um grande número de classes
para o atributo de predição. Para resolver este problema LEUNG & SZE (1998)
apresentaram uma interessante e útil solução utilizando o algoritmo de Branch-and-
Bound, numa aplicação de reconhecimento de caracteres do idioma chinês. Esta
aplicação utilizava um conjunto de dados de treinamento com 120.000 casos e 5.515
classes.
17
V. Provedor de Recursos de Mineração de Dados DMclcMine
As diferentes abordagens de integração de recursos de DM com SGBDs citadas

no capítulo II são classificadas de acordo com o grau de acoplamento com o SGBD.
As vantagens e desvantagens destas abordagens são discutidas, justificando a
escolha da abordagem adotada para implementar o provedor de recursos de DM
DMclcMine com o algoritmo de classificação SNBi apresentado no capítulo anterior.
V.1 Sistemas de Integração com SGBDs
A integração de recursos de DM com SGBDs foi objeto de várias abordagens

distintas. Neste sentido, BEZERRA, MATTOSO & XEXÉO (2000) apresentaram uma
classificação destas abordagens, mostrando em detalhes as características de cada
uma delas.
Em relação ao grau de integração, ou acoplamento, com o SGBD, estas
abordagens podem ser agrupadas em três categorias diferentes: sistemas externos ou
desacoplados, sistemas internos e sistemas acoplados.
V.1.1 Sistemas Externos
Nesta categoria de acoplamento não existe uma integração propriamente dita,

mas tão somente a utilização do SGBD como um repositório de dados.
Sua principal vantagem é a portabilidade, já que não são necessárias maiores
modificações no aplicativo de DM, pois somente a interface de entrada de dados
precisa ser eventualmente alterada. Ou para tornar o aplicativo totalmente portável,
basta o desenvolvimento de um pequeno utilitário que gere um arquivo intermediário
no formato adequado para o aplicativo de DM, extraindo os dados necessários do
SGBD. Devido a esta facilidade, durante muito tempo foi a única forma utilizada pelos
desenvolvedores de aplicativos de DM.
Sua principal desvantagem é o total isolamento do aplicativo em relação a
possíveis colaborações de outros desenvolvedores em tarefas tais como visualização
de resultados, entre outras. Deve ser lembrado que a etapa de mineração de dados é
somente uma parte do processo de KDD. O eventual uso de aplicativos para outras
tarefas implicará no desenvolvimento de outros utilitários para conversão de dados.
Desta forma, outra grande desvantagem deste sistema é o elevado tráfego de
transferência de dados. Além disso, nenhuma das possíveis facilidades do SGBD tais
como paralelismo e distribuição podem ser aproveitadas.
Mesmo sistemas específicos para DM como o dbMiner (HAN & KAMBER, 2001;
DBMINER, 2002) podem ser enquadrados nesta categoria.
18
V.1.2 Sistemas Internos
Esta categoria de acoplamento possui integração total com o SGBD podendo

aproveitar todas as facilidades inerentes ao mesmo.
É a opção que tem potencial para ter o melhor resultado computacional em
termos de tempo de processamento. Além do mais, permite o armazenamento do
modelo de DM para a utilização com as diversas tarefas do processo de KDD.
Todavia, sua principal desvantagem é a total falta de portabilidade, já que
somente os recursos de DM implementados no SGBD estariam disponíveis.
A principal característica do DM é que não existe um algoritmo adequado para
todos os conjuntos de dados. Cada problema deve ser estudado e o algoritmo
escolhido de acordo com as suas características. Os constantes aperfeiçoamentos
disponibilizados pela comunidade científica implicarão em constantes modificações
internas no SGBD provocando uma defasagem entre a oferta de tecnologia e a
possibilidade de uso da mesma pela comunidade de usuários.
Outras desvantagens são a duplicação de esforço de desenvolvimento destes
aperfeiçoamentos e a vinculação obrigatória de longo prazo com o fabricante do
SGBD.
Um exemplo desta abordagem pode ser vista no trabalho de BEZERRA & XEXÉO
(1998, 1999) e BEZERRA (1999) que implementaram funcionalidades internas para
extração e armazenamento de regras em um SGBD de uso experimental.
V.1.3 Sistemas Acoplados
Esta categoria de acoplamento possui um grau de integração dependente da

forma que este acoplamento é realizado com o SGBD, da sua arquitetura e dos
recursos disponíveis.
V.1.3.1 Sistemas de Acoplamento Íntimo

Esta forma de acoplamento faz uso dos comandos SQL disponíveis e de
extensões desta linguagem, visando aproveitar as características internas do SGBD, tais
como paralelismo e distribuição. São utilizados recursos de procedimentos
armazenados, funções definidas pelo usuário e acesso às estruturas de dados internas
para encapsular código de programação no SGBD.
Os trabalhos de SOUSA (1998) e SOUSA, MATTOSO & EBECKEN (19981,2,3) são um
exemplo desta forma de acoplamento.
MEO, PSAILA & CERI (1996) implementaram um operador de DM projetado como
uma extensão SQL para extração de regras de associação.
19
SATTLER & DUNEMANN (2001) desenvolveram primitivas para classificadores de
árvores de decisão utilizando funções definidas pelo usuário, implementadas em C
usando a OCI (interface de chamadas de procedimentos da Oracle®).
Esta abordagem apresenta como principal desvantagem a total falta de
portabilidade e o elevado custo de desenvolvimento, já que exige que os algoritmos
de DM sejam desenvolvidos em linguagens proprietárias utilizando estruturas de dados
específicas de cada SGBD.
Todavia, o uso indiscriminado de SQLs para o cálculo de contagens e
probabilidades conduz a repetidas varreduras de dados que acarretam um baixo
desempenho no tempo de processamento, inviabilizando completamente o
procedimento adotado (BERNHARDT, CHAUDHURI S. & FAYYAD, 1999).
A intimidade do acoplamento obtido através de recursos internos de um SGBD é
diretamente proporcional à intimidade que o desenvolvedor obrigatoriamente terá
com o fabricante do mesmo, criando uma dependência de longo prazo, que pode
ser prejudicial.
V.1.3.2 Sistemas de Acoplamento por API

Esta forma de acoplamento procura utilizar os recursos internos do SGBD,
fazendo uso de comandos SQL quando for conveniente, porém sem utilizar nenhum
recurso proprietário do gerenciador, evitando assim as desvantagens apresentadas
pela forma de acoplamento íntimo.
BERNHARDT, CHAUDHURI S. & FAYYAD (1999) implementaram um aplicativo para
classificação de árvores de decisão que utiliza um módulo de processamento que
acessa recursos internos de um SGBD através de uma API buscando otimizar os
acessos aos dados do gerenciador. Posteriormente este módulo de processamento foi
utilizado pelo classificador MSDT.
Um problema apresentado por esta forma de acoplamento é o rompimento
repetido da ligação com o SGBD, causando várias operações de cópia de memória.
Além disso, se cada fabricante definir uma API, esta forma de acoplamento
ainda terá as desvantagens de falta de portabilidade e a vinculação compulsória
com o fabricante do SGBD.
Desta forma a padronização de uma API para DM seria a solução para tornar
um aplicativo de DM portável com todas as vantagens de um acoplamento com um
SGBD.
V.2 Tecnologia OLE DB DM
A tecnologia OLE DB DM (MICROSOFT, 20002) define uma API padrão para o

desenvolvimento de provedores de recursos de DM.
20
Esta padronização possibilita a total portabilidade destes provedores, que se
constituem em sistemas acoplados por API, que podem aproveitar os recursos internos
de SGBDs, bem como de qualquer fonte de dados que seja compatível com esta API.
Utilizando esta tecnologia um SGBD pode gerenciar diferentes aplicativos
desenvolvidos por desenvolvedores distintos para cada tarefa que constitui o processo
de KDD, por exemplo, preparação de dados, mineração de dados, visualização e
avaliação.
Esta integração entre as diferentes etapas deste processo é possibilitada pelo
armazenamento do modelo de DM que fica disponível para utilização por qualquer
aplicativo que utilize esta tecnologia.
Visando a portabilidade e o livre intercâmbio de informações o armazenamento
é realizado através da especificação PMML (Predictive Model Markup Language)
(DMG, 2002), que é uma linguagem de marcação para modelos estatísticos e de DM
baseada em XML (Extensible Markup Language) (WC3, 2000).
Além do mais, esta tecnologia permite que um provedor de recursos de DM
tenha total portabilidade, podendo funcionar com um aplicativo independente, sem
a presença de qualquer SGBD. Basta a existência de uma conexão com uma fonte de
dados qualquer, que pode ser até mesmo formada por arquivos lineares tipo texto.
É importante salientar que esta tecnologia, apesar de ter sido criada pela
Microsoft®, é totalmente independente de qualquer fabricante, de qualquer software
ou de qualquer provedor de dados.
De uma forma geral, esta abordagem apresenta as vantagens de todas as
abordagens citadas anteriormente. A única provável desvantagem é a perda de
desempenho em relação àquela apresentada pelos sistemas internos, ocasionada
pelas repetidas cópias de memória causadas pelos rompimentos sucessivos da
ligação com o SGBD, inerentes à esta forma de acoplamento.
No entanto as vantagens claramente superam esta pequena desvantagem.
Além disso se faz necessária uma implementação cuidadosa e eficiente dos
algoritmos de DM para otimizar o uso das funcionalidades internas disponíveis do SGBD
(CHAUDHURI, 1998).
Do ponto de vista do pesquisador de DM esta tecnologia é altamente
promissora, já que possibilita a qualquer pesquisador, com um mínimo de esforço,
portar ou desenvolver seu algoritmo de DM, seu visualizador de resultados, ou outro
aplicativo qualquer, em uma linguagem de programação não proprietária, para que
este se torne um provedor de recursos de DM, pronto para uso integrado com um
SGBD.
21
V.3 Arquitetura de Acesso Universal de Dados
A integração interna com o SGBD relacional MSSQL será obtida pela

implementação do classificador SNBi utilizando a tecnologia OLE DB DM. Desta forma,
será criado o DMclcMine, um provedor de recursos de DM, na forma de uma DLL, que
poderá ser utilizado tanto pelo SGBD como por qualquer aplicativo, através de simples
chamadas de funções que são vinculadas ao aplicativo em tempo de execução.
Consumidores de dados
Aplicativo Browser
IIS – Servidor Internet
ADO - API para manipulação de dados através de objetos
Provedores OLE DB
Provedores de Serviços OLE DB

Proc. de Cursor Proc. de Consultas Outros
Provedores de dados OLE DB
SQLOLEDB MSJet MSOLAP MSDMine DMclcMine Outros
SQL Server Jet (Access Cubos Modelos de Modelos de Outras

& outras MOLAP & Data Mining Data Mining fontes de
fontes) ROLAP dados
Armazenadores de dados
Figura V.1. Arquitetura de acesso universal de dados
A Figura V.1 mostra a arquitetura de acesso universal de dados (UDA) através

dos componentes de acesso de dados da Microsoft® - MDAC, bem como o provedor
DMclcMine no contexto desta arquitetura.
Esta arquitetura permite acesso simples e eficiente a uma ampla gama de
dados, relacionais e não relacionais, em múltiplas plataformas através de redes
internas e externas.
Os provedores OLE DB podem ser simples ou complexos (ver Apêndice B). Para
realizar consultas que envolvem múltiplas fontes de dados, eles podem utilizar outros
provedores.
22
V.4 Ferramentas
O trabalho de implementação computacional foi totalmente realizado em um

ambiente composto por: um microcomputador IBM® PC compatível, equipado com
um processador Intel® Pentium III 500 MHz; 512 megabytes de memória RAM; 30
megabytes de disco rígido; sistema operacional Microsoft® Windows® 2000 Advanced
Server Service Pack 3 e MSSQL 2000 Enterprise Service Pack 3 (MICROSOFT, 20001). A
configuração de memória virtual utilizada, de acordo com o recomendado pelo
sistema operacional foi de 768 megabytes de memória inicial e de 2048 megabytes de
memória máxima.
Esta implementação foi feita com a utilização do ambiente de desenvolvimento
Microsoft® Visual Studio® 6.0 Service Pack 5 (MICROSOFT, 19982), compostos pelos
compiladores Visual C++®, Visual J++® e Visual Basic®; Microsoft® Platform SDK
February 2001 Edition (MICROSOFT, 2001) e com o analisador de sintaxe de comandos
Sandstone Visual++ Parse 4.00 (SANDSTONE, 2000).
Este equipamento excede os requisitos de hardware exigidos isoladamente pelos
programas utilizados. Contudo o processo de depuração de erros durante a
implementação do provedor de recursos de DM requer uma grande quantidade de
memória, desde que usualmente são utilizados em conjunto: o MSSQL com o módulo
de Serviços de Análise, e os compiladores Visual C++® e Visual Basic®.
O modelo utilizado para o desenvolvimento do provedor de recursos de DM é o
provedor exemplo do kit de recursos OLE DB DM (MICROSOFT, 2002).
O visualizador de tabelas virtuais RowsetViewer é uma ferramenta exemplo que
integra o kit de desenvolvimento de Acesso de Dados do Microsoft® Platform SDK
February 2001 Edition (MICROSOFT, 2001). Sua utilização é importante principalmente
na fase de correção de erros da implementação do provedor, desde que oferece um
simples meio para visualizar e manipular tabelas virtuais de provedores OLE DB.
Outro visualizador de tabelas virtuais, que foi aperfeiçoado para tratar com
provedores de recursos de DM, é o utilitário DMSamp (KIM & CARROLL, 2002), utilizado
para visualização das tabelas produzidas pelo provedor de recursos de DM, bem
como para montar os comandos.
V.5 Implementação do Provedor DMclcMine
O provedor de recursos de DM DMclcMine foi desenvolvido a partir do código

fonte do kit de recursos OLE DB DM (MICROSOFT, 2002).
Algumas modificações são necessárias para preparar o código fonte do
exemplo de provedor para que um novo algoritmo seja implementado. Além disso
algumas modificações também devem ser feitas para que o provedor possa funcionar
23
tanto de forma isolada, utilizado diretamente por um aplicativo, como de forma
agregada, utilizado em conjunto com o MSSQL. Estas modificações, bem como
detalhes da implementação, são descritos no Apêndice C.
A implementação será apresentada no contexto da descrição das operações
fundamentais de um provedor de recursos de DM, expostas nos itens a seguir.
V.5.1 Exemplo AllElet
Para ilustrar estas operações bem como os passos da implementação, será

adotado o exemplo AllElet, utilizado por HAN & KAMBER (2001), referente a um banco
de dados de clientes - AllEletronics, cujos dados de treinamento e atributos são
mostrados na Tabela V.1. Por sua vez a Tabela V.2 apresenta as estatísticas do modelo
marginal deste exemplo.
Tabela V.1. AllElet - Dados de treinamento
Valores dos atributos

Caso
Age Income Student CreditRating BuysComputer
1 <=30 high no fair No
2 <=30 high no excellent No
3 31-40 high no fair Yes
4 >40 medium no fair Yes
5 >40 low yes fair Yes
6 >40 low yes excellent No
7 31-40 low yes excellent Yes
8 <=30 medium no fair No
9 <=30 low yes fair Yes
10 >40 medium yes fair Yes
11 <=30 medium yes excellent Yes
12 31-40 medium no excellent Yes
13 31-40 high yes fair Yes
14 >40 medium no excellent No
24
Tabela V.2. AllElet - Estatísticas do modelo marginal
Valores dos atributos /Número de ocorrências

<=30 high no fair No
5 4 7 8 5
Estados 31-40 medium yes excellent Yes
dos
Atributos
4 6 7 6 9
>40 low
5 4
Ausentes 0 0 0 0 0
V.5.2 Operações Fundamentais de um Provedor de Recursos de DM
NETZ et alii (2000, 2001) descreveram a filosofia básica e as decisões de projeto

que culminaram com a especificação OLE DB DM (MICROSOFT, 20002). Eles
formularam precisamente as quatro operações fundamentais que devem ser
suportadas por um provedor de recursos de DM, conforme será reproduzido a seguir:
1. Criar o modelo de DM, identificando o conjunto de atributos de dados a serem
preditos, o conjunto de atributos de dados a serem utilizados para predição e o
algoritmo utilizado para construir o modelo de DM;
2. Povoar o modelo de DM utilizando o algoritmo especificado com os dados de
treinamento;
3. Predizer os atributos para novos dados utilizando o modelo de DM que foi
povoado;
4. Expor o modelo de DM para aplicativos de visualização, de geração de
relatórios e de outras tarefas do processo KDD tais como interpretação e
avaliação de resultados.
V.5.3 Criando o Modelo de DM
A sintaxe do novo algoritmo é definida utilizando o analisador de sintaxe de

comandos Sandstone Visual++ Parse 4.00 (SANDSTONE, 2000). Somente algumas
modificações são necessárias no exemplo de provedor para implementar esta fase.
O Editor Relacional de Modelos de DM do Gerenciador de Serviços de Análise
pode ser utilizado para criar os comandos SQL DM necessários para esta tarefa.
Detalhes desta linguagem são encontrados na especificação OLE DB DM (MICROSOFT,
20002), na documentação do MSSQL 2000 (MICROSOFT, 20001) e no livro de SEIDMAN,
2001.
25
Todas as operações necessárias para esta tarefa estão disponíveis no provedor
exemplo, não sendo necessária nenhuma modificação em implementações de novos
algoritmos.
O comando SQL DM para criar o modelo com dois atributos de predição do
conjunto de dados da Tabela V.1 é mostrado a seguir:
CREATE MINING MODEL [AllElet_SNBi] ([NumReg] LONG KEY, [Age] TEXT DISCRETE,
[Income] TEXT DISCRETE, [Student] TEXT DISCRETE PREDICT, [CreditRating] TEXT
DISCRETE, [BuysComputer] TEXT DISCRETE PREDICT) USING Simple_Naive_Bayes
Utilizando o utilitário DMSamp (KIM & CARROLL, 2002) para executar o comando
acima, será criado o correspondente modelo de DM armazenado no formato texto
através da especificação PMML (DMG, 2002), versão 1.0. Esta é uma linguagem de
marcação para modelos estatísticos e de DM baseada em XML (WC3, 2000). O
arquivo deste modelo de DM é reproduzido pela Listagem V.1.
Listagem V.1. AllElet - Arquivo XML de criação do modelo de DM
<?xml version="1.0"?>
<pmml name = "AllElet_SNBi" GUID = "{4888A64B-C5A3-4CF8-AFB7-593495434496}"
creation-time = "2003-05-03T01:35:34" modified-time = "2003-05-03T01:35:34">
<statements>
<statement type = "CREATE" value = "CREATE MINING MODEL [AllElet_SNBi]
([NumReg] LONG KEY, [Age] TEXT DISCRETE, [Income] TEXT DISCRETE,
[Student] TEXT DISCRETE PREDICT, [CreditRating] TEXT DISCRETE,
[BuysComputer] TEXT DISCRETE PREDICT) USING Simple_Naive_Bayes"/>
</statements>
<data-dictionary column-ordering = "ORDINAL" column-count = "6">
<key name = "NumReg" datatype = "LONG" isinput = "true" column-ordinal = "0"/>
<categorical name = "Age" isinput = "true"
datatype = "TEXT" column-ordinal = "1"/>
<categorical name = "Income" isinput = "true"
<categorical name = "Student" isinput = "true" ispredict = "true"
<categorical name = "CreditRating" isinput = "true"
<categorical name = "BuysComputer" isinput = "true" ispredict = "true"
</data-dictionary>
<Simple-naive-bayes-model/>
</pmml>
V.5.4 Povoando o Modelo de DM
O próximo parágrafo mostra o comando SQL DM necessário para povoar o

modelo de DM do exemplo adotado, utilizando dados armazenados em um banco de
dados do MSSQL:
INSERT INTO [AllElet_SNBi] (SKIP, [Age], [Income], [Student], [CreditRating],

[BuysComputer]) OPENROWSET ('SQLOLEDB.1', 'Provider=SQLOLEDB;Integrated
Security=SSPI;Persist Security Info=False;Initial Catalog=AllElet;Data
Source=CLC', 'SELECT "NumReg", "Age", "Income", "Student", "CreditRating",
"BuysComputer" FROM "AllEletTrain"')
26
Este comando é gerado automaticamente pelo Gerenciador de Serviços de
Análise. Todo o suporte necessário para o funcionamento deste comando na inserção
de casos no modelo DM deve ser desenvolvido para novos algoritmos. O
desenvolvedor deve dedicar atenção especial nesta tarefa. A estrutura de dados
interna que representa o modelo é definida e todas as funções relativas ao
treinamento do conjunto de dados, montagem da árvore do modelo,
armazenamento e recuperação do modelo são desenvolvidas nesta etapa. A
estrutura de dados deve ser compatível com o processamento das duas últimas
operações: de predição de atributos e de exposição do modelo de DM.
Listagem V.2. AllElet - Arquivo XML do modelo completo de DM
<pmml name = "AllElet_SNBi" GUID = "{4888A64B-C5A3-4CF8-AFB7-593495434496}"
<statements>
<statement type = "CREATE" value = "CREATE MINING MODEL [AllElet_SNBi]
</statements>
<categorical name = "Age" isinput = "true"
datatype = "TEXT" column-ordinal = "1">
<category missing = "true"/>
<category value = "<=30"/>
<category value = "31-40"/>
<category value = ">40"/>
</categorical>
<category value = "high"/>
<category value = "medium"/>
<category value = "low"/>
</categorical>
<category value = "no"/>
<category value = "yes"/>
</categorical>
<category value = "fair"/>
<category value = "excellent"/>
</categorical>
<category value = "no"/>
<category value = "yes"/>
</categorical>
</data-dictionary>
<global-statistics>
<data-distribution>
<simple-attribute name = "Age"/>
<state missing = "true" support = "0"/>
<state value = "<=30" support = "5"/>
<state value = "31-40" support = "4"/>
27
<state value = ">40" support = "5"/>
</data-distribution>
<data-distribution>
<simple-attribute name = "Income"/>
<state value = "high" support = "4"/>
<state value = "medium" support = "6"/>
<state value = "low" support = "4"/>
<data-distribution>
<simple-attribute name = "Student"/>
<state value = "no" support = "7"/>
<state value = "yes" support = "7"/>
<data-distribution>
<simple-attribute name = "CreditRating"/>
<state value = "fair" support = "8"/>
<state value = "excellent" support = "6"/>
<data-distribution>
<simple-attribute name = "BuysComputer"/>
</global-statistics>
<Simple-naive-bayes-model>
<info name = "Count of Cases" value = "14"/>
<info name = "Count of Trees" value = "2"/>
<data-distribution>
<state value = "no" support = "7">
<data-distribution>
<data-distribution>
<data-distribution>
<data-distribution>
</state>
<state value = "yes" support = "7">
<data-distribution>
<data-distribution>
<data-distribution>
28
<data-distribution>
</state>
<data-distribution>
<state value = "no" support = "5">
<data-distribution>
<data-distribution>
<data-distribution>
<data-distribution>
</state>
<state value = "yes" support = "9">
<data-distribution>
<data-distribution>
<data-distribution>
<data-distribution>
</state>
</Simple-naive-bayes-model>
</pmml>
Utilizando o mesmo utilitário DMSamp para executar o comando de

povoamento do modelo de DM, o arquivo XML mostrado pela Listagem V.1 será
completado com os dados de treinamento, sendo incluídos no dicionário de dados os
29
valores possíveis dos atributos e incluídos no arquivo as estatísticas globais e os dados
estatísticos que definem o modelo de DM conforme mostra a Listagem V.2.
V.5.5 Predizendo Atributos
A criação do comando SQL DM necessário para esta tarefa pode ser feita com
o auxílio do utilitário DMSamp (KIM & CARROLL, 2002) ou com o auxílio de utilitários DTS
(Data Transformation Services). O desenvolvedor deve implementar todo o suporte
para o funcionamento deste comando. Para o exemplo adotado o comando é o que
segue:
SELECT FLATTENED [T1].[NumReg], [T1].[Age], [T1].[Income], [T1].[Student],

[T1].[CreditRating], [T1].[BuysComputer], [AllElet_SNBi].[BuysComputer] as
BuysComputer FROM [AllElet_SNBi] PREDICTION JOIN OPENROWSET ('SQLOLEDB.1',
'Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist Security Info=False;Initial
Catalog=allelet;Data Source=CLC', 'SELECT "NumReg", "Age", "Income", "Student",
"CreditRating", "BuysComputer" FROM "AllElet" ORDER BY "NumReg"') AS [T1] ON
[AllElet_SNBi].[NumReg] = [T1].[NumReg] AND [AllElet_SNBi].[Age] = [T1].[Age] AND
[AllElet_SNBi].[Income] = [T1].[Income] AND [AllElet_SNBi].[Student] =
[T1].[Student] AND [AllElet_SNBi].[CreditRating] = [T1].[CreditRating] AND
[AllElet_SNBi].[BuysComputer] = [T1].[BuysComputer]
V.5.6 Expondo o Modelo de DM
O modelo de DM é exposto para outros aplicativos, tais como aplicativos de

visualização e de geração de relatórios através de tabelas virtuais (rowsets). O
conteúdo destas tabelas virtuais é recuperado por aplicativos clientes do provedor de
recursos de DM através de comandos SQL DM do tipo Select ou diretamente através
de chamadas de função de recuperação das propriedades dos nós das árvores de
predição.
A Figura V.2 mostra a tela do Editor Relacional de Modelos de DM exibindo parte
das duas árvores de predição do modelo para o exemplo adotado enquanto que a
Figura V.3 mostra a árvore completa para o atributo de predição BuysComputer.
Pode ser observado que a caixa de listagem de árvores de predição esta vazia.
Acontece que a Microsoft®, contra sua própria especificação, não permite que este
tipo de modelo seja mostrado normalmente em seu Editor. A caixa de listagem de
árvores de predição é codificada internamente para ser preenchida somente pelo
classificador MSDT (CHICKERING, GEIGER & HECKERMAN, 1994). O conteúdo produzido
por outros algoritmos não pode aparecer nesta caixa. Nós tipo árvore não podem ser
utilizados pois causam terminação anormal no editor, mas um simples artifício contorna
este problema: o nó raiz é do tipo modelo e os seus filhos serão as raízes das árvores de
predição.
30
Figura V.2. AllElet - Árvores do modelo para os atributos de predição
31
Figura V.3. AllElet - Árvore do atributo de predição BuysComputer
Com a finalidade de verificação de erros e para utilização com aplicativos

clientes, consultas SQL DM podem ser realizadas para recuperar o conteúdo das
tabelas virtuais do modelo de DM. A Figura V.4 mostra a tela do utilitário DMSamp (KIM
& CARROLL, 2002) exibindo parte dos resultados da consulta que recupera o conteúdo
inteiro do modelo de DM do exemplo adotado:
SELECT * FROM [AllElet_SNBi].CONTENT
32
Figura V.4. AllElet - Conteúdo da tabela virtual do modelo de DM
A Figura V.5 mostra a mesma árvore de predição da Figura V.3, produzida por
outra interessante ferramenta: ThinClientTree criada por TANG (20021) e modificada por
CUROTTO (2002) para suportar outros algoritmos além do MSDT (CHICKERING, GEIGER &
HECKERMAN, 1994).
Figura V.5. AllElet – Árvore do atributo de predição BuysComputer exibida pelo Internet Explorer
33
VI. Experimentos Computacionais
Quatro tipos de experimentos são realizados para comparar resultados e avaliar

o desempenho do classificador SNBi, suportado pelo provedor DMclcMine, formulado,
desenvolvido e implementado nesta tese.
O primeiro deles, um problema clássico de DM, utiliza um conjunto de dados
artificial para verificar a acurácia dos resultados e a velocidade de processamento em
comparação com outros classificadores.
Os dados de previsão do tempo e de seguro de vida possibilitam estudar o
comportamento do classificador SNBi perante dados reais.
Os dados artificiais do quarto experimento são utilizados para avaliar a
escalabilidade e o desempenho do classificador SNBi considerando os fatores de
cardinalidade, número de atributos de dados, número de estados dos atributos e
número dos atributos de predição.
Três outros classificadores são utilizados nos experimentos:
• MSDT (CHICKERING, GEIGER & HECKERMAN, 1994), Microsoft® Decision Trees,
classificador de árvores de decisão disponível no módulo de Serviços de
Análise do MSSQL;
• WEKA (WITTEN & FRANK, 2000), implementação Visual J++® do Classificador
Bayesiano Simples do Ambiente de Análise de Conhecimento da
Universidade de Waikato;
• C45 (Quinlan, 19932), implementação Visual C++® do Classificador de Árvores
de Decisão C4.5.
Os classificadores SNBi e MSDT são implementados como provedores de recursos
de DM, portanto funcionam integrados com o MSSQL. Os classificadores WEKA e C45
são implementados como aplicativos independentes e utilizam arquivos tipo texto
para leitura dos dados de treinamento e predição, bem como para o arquivamento
de resultados das tarefas de predição. Os parâmetros utilizados pelos classificadores
MSDT e C45 nos experimentos foram aqueles que apresentaram os melhores resultados
para os respectivos dados.
A avaliação da acurácia dos resultados obtidos pela tarefa de predição de
problemas de classificação é realizada através de uma taxa de acerto calculada
como uma porcentagem de casos classificados corretamente (QUINLAN, 19933).
Dois procedimentos são utilizados para avaliar esta acurácia. O primeiro deles
consiste na divisão dos dados disponíveis em duas parcelas, sendo uma parcela
menor (em torno de 30%) utilizada como teste do modelo obtido com o treinamento
dos dados da parcela restante.
34
O segundo procedimento é o da validação cruzada. Este é um procedimento
que resulta do processamento de N conjuntos de dados de treinamento e teste
obtidos a partir do conjunto total de dados. Para realizar este procedimento o
conjunto total de dados é dividido em N partes aproximadamente iguais com
distribuição uniforme randômica das classes do atributo de predição. Cada uma
destas N partes se constitui nos N conjuntos de dados de teste. Os N conjuntos de
dados de treinamento são formados pelas N-1 partes restantes (com a exclusão da
parte utilizada para teste). Desta forma em cada processamento um conjunto de
dados de treinamento com dados diferentes é utilizado e testado em um conjunto
com dados não pertencentes ao conjunto de dados de treinamento. A acurácia dos
classificadores escolhidos para teste é obtida pela média da acurácia dos N
resultados. Em todos os experimentos foi adotado N = 10.
Nas tabelas que mostram os resultados dos experimentos, os melhores valores
são destacados em negrito e as colunas dos valores do classificador SNBi são
destacadas com fundo cinza claro.
Deve ser obserbado que os tempos de processamento mostrados por estas
tabelas são os tempos decorridos e não o tempo real do processador para a tarefa
considerada. Durante os experimentos o equipamento foi utilizado como servidor
isolado, sem nenhum cliente conectado e somente de forma eventual ocorreu a
utilização de um editor de textos em conjunto com a execução das tarefas.
O Apêndice E mostra todos os detalhes necessários para o processamento dos
experimentos tais como programas e utilitários utilizados.
VI.1 Waveform - Reconhecimento de Formas de Onda
O exemplo clássico do problema de reconhecimento de formas de onda

(Waveform) descrito por BREIMAN et alii (1984) foi utilizado para verificar a acurácia
dos resultados e a velocidade de processamento em comparação com outros
classificadores. Este é um problema artificial que possui um atributo de predição com 3
classes e 21 atributos contínuos de dados.
Cinco grupos de casos foram considerados. O conjunto de dados de teste para
todos eles foi o conjunto de 5.000 casos existente no repositório de dados da
Universidade da Califórnia em Irvine (BLAKE & MERZ, 1998). Juntamente com estes
dados o repositório disponibiliza um programa gerador de dados em C que foi
utilizado para gerar os conjuntos de dados de treinamento (ver Apêndice E, item E.2).
Estes conjuntos de dados de treinamento foram nomeados: a, b, c, d, e, possuindo
respectivamente 300, 5.000, 10.000, 100.000 e 1.000.000 casos gerados

randomicamente por este programa.
35
A Tabela VI.1 mostra a lista dos parâmetros dos classificadores utilizados neste
experimento, enquanto que os resultados de tempos de processamento e acurácia
obtidos são mostrados nas Tabelas VI.2 e VI.3.
Os resultados do classificador MSDT (MSDT1 e MSDT2) identificados pelo sinal de
interrogação (?) significam que a execução deste classificador falhou e o processo
não obteve uma terminação normal. Este erro foi reportado para a Microsoft®, sendo
qualificado como um erro de programação que deverá ser corrigido em futuras
versões do provedor. Para preencher esta lacuna as tabelas apresentam também o
resultado do classificador MSDT2d, que utiliza atributos de dados discretizados ao invés
de atributos de dados contínuos.
Tabela VI.1. Waveform - Parâmetros dos classificadores utilizados
Classificador Parâmetros
SNBi todos atributos de dados contínuos
SNBid todos atributos de dados discretizados
MSDT1 COMPLEXITY_PENALTY = 0.9, MINIMUM_LEAF_CASES = 10, SCORE_METHOD = 4,

SPLIT_METHOD = 3; todos atributos de dados contínuos
MSDT2 COMPLEXITY_PENALTY = 0, MINIMUM_LEAF_CASES = 1, SCORE_METHOD = 4,

MSDT2d COMPLEXITY_PENALTY = 0, MINIMUM_LEAF_CASES = 1, SCORE_METHOD = 4,

SPLIT_METHOD = 2; todos atributos de dados discretizados
WEKA todos atributos de dados contínuos; probabilidades não normalizadas
C45 todos atributos de dados contínuos; resultados antes da poda
Os dois modelos do classificador SNBi apresentaram os menores tempos de

treinamento entre todos os classificadores, enquanto que os tempos de predição do
treinamento foram os piores. Os tempos de treinamento de todos os classificadores,
com a exceção do C45, demonstraram escalabilidade, crescendo linearmente com o
acréscimo do número de casos. Este comportamento pode ser melhor observado no
gráfico da Figura VI.1.
O comportamento não linear do classificador C45 ocorreu devido a grande
demanda de memória exigida por este classificador para o treinamento de 1.000.000
de casos, excedendo a capacidade eficiente do equipamento utilizado. O uso
intensivo de memória virtual introduz a variável de tempo de acesso ao disco rígido
ocasionando o comportamento não linear do classificador.
36
Tabela VI.2. Waveform - Tempos de processamento (s)
Etapa Grupo SNBi WEKA SNBid MSDT1 MSDT2 MSDT2d C45
a 5 3 2 3 4 3 1
b 5 58 4 13 46 6 6
Treinamento c 8 107 6 25 85 8 13
d 47 981 45 307 912 69 282
e 428 9629 429 ? ? 934 12684
a 1 2 2 1 1 1 0
b 22 40 22 18 19 19 0
Predição do
Treinamento
c 45 74 44 35 35 37 0
d 430 693 413 333 328 352 1
e 4111 6704 4079 ? ? 3801 13
a 23 64 21 18 18 18 1
b 22 64 22 19 18 17 1
Predição do
Teste
c 22 63 22 18 19 17 1
d 21 61 22 17 20 17 1
e 29 59 36 ? ? 23 1
a 29 69 25 22 23 22 2
b 49 165 48 50 83 42 7
Total c 75 244 72 78 139 62 14
d 498 1735 480 657 1260 438 284
e 4568 16392 4544 ? ? 4758 12698
Os valores nulos de tempos de processamento da predição dos dados de

treinamento do classificador C45 se devem ao fato que estes valores são muito
pequenos, que arredondados para a unidade se tornaram nulos. Neste classificador
esta operação é efetuada com a utilização de uma estrutura de dados tal que
possibilita tempos de processamento infímos tanto para a predição dos dados de
treinamento quanto dos dados de teste, conforme pode ser observado nas tabelas de
resultados.
37
14000
C45
12000
Tempo de Treinamento (s)
WEKA
10000
8000
6000
4000
2000
MSDT2 MSDT2d
i
MSDT1 SNB d
0 i
SNB
0 200000 400000 600000 800000 1000000
Número de Casos
Figura VI.1. Waveform - Tempo de treinamento x Número de casos
Tabela VI.3. Waveform - Acurácia (%)
Dados Grupo SNBi WEKA SNBid MSDT1 MSDT2 MSDT2d C45
a 81,00 81,00 82,67 76,33 100,00 80,67 97,67

b 81,76 81,76 81,52 79,54 98,62 78,60 95,64
Treinamento c 80,39 80,39 80,43 80,47 96,79 79,19 95,80
d 80,55 80,55 80,47 81,87 90,25 80,31 94,19
e 81,41 81,41 81,75 ? ? 85,37 94,24
a 80,94 80,94 79,26 67,72 68,78 67,72 71,24
b 80,86 80,86 80,78 74,42 76,16 74,42 76,18
Teste c 81,08 81,08 80,46 76,04 75,58 76,04 77,76
d 80,86 80,86 80,60 79,66 79,60 79,66 80,18
e 81,14 81,14 80,64 ? ? 79,66 80,60
A Tabela VI.3 mostra que, conforme o esperado, os resultados apresentados

pelos classificadores SNBi e WEKA são idênticos. A acurácia dos resultados de
treinamento do classificador SNBi é uma das piores, todavia em relação aos dados de
teste é a melhor de todas, porém não se destaca tanto quanto o resultado do
38
classificador C45 no treinamento. Além disso, se for considerado o produto tempo x
acurácia, no grupo d, o classificador C45 alia rapidez com acurácia competitiva.
Os resultados do procedimento de validação cruzada realizado com os

classificadores SNBi e MSDT2 são mostrados nas Tabelas VI.4 e VI.5. Os tempos de
processamento do classificador SNBi permaneceram os menores. Da mesma maneira,
para este mesmo classificador, a acurácia dos resultados se mostrou menor para os
dados de treinamento e maior para os dados de teste.
Tabela VI.4. Waveform - Tempos de processamento (s) da validação cruzada
Etapa SNBi MSDT2
Treinamento 41 356
Predição Treinamento 198 162
Predição Teste 27 22
Total 266 540
Tabela VI.5. Waveform - Acurácia (%) da validação cruzada
Dados SNBi MSDT2
Treinamento 81,01±0,15 97,80±0,82

Teste 80,83±1,56 74,72±1,43
Os bons e uniformes resultados apresentados pelo classificador SNBi neste

experimento se devem provavelmente ao fato que este problema foi gerado
artificialmente, através de distribuição normal e sem dependência entre os atributos.
VI.2 Meteo - Previsão de Tempo
De 1951 a 1960, durante um período de 10 anos, o Instituto de Pesquisas

Meteorológicas da UNESP – Universidade Estadual de São Paulo coletou dados
meteorológicos no Aeroporto Internacional do Rio de Janeiro. A finalidade desta
pesquisa era a elaboração de um modelo para previsão de nevoeiro, situação de
risco para as aeronaves que utilizam este aeroporto.
Estes dados, coletados diariamente, hora a hora, eram compostos por 36
atributos perfazendo um total aproximado de 87600 casos. Falhas na coleta
ocasionaram valores omissos em alguns atributos de vários casos.
COSTA (1999) realizou um trabalho intensivo de preparação de dados que
resultou num conjunto de dados composto por 26482 casos com 18 atributos de dados
e um atributo de predição (classe) (ver Apêndice E, item E.3).
39
Dois tipos de procedimentos foram utilizados no experimento. No primeiro deles a
massa de dados foi separada em dois conjuntos de dados: treinamento e teste. Esta
separação foi realizada utilizando uma distribuição randômica uniforme procurando
manter a mesma distribuição das classes. Os dados de treinamento são compostos por
18264 casos (68,97% da massa de dados) e os dados de teste são compostos por 8218
casos (31,03& da massa de dados).
A lista dos parâmetros dos classificadores utilizados é mostrada pela Tabela VI.6.
Tabela VI.6. Meteo - Parâmetros dos classificadores utilizados
SNBi1 todos atributos de dados contínuos
SNBi2 alguns atributos de dados discretos (ver Apêndice E, item E.2)


SPLIT_METHOD = 3; alguns atributos de dados discretos (ver Apêndice E, item
E.2)
C45 todos atributos de dados contínuos; resultados antes da poda
Tabela VI.7. Meteo - Tempos de processamento (s)
Etapa SNBi1 SNBi2 MSDT1 MSDT2 C45
Treinamento 10 10 28 20 19
Predição do Treinamento 72 69 58 59 0
Predição do Teste 33 32 26 27 1
Total 115 111 112 106 20
Tabela VI.8. Meteo - Acurácia (%)
Dados SNBi1 SNBi2 MSDT1 MSDT2 C45
Treinamento 57,81 64,99 80,61 79,93 95,53

Teste 56,17 63,30 79,44 78,44 78,97
Conforme mostram as Tabelas VI.7 e VI.8, os resultados para o classificador SNBi1,

com todos atributos de dados contínuos, são inferiores ao do classificador SNBi2, com
alguns atributos discretos. Isto se deve ao fato que o classificador Bayesiano simples
utiliza distribuição normal para atributos contínuos. Quando existem poucos valores
para um atributo certamente o modelo terá maiores distorções. Foi realizado um teste
com todos os atributos discretos e o resultado obtido foi ainda melhor. Porém alguns
atributos, por suas características próprias não podem ser modelados como discretos.
40
Os tempos de processamento de todos os classificadores foram equiparáveis,
com exceção do classificador C45 que teve disparado o melhor desempenho.
Os resultados de acurácia dos modelos do classificador SNBi foram os piores
entre todos, ao contrário do experimento anterior.
classificadores SNBi2 e MSDT1 são mostrados nas Tabelas VI.9 e VI.10.
Tabela VI.9. Meteo - Tempos de processamento (s) da validação cruzada
Etapa SNBi2 MSDT1
Treinamento 156 496

Total 1368 1694
Tabela VI.10. Meteo - Acurácia (%) da validação cruzada
Dados SNBi2 MSDT1
Treinamento 64,72±0,11 80,72±0,19

Teste 64,02±0,61 80,39±0,87
Os resultados do procedimento de validação cruzada não apresentaram

diferenças significativas em relação ao procedimento que utiliza parte dos dados para
teste.
Resultados apresentados por COELHO & EBECKEN (2002) mostram resultados
muito próximos dos obtidos pelo classificador SNBi2 por um classificador Bayesiano
simples: Roc, um classificador acadêmico.
A acurácia inferior apresentada pelo classificador SNBi se deve provavelmente
ao fato que este problema apresenta dependência entre os atributos o que não é
considerado por este classificador.
VI.3 Insurance - Dados de Seguro de Vida
Este conjunto de dados foi extraído do data warehouse MASY (STAUDT, KIETZ &
REIMER, 1998) da companhia de seguros européia SwissLife com a finalidade de servir
para uma competição denominada KDD Sisyphus I (KIETZ & STAUDT, 1998) que acabou
não se completando. É um problema de grande dimensão e complexidade, tendo
sido exaustivamente preparado e estudado por COSTA (1999). Também foi objeto de
estudo por BLOCKEEL & STRUYF (20011), GÄRTNER (20011,2) e GÄRTNER, WU & FLACH
(2001).
41
Este experimento foi dividido em duas partes: a primeira delas estuda os dados
preparados (COSTA, 1999) e a segunda estuda os dados na sua forma original. Os
resultados obtidos pelas duas partes são comparados.
Os dados originais são multirelacionais e compostos por 10 tabelas. Para uso
neste experimento uma consulta SQL gerou uma tabela única a partir destas tabelas
(ver Apêndice E, item E.4).
As descrições dos parâmetros dos classificadores utilizados neste experimento se
encontram relacionadas na Tabela VI.11. Alguns atributos de dados são discretos e de
tipos idênticos para todos os classificadores utilizados.
Tabela VI.11. Insurance - Parâmetros dos classificadores utilizados
SNBi Nenhum

SPLIT_METHOD = 3

SPLIT_METHOD = 3
C45 resultados antes da poda
VI.3.1 Dados Preparados
O conjunto de dados preparados possui 130143 casos com 63 atributos de dados

e um atributo de predição (classe) (ver Apêndice E, item E.4).
Tabela VI.12. Insurance - dados preparados - Tempos de processamento (s)
Etapa SNBi MSDT1 MSDT2 C45
Treinamento 127 838 27396 270

Predição Treinamento 632 471 580 1
Predição Teste 290 215 244 8
Total 1049 1524 28220 279
Tabela VI.13. Insurance – dados preparados - Acurácia (%)
Dados SNBi MSDT1 MSDT2 C45
Treinamento 70,88 89,50 93,87 99,02

Teste 70,88 87,96 90,24 92,57
Para o primeiro procedimento este conjunto foi separado em dois: treinamento e

teste. Esta separação foi realizada utilizando uma distribuição randômica uniforme
procurando manter a mesma distribuição das classes. Os dados de treinamento são
42
compostos por 89543 casos (68,80% da massa de dados) e os dados de teste são
compostos por 40600 casos (31,20% da massa de dados). As Tabelas VI.12 e VI.13
mostram os resultados de tempo de processamento e acurácia.
Apesar de obter o menor tempo de treinamento entre os classificadores
comparados, o classificador SNBi mostrou novamente o pior resultado para acurácia.
Por sua vez, o classificador C45 apresentou um excelente desempenho em todos os
resultados. Deve ser notado o elevado tempo de processamento utilizado pelo
classificador MSDT2 que por outro lado apresentou um resultado de acurácia próximo
ao do classificador C45. Provavelmente isto se deve ao fato que o classificador MSDT2
utiliza o método da entropia para controlar o crescimento de uma árvore de decisão,
que é o mesmo método utilizado pelo classificador C45.
O procedimento de validação cruzada realizado com os classificadores SNBi e
MSDT1 é mostrado nas Tabelas VI.14 e VI.15.
Tabela VI.14. Insurance – dados preparados - Tempos de processamento (s) da validação cruzada
Etapa SNBi MSDT1
Treinamento 1661 11974

Total 10986 18926
Tabela VI.15. Insurance – dados preparados - Acurácia (%) da validação cruzada
Dados SNBi MSDT1
Treinamento 70,83±0,08 91,02±0,65

Teste 70,83±0,57 89,52±0,68
Os resultados do procedimento de validação cruzada não apresentaram

diferenças significativas em relação ao procedimento que utiliza parte dos dados para
teste.
Novamente os resultados apresentados por COELHO & EBECKEN (2002) mostram
resultados muito próximos dos obtidos pelo classificador SNBi pelo classificador
Bayesiano simples: Roc.
A acurácia inferior apresentada pelo classificador SNBi se deve provavelmente
ao fato que este problema apresenta dependência entre os atributos o que não é
considerado por este classificador.
43
VI.3.2 Dados Originais
Os mesmos procedimentos utilizados para os dados preparados foram aplicados

nos dados originais sem nenhuma preparação. Esta massa de dados engloba 146796
registros. Os dados de treinamento são compostos por 101046 casos (68,83% do total) e
os dados de teste são compostos por 45750 casos (31,17% do total). As Tabelas VI.16 e
VI.17 mostram os resultados dos tempos de processamento e acurácia.
De uma maneira geral todos os resultados apresentados, para tempos de
processamento e acurácia, foram piores do que aqueles obtidos para os dados
preparados, comprovando a necessidade de preparação. As relações entre
resultados dos classificadores são praticamente as mesmas.
Tabela VI.16. Insurance - dados originais - Tempos de Processamento (s)
Etapa SNBi MSDT1 MSDT2 C45
Treinamento 164 1158 90339 421

Total 1643 2588 91881 434
Tabela VI.17. Insurance - dados originais - Acurácia (%)
Dados SNBi MSDT1 MSDT2 C45
Treinamento 63.51 84,28 60,99 97,29

Teste 63,27 83,08 60,78 88,99
Tabela VI.18. Insurance – dados originais - Tempos de Processamento (s) da validação cruzada
Etapa SNBi MSDT1

Total 20015 31738
Tabela VI.19. Insurance – dados originais - Acurácia (%) da validação cruzada
Dados SNBi MSDT1
Treinamento 65,01±0,48 86,46±0,88

Teste 64,97±0,80 85,45±1,01

classificadores SNBi e MSDT1 são mostrados nas Tabelas VI.18 e VI.19. Estes resultados
44
não apresentaram diferenças significativas em relação ao procedimento que utiliza
parte dos dados para teste.
VI.4 Estudo de Desempenho
SONI, TANG & YANG (2002) realizaram um estudo de desempenho para o

classificador MSDT. Com base neste trabalho foi realizado um experimento para avaliar
a escalabilidade e o desempenho do classificador SNBi considerando os fatores de
cardinalidade (número de casos), número de atributos de dados, número de estados
dos atributos e número dos atributos de predição e comparando os resultados com os
produzidos pelo classificador MSDT no mesmo equipamento.
Para este experimento foi utilizado um gerador de dados artificial (MELLI, 1999)
para obtenção dos dados de treinamento. Os detalhes da geração de dados e dos
utilitários utilizados para o processamento do experimento podem ser vistos no
Apêndice E, item E.5.
Em cada procedimento do experimento é medido o tempo de treinamento
para uma variável. As descrições dos parâmetros dos classificadores utilizados podem
ser vistas na Tabela VI.20. Os tipos de atributos são discretos e idênticos para todos os
classificadores.
Tabela VI.20. Desempenho - Parâmetros dos classificadores utilizados
SNBi nenhum
MSDT COMPLEXITY_PENALTY = 0.9, MINIMUM_LEAF_CASES = 10, SCORE_METHOD = 4,

SPLIT_METHOD = 3
VI.4.1 Variação do Número de Atributos de Dados
Neste procedimento o número de casos de treinamento foi fixado em 1.000.000.

Cada atributo de dados pode ter 25 estados diferentes. O único atributo de predição
pode ter 5 diferentes classes. O gráfico da Figura VI.2 mostra os tempos de
processamento necessários para o treinamento dos dados com os números dos
atributos variando em 12, 25, 50, 100 e 200.
O classificador SNBi teve um comportamento absolutamente linear e melhor do
que o classificador MSDT que teve um comportamento praticamente linear. É
interessante notar que conforme reportado por SONI, TANG & YANG (2002) o
classificador MSDT demorou 130 minutos, ou seja 7800 segundos para treinar 1.000.000
de casos em um equipamento muito superior (4 processadores Intel Xeon de 550 MHz
e 4 gigabytes de memória RAM) ao utilizado no presente experimento. No presente
45
experimento, conforme mostra a figura citada, este tempo foi de apenas 8673
segundos.
MSDT (8673)
9000
8000
7000 i
SNB (6285)
6000
5000
4000
3000
2000
1000
0
0 50 100 150 200
Número de Atributos
Figura VI.2. Desempenho - Tempo de treinamento x Número de atributos de dados
VI.4.2 Variação do Número de Casos
Neste procedimento foi estudado o desempenho dos classificadores

comparados variando a cardinalidade do conjunto de dados de treinamento. O
número de casos de treinamento variou em 10.000, 25.000, 50.000, 75.000, 100.000,
1.000.000, 2.000.000 e 10.000.000. Enquanto isso os demais valores permaneceram
constantes. Os atributos de dados são 20, cada um com até 25 estados diferentes. O
único atributo de predição pode ter 5 diferentes classes. O gráfico da Figura VI.3
mostra os resultados com os tempos de processamento necessários para o
treinamento dos dados para os diferentes números de casos.
Novamente o classificador SNBi teve um comportamento absolutamente linear
com um desempenho melhor do que o classificador MSDT, que teve um
comportamento praticamente linear.
A Figura VI.4 mostra o gráfico com os resultados para os tempos de
processamento necessários para a predição dos mesmos conjuntos de dados de
treinamento. Este procedimento possibilitou avaliar a capacidade de processamento
do equipamento utilizado, já que na ocasião da execução da tarefa de
processamento da predição de 1.000.000 casos de treinamento com o classificador
46
SNBi ocorreu falta de memória do sistema após 2 horas e 16 minutos decorridos. Nesta
ocasião a memória virtual instalada era de apenas 1024 megabytes. Somente após
esta capacidade de memória ter sido aumentada para 2048 megabytes é que esta
tarefa pode ser completada. No entanto conforme já relatado no item VI.1 esta tarefa
excede a capacidade eficiente do equipamento utilizado devido ao uso intensivo de
memória virtual, que ocasiona o comportamento não linear nos resultados.
Outro problema ocorreu com a tarefa de predição dos dados de treinamento
pelo classificador MSDT para 1.000.000 de casos. Os dados de treinamento são obtidos
a partir de uma consulta simples de uma tabela armazenada no MSSQL, contendo
10.000.000 de registros. Ocorre que existe um limite não configurável de tempo de
espera de 30 segundos para realizar operações de consultas neste servidor. Como
consultas envolvendo esta ordem de grandeza podem ultrapassar este limite, esta
tarefa fica inviabilizada se for utilizada uma consulta. Este é um erro de programação
reportado pela Microsoft® que deverá ser alterado em futuras versões do servidor.
Para contornar este problema podem ser utilizadas tabelas ao invés de consultas. Se o
uso de consultas for necessário, estas poderão ser feitas somente através da
ferramenta de Análise de Consultas (SQL Query Analyser) a qual permite a alteração
deste tempo limite. Este problema curiosamente também foi resolvido com o aumento
da capacidade de memória virtual.
O gráfico da Figura VI.3 mostra o comportamento linear dos dois classificadores
em relação à variação do número de casos, para o tempo de treinamento. No
entanto conforme mostra o gráfico da Figura VI.4 este comportamento linear, para o
classificador SNBi, para a tarefa de predição, somente ocorreu até o número de casos
igual a 100.000.
A partir deste valor ocorreu um comportamento não linear ocasionado pela
elevada demanda de memória exigida pelo classificador para a tarefa de predição.
Este fato pode ser explicado pelos mesmos motivos expostos anteriormente com
relação ao uso de memória virtual. O consumo de memória pelo classificador SNBi
para processar a predição de 1.000.000 de casos foi de aproximadamente 1,6
megabytes.
47
8000
MSDT (7626)
7500
7000 i
SNB (6476)
6500
6000
5500
5000
4500
4000
3500
3000
2500
2000
1500
1000
500
0
0 2000000 4000000 6000000 8000000 10000000
Número de Casos
Figura VI.3. Desempenho - Tempo de treinamento x Número de casos
A partir deste resultado, como era esperado, a tarefa de predição de 10.000.000

de casos foi impossível de ser realizada pois ocorreu erro de falta de memória
(estavam em uso aproximadamente 2,2 megabytes) após 6 horas e 34 minutos de
processamento do classificador SNBi. Para viabilizar esta tentativa de processamento
foram utilizados os dados diretos da tabela pois o uso de consultas na tarefa anterior já
havia provocado excesso do tempo limite de espera no acesso ao servidor. No
entanto, mesmo assim, o classificador MSDT excedeu o tempo limite de espera para a
realização desta última tarefa. A diferença entre os tipos de erros pode ser explicada
pela maneira que cada um dos classificadores acessa internamente os dados de
treinamento. Conforme relata o trabalho de BERNHARDT, CHAUDHURI S. & FAYYAD
(1999), o classificador MSDT possui um módulo de processamento que faz consultas ao
MSSQL, o que justifica o tipo de erro apresentado por este classificador.
48
MSDTp (11002)
11000
i
SNB (9719)
10000 i
SNB p (9273)
9000
8000
Tempo de Predição (s)
7000
6000
MSDT (4987)
5000
4000
3000
2000
1000
0
0 500000 1000000 1500000 2000000
Número de Casos
Figura VI.4. Desempenho - Tempo de predição x Número de casos
Para contornar o problema da tarefa de predição de dados, foi elaborado um

procedimento para predição por partes. Assim os dados foram divididos em partes de
10.000 casos. As linhas pontilhadas do gráfico da Figura VI.4 mostram o resultado deste
teste comprovando a linearidade do comportamento dos dois classificadores para
esta tarefa.
Foram efetuados testes com atributos de dados contínuos e ambos os
classificadores apresentaram resultados similares aos resultados apresentados para
atributos de dados discretos.
49
9500
ia
SNB (8940)
9000
8500
8000
7500
7000 i
SNB (6476)
6500
6000
ii
SNB (6314)
5500
5000
4500
4000
3500
3000
2500
2000
1500
1000
500
0
0 2000000 4000000 6000000 8000000 10000000
Número de Casos
Figura VI.5. Desempenho – Incremental - Tempo de treinamento x Número de casos
Para avaliar o recurso de treinamento incremental do classificador SNBi o

procedimento para estudo da cardinalidade foi repetido com a introdução da
simulação do incremento do número de casos de treinamento. Assim o número de
casos começa com 10.000, sendo incrementado sucessivamente para 25.000, 50.000,
75.000, 100.000, 1.000.000, 2.000.000 e 10.000.000. Os resultados do classificador SNBi
não incremental, para o procedimento de cardinalidade, são reproduzidos
novamente na Figura VI.5, em linha pontilhada rotulada SNBi, para efeito de
comparação. Os resultados do classificador SNBi não incremental para este
procedimento corresponde ao valores acumulados dos resultados anteriores,
representados na figura em questão pela linha rotulada SNBia. Já os resultados do
50
classificador SNBi incremental são representados na figura pela linha rotulada SNBii.
Pode ser observado, como era óbvio, que os resultados de tempo de processamento
do processo incremental são inferiores aqueles obtidos pelo processo não incremental.
Mas a comparação entre as curvas SNBi e SNBii mostra ainda que o processo
incremental permitiu a obtenção de resultados ligeiramente melhores (~2,5%) do
aqueles obtidos pelo processo não incremental para um mesmo número de casos.
VI.4.3 Variação do Número de Estados dos Atributos de Dados
800
i
SNB (716)
700
MSDT (672)
600
500
400
300
200
100
0
0 25 50 75 100
Número de Estados
Figura VI.6. Desempenho - Tempo de treinamento x Número de estados dos atributos de dados
Neste procedimento o número de casos de treinamento é fixo em 1.000.000 e o

número de atributos de dados é constante igual a 20. O único atributo de predição
pode ter 5 diferentes classes. Os estados dos atributos de dados variam em 2, 5, 10, 25,
50, 75 e 100. Os resultados para os tempos de processamento são mostrados no
gráfico da Figura VI.6.
O gráfico da Figura VI.6 mostra ainda a clara linearidade do comportamento do
classificador SNBi, que apresentou uma leve tendência de acréscimo do tempo de
treinamento em relação ao número de estados dos atributos de dados. Por sua vez o
classificador MSDT oscilou nesta mesma tendência, apresentando um grau de
linearidade maior do que a reportada por SONI, TANG & YANG (2002).
51
VI.4.4 Variação do Número de Atributos de Predição
14000
MSDT (12330)
12000
10000
8000
6000
i
SNB (4607)
4000
2000
0
0 4 8 12 16 20 24 28 32
Número de Atributos de Predição
Figura VI.7. Desempenho - Tempo de treinamento x Número de atributos de predição
Os classificadores SNBi e MSDT possuem o recurso de gerar árvores múltiplas,

considerando múltiplos atributos de predição. Este procedimento estuda o
comportamento dos dois classificadores perante a variação do número de atributos
de predição em 1, 2, 4, 16 e 32. Enquanto isso permanecem constantes todos os outros
valores: 1.000.000 de casos; 40 atributos, incluindo entre estes o atributo de predição
para cada tarefa; e 25 estados para cada um dos atributos, inclusive para o atributo
de predição.
O gráfico da Figura VI.7 mostra nitidamente a linearidade do comportamento do
classificador SNBi, que apresentou uma leve tendência de acréscimo do tempo de
treinamento em relação ao número de atributos de predição. Novamente o
classificador MSDT apresentou linearidade no seu comportamento perante esta tarefa,
num resultado melhor do que o reportado por SONI, TANG & YANG (2002).
52
VII. Conclusão
Conforme podia ser antecipado, devido a sua formulação estatística, bem

como pela estrutura de dados da implementação, o classificador SNBi apresentou
excelente escalabilidade dentro das limitações do equipamento utilizado nos
experimentos.
Os bons resultados de acurácia do classificador SNBi no primeiro experimento e
os resultados razoáveis nos outros dois permitem concluir que, de acordo com
experiências já relatadas por outros pesquisadores (HAN & KAMBER, 2001), os
classificadores mais simples sempre devem ser incluídos entre outros classificadores
mais elaborados em estudos para escolha do melhor classificador para um
determinado problema de DM.
Os baixos tempos de processamento e a sua total escalabilidade perante
grandes massas de dados permitem concluir que, o classificador SNBi é uma opção
obrigatória no estudo de problemas deste tipo. O uso do recurso incremental, aliado
ao uso da predição por partes permite, virtualmente, o estudo de problemas de
qualquer ordem de grandeza.
A tecnologia OLE DB DM mostrou ser uma excelente ferramenta para
implementação eficiente de algoritmos de DM, alcançando a completa integração
com um SGBD relacional de uso comercial.
A diversidade dos experimentos realizados, utilizando grandes massas de dados
no experimento de desempenho, comprovam a possibilidade de disponibilização de
recursos agrupados de KDD com custo acessível, através de microcomputadores.
De acordo com o que foi apresentado, pode se concluir que foi dada uma
contribuição substancial ao desenvolvimento de ferramentas para extração de
conhecimento de dados, particularmente em relação ao desenvolvimento e
implementação de classificadores incrementais, bem como em relação ao estudo da
integração de recursos de DM com SGBDs relacionais e à utilização de
microcomputadores.
53
VIII. Trabalhos Futuros
O desempenho inferior do classificador SNBi durante as tarefas de predição de

dados sugere um aperfeiçoamento da implementação desta tarefa, tal como foi
realizado por LEUNG & SZE (1998).
O comportamento não linear dos classificadores perante um grande número de
casos justifica a execução de experimentos que utilizem equipamentos com maior
capacidade, incluindo entre estes o uso de federações de servidores de bancos de
dados, bem como equipamentos dotados de multiprocessadores.
O sucesso da experiência de implementação de um classificador simples,
utilizando a tecnologia OLE DB DM, serve de incentivo para a implementação de
classificadores e algoritmos mais complexos.
O conhecimento obtido de problemas de classificação pode ser avaliado
através de medidas de precisão, interessabilidade e compreensibilidade (NAGAI,
2000).
A avaliação de precisão do conhecimento obtido de problemas de
classificação é realizada através de uma taxa de erro calculada como uma
porcentagem de casos classificados erroneamente (QUINLAN, 19932), tal como foi
realizado nos experimentos.
A qualidade do conhecimento obtido pode ser avaliada através de medidas de
compreensibilidade (RAM, 1990) e interessabilidade (PIATETSKY-SHAPIRO & MATHEUS,
1994).
As medidas de interessabilidade incluem quatro tipo de abordagens (NAGAI,
2000):
1. Modelos de regras (regras que possuem o mesmo modelo pré-definido) (FU &
HAN, 1995; KLEMETTINEN et alii, 1994);
2. Cobertura de Regras Mínimas (regras pertencentes a um conjunto mínimo que
cobrem o maior número de casos) (TOIVONEN et alii, 1995);
3. Acionabilidade de Regras (regras que possam oferecer vantagens no seu uso)
(PIATETSKY-SHAPIRO & MATHEUS; 1994, SILBERSCHATZ, 1995);
4. Inesperabilidade de Regras (regras que possuem um fator de surpresa, medido
estatisticamente como: uma alta casualidade que aparece sob uma suposição
ou hipótese independente; ou como uma tendência contrária ao esperado
pelo usuário) (LIU & HSU, 1996; Freitas, 19981,2).
Um exemplo simples e eficiente de avaliação da interessabilidade de regras
para problemas de classificação foi mostrado por CHEN & LIU (2001).
A implementação de procedimentos para avaliação do conhecimento obtido,
baseados nos trabalhos citados, é uma tarefa altamente desejável e promissora.
54
REFERÊNCIAS
AGRAWAL, R. & SHIM, K., 1995, Developing Tightly-Coupled Applications on IBM DB2/CS
Relational Database System: Methodology and Experience, IBM Research Report RJ 10005,
IBM Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/udfrj.pdf.
AGRAWAL, R. & SRIKANT, R., 19941, Fast Algorithms for Mining Association Rules, IBM Research
Report RJ 9839, IBM Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/vldb94_rj.pdf.
AGRAWAL, R. & SRIKANT, R., 19942, Mining Sequential Patterns, IBM Research Report RJ 9910, IBM
Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/icde95_rj.pdf.
AGRAWAL, R. et alii, 1992, "An Interval Classifier for Database Mining Applications", In: Proc. of the
VLDB 1992, 18th Int'l Conf. on Very Large Databases, Vancouver, British Columbia,
Canada, pp. 560-573. http://www.almaden.ibm.com/cs/quest/papers/vldb92.pdf.
AGRAWAL, R. et alii, 19952, "Fast Similarity Search in the Presence of Noise, Scaling, and Translation
in Time-Series Databases", In: Proc. of the VLDB 1995, 21st Int'l Conf. on Very Large
Databases, Zurich, Switzerland, pp. 490-501.
http://www.almaden.ibm.com/cs/quest/papers/vldb95_seq.pdf.
AGRAWAL, R. et alii, 19961, "The Quest Data Mining System", In: Proc. of the KDD'96, 2nd Int'l Conf.
on Knowledge Discovery in Databases and Data Mining, Portland, Oregon, USA, pp. 244-
249. http://www.almaden.ibm.com/cs/quest/papers/kdd96_quest.pdf.
AGRAWAL, R., BAYARDO JR., R.J. & SRIKANT, R., 1999, Athena: Mining-based Interactive
Management of Text Databases, IBM Research Report RJ 10153, IBM Almaden Research
Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/people/ragrawal/papers/athena.ps.
AGRAWAL, R., FALOUTSOS, C. & SWAMI, A., 1993, "Efficient Similarity Search in Sequence
Databases", In: Proc. of the 4th Int'l Conf. on Foundations of Data Organization and
Algorithms, Lecture Notes in Computer Science 730, Chicago, Illinois, USA, Springer-Verlag,
pp. 69-84. http://www.almaden.ibm.com/cs/quest/papers/fodo93.pdf.
AGRAWAL, R., IMIELINSKI, T. & SWAMI, A., 19931, "Mining Association Rules between Sets of Items in
Large Databases", In: Proc. of the SIGMOD'93, ACM SIGMOD Int'l Conf. on Management of
Data, Washington DC, USA, pp. 207-216.
http://www.almaden.ibm.com/cs/quest/papers/sigmod93.pdf.
AGRAWAL, R., IMIELINSKI, T. & SWAMI, A., 19932, "Database Mining: A Performance Perspective",
IEEE Transactions on Knowledge and Data Engineering, Vol. 5, No. 6, pp. 914-925.
http://www.almaden.ibm.com/cs/quest/papers/tkde93.pdf.
BAESENS, B. et alii, 2002, "Learning Bayesian Network Classifiers for Credit Scoring using Markov
Chain Monte Carlo Search", In: Proc. of the 16th Int'l Conf. on Pattern Recognition, Quebec
City, Quebec, Canada, Vol. 3, pp. 49-52. http://ieeexplore.ieee.org.
55
BECERRA-FERNANDEZ, I., ZANAKIS, S.H. & WALCZAK, S., 2002, "Knowledge Discovery Techniques for
Predicting Country Investment Risk", Computers & Industrial Engineering, Vol. 43, No. 4, pp.
787-800. http://www.elsevier.com.
BERNHARDT, J., CHAUDHURI S. & FAYYAD, U.M., 1999, "Scalable Classification over SQL
Databases", In: Proc. of the ICDE'99, 15th Int´l Conf. on Data Engineering, Sydney, Australia,
pp. 470-479. ftp://ftp.research.microsoft.com/users/AutoAdmin/icde99.pdf.
BEZERRA, E., 1999, Explorando Paralelismo em Primitivas de Mineração de Dados para a Tarefa
de Classificação, Tese de Mestrado, COPPE/UFPR, Rio de Janeiro, RJ, Brasil.
http://www.cos.ufrj.br/~bezerra/publications/Thesis/MSc/thesis.html.
BEZERRA, E. & XEXÉO, G.B., 1998, "Constructing Data Mining Functionalities in a DBMS", In: Data
Mining (Proc. of the Int'l Conf. on Data Mining), Rio de Janeiro, RJ, Brazil, Ebecken, N. F. F.
(ed.), WIT Press, pp. 367-381. http://www.witpress.com.
BEZERRA, E. & XEXÉO, G.B., 1999, "Uma Primitiva para dar Suporte à Tarefa de Classificação em
Mineração de Dados", In: Proc. of the XIV Brazilian Simposium on Data Bases, Florianópolis,
SC, Brazil. http://www.cos.ufrj.br/~bezerra/publications/sbbd99.pdf.
BEZERRA, E., MATTOSO, M.L.Q & XEXÉO, G.B., 2000, "An Analysis of the integration between data
mining applications and database systems", In: Data Mining II (Proc. of the 2nd Int'l Conf.
on Data Mining), Cambridge, UK, Ebecken, N. & Brebbia, C.A. (eds.), WIT Press, pp. 151-
160. http://www.witpress.com.
BLAKE, C.L. & MERZ, C.J., 1998, UCI Repository of Machine Learning Databases, University of
California, Department of Information and Computer Science, Irvine, CA, USA.
http://www.ics.uci.edu/~mlearn/MLRepository.html.
BLOCKEEL, H. & STRUYF, J., 20011, "Frankenstein Classifiers: Some experiments on the Sisyphus data
set", In: Proc. of IDDM-2001 - ECML/PKDD01 Workshop on Integrating Aspects of Data
Mining, Decision Support and Meta-Learning, Freiburg, Germany, Giraud-Carrier, C.,
Lavrac, N. & Moyle, S. (eds.), pp. 1-12.. http://ai.ijs.si/branax/iddm-2001-proceedings/paper3.pdf.
BLOCKEEL, H. & STRUYF, J., 20012, "Deriving Biased Classifiers for Better ROC Performance", In: Proc.
of the Information Society 2001, Ljubljana, Slovenia, Grobelnik, M. & Mladenic, D. (eds.),
pp. 124-127. http://www.cs.kuleuven.ac.be/~dtai/publications/files/36366.ps.gz.
BOJARCZUK, C.C., LOPES, H.S. & FREITAS, A.A., 1999, "Discovering Comprehensible Classification
Rules using Genetic Programming: a Case Study in a Medical Domain", In: Proc. of the
GECCO'99, Genetic and Evolutionary Computation Conf., Orlando, Florida, USA, pp. 953-
958. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/gecco99.ps.
BOJARCZUK, C.C., LOPES, H.S. & FREITAS, A.A., 2000, "Genetic Programming for Knowledge
Discovery in Chest Pain Diagnosis", IEEE Engineering in Medicine and Biology Magazine,
Vol. 19, No. 4, pp. 38-44. http://www.ppgia.pucpr.br/~alex.
BRADLEY, P.S., FAYYAD, U.M & REINA, C.A., 1999, Scaling EM (Expectation Maximization) Clustering
to Large Databases, Technical Report MSR-TR-98-35, Microsoft Research, Microsoft
Corporation, Redmond, Washington, USA. ftp://ftp.research.microsoft.com/pub/tr/tr-98-35.pdf.
BREIMAN, L. et alii, 1984, Classification And Regression Trees, 1st ed., Boca Raton, Florida, USA,
Chapman & Hall/CRC. http://www.crcpress.com.
56
CHAKRABARTI, S. et alii, 1997, Using Taxonomy, Discriminants, and Signatures for Navigating in Text
Databases, IBM Research Report, IBM Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/vldb97_txt_j.ps.gz.
CHAPMAN, P. ET ALLI, 2000, CRISP-DM 1.0 - Step-by-step Data Mining Guide, Technical Report,
CRISP-DM consortium, SPSS Inc., USA. http://www.crisp-dm.org.
CHAU, K.W. et alii, 2003, "Application of Data Warehouse and Decision Support System in
Construction Management", Automation in Construction, Vol. 12, No. 2, pp. 213-224.
http://www.elsevier.com.
CHAUDHURI, S., 1998, "Data Mining and Database Systems: Where is the Intersection?", IEEE Data
Engineering Bulletin, Vol. 21, No. 1, pp. 4-8. ftp://ftp.research.microsoft.com/pub/debull/98MAR-
CD.pdf.
CHEESEMAN, P. & STUTZ, J., 1995, "Bayesian Classification (AutoClass): Theory and Results", In:
Advances in Knowledge Discovery and Data Mining, Fayyad, U.M. et alii (eds.), AAAI/MIT
Press, pp. 153-180. http://ic.arc.nasa.gov/ic/projects/bayes-group/images/kdd-95.ps.
CHEN, M.S., HAN, J. & YU, P.S., 1996, "Data Mining: An Overview from a Database Perspective",
IEEE Transactions on Knowledge and Data Engineering, Vol. 8, No. 6, pp. 866-883.
ftp://ftp.fas.sfu.ca/pub/cs/han/kdd/survey97.ps.gz.
CHEN, Q., 1999, Mining Exceptions and Quantitative Association Rules in OLAP Data Cube, M.Sc.
Thesis, Computing Science, Simon Fraser University, Burnaby, British Columbia, Canada.
ftp://fas.sfu.ca/pub/cs/theses/1999/QingChenMSc.ps.gz.
CHEN, S. & LIU, B., 2001, "Generating Classification Rules According to User's Existing Knowledge",
In: Proc. of the SDM-01- 1st SIAM Int'l Conf. on Data Mining, Chicago, Illinois, USA.
http://www.siam.org/meetings/sdm01/pdf/sdm01_15.pdf.
CHICKERING, D.M., GEIGER, D. & HECKERMAN, D., 1994, Learning Bayesian Networks: The
Combination of Knowledge and Statistical Data, Technical Report MSR-TR-94-09, Microsoft
Research, Microsoft Corporation, Redmond, Washington, USA.
ftp://ftp.research.microsoft.com/pub/tr/tr-94-09.ps.
COELHO, P.S.S. & EBECKEN, N.F.F., 2002, "A Comparison of some Classification Techniques", In:
Data Mining III (Proc. of the 3rd Int'l Conf. on Data Mining), Bologna, Italy, Zanasi, A. et alii
(eds.), WIT Press, pp. 573-582. http://www.witpress.com.
COSTA, M.C.A., 1999, Data Mining em Computadores de Alto Desempenho Utilizando-se Redes
Neurais, Tese de Doutorado, COPPE/UFPR, Rio de Janeiro, RJ, Brasil. http://www.coc.ufrj.br.
CRAVEN, M. et alii, 2000, "Learning to Construct Knowledge Bases from the World Wide Web",
Artificial Intelligence, Vol. 118, No. 1-2, pp. 69-113. http://www.cs.wisc.edu/~craven/aij00.ps.gz.
CRAWFORD, S.L., 1989, "Extensions to the CART algorithm", Int'l Journal of Man-Machine Studies,
Vol. 31, No. 2, pp. 197-217. http://dblab.ce.cnu.ac.kr/~dolphin/db/indices/a-
tree/c/Crawford:Stuart_L=.html.
CUROTTO, C.L., 2002, Thin Client Decision Viewer Sample Modified, ASP utility application hosted
by Data Mining Community Web Site. http://communities.msn.com/AnalysisServicesDataMining.
DBMINER TECHNOLOGY INC., 2002, DBMiner, DBMiner Technology Inc., Vancouver, British
Columbia, Canada. http://www.dbminer.com.
57
DMG - DATA MINING GROUP, 2002, PMML - Predictive Model Markup Language Version 2.0
Specification, Data Mining Group. http://www.dmg.org.
DOMINGOS, P. & PAZZANI, M., 1996, "Beyond Independence: Conditions for the Optimality of the
Simple Bayesian Classifier", In: Proc. of the 13th Int'l Conf. on Machine Learning, Bari, Italy,
pp. 105-112. http://www.cs.washington.edu/homes/pedrod/papers/mlc96.pdf.
DOMINGOS, P. & PAZZANI, M., 1997, "On the Optimality of the Simple Bayesian Classifier under
Zero-One Loss", Machine Learning, Vol. 29, No. 2-3, pp. 103-130.
http://www.cs.washington.edu/homes/pedrod/papers/mlj97.pdf.
FAIRBAIRN, E.M.R. et alii, 1999, "Retroanálise Neural Para a Identificação dos Parâmetros Elásticos
da Barragem Casca de Funil", In: Anais do XXIII Seminário Nacional de Grandes Barragens,
Belo Horizonte, MG, Brazil, V.1, pp 339-345. http://www.coc.ufrj.br/~alvaro/papers/funil.ps.gz.
FAYYAD, U.M., CHAUDHURI, S. & BRADLEY, P.S., 2000, "Data Mining and its Role in Database
Systems. Tutorial", VLDB 2000, 26th Int´l Conf. on Very Large Databases, Cairo, Egypt,
Tutorial. http://www.research.microsoft.com/dmx/VLDB2000Tut/VLDB2000Tut-Web.pdf.
FAYYAD, U.M., PIATETSKY-SHAPIRO, G. & SMYTH, P., 1995, "From Data Mining to Knowledge
Discovery: An Overview", In: Advances in Knowledge Discovery and Data Mining, Fayyad,
U.M. et alii (eds.), AAAI/MIT Press, pp. 1-36. http://mitpress.mit.edu.
FAYYAD, U.M., PIATETSKY-SHAPIRO, G. & SMYTH, P., 19961, "From Data Mining to Knowledge
Discovery in Databases", AI Magazine, Vol. 17, No. 3, pp. 37-54.
http://kdnuggets.com/gpspubs/aimag-kdd-overview-1996-Fayyad.pdf.
FAYYAD, U.M., PIATETSKY-SHAPIRO, G. & SMYTH, P., 19962, "Knowledge Discovery and Data Mining:
Towards a Unifying Framework", In: Proc. of the KDD'96, 2nd Int'l Conf. on Knowledge
Discovery and Data Mining, Portland, Oregon, USA. pp. 82-88.
http://citeseer.nj.nec.com/fayyad96knowledge.html.
FRANK, E. et alii, 2000, "Technical Note: Naive Bayes for Regression", Machine Learning, Vol. 41,
No. 1, pp. 5-25. http://www.cs.waikato.ac.nz/~ml/publications/2000/Frank-et-al-Naive-Bayes.pdf.
FREITAS, A.A., 19971, "A Genetic Programming Framework for Two Data Mining Tasks: Classification
and Generalized Rule Induction", In: Genetic Programming 1997 (Proc. of the 2nd Annual
Conf.), Stanford, UK, Deb, K. et alii (eds.), Morgan Kaufmann Publishers, pp. 96-101.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/gp97.ps.
FREITAS, A.A., 19972, Generic, Set-Oriented Primitives to Support Data-Parallel Knowledge

Discovery in Relational Database Systems, Ph.D. Thesis, University of Essex, UK.
http://www.ppgia.pucpr.br/~alex/thesis.html.
FREITAS, A.A., 19973, "Towards Large-scale Knowledge Discovery in Databases (KDD) by Exploiting
Parallelism in Generic KDD Primitives", In: Proc. of the 3rd Int'l Workshop on Next-Generation
Info. Technologies and Systems, Neve Ilan, Israel, pp. 33-43.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/ngits97.ps.
FREITAS, A.A., 19981, "A Multi-Criteria Approach for the Evaluation of Rule Interestingness", In: Data
Mining (Proc. of the Int'l Conf. on Data Mining), Rio de Janeiro, RJ, Brazil, Ebecken, N. F. F.
(ed.), WIT Press, pp. 7-20. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/dmrio98.ps.
58
FREITAS, A.A., 19982, "On Objective Measures of Rule Surprisingness", In: Principles of Data Mining &
Knowledge Discovery (Proc. of the PKDD'98, 2th European Conf.), Lecture Notes in Artificial
Intelligence 1510, Nantes, France, Zytkow, J. M. & Quafafon, M. (eds.), Springer-Verlag, pp.
1-9. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/pkdd98.ps.
FREITAS, A.A. & LAVINGTON, S.H., 19961, "Parallel Data Mining for Very Large Relational
Databases", In: Proc. of the HPCN'96, Int'l Conf. on High-Performance Computing and
Networking, Lecture Notes in Computer Science 1067, Brussels, Belgium, Liddel, H. et alii
(eds.), Springer-Verlag, pp. 158-163. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/hpcn96.ps.
FREITAS, A.A. & LAVINGTON, S.H., 19962, "Using SQL Primitives and Parallel DB Servers to Speed Up
Knowledge Discovery in Large Relational Databases", In: Cybernetics and Systems'96 (Proc.
of the 13th European Meeting on Cybernetics and Systems Research), Vienna, Austria,
Trappl, R. (eds.), pp. 955-960. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/cyber96.ps.
FREITAS, A.A. & LAVINGTON, S.H., 19963, "Speeding up Knowledge Discovery in Large Relational
Databases by Means of a New Discretization Algorithm", In: Advances in Databases (Proc.
of the BNCOD-14, 14th British Nat. Conf. on Databases), Lecture Notes in Artificial
Intelligence 1094, Edinburgh, UK, Morrison, R. & Kennedy, J. (eds.), Springer-Verlag, pp. 124-
133. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/bncod96.ps.
FREITAS, A.A. & LAVINGTON, S.H., 19964, "A Framework for Data-Parallel Knowledge Discovery in
Databases", In: Proc. of the IEE Colloquium on Knowledge Discovery and Data Mining,
London, UK, Digest No. 96/198, pp. 6/1-6/4.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/iee96.ps.
FU, Y. & HAN, J., 1995, "Meta-Rule-Guided Mining of Association Rules in Relational Databases", In:
Proc. of the KDOOD'95, Int'l Workshop. on Knowledge Discovery and Deductive and
Object-Oriented Databases, Singapore, Malaysia, pp. 39-46.
ftp://ftp.fas.sfu.ca/pub/cs/han/kdd/kdood95.ps.gz.
GÄRTNER, T., 20011, The Contribution of the University of Bristol to the Sisyphus Data Mining
Problem, Technical Report, University of Bristol, Bristol, UK.
http://www.cs.bris.ac.uk/~SolEuNet/Library/Ps/gaertner-sisyphus.pdf.
GÄRTNER, T., 20012, ROC analysis on Sisyphus Data, Technical Report, University of Bristol, Bristol,
UK. http://www.cs.bris.ac.uk/~SolEuNet/Library/Ps/gaertner-sisyphus-roc.pdf.
GÄRTNER, T., WU, S. & FLACH, P. A., 2001, "Data Mining on the Sisyphus Dataset: Evaluation and
Integration of Results", In: Proc. of IDDM-2001 - ECML/PKDD01 Workshop on Integrating
Aspects of Data Mining, Decision Support and Meta-Learning, Freiburg, Germany, Giraud-
Carrier, C., Lavrac, N. & Moyle, S. (eds.), pp. 69-80.. http://ai.ijs.si/branax/iddm-2001-
proceedings/paper10.pdf.
HAN, J., 1997, "OLAP Mining: An Integration of OLAP with Data Mining", In: Proc. of the DS-7, IFIP
Conf. on Data Semantics, Leysin, Switzerland, pp. 1-11.
ftp://ftp.fas.sfu.ca/pub/cs/han/kdd/olapm.ps.gz.
HAN, J. & KAMBER, M., 2001, Data Mining: Concepts and Techniques, 1st ed., San Francisco,
California, USA, Morgan Kaufmann Publishers. http://www.mkp.com.
59
HAN, J. et alii, 19961, "DMQL: A Data Mining Query Language for Relational Databases", DMKD'96,
SIGMOD'96 Workshop on Research Issues on Data Mining and Knowledge Discovery,
Montreal, Quebec, Canada. ftp://ftp.fas.sfu.ca/pub/cs/han/kdd/dmql96.ps.gz.
HAN, J. et alii, 19962, "DBMiner: Interactive Mining of Multiple-Level Knowledge in Relational
Databases", In: Proc. of the SIGMOD'96, ACM SIGMOD Int'l Conf. on Management of Data,
Montreal, Quebec, Canada, pp. 550-550. http://www.acm.org.
HAN, J. et alii, 19963, "DBMiner: A System for Mining Knowledge in Large Relational Databases", In:
Proc. of the KDD'96, 2nd Int'l Conf. on Knowledge Discovery in Databases and Data
Mining, Portland, Oregon, USA, pp. 250-255. ftp://ftp.fas.sfu.ca/pub/cs/han/kdd/kdd96.ps.gz.
HAN, J., CHEE, S. & CHIANG, J.Y., 1998, "Issues for On-Line Analytical Mining of Data Warehouses",
In: Proc. of the DMKD'98, SIGMOD'98 Workshop on Research Issues on Data Mining and
Knowledge Discovery, Seattle, Washington, USA, pp. 2:1-2:5.
ftp://ftp.fas.sfu.ca/pub/cs/han/kdd/dmkd98.ps.gz.
HANSON, R., STUTZ, J. & CHEESEMAN, P., 1991, Bayesian Classification Theory, Technical Report
FIA-90-12-7-01, NASA Ames Research Center, Artificial Intelligence Branch, Moffett Field,
California, USA. http://ic.arc.nasa.gov/ic/projects/bayes-group/images/tr-fia-90-12-7-01.ps.
JOHN, G.H., 1997, Enhancements to the Data Mining Process, Ph.D. Dissertation, Stanford
University, California, USA. http://robotics.stanford.edu/users/gjohn.
JOHN, G.H. & LANGLEY, P., 1995, "Estimating Continuous Distributions in Bayesian Classifiers", In:
Proc. of the UAI'95, 11th Conf. on Uncertainty in Artificial Intelligence, Montreal, Quebec,
Canada, pp. 338-345. http://www.isle.org/~langley/papers/flex.uai95.ps.gz.
KALLES, D., 1994, Decision Trees and Domain Knowledge in Pattern Recognition, Ph.D. Thesis,
University of Manchester Institute of Science and Technology (UMIST), Manchester, UK.
http://www.cti.gr/RD3/users/kallesData/abstractphd.htm.
KIETZ, J.U. & STAUDT, M., 1998, KDD Sisyphus I - Data set, Information Systems Research, CH/IFUE,
Swiss Life, Zurich, Switzerland. http://www.cs.wisc.edu/~lists/archive/dbworld/0426.html.
KIM, P., 2002, Microsoft.public.sqlserver.datamining FAQ (Frequently Asked Questions and
Answers), Resource hosted by Data Mining Community Web Site.
http://communities.msn.com/AnalysisServicesDataMining.
KIM, P. & CARROLL, M., 2002, Making OLE DB for Data Mining queries against a DM provider,
Visual Basic utility application hosted by Data Mining Community Web Site.
KING, M.D. & GREENSTONE, R., 1999, 1999 EOS Reference Handbook, 1999 ed., Greenbelt,
Maryland, USA, NASA/Goddard Space Flight Center.
http://eospso.gsfc.nasa.gov/eos_homepage/misc_html/refbook.html.
KLEMETTINEN, M. et alii, 1994, "Finding Interesting Rules from Large Sets of Discovered Association
Rules", In: Proc. of the CIKM'94, 3rd Int'l Conf. on Information and Knowledge Management,
Gaithersburg, Maryland, USA, pp. 401-407.
http://www.cs.helsinki.fi/research/fdk/datamining/pubs/cikm94.ps.gz.
LANGLEY, P., IBA, W. & THOMPSON, K., 1992, "An Analysis of Bayesian Classifiers", In: Proc. of the
AAAI'92, 10th National Conf. on Artificial Intelligence, San Jose, California, USA, pp. 223-
228. http://www.isle.org/~langley/papers/bayes.aaai92.ps.gz.
60
LEUNG, C.H. & SZE, L., 1998, "A Method to Speed Up the Bayes Classifier", Engineering Applications
of Artificial Intelligence, Vol. 11, No. 3, pp. 419-424. http://www.elsevier.com.
LIU, B. & HSU, W., 1996, "Post-Analysis of Learned Rules", In: Proc. of the AAAI'96, 13th National
Conf. on Artificial Intelligence, Portland, Portland, Oregon, USA, pp. 828-834.
http://www.comp.nus.edu.sg/~liub/publications/aaai96.int.ps.
MADIGAN, D. & RIDGEWAY, G., 2002, Bayesian Data Analysis for Data Mining, Technical Report,
Rutgers University, Piscataway, New Jersew, USA.
http://www.stat.rutgers.edu/~madigan/PAPERS/bayes.ps.
MAES, S. et alii, 2002, "Credit Card Fraud Detection. Applying Bayesian and Neural networks", In:
Proc. of the NF2002, 1st Int'l NAISO Congress on Neuro Fuzzy Technologies, Havana, Cuba.
http://como.vub.ac.be/Members/karl/P100027-01-BM-096.ps.
MELLI, G., 1999, DatGen - Dataset Generator, Web Resource. http://www.datgen.com.

MENESES, C.J. & GRINSTEIN, G.G., 1998, "Categorization and Evaluation of Data Mining
Techniques", In: Data Mining (Proc. of the Int'l Conf. on Data Mining), Rio de Janeiro, RJ,
Brazil, Ebecken, N. F. F. (ed.), WIT Press, pp. 53-80. http://www.witpress.com.
MEO, R., PSAILA, G. & CERI, S., 1996, "A New SQL-like Operator for Mining Association Rules", In:
Proc. of the VLDB 1996, 22th Int'l Conf. on Very Large Databases, Mumbai, Bombay, India,
pp. 122-133. http://www.vldb.org/conf/1996/P122.PDF.
MICROSOFT CORPORATION, 19981, Visual Studio™ Developing for the Enterprise, online ed.,
Redmond, Washington, USA, Microsoft Corporation.
http://msdn.microsoft.com/library/default.asp?url=/library/en-
us/vsentpro/html/veovrdevelopingforenterprise.asp.
MICROSOFT CORPORATION, 19982, Visual Studio™ 6.0, Microsoft Corporation, Redmond,

Washington, USA. http://msdn.microsoft.com/vstudio.
MICROSOFT CORPORATION, 20001, Microsoft® SQL Server™ 2000, Microsoft Corporation,
Redmond, Washington, USA. http://www.microsoft.com/sql.
MICROSOFT CORPORATION, 20002, OLE DB for Data Mining Specification Version 1.0, Microsoft
Corporation, Redmond, Washington, USA. http://www.microsoft.com/data/oledb/dm.htm.
MICROSOFT CORPORATION, 2001, Microsoft® Platform Software Development Kit, Microsoft
Corporation, Redmond, Washington, USA.
http://www.microsoft.com/msdownload/platformsdk/sdkupdate.
MICROSOFT CORPORATION, 2002, OLE DB for Data Mining Resource Kit, Microsoft Corporation,
Redmond, Washington, USA. http://www.microsoft.com/data/oledb/DMResKit.htm.NAGAI, W.A.,
2000, Avaliação do Conhecimento Extraído de Problemas de Regressão (Evaluation of
Knowledge Extracted from Regression Problems), Dissertação de Mestrado (M.Sc.
Dissertation), Universidade de São Paulo – São Carlos - SP, Brazil.
http://www.icmc.sc.usp.br/~solange.
NETZ, A. et alii, 2000, "Integration of Data Mining and Relational Databases", In: Proc. of the VLDB
2000, 26th Int´l Conf. on Very Large Data Bases, Cairo, Egypt, pp. 719-722.
ftp://ftp.research.microsoft.com/users/AutoAdmin/vldb00DM.pdf.
61
NETZ, A. et alii, 2001, "Integrating Data Mining with SQL Databases: OLE DB for Data Mining", In:
Proc. of the ICDE'01, 17th Int´l Conf. on Data Engineering, Heidelberg, Germany, pp. 379-
387. ftp://ftp.research.microsoft.com/users/AutoAdmin/netza_oledb.pdf.
PARPINELLI, R.S., LOPES H.S. & FREITAS, A.A., 2001, "An Ant Colony Based System for Data Mining:
Applications to Medical Data", In: Proc. of the GECCO'2001, Genetic and Evolutionary
Computation Conf., San Francisco, California, USA.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/GECCO-2001-Raf.ps.
PERLMAN, G., 1986, The |STAT Handbook Data Analysis Programs on UNIX and MSDOS, online ed.,
Gary Perlman's Home Page. http://www.acm.org/~perlman/stat.
PIATETSKY-SHAPIRO, G. & MATHEUS, C.J., 1994, "The Interestingness of Deviations", In: Proc. of the
KDD'94, AAAI'94 Knowledge Discovery in Databases Workshop, Seattle, Washington, USA,
pp. 25-36. ftp.gte.com/pub/matheus/kd/kdd94-int.ps.
PYLE, D., 1999, Data Preparation for Data Mining, 1st ed., San Francisco, California, USA, Morgan
Kaufmann Publishers. http://www.mkp.com.
QUAH, T. & SRINIVASAN, B., 1999, "Improving Returns on Stock Investment through Neural Network
Selection", Expert Systems with Applications, Vol. 17, No. 4, pp. 295-301.
http://www.elsevier.com.
QUINLAN, J.R., 19931, "A Case Study in Machine Learning", In: Proc. of the ACSC'93, 16th Australian
Computer Science Conf., Brisbane, Australia, pp. 731-737.
http://www.cse.unsw.edu.au/~quinlan/q.acsc93.ps.
QUINLAN, J.R., 19932, C4.5: Programs for Machine Learning, 1st ed., San Mateo, California, USA,
Morgan Kaufmann Publishers. http://www.cse.unsw.edu.au/~quinlan.
RAM, A., 1990, "Kknowledge Goals: A Theory of Interestigness", In: Proc. of the 12th Annual Conf.
of the Cognitive Science Society, Cambridge, Massachusetts, USA, pp. 206-214.
http://www.cc.gatech.edu/faculty/ashwin/papers/er-90-02.ps.Z.
ROUSU, J., ELOMAA, T. & AARTS, R., 1999, "Predicting the Speed of Beer Fermentation in
Laboratory and Industrial Scale", In: Engineering Applications of Bio-Inspired Artificial Neural
Networks (Proc. of the 5th Int'l Work-Conf), Lecture Notes in Computer Science 1607,
Alicante, Spain, Mirá, J. & Sánchez-Andrés, J. V. (eds.), Springer-Verlag, pp. 893-901.
http://www.cs.helsinki.fi/~elomaa/papers/iwann-final.ps.gz.
SANDSTONE TECNOLOGY INC., 2000, Visual Parse++ Version 4.00, Sandstone Tecnology Inc.,
Carlsbad, California, USA. http://www.sand-stone.com.
SARAWAGI, S., THOMAS, S. & AGRAWAL, R., 1998, Integrating Association Rule Mining with
Databases: Alternatives and Implications, IBM Research Report RJ 10107, IBM Almaden
Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/sigmod98_dbi_rj.pdf.
SATTLER, K. & DUNEMANN, O., 2001, "SQL Database Primitives for Decision Tree Classifiers", In: Proc.
of the CIKM 2001, 10th ACM Int'l Conf. on Information and Knowledge Management,
Atlanta, Georgia, USA, pp. 379-386. http://www.acm.org.
SEIDMAN, C., 2001, Data Mining with Microsoft® SQL Server™ 2000 - Technical Reference, 1st ed.,
Redmond, Washington, USA, Microsoft Press. http://www.mspress.microsoft.com.
62
SETH, P., 2001, Third-Party Data Mining Providers, White paper, Microsoft Research, Microsoft
Corporation, Redmond, Washington, USA.
http://www.microsoft.com/sql/techinfo/BI/2000/DMAggregator.doc.
SETH, P., GUATAM, N. & BALINT, R., 2002, Preparing and Mining Data with Microsoft® SQL Server™
2000 and Analysis Services, online ed., Redmond, Washington, USA, Microsoft Online Books.
http://msdn.microsoft.com/library/default.asp?url=/servers/books/sqlserver/mining.asp.
SFORNA, M., 2000, "Data Mining in a Power Company Customer Database", Electric Power
Systems Research, Vol. 55, No. 3, pp. 201-209. http://www.elsevier.com.
SILBERSCHATZ, A., 1995, "On Subjective Measures of Interestingness in Knowledge Discovery", In:
Advances in Knowledge Discovery and Data Mining (Proc. of the KDD'95, 1st Int'l Conf. on
Knowledge Discovery and Data Mining), Montreal, Quebec, Canada, Fayyad, U.M. &
Uthurusamy, R. (eds.), AAAI/MIT Press, pp. 275-281. http://www.bell-
labs.com/user/avi/publication-dir/kdd95.ps.
SILVER, D.L, 1998, Knowledge Discovery and Data Mining, MBA course notes of Dalhousie
University, Nova Scotia, Canada. http://ttg.sba.dal.ca/sba/profs/dsilver.
SKONNARD, A., 1998, "Say UDA for All Your Data Access Needs", Microsoft Interactive Developer,
April, 1998. http://www.microsoft.com/mind/0498/uda/uda.asp.
SONI, S., TANG, Z. & YANG, J., 2002, Performance Study of Microsoft® Data Mining Algorithms,
White paper, Microsoft Research, Microsoft Corporation, Redmond, Washington, USA.
http://www.microsoft.com/SQL/evaluation/compare/AnalysisDMWP.asp.
SOUSA, M.S., 1998, Mineração de Dados: uma Implementação Fortemente Acoplada a um

Sistema Gerenciador de Banco de Dados Paralelo, Tese de Mestrado, COPPE/UFPR, Rio
de Janeiro, RJ, Brasil. http://www.cos.ufrj.br/~mauros.
SOUSA, M.S., MATTOSO, M.L.Q. & EBECKEN, N.F.F., 19981, "Data Mining on Parallel Database
Systems", In: Proc.of the Int'l Conf. on PDPTA, Special Session on Parallel Data Warehousing,
Las Vegas, Nevada, USA. http://www.cos.ufrj.br/~mauros.
SOUSA, M.S., MATTOSO, M.L.Q. & EBECKEN, N.F.F., 19982, "Data Mining: A Tightly- Coupled
Implementation using a Parallel Database Server", In: Proc. of the DEXA 1998 9th Int'l
Workshop on Database and Expert Systems Applications, Vienna, Austria, pp. 711-716.
http://www.cos.ufrj.br/~mauros.
SOUSA, M.S., MATTOSO, M.L.Q. & EBECKEN, N.F.F., 19983, "Data Mining: a Database Perspective",
In: Data Mining (Proc. of the Int'l Conf. on Data Mining), Rio de Janeiro, RJ, Brazil, Ebecken,
N. F. F. (ed.), WIT Press, pp. 413-431. http://www.cos.ufrj.br/~mauros.
STAUDT, M., KIETZ, J.U. & REIMER, U., 1998, "A Data Mining Support Environment and its Application
on Insurance Data", In: Proc. of the KDD'98, 4th Int'l Conf. on Knowledge Discovery and
Data Mining, New York City, New York, USA, Agrawal, R., Stolorz, P.E. & Piatetsky-Shapiro, G.
(eds.), AAAI Press, pp. 105-111. http://kietz.ch/kdd98.ps.gz.
STEFANOVIC, N., 1997, Design and Implementation of On-Line Analytical Processing (OLAP) of
Spatial Data, M.Sc. Thesis, Computing Science, Simon Fraser University, Burnaby, British
Columbia, Canada. ftp://fas.sfu.ca/pub/cs/theses/1997/NebojsaStefanovicMSc.ps.gz.
63
TAM, Y.J., 1998, Datacube: Its Implementation and Application in OLAP Mining, M.Sc. Thesis,
Computing Science, Simon Fraser University, Burnaby, British Columbia, Canada.
ftp://fas.sfu.ca/pub/cs/theses/1998/YinJennyTamMSc.ps.gz.
TANG, Z., 20021, Thin Client Decision Viewer Sample, ASP utility application hosted by Data Mining
Community Web Site. http://communities.msn.com/AnalysisServicesDataMining.
TOIVONEN, H. et alii, 1995, "Pruning and Grouping Discovered Association Rules", In: Workshop
Notes of the ECML'95 Workshop on Statistics, Machine Learning and Knowledge Discovery
in Databases, Heraklion, Greece, pp. 47-52.
http://www.cs.helsinki.fi/research/fdk/datamining/pubs/crete95.ps.gz.
UTGOFF, P.E., 1989, "Incremental Induction of Decision Trees", Machine Learning, Vol. 4, No. 2, pp.
161-186. http://www.cs.umass.edu/~utgoff.
UTGOFF, P.E., 1994, An Improved Algorithm for Incremental Induction of Decision Trees, Technical
Report 94-07, University of Massachusetts, Department of Computer Science, Amherst,
Massachusetts, USA. ftp://ftp.cs.umass.edu/pub/techrept/techreport/1994/UM-CS-1994-007.ps.
VAILAYA, A. & JAIN, A., 1999, "Incremental Learning for Bayesian Classification of Images", In:
Proc. of the ICIP'99, Int'l Conf. on Image Processing, Kobe, Japan, Vol. 2, pp. 585 -589.
http://ieeexplore.ieee.org.
VANIER, D.J. & DANYLO, N.H., 19981, "Municipal Infrastructure Investment Planning: Managing The
Data", In: Proc. of the 1st Int'l Conf. on New Information Technologies for Decision Making in
Civil Engineering, Montreal, Quebec, Canada, pp. 1-14.
http://www.nrc.ca/irc/fulltext/nrcc42664.pdf.
VANIER, D.J. & DANYLO, N.H., 19982, "Municipal Infrastructure Investment Planning: Asset
Management", In: Proc. of the APWA Int'l Public Works Congress and Exhibition, Las Vegas
Nevada, USA, pp. 25-39. http://www.nrc.ca/irc/fulltext/nrcc42665.pdf.
VILLE, B., 2001, "Data Mining in SQL Server™ 2000", SQL SERVER MAGAZINE, January, 2001.
http://www.sqlmag.com/Articles/Index.cfm?ArticleID=16175.
WC3 - WORLD WIDE WEB CONSORTIUM, 2000, Extensible Markup Language (XML) 1.0 (Second
Edition), Bray, T. et alii (eds.), WC3 - World Wide Web Consortium. http://www.w3.org/TR/REC-
xml.
WITTEN, I.H. & FRANK, E., 2000, Data Mining: Practical Machine Learning Tools with Java
Implementations, 1st ed., San Francisco, California, USA, Morgan Kaufmann Publishers.
http://www.cs.waikato.ac.nz/~ml.
ZHU, H., 1998, On-Line Analytical Mining of Association Rules, M.Sc. Thesis, Computing Science,
Simon Fraser University, Burnaby, British Columbia, Canada.
ftp://fas.sfu.ca/pub/cs/theses/1998/HuaZhuMSc.ps.gz.
64
REFERÊNCIAS COMPLEMENTARES
AGRAWAL, R., 1999, "Data Mining: Crossing the Chasm", KDD'99, 5th ACM SIGKDD Int'l Conf. on
Knowledge Discovery and Data Mining, San Diego, California, USA, Invited Talk.
http://www.almaden.ibm.com/cs/quest/papers/kdd99_chasm.ppt.
AGRAWAL, R. & PSAILA, G., 1995, "Active Data Mining", In: Advances in Knowledge Discovery and
Data Mining (Proc. of the KDD'95, 1st Int'l Conf. on Knowledge Discovery and Data Mining),
Montreal, Quebec, Canada, Fayyad, U.M. & Uthurusamy, R. (eds.), AAAI/MIT Press, pp. 3-8.
http://www.almaden.ibm.com/cs/quest/papers/kdd95_active.pdf.
AGRAWAL, R. & SHAFER, J.C., 1996, Parallel Mining of Association Rules, Research Report 10004,
IBM Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/rj10004.pdf.
AGRAWAL, R. et alii, 19951, Querying Shapes of Histories, IBM Research Report RJ 9962, IBM
Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/vldb95_shape_rj.pdf.
AGRAWAL, R. et alii, 19962, "On the Computation of Multidimensional Aggregates", In: Proc. of the
VLDB 1996, 22th Int'l Conf. on Very Large Databases, Mumbai, Bombay, India, pp. 506-521.
http://www.almaden.ibm.com/cs/quest/papers/vldb96_cube.pdf.
AGRAWAL, R. et alii, 1998, "Automatic Subspace Clustering of High Dimensional Data for Data
Mining Applications", In: Proc. of the SIGMOD'98, ACM SIGMOD Int'l Conf. on Management
of Data, Seattle, Washington, USA, pp. 94-105.
http://www.almaden.ibm.com/cs/quest/papers/sigmod98_clique.pdf.
AGRAWAL, R., GUPTA, A. & SARAWAGI, S., 1997, Modeling Multidimensional Databases, IBM
Research Report, IBM Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/md_model_rj.pdf.
AHA, D.W., 1991, "Incremental Constructive Induction: An Instance-Based Approach", In: Proc. of
the 8h Int'l Workshop on Machine Learning, Evanston, Illinois, USA, pp. 117-121.
http://www.aic.nrl.navy.mil/~aha/papers/aha-imlw91.ps.
AL-SALEH, M.F. & MASOUD, F.A., 2003, "A Note on the Posterior Expected Loss as a Measure of
Accuracy in Bayesian Methods", Applied Mathematics and Computation, Vol. 134, No. 2-3,
pp. 507-514. http://www.elsevier.com.
ARAUJO, D.L.A., LOPES, H.S. & FREITAS, A.A., 1999, "A Parallel Genetic Algorithm for Rule Discovery
in Large Databases", In: Proc. of the IEEE Systems, Man and Cybernetics Conf., Tokyo,
Japan, Vol. III, pp. 940-945. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/smc99.ps.
ARNING, A., AGRAWAL, R. & RAGHAVAN, P., 1996, "A Linear Method for Deviation Detection in
Large Databases", In: Proc. of the KDD'96, 2nd Int'l Conf. on Knowledge Discovery in
Databases and Data Mining, Portland, Oregon, USA, pp. 164-169.
http://www.almaden.ibm.com/cs/quest/papers/kdd96_dev.pdf.
65
ASELTINE, J.H., 1999, WAVE: An Incremental Algorithm for Information Extraction, Technical Report
- Dep. of Computer Science, University of Massachusetts at Amherst, Massachusetts, USA.
http//www-nlp.cs.umass.edu/ciir-pubs/JAseltine1999.pdf.
BAYARDO JR., R.J. & AGRAWAL, R., 1999, "Mining the Most Interesting Rules", In: Proc. of the
KDD'99, 5th ACM SIGKDD Int'l Conf. on Knowledge Discovery and Data Mining, San Diego,
California, USA, pp. 145-154. http://www.almaden.ibm.com/cs/quest/papers/kdd99.pdf.
BAYARDO JR., R.J., AGRAWAL, R. & GUNOPULOS, D., 1999, Constraint-Based Rule Mining in Large,
Dense Databases, IBM Research Report RJ 10146, IBM Almaden Research Center, San
Jose, California, USA. http://www.almaden.ibm.com/cs/quest/papers/icde99_rj.pdf.
BERKMAN, N.C. & SANDHOLM, T.W., 1995, What Should be Minimized in a Decision Tree: A Re-
examination, Technical Report 95-20, University of Massachusetts, Department of
Computer Science, Amherst, Massachusetts, USA.
ftp://ftp.cs.umass.edu/pub/techrept/techreport/1995/UM-CS-1995-020.ps.
BJANGER, M.S., 2000, Induction of Decision Trees from Partially Classifed Data using Belief
Functions, Master's Thesis, Norwegian University of Science and Technology, Department of
Computer and Information Science, Trondheim, Norway.
http://www.hds.utc.fr/~tdenoeux/rapports/Rapport_marte.ps.
BRAZDIL, P.B. & TORGO, L., 19901, Knowledge Integration and Learning, Technical Report, LIACC,
University of Porto, Porto, Portugal. http://www.ncc.up.pt/~ltorgo/Papers/KIL.ps.gz.
BRAZDIL, P.B. & TORGO, L., 19902, "Knowledge Acquisition via Knowledge Integration", In: Current
Trends in Knowledge Acquisition (Proc. of the EKAW'90, 4th European Knowledge
Acquisition for Knowledge Based Systems Workshop), Amsterdam, Netherlands, Wielinga, B.
et alii (eds.), IOS Press, pp. 90-104. http://www.ncc.up.pt/~ltorgo/Papers/KAKI.ps.gz.
BRESLOW, L.A. & AHA, D.W., 1996, Simplifying Decision Trees: A Survey, NCARAI Technical Report
AIC-96-014, Navy Center for Applied Research in Artificial Intelligence, Naval Research
Laboratory, Washington, DC, USA. http://www.aic.nrl.navy.mil/~aha.
BRODLEY, C.E. & UTGOFF, P.E., 1992, Multivariate Versus Univariate Decision Trees, Technical
Report 92-008, University of Massachusetts, Department of Computer Science, Amherst,
Massachusetts, USA. .
BUJA, A. & LEE, Y., 2001, "Data Mining Criteria for Tree-Based Regression and Classification", In:
Proc. of the the KDD'01, 7th ACM SIGKDD Int'l Conf. on Knowledge Discovery and Data
Mining, San Francisco, California, USA, pp. 27-36. http://www.acm.org.
CARVALHO, D.R., 1999, Data Mining através de Indução de Regras e Algoritmos Genéticos,
Dissertação de Mestrado, Pontifícia Universidade Católica do Paraná, Curitiba, PR, Brazil.
avila@ppgia.pucpr.br.
CARVALHO, D.R. & FREITAS, A.A., 20001, "A Genetic Algorithm-Based Solution for the Problem of
Small Disjuncts", In: Principles of Data Mining and Knowledge Discovery (Proc. of
PKDD'2000, 4th European Conf.), Lecture Notes in Artificial Intelligence 1910, Lyon, France,
Zighed, D.A., Komorowski, J. & Zytkow, J. (eds.), Springer-Verlag, pp. 345-352.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/PKDD-2000.ps.
66
CARVALHO, D.R. & FREITAS, A.A., 20002, "A Hybrid Decision Tree/Genetic Algorithm for Coping
with the Problem of Small Disjuncts in Data Mining", In: Proc. of the GECCO'2000, Genetic
and Evolutionary Computation Conf., Las Vegas, Nevada, USA, pp. 1061-1068.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/GECCO-2000-Deb.ps.
CARVALHO, D.R., AVILA, B.C. & FREITAS, A.A., 1999, "A Hybrid Genetic Algorithm/Decision Tree
Approach for Coping with Unbalanced Classes", In: Proc. of the PADD'99, 3rd Int'l Conf. on
the Practical Applications of Knowledge Discovery & Data Mining, London, UK, pp. 61-70.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/padd99.ps.
CHAUDHURI, S. & DAYAL, U., 1997, An Overview of Data Warehousing and OLAP Technology,
Technical Report MSR-TR-97-14, Microsoft Research, Microsoft Corporation, Redmond,
Washington, USA. ftp://ftp.research.microsoft.com/pub/tr/tr-97-14.doc.
CHAUDHURI, S., NARASAYYA, V. & SARAWAGI, S., 2002, "Efficient Evaluation of Queries with Mining
Predicates", In: Proc. of the ICDE'02, 18th Int´l Conf. on Data Engineering, San Jose,
California, USA. http://www.it.iitb.ac.in/~sunita/papers/icde02.ps.
CLEARY, J.G., LEGG, S. & WITTEN, I.H., 1996, "An MDL Estimate of the Significance of Rules", In: Proc
of the ISIS, Information, Statistics, and Induction in Science, Melbourne, Australia, pp. 43-53.
http://www.cs.waikato.ac.nz/~ml/publications/1996/Cleary96-MDL.ps.
COOK, D., POTTS, J. & TAYLOR, W., 2002, AutoClass C - A public domain version of AutoClass III in
C, Visual C application. http://ic.arc.nasa.gov/ic/projects/bayes-group/autoclass/autoclass-c-win-
3-3-4.tar.gz.
CRAVEN, M., 1996, Extracting Comprehensible Models from Trained Neural Networks, Ph.D. Thesis,
Department of Computer Sciences, University of Wisconsin-Madison, Madison, Wisconsin,
USA. ftp://ftp.cs.wisc.edu/machine-learning/shavlik-group/craven.thesis.ps.Z.
CRAVEN, M. & SHAVLIK, J., 1999, Rule Extraction: Where Do We Go from Here?, Working Paper 99-
1, Machine Learning Research Group, University of Wisconsin, Madison, Wisconsin, USA.
http://www.cs.cmu.edu/~craven/rule-ex-position.ps.
CRAWFORD, S.L., 1987, Resampling Strategies for Recursive Partitioning Classification with the
Cart™ Algorithm, Ph.D. Thesis, School of Education, Stanford University, California, USA.
http://www-sul.stanford.edu/search/socii.
CUROTTO, C.L., 2000, Árvores de Decisão (Decision Trees), Relatório Técnico, COPPE/UFRJ, Rio de
Janeiro, RJ, Brasil. http://www.curotto.com/doc/portugues/arvores/arvores.zip.
CUROTTO, C.L. & EBECKEN, N.F.F., 20021, "Implementing Data Mining Algorithms with Microsoft®
SQL Server™", In: Data Mining III (Proc. of the 3rd Int'l Conf. on Data Mining), Bologna, Italy,
Zanasi, A. et alii (eds.), WIT Press, pp. 73-82. http://www.curotto.com/doc/english/icdm02.
CUROTTO, C.L. & EBECKEN, N.F.F., 20022, Implementing Data Mining Algorithms with Microsoft®
SQL Server™, Technical Report, COPPE/UFRJ, Rio de Janeiro, RJ, Brazil.
http://www.curotto.com/doc/english/icdm02.
CUROTTO, C.L. & EBECKEN, N.F.F., 2003, Developing Data Mining Providers for Microsoft® SQL
Server™, to appear. http://www.curotto.com/doc/english/ddmp.
67
DENOEUX, T. & BJANGER, M.S., 2000, "Induction of Decision Trees from Partially Classifed Data
using Belief Functions", In: Proc. of the SMC'2000, IEEE Int'l Conf. on Systems, Man, and
Cybernetics, Nashville, Tennessee, USA, pp. 2923 -2928.
http://www.hds.utc.fr/~tdenoeux/congres/smc2000.ps.
DOBRA, A. & GEHRKE, J., 2002, "SECRET: A Scalable Linear Regression Tree Algorithm", In: Proc. of
the the KDD'02, 8th ACM SIGKDD Int'l Conf. on Knowledge Discovery and Data Mining,
Edmonton, Alberta, Canada, pp. 481-487. http://www.acm.org.
ELOMAA, T., 1994, "In Defense of C4.5: Notes on Learning One-Level Decision Trees", In: Machine
Learning (Proc. of the ICML 1994, 11th Int'l Conf. on Machine Learning), New Brunswick,
New Jersey, USA, Cohen, W.W. & Hirsh, H. (eds.), Morgan Kaufmann Publishers, pp. 62-69.
http//www.cs.helsinki.fi/elomaa/papers/ml94.ps.gz.
ELOMAA, T., 1996, Tools and Techniques for Decision Tree Learning, Ph.D. Thesis, Report A-1996-2,
Department of Computer Science, University of Helsinki, Helsinki, Finland.
http://www.cs.helsinki.fi/TR/A-1996/2/A-1996-2.ps.gz.
ELOMAA, T., 1999, "The Biases of Decision Tree Pruning Strategies", In: Advances in Intelligent Data
Analysis (Proc. of the 3rd Int'l Symposium), Lecture Notes in Computer Science 1642,
Amsterdam, Netherlands, Hand, D. J. et alii (eds.), Springer-Verlag, pp. 63-74.
http//www.cs.helsinki.fi/elomaa/papers/ida-final.ps.gz.
ELOMAA, T. & ROUSU, J., 19971, "Well-Behaved Attribute Evaluation Functions for Numerical
Attributes", In: Foundations of Intelligent Systems (Proc. of the ISMIS'97), Lecture Notes in
Artificial Intelligence 1325, Charlotte, North Carolina, USA, Ras, Z. W. & Skowron (eds.),
Springer-Verlag, pp. 147-156. http://www.cs.helsinki.fi/~elomaa/papers/ismis97final.ps.gz.
ELOMAA, T. & ROUSU, J., 19972, "On the Well-Behavedness of Important Attribute Evaluation
Functions", In: Proc. of the SCAI'97, 6th Scandinavian Conf. on Artificial Intelligence, Helsinki,
Finland, pp. 95-106. http://www.cs.helsinki.fi/~elomaa/papers/scai97final.ps.gz.
ELOMAA, T. & ROUSU, J., 19981, "Postponing the Evaluation of Attributes with a High Number of
Boundary Points", In: Principles of Data Mining & Knowledge Discovery (Proc. of the
PKDD'98, 2th European Conf.), Lecture Notes in Artificial Intelligence 1510, Nantes, France,
Zytkow, J. M. & Quafafon, M. (eds.), Springer-Verlag, pp. 221-229.
http://www.cs.helsinki.fi/~elomaa/papers/pkdd98-final.ps.gz.
ELOMAA, T. & ROUSU, J., 19982, Postponing the Evaluation of Attributes with a High Number of
Boundary Points, Series of Publications C, Report C-1998-11, Department of Computer
Science, University of Helsinki, Helsinki, Finland. http://www.cs.helsinki.fi/~elomaa/papers/C-1998-
11.ps.gz.
ELOMAA, T. & ROUSU, J., 19991, "Speeding up the Search for Optimal Partitions", In: Principles of
Data Mining and Knowledge Discovery (Proc. of the PKDD'99, 3rd European Conf.), Lecture
Notes in Artificial Intelligence 1704, Pragne, Czech Republic, Zytkow, J. M. & Ranch, J
(eds.), Springer-Verlag, pp. 89-97. http://www.cs.helsinki.fi/~elomaa/pages/papers/pkdd99-
final.ps.gz.
ELOMAA, T. & ROUSU, J., 19992, "General and Efficient Multisplitting of Numerical Attributes",
Machine Learning, Vol. 36, No. 3, pp. 201-244. http://www.cs.helsinki.fi/~elomaa/papers/MLJ-
final.ps.gz.
68
ELOMAA, T. & ROUSU, J., 20001, Uses of Convexity in Numerical Domain Partitioning, NeuroCOLT2
Technical Report Series, Technical Report NC2-TR-2000-074.
http://www.cs.helsinki.fi/~elomaa/pages/papers/NCTR.ps.gz.
ELOMAA, T. & ROUSU, J., 20002, On the Splitting Properties of Common Attribute Evaluation
Functions, Series of Publications C, Report C-2000-1, Department of Computer Science,
University of Helsinki, Helsinki, Finland. http://www.cs.helsinki.fi/~elomaa/papers/C-2000-1.ps.gz.
FAYYAD, U.M., REINA, C.A. & BRADLEY, P.S., 1998, Initialization of Iterative Refinement Clustering
Algorithms, Technical Report MSR-TR-98-38, Microsoft Research, Microsoft Corporation,
Redmond, Washington, USA. ftp://ftp.research.microsoft.com/pub/tr/tr-98-38.pdf.
FERTIG, C.S. et alii, 1999, "A Fuzzy Beam-Search Rule Induction Algorithm", In: Principles of Data
Mining and Knowledge Discovery (Proc. of the PKDD'99, 3rd European Conf.), Lecture
Notes in Artificial Intelligence 1704, Pragne, Czech Republic, Zytkow, J. M. & Ranch, J
(eds.), Springer-Verlag, pp. 341-347. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/pkdd99.ps.
FIDELIS, M.V., LOPES, H.S. & FREITAS, A.A., 2000, "Discovering Comprehensible Classification Rules
with a Genetic Algorithm", In: Proc. of the CEC'2000, Congress on Evolutionary
Computation, La Jolla, California, USA, pp. 805-810.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/CEC-2000.ps.
FRANK, E., 2000, Pruning Decision Trees and Lists, Ph.D. Thesis, Department of Computer Science,
University of Waikato, Hamilton, New Zealand. http://citeseer.nj.nec.com/frank00pruning.html.
FRANK, E. et alii, 1998, "Using Model Trees for Classification", Machine Learning, Vol. 32, No. 1, pp.
63-76. http://www.cs.waikato.ac.nz/~ml/publications/1998/Frank-et-al-Model-Trees.pdf.
FREITAS, A.A., 19983, "The Principle of Transformation between Efficiency and Effectiveness:
Towards a Fair Evaluation of the Cost-effectiveness of KDD Techniques", In: Principles of
Data Mining and Knowledge Discovery (Proc. of the PKDD'97, 1th European Conf.), Lecture
Notes in Artificial Intelligence 1263, Trondheim, Norway, Springer-Verlag, pp. 299-306.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/pkdd97.ps.
FREITAS, A.A., 19984, "A Survey of Parallel Data Mining", In: Proc. of the PADD'98, 2nd Int'l Conf. on
the Practical Applications of Knowledge Discovery and Data Mining, London, UK, pp. 287-
300. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/padd98.ps.
FREITAS, A.A., 19991, "On Rule Interestingness Measures", Knowledge-Based Systems, Vol. 12, No. 5-
6, pp. 309-315. http://www.ppgia.pucpr.br/~alex.
FREITAS, A.A., 19992, "A Genetic Algorithm for Generalized Rule Induction", In: Advances in Soft
Computing - Engineering Design and Manufacturing (Proc. WSC3, 3rd On-Line World Conf.
on Soft Computing), Roy, R. et alii (eds.), Springer-Verlag, pp. 340-353.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/wsc3-98.ps.
FREITAS, A.A., 2000, "Understanding the Crucial Differences Between Classification and Discovery
of Association Rules: A Position Paper", ACM SIGKDD Explorations Newsletter, Vol. 2, No. 1,
pp. 65-69. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/SIGKDD-2000.ps.
GAMA, J., 2000, Combining Classification Algorithms, D.Sc. Thesis, Faculdade de Ciências da
Universidade do Porto, Porto, Portugal. http://www.ncc.up.pt/~jgama/tese.ps.gz.
69
GAMA, J. & BRAZDIL, P.B., 1995, "Characterization of Classification Algorithms", In: Proc. of the
EPIA'95, Portuguese Conf. on Artificial Intelligence, Funchal, Madeira Island, Portugal, pp.
189-200. http://www.ncc.up.pt/~jgama/mepia.ps.gz.
GINGRAS, F. & LAKSHMANAN, L.V.S., 1998, "nD-SQL: A Multi-dimensional Language for
Interoperability and OLAP", In: Proc. of the VLDB 1998, 24th Very Large Databases Conf.,
New York City, New York, USA, pp. 134-145.
ftp://ftp.cs.concordia.ca/pub/laks/papers/vldb98.ps.gz.
GRAY, J. et alii, 1995, Data Cube: A Relational Aggregation Operator Generalizing Group-By,
Cross-Tab, and Sub-Totals, Technical Report MSR-TR-95-22, Microsoft Research, Microsoft
Corporation, Redmond, Washington, USA. ftp://ftp.research.microsoft.com/pub/tr/tr-95-22.pdf.
GRAY, J. et alii, 1997, Data Cube: A Relational Aggregation Operator Generalizing Group-By,
Cross-Tab, and Sub-Totals, Technical Report MSR-TR-97-32, Microsoft Research, Microsoft
Corporation, Redmond, Washington, USA. ftp://ftp.research.microsoft.com/pub/tr/tr-97-32.doc.
HARINARAYAN, V., RAJARAMAN, A. & ULLMAN, J.D., 1996, "Implementing Data Cubes Efficiently",
In: Proc. of the SIGMOD'96, ACM SIGMOD Int'l Conf. on Management of Data, Montreal,
Quebec, Canada, pp. 205-216. http://www-db.stanford.edu/pub/papers/cube.ps.
HECKERMAN, D. & MEEK, C., 1997, Models and Selection Criteria for Regression and Classification,
Technical Report MSR-TR-97-08, Microsoft Research, Microsoft Corporation, Redmond,
Washington, USA. ftp://ftp.research.microsoft.com/pub/tr/tr-97-08.ps.
HO, C.T. et alii, 1997, "Range Queries in OLAP Data Cubes", In: Proc. of the SIGMOD'97, ACM
SIGMOD Int'l Conf. on Management of Data, Tucson, Arizona, USA, pp. 73-88.
http://citeseer.nj.nec.com/ho97range.html.
HO, C.T., BRUCK, J. & AGRAWAL, R., 1997, "Partial-Sum Queries in OLAP Data Cubes Using
Covering Codes", In: Proc. of the PODS'97, 16th ACM SIGACT-SIGMOD-SIGART Symposium
on Principles of Database Systems, Tucson, Arizona, USA, pp. 228-237.
http://citeseer.nj.nec.com/83887.html.
HOLMES, G., HALL, M. & FRANK, E., 1999, Generating Rule Sets from Model Trees, Working Paper
99/2, Department of Computer Science, University of Waikato, Hamilton, New Zealand.
http://www.cs.waikato.ac.nz/~ml/publications/1999/99GH-MH-EF-Rule-Sets.pdf.
HULTEN, G. & DOMINGOS, P., 2002, "Mining Complex Models from Arbitrarily Large Databases in
Constant Time", In: Proc. of the the KDD'02, 8th ACM SIGKDD Int'l Conf. on Knowledge
Discovery and Data Mining, Edmonton, Alberta, Canada, pp. 525-531. http://www.acm.org.
KALLES, D. & PAPAGELIS, A., 1999, "Induction of Decision Trees in Numeric Domains using Set-
Valued Attributes", ACAI-99, ECCAI Advanced Course on Artificial Intelligence, Crete,
Greece, Invited Talk. http://www.iit.demokritos.gr/skel/eetn/acai99/Workshops/w06/w06_03.pdf.gz.
KAMBER, M., HAN, J. & CHIANG, J.Y., 19971, Using Data Cubes for Metarule-Guided Mining of
Multi-Dimensional Association Rules, Technical Report CS-TR 97-10, School of Computing
Science, Simon Fraser University, Burnaby, British Columbia, Canada.
ftp://ftp.fas.sfu.ca/pub/cs/han/kdd/kdd97long.ps.gz.
70
KAMBER, M., HAN, J. & CHIANG, J.Y., 19972, "Metarule-Guided Mining of Multi-Dimensional
Association Rules Using Data Cubes", In: Proc. of the KDD'97, 3rd Int'l Conf. on Knowledge
Discovery and Data Mining, Newport Beach, California, USA, pp. 207-210.
ftp://ftp.fas.sfu.ca/pub/cs/han/kdd/kdd97short.ps.gz.
KNOBBE, A.J. et alii, 1999, Multi-relational data mining, Technical Report INS-R9908, CWI - National
Research Institute for Mathematics, Amsterdam, Netherlands.
http://www.cs.kuleuven.ac.be/~dtai/publications/files/20404.ps.gz.
KOCK, T., 1992, Inductive Learning of Compact Rule Sets by using Efficient Hypotheses Reduction,
Technical Report 92-069, University of California, Berkeley, California, USA.
ftp://ftp.icsi.berkeley.edu/pub/techreports/1992/tr-92-069.ps.gz.
KONTKANEN, P.T. et alii, 1998, "BAYDA: Software for Bayesian Classification and Feature Selection",
In: Proc. of the KDD'98, 4th Int'l Conf. on Knowledge Discovery and Data Mining, New York
City, New York, USA, Agrawal, R., Stolorz, P.E. & Piatetsky-Shapiro, G. (eds.), AAAI Press, pp.
254–258. http://citeseer.nj.nec.com/kontkanen98bayda.html.
KONTKANEN, P.T., MYLLYMÄKI, P.J. & TIRRI, H.R., 1996, "Comparing Bayesian Model Class Selection
Criteria by Discrete Finite Mixtures", In: Information, Statistics and Induction in Science (Proc.
of the ISIS'96 Conf.), Melbourne, Australia, Dowe, D.L., Korb, K.B. & Oliver, J.J. (eds.), Word
Scientific, pp. 364-374. http://citeseer.nj.nec.com/kontkanen96comparing.html.
LANGLEY, P. & SAGE, S., 1994, "Induction of Selective Bayesian Classifiers", In: Proc. of the UAI'94,
10th Conf. on Uncertainty in Artificial Intelligence, Seattle, Washington, USA, pp. 399-406.
http://www.isle.org/~langley/papers/select.uai94.ps.gz.
LAROCCA NETO, J. et alii, 20001, "Generating Text Summaries through the Relative Importance of
Topics", In: Advances in Artificial Intelligence (Proc. of the IBERAMIA'2000 & SBIA'2000),
Lecture Notes in Computer Science 1952, Atibaia, SP, Brazil, Monard, M.C. & Sichman, J.S.
(eds.), Springer-Verlag, pp. 300-309. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/SBIA-
2000.ps.
LAROCCA NETO, J. et alii, 20002, "Document Clustering and Text Summarization", In: Proc. of the
PADD'2000, 4th Int'l Conf. Practical Applications of Knowledge Discovery & Data Mining,
London, UK, pp. 41-55. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/PADD2000.ps.
LAROCCA NETO, J. et alii, 20003, "A Trainable Algorithm for Summarizing News Stories", PKDD'2000
Workshop on Machine Learning and Textual Information Access, Lyon, France.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/PKDD-Ws-2000.ps.
LAVINGTON, S.H. et alii, 1999, "Interfacing Knowledge Discovery Algorithms to Large Database
Management Systems", Information and Software Technology, Vol. 41, No. 9, pp. 605-617.
http://www.ppgia.pucpr.br/~alex.
LEE, C.H., 2002, Mining Association Relationship in a Temporal Database, Ph.D. Thesis, Electrical
Engineering Department, National Taiwan University, Taipei, Taiwan.
http://arbor.ee.ntu.edu.tw/~chlee/papers/PhDThesis052502.pdf.
LEE, C.H., LIN, C.R. & CHEN, M.S., 2001, "Sliding-Window Filtering: An Efficient Algorithm for
Incremental Mining", In: Proc. of the CIKM 2001, 10th ACM Int'l Conf. on Information and
Knowledge Management, Atlanta, Georgia, USA, pp. 263-270.
http://arbor.ee.ntu.edu.tw/~mschen/paperps/cikm414.pdf.
71
LENT, B., AGRAWAL, R. & SRIKANT, R., 1997, "Discovering Trends in Text Databases", In: Proc. of the
KDD'97, 3rd Int'l Conf. on Knowledge Discovery and Data Mining, Newport Beach,
California, USA, pp. 227-230. http://www.almaden.ibm.com/cs/quest/papers/kdd97_trends.pdf.
LI, R. & BELFORD, G.G., 2002, "Instability of Decision Tree Classification Algorithms", In: Proc. of the
the KDD'02, 8th ACM SIGKDD Int'l Conf. on Knowledge Discovery and Data Mining,
Edmonton, Alberta, Canada, pp. 570-575. http://midas-
10.cs.ndsu.nodak.edu/data/kdd2002/papers/p24.pdf.
MEHTA, M., AGRAWAL, R. & RISSANEN, J., 1996, "SLIQ: A Fast Scalable Classifier for Data Mining", In:
Proc. of the EDBT'96, 5th Int'l Conf. on Extending Database Technology, Avignon, France,
pp. 18-32. http://www.almaden.ibm.com/cs/quest/papers/edbt96_sliq.pdf.
MEHTA, M., RISSANEN, J. & AGRAWAL, R., 1995, "MDL-Based Decision Tree Pruning", In: Advances
in Knowledge Discovery and Data Mining (Proc. of the KDD'95, 1st Int'l Conf. on Knowledge
Discovery and Data Mining), Montreal, Quebec, Canada, Fayyad, U.M. & Uthurusamy, R.
(eds.), AAAI/MIT Press, pp. 216-221.
http://www.almaden.ibm.com/cs/quest/papers/kdd95_mdl.pdf.
MERZ, C.J., 1998, Classification and Regression by Combining Models, Ph.D. Dissertation, University
of California, Irvine, CA, USA. http://www.ics.uci.edu/~cmerz.
MIURA, T. & SHIOYA, I., 1999, "Incremental Update of Decision Trees for Temporal Objects", In:
Proc. of the KRDB'99, 6th Int'l Workshop on Knowledge Representation meets Databases,
Linköping, Sweden, pp. 41-45. http://sunsite.informatik.rwth-aachen.de/Publications/CEUR-WS/Vol-
21/miura.ps.
MURTHY, S.K., 1995, On Growing Better Decision Trees from Data, Ph.D. Thesis, John Hopkins
University, Baltimore, Maryland, USA. http://citeseer.nj.nec.com/murthy97growing.html.
MURTHY, S.K., 1997, Statistical Preprocessing for Decision Tree Induction, Technical Report, John
Hopkins University, Baltimore, Maryland, USA. http://www.cs.jhu.edu/~murthy/cluster.ps.Z.
MURTHY, S.K., KASIF, S. & SALZBERG, S., 19941, "A System for Induction of Oblique Decision Trees",
JAIR - Journal of Artificial Intelligence Research, Vol. 2, pp. 1-32.
http://www.cs.cmu.edu/afs/cs/project/jair/pub/volume2/murthy94a.ps.
MURTHY, S.K., KASIF, S. & SALZBERG, S., 19942, "OC1 - A System for Induction of Oblique Decision
Trees", JAIR - Journal of Artificial Intelligence Research, Vol. 2, Appendix.
http://www.cs.cmu.edu/afs/cs/project/jair/pub/volume2/murthy94a-appendix.tar.Z.
NODA, E., FREITAS, A.A. & LOPES, H.S., 1999, "Discovering Interesting Prediction Rules with a
Genetic Algorithm", In: Proc. of the CEC'99, Congress on Evolutionary Computation,
Washington, DC, USA, pp. 1322-1329. http://www.ppgia.pucpr.br/~alex/pub_papers.dir/cec99.ps.
PFAHRINGER, B., 1998, Inducing Small and Accurate Decision Trees, Technical Report 98-09,
Austrian Research Institute for Artificial Intelligence, Vienna, Austria.
ftp://ftp.ai.univie.ac.at/papers/oefai-tr-98-09.ps.gz.
PIATER, J.H., RISEMAN, E.M. & UTGOFF, P.E., 1997, Interactive Training of Pixel Classifiers Opens New
Possibilities, Technical Report 1997-051, University of Massachusetts, Department of
Computer Science, Amherst, Massachusetts, USA.
ftp://ftp.cs.umass.edu/pub/techrept/techreport/1997/UM-CS-1997-051.ps.
72
PIATER, J.H., RISEMAN, E.M. & UTGOFF, P.E., 19981, Interactive Training of Pixel Classifiers Opens
New Possibilities, Technical Report - Dep. of Computer Science, University of Massachusetts
at Amherst, Massachusetts, USA. http://vis-www.cs.umass.edu/~piater/lc/ISPRS98.ps.gz.
PIATER, J.H., RISEMAN, E.M. & UTGOFF, P.E., 19982, "Interactively Training Pixel Classifiers", In: Proc. of
the FLAIRS 1998, 11th Int'l Florida Artificial Intelligence Research Society Conf., Orlando,
Florida, USA. http://vis-www.cs.umass.edu/~piater/lc/FLAIRS98.ps.gz.
PIATER, J.H., RISEMAN, E.M. & UTGOFF, P.E., 1999, "Interactively Training Pixel Classifiers", Int'l Journal
of Pattern Recognition and Artificial Intelligence, Vol. 13, No. 2, pp. 171-194.. ftp://vis-
ftp.cs.umass.edu/Papers/piater/ijprai99.ps.gz.
QUINLAN, J.R., 1990, Comparing Connectionist and Symbolic Learning Methods, Technical
Report, University of New South Wales, Australia. http://www.cse.unsw.edu.au/~quinlan/pr90.ps.
QUINLAN, J.R., 1992, "Learning with Continuous Classes", In: Proc. of the Fifth Australian Joint Conf.
on Artificial Intelligence, Hobart, Tasmania, Australia, pp. 343-348.
http://www.cse.unsw.edu.au/~quinlan/q.ai92.ps.
QUINLAN, J.R., 19961, "Boosting, Bagging, and C4.5", In: Proc. of the AAAI'96, 13th National Conf.
on Artificial Intelligence, Portland, Oregon, USA, pp. 725-730.
http://www.cse.unsw.edu.au/~quinlan/q.aaai96.ps.
QUINLAN, J.R., 19962, "Boosting First-Order Learning", In: Algorithmic Learning Theory (Proc. of the
ALT '96, 7th Int'l Workshop), Lecture Notes in Computer Science 1160, Sydney, Australia,
Arikawa, S. & Sharma, A. (eds.), Springer-Verlag, pp. 143-155.
http://www.cse.unsw.edu.au/~quinlan/q.alt96.ps.
QUINLAN, J.R., 1999, MiniBoosting Decision Trees, Technical Report, University of New South Wales,
Australia. http://www.cse.unsw.edu.au/~quinlan/miniboost.ps.
QUINLAN, J.R. & CAMERON-JONES, R.M., 1995, "Oversearching and Layered Search in Empirical
Learning", In: Proc. of the IJCAI'95, 14th Int'l Joint Conf. on Artificial Intelligence, Montreal,
Quebec, Canada, pp. 1019-1024. http://www.cse.unsw.edu.au/~quinlan/q+cj.ijcai95.ps.
RATSABY, J., 1998, "Incremental Learning With Sample Queries", IEEE Trans. on Patttern Analysis
and Machine Intelligence, Vol. 20, No. 8, pp. 883-888. http://ieeexplore.ieee.org.
RIDGEWAY, G. & MADIGAN, D., 2002, "Bayesian Analysis of Massive Datasets via Particle Filters", In:
Proc. of the the KDD'02, 8th ACM SIGKDD Int'l Conf. on Knowledge Discovery and Data
Mining, Edmonton, Alberta, Canada, pp. 5-13. http://www.acm.org.
RISSANEN, J., 1998, "Hypothesis Selection and Testing by the MDL Principle", The Computer Journal,
Vol. 42, No. 4, pp. 260-269. http://www.cs.tut.fi/~rissanen/papers/hypo.ps.
RULEQUEST RESEARCH, 2000, See5 Induction System, Rulequest Research, Sydney, Australia.
http://www.rulequest.com.
SANTOS, R., NIEVOLA, J.C. & FREITAS, A.A., 2000, "Extracting Comprehensible Rules from Neural
Networks via Genetic Algorithms", In: Proc. of the ECNN'2000, IEEE Symp. on Combinations
of Evolutionary Computation and Neural Networks, San Antonio, Texas, USA, pp. 130-139.
http://www.ppgia.pucpr.br/~alex/pub_papers.dir/ECNN-2000.ps.
SARAWAGI, S., AGRAWAL, R. & GUPTA, A., 1996, On Computing the Data Cube, Research Report
10026, IBM Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/cube_rj.pdf.
73
SARAWAGI, S., AGRAWAL, R. & MEGIDDO, N., 1998, Discovery-Driven Exploration of OLAP Data
Cubes, IBM Research Report RJ 10102, IBM Almaden Research Center, San Jose, California,
USA. http://www.almaden.ibm.com/cs/quest/papers/edbt98_ex_rj.pdf.
SHAFER, J.C. & AGRAWAL, R., 1997, "Parallel Algorithms for High-dimensional Proximity Joins", In:
Proc. of the VLDB 1997, 23rd Int'l Conf. on Very Large Databases, Athens, Greece, pp. 176-
185. http://www.almaden.ibm.com/cs/quest/papers/vldb97_ekdb.pdf.
SHAFER, J.C., AGRAWAL, R. & MEHTA, M., 1996, "SPRINT: A Scalable Parallel Classifier for Data
Mining", In: Proc. of the VLDB 1996, 22th Int'l Conf. on Very Large Databases, Mumbai,
Bombay, India, pp. 544-555. http://www.almaden.ibm.com/cs/quest/papers/vldb96_sprint.pdf.
SHANMUGASUNDARAM, J., FAYYAD, U.M. & BRADLEY, P.S., 1998, Compressed Data Cubes for
OLAP Aggregate Query Approximation on Continuous Dimensions, Technical Report MSR-
TR-99-13, Microsoft Research, Microsoft Corporation, Redmond, Washington, USA.
ftp://ftp.research.microsoft.com/pub/tr/tr-99-13.pdf.
SHIM, K., SRIKANT, R. & AGRAWAL, R., 1997, High-dimensional Similarity Joins, IBM Research Report
RJ 10081, IBM Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/de97_ekdb_rj.pdf.
SRIKANT, R. & AGRAWAL, R., 19951, Mining Generalized Association Rules, IBM Research Report RJ
9963, IBM Almaden Research Center, San Jose, California, USA.
http://www.almaden.ibm.com/cs/quest/papers/vldb95_tax_rj.pdf.
SRIKANT, R. & AGRAWAL, R., 19952, Mining Sequential Patterns: Generalizations and Performance
Improvements, IBM Research Report RJ 9994, IBM Almaden Research Center, San Jose,
California, USA. http://www.almaden.ibm.com/cs/quest/papers/edbt96_rj.ps.gz.
SRIKANT, R. & AGRAWAL, R., 1996, "Mining Quantitative Association Rules in Large Relational
Tables", In: Proc. of the SIGMOD'96, ACM SIGMOD Int'l Conf. on Management of Data,
Montreal, Quebec, Canada, pp. 1-12.
http://www.almaden.ibm.com/cs/quest/papers/sigmod96.pdf.
SRIKANT, R., VU, Q. & AGRAWAL, R., 1997, "Mining Association Rules with Item Constraints", In: Proc.
of the KDD'97, 3rd Int'l Conf. on Knowledge Discovery and Data Mining, Newport Beach,
California, USA, pp. 67-73. http://www.almaden.ibm.com/cs/quest/papers/kdd97_const.pdf.
TANG, Z., 20022, Building Cluster Dimension using Microsoft® Cluster Algorithm, White paper,
Microsoft Research, Microsoft Corporation, Redmond, Washington, USA.
TING, K.M. & ZHENG, Z., 1998, "Boosting Trees for Cost-Sensitive Classifications", In: Proc. of the
ECML'98, 10th European Conf. on Machine Learning, Lecture Notes in Artificial Intelligence
1398, Chemnitz, Germany, Nedellec, C. & Rouveirol, C. (eds.), Springer-Verlag, pp. 190-195.
http://www.cs.waikato.ac.nz/~ml/publications/1998/Ting-Zheng.ps.
TORGO, L., 19931, "Controlled Redundancy in Incremental Rule Learning", In: Proc. of the ECML'93,
European Conf. on Machine Learning, Lecture Notes in Computer Science 667, Vienna,
Austria, Brazdil, P. B. (ed.), Springer-Verlag, pp. 185-195.
http://www.ncc.up.pt/~ltorgo/Papers/CRIRL.ps.gz.
74
TORGO, L., 19932, "Rule Combination in Inductive Learning", In: Proc. of the ECML'93, European
Conf. on Machine Learning, Lecture Notes in Computer Science 667, Vienna, Austria,
Brazdil, P. B. (ed.), Springer-Verlag, pp. 384-389.
http://www.ncc.up.pt/~ltorgo/Papers/RCIL.ps.gz.
TORGO, L., 19951, "Data Fitting with Rule-based Regression", AIT'95, 2nd Int'l Workshop on Artificial
Intelligence Techniques, Brno, Czech Republic.
http://www.ncc.up.pt/~ltorgo/Papers/DFRBR.ps.gz.
TORGO, L., 19952, "Applying Propositional Learning to Time Series Prediction", ECML 1995 Workshop
on Statistics, Machine Learning and Knowledge Discovery in Databases, Heraclion, Crete,
Greece. http://www.ncc.up.pt/~ltorgo/Papers/APLTSP.ps.gz.
TORGO, L., 19971, "Functional Models for Regression Tree Leaves", In: Proc. of the ICML'97, 14th Int'l
Conf. on Machine Learning, Nashville, Tennessee, USA.
http://www.ncc.up.pt/~ltorgo/Papers/FMRTL.ps.gz.
TORGO, L., 19972, "Search-based Class Discretization", In: Proc. of the ECML'97, European Conf. on
Machine Learning, Lecture Notes in Artificial Intelligence 1224, Prague, Czech Republic,
Someren, M.V. & Widmer, G. (eds.), Springer-Verlag, pp. 266-273.
http://www.ncc.up.pt/~ltorgo/Papers/SCD.ps.gz.
TORGO, L., 19973, "Kernel Regression Trees", In: Proc. of the ECML'97, European Conf. on Machine
Learning, Prague, Czech Republic, Poster Papers.
http://www.ncc.up.pt/~ltorgo/Papers/KRT.ps.gz.
TORGO, L., 19981, "Error Estimates for Pruning Regression Trees", In: Proc. of the ECML'98, 10th
European Conf. on Machine Learning, Lecture Notes in Artificial Intelligence 1398,
Chemnitz, Germany, Nedellec, C. & Rouveirol, C. (eds.), Springer-Verlag, pp. 125-130.
http://www.ncc.up.pt/~ltorgo/Papers/EEPRT.ps.gz.
TORGO, L., 19982, "A Comparative Study of Reliable Error Estimators for Pruning Regression Trees",
In: Progress in Artificial Intelligence (Proc. of the IBERAMIA'98, 6th Ibero-American Conf. on
Artificial Intelligence), Lecture Notes in Computer Science 1484, Lisbon, Portugal, Coelho,
H. (ed.), Springer-Verlag. http://www.ncc.up.pt/~ltorgo/Papers/CSREEPRT.ps.gz.
TORGO, L., 19991, Inductive Learning of Tree-based Regression Models, D.Sc. Thesis,
Departamento de Ciência de Computadores, Faculdade de Ciências da Universidade do
Porto, Porto, Portugal. http://www.ncc.up.pt/~ltorgo.
TORGO, L., 19992, "Predicting the Density of Algae Communities using Local Regression Trees", In:
Proc. of the EUFIT'99, European Congress on Intelligent Techniques and Soft Computing,
Invited Paper. http://www.ncc.up.pt/~ltorgo/Papers/PDACLRT.ps.gz.
TORGO, L., 20001, "Partial Linear Trees", In: Proc. of the ICML'2000, 17th Int'l Conf. on Machine
Learning, Stanford, California, USA, pp. 1007-1014.
http://www.ncc.up.pt/~ltorgo/Papers/PLT.ps.gz.
TORGO, L., 20002, "Efficient and Comprehensible Local Regression", In: Proc. of the PAKDD'2000,
4th Pacific-Asia Conf. on Knowledge Discovery and Data Mining, Lecture Notes in Artificial
Intelligence 1805, Terano et alii (eds.), Springer-Verlag, pp. 376-379.
http://www.ncc.up.pt/~ltorgo/Papers/ECLR.ps.gz.
75
TORGO, L., 20003, Efficient and Comprehensible Local Regression, Technical Report 99-2, LIACC,
University of Porto, Porto, Portugal. http://www.ncc.up.pt/~ltorgo/Papers/ECLR_int_rpt.ps.gz.
TORGO, L. & COSTA, J.P., 2000, "Clustered Partial Linear Regression", In: Proc. of the ECML'2000,
11th European Conf. on Machine Learning, Lecture Notes in Artificial Intelligence 1810,
Barcelona, Catalonia, Spain, Mantaras, L. R. & Plaza, E. (eds.), Springer-Verlag, pp. 426-436.
http://www.ncc.up.pt/~ltorgo/Papers/cplr_msl2000.ps.gz.
TORGO, L. & GAMA, J., 1996, "Regression by Classification", In: Proc. of the SBIA'96, Brasilian
Artificial Intelligence Symposium, Lecture Notes in Artificial Intelligence 1159, Curitiba, PR,
Brazil, Borges, D. & Kaestner, C. (eds.), Springer-Verlag, pp. 51-60.
http://www.ncc.up.pt/~ltorgo/Papers/RBC.ps.gz.
TORGO, L. & KUBAT, M., 1991, "Knowledge Integration and Forgetting", In: Proc. of the
Checoslovak Artificial Intelligence Conf., Prague, Czech Republic.
http://www.ncc.up.pt/~ltorgo/Papers/KIF.ps.gz.
TRIGG, L., 1998, An Entropy Gain Measure of Numeric Prediction Performance, Working Paper
98/11, Department of Computer Science, University of Waikato, Hamilton, New Zealand.
http://www.cs.waikato.ac.nz/~ml/publications/1998/Trigg-Entropy.pdf.
UTGOFF, P.E., 1995, Decision Tree Induction Based on Efficient Tree Restructuring, Technical Report
95-18, University of Massachusetts, Department of Computer Science, Amherst,
Massachusetts, USA. ftp://ftp.cs.umass.edu/pub/techrept/techreport/1995/UM-CS-1995-018.ps.
UTGOFF, P.E. & BRODLEY, C.E., 1991, Linear Machine Decision Trees, Technical Report 91-010,
University of Massachusetts, Department of Computer Science, Amherst, Massachusetts,
USA. ftp://ftp.cs.umass.edu/pub/techrept/techreport/1991/UM-CS-1991-010.ps.
UTGOFF, P.E. & CLOUSE, J.A., 1996, A Kolmogorov-Smirnoff Metric for Decision Tree Induction,
Technical Report 96-03, University of Massachusetts, Department of Computer Science,
Amherst, Massachusetts, USA. ftp://ftp.cs.umass.edu/pub/techrept/techreport/1996/UM-CS-1996-
003.ps.
VITANYI, P. & LI, M., 2000, "Minimum Description Length Induction, Bayesianism, and Kolmogorov
Complexity", IEEE Transactions on Informational Theory, Vol. 46, No. 2, pp. 446-464.
http://www.cwi.nl/~paulv/papers/mdlindbayeskolmcompl.pdf.
WANG, Y. & WITTEN, I.H., 1997, "Inducing Model Trees for Predicting Continuous Classes", In: Proc.
of the ECML'97, European Conf. on Machine Learning, Prague, Czech Republic, Poster
Papers, pp. 128-137. http://www.cs.waikato.ac.nz/~ml/publications/1997/Wang-Witten-Induct.pdf.
WIETEK, F., 1999, "Modelling Multidimensional Data in a Dataflow-Based Visual Data Analysis
Environment", In: Proc. of the CAiSE*99, 11th Conf. on Advanced Information Systems
Engineering, Heidelberg, Germany, pp. 149-163. http://www-is.informatik.uni-
oldenburg.de/~wietek/paper/CAiSE99.ps.gz.
WILBUR, W., 2000, "Boosting Naive Bayesian Learning on a Large Subset of MEDLINE", In:
Converging Information, Technology, and Health Care (Proc. of the American Medical
Informatics Association 2000 Symposium), Los Angeles, California, USA, Overhage, J.M.
(ed.), AMIA Press. http://citeseer.nj.nec.com/516083.html.
76
WONG, J.S.K., NAYAR R. & MIKLER, A.R., 1998, "A Framework for a World Wide Web-Based Data
Mining System", Journal of Network and Computer Applications, Vol. 21, No. 3, pp. 163-185.
http://www.sciencedirect.com.
YE, N. & LI, X., 2002, "A Scalable, Incremental Learning Algorithm for Classification Problems",
Computers & Industrial Engineering, Vol. 43, No. 4, pp. 677-692. http://www.elsevier.com.
77
Apêndice A. Classificador Bayesiano Simples
O classificador Bayesiano é um classificador estatístico que pode prever

probabilidades de classificação de uma amostra em relação a uma classe. Ele é
baseado no teorema de Bayes, descrito a seguir.
Formulado pelo matemático britânico Thomas Bayes (†1761), o teorema versa
sobre probabilidades condicionais:

P(B | A )P ( A )
P( A | B ) = (A-1)
P(B )
onde:
P(A|B) probabilidade de ocorrência do evento A dado que o evento

B já tenha ocorrido
P(B|A) probabilidade de ocorrência do evento B dado que o evento
A já tenha ocorrido
P(A) probabilidade de ocorrência do evento A
P(B) probabilidade de ocorrência do evento B
P(A) e P(B) são probabilidades a priori, pois independem de qualquer
conhecimento anterior, por outro lado, P(A|B) e P(B|A) são probabilidades a posteriori,
pois dependem de conhecimento anterior (da ocorrência de outros fatos).
O Classificador Bayesiano Simples, pode ser formulado como segue (HAN &
KAMBER, 2001).
Seja um conjunto de dados de treinamento composto por v amostras ou casos.
Cada caso é representado por um vetor X = xi, i = 1, n composto por n valores de
atributos do vetor A = ai, i = 1, n. As classes as quais cada caso pode pertencer são
representadas pelo vetor C = cj, j = 1, m.
Seja um caso desconhecido representado por um vetor Y, yi, i = 1, n, o
Classificador Bayesiano Simples selecionará para este caso a classe com a maior
probabilidade a posteriori, ou seja escolherá aquela que tiver:
P(c j | Y ) > P(ck | Y ) para 1 ≤ k ≤ m, k ≠ j (A-2)
A classe cj de maior probabilidade P(cj|Y) é denominada hipótese de máxima

posteriori. A aplicação do Teorema de Bayes para o cálculo desta probabilidade
conduz a:
P( Y | c j ) P( c j )
P(c j | Y ) = (A-3)
P( Y )
onde:
P(cj|Y) probabilidade de que o caso Y pertença à classe cj
78
P(Y|cj) probabilidade de ocorrência de um caso Y de classe cj
P(cj) probabilidade de ocorrência de uma classe cj
P(Y) probabilidade de ocorrência de um caso Y
Como a probabilidade de ocorrência de um caso é uma constante igual para
todas as classes, somente o numerador do lado direito da fórmula acima precisa ser
calculado. As probabilidades (a priori) de ocorrência das classes podem ser
calculadas através da fórmula seguinte:
sj
P(c j ) = (A-4)
v
onde:
sj número de casos de treinamento de classe cj

v número total de casos de treinamento
Assumindo a simples premissa de independência condicional entre os atributos
(dai o nome Classificador Bayesiano Simples) a probabilidade P(Y|cj) pode ser expressa
por:
n
P( Y | c j ) = ∏ P( yi | c j ) (A-5)
i=1
onde:
P(Y|cj) probabilidade de ocorrência de um caso Y de classe cj

P(yi|cj) probabilidade de que ocorra um valor yi para um atributo ai de
um caso desconhecido Y pertencente à classe cj
As probabilidades P(yi|cj) são calculadas a partir dos dados de treinamento por
fórmulas que dependem do tipo do atributo ai. Se ai for discreto, então:
rjih
P( yi | c j ) = (A-6)
sj
onde:
rjih número de casos de treinamento de classe cj tendo o valor yi,
de ordem h, para o atributo ai

sj número de casos de treinamento de classe cj
Se por outro lado, ai for um valor contínuo, então será utilizada a fórmula
seguinte:
2
1  y i − µ ji 
−  
1 2  σ ji 
P( yi | c j ) = g( yi, µ ji,σ ji ) = e (A-7)
2πσ ji
onde:
79
g( yi, µ ji,σ ji ) função de distribuição normal de Gauss para o atributo ai
yi valor yi para o atributo ai do caso desconhecido Y

e número neperiano
µ ji e σ ji respectivamente, média aritmética e desvio padrão dos valores xi para
os atributos ai dos casos de treinamento de classe cj

A média aritmética é calculada por:
r1
ji
z ji ∑ xkij
k =1
µ ji = 1 = (A-8)
rji r1ji
onde:
z ji somatória dos valores xi para o atributo ai dos casos de
treinamento de classe cj
r1ji número de casos de treinamento de classe cj tendo qualquer
valor presente de xi, de ordem h = 1, (h = 1 é utilizado para

valores ausentes de atributos contínuos e discretos) para o
atributo ai
x kij valores xi para o atributo ai dos casos de classe cj
A fórmula original do desvio padrão é a seguinte:
r1
( )
ji 2
∑ xkij − µ ji
σ ji = k =1 (A-9)
r1ji −1
onde:
x kij valores xi para o atributo ai dos casos de classe cj
µ ji média aritmética dos valores xi para os atributos ai dos casos de

atributo ai
A substituição dos valores da média aritmética na fórmula acima e o
desenvolvimento da operação do quadrado leva a:
80
r1
   
2
k z ji  z ji  
ji
 k2
∑  x ij − 2xij 1 + 1 
k =1  s ji  rji  
σ ji =   (A-10)
r1ji −1
A fórmula acima simplificada, fica como segue:
r1 r1 2 r1
ji
k2 z ji ji k  z ji  ji
∑ x ij −2 1 ∑ x ij +  1  ∑ 1
k =1 rji k =1  rji  k =1
σ ji =   (A-11)
r1ji −1
Considerando a somatória dos quadrados dos valores xi como sendo:
r1ji
q ji = ∑ xk2
ij
(A-12)
k =1
A substituição de valores conhecidos e uma nova simplificação levam a fórmula
seguinte:
z ji2 z ji2 1
q ji −2 + rji
r1ji r12
ji
σ ji = (A-13)
r1ji −1
Que simplificada novamente conduz a fórmula final que é completamente

independente dos valores individuais xi, o que é muito conveniente para sua utilização
no classificador incremental:
z ji2
q ji −
r1ji
σ ji = (A-14)
r1ji −1
onde:
q ji somatória dos quadrados dos valores de xi para o atributo ai
dos casos de treinamento de classe cj

z ji somatória dos valores xi para o atributo ai dos casos de

atributo ai
81
Apêndice B. Tecnologia OLE DB
A tecnologia OLE DB DM é uma extensão da tecnologia OLE DB, a qual será

descrita sucintamente a seguir, de acordo com várias transcrições do trabalho original
de SKONNARD (1998).
Consumidores de dados
Aplicativos
Provedores OLE DB
Provedores de Serviços OLE DB
Proc. de Consultas
Provedores de dados OLE DB
SQLOLEDB MSJet MSJet
Banco de Banco de Planilha do

Dados do Dados do Excell
SQL Server Access
Armazenadores de dados
Figura B.1. Arquitetura OLE DB
OLE DB é baseada na tecnologia OLE, sendo uma especificação para um

conjunto de interfaces de acesso de dados projetadas para possibilitar que uma
variedade de armazenadores de dados, de todos os tipos e tamanhos, interajam
harmonicamente juntos.
Não existe uma restrição para que os dados sejam manipulados através da
linguagem SQL. O único critério imposto por esta tecnologia é que os dados
resultantes de um comando devem ser expostos na forma de uma tabela. Assim
qualquer dado pode ser manipulado, desde que um simples dado pode ser
interpretado como uma tabela de uma linha e uma coluna.
Conforme mostra a Figura B.1, uma característica importante da OLE DB é a sua
heterogeneidade, que permite consultas baseadas em dados de diferentes formatos,
armazenados por diferentes fontes, tais como servidores SQL, bancos de dados
Access® e planilhas Excell®, entre outros.
82
A arquitetura OLE DB é composta por três componentes: consumidores de
dados, provedores de serviços e provedores de dados.
Os consumidores de dados são aplicativos ou sistemas, podendo ser inclusive
provedores OLE DB.
Os provedores de dados possuem os dados e expõem os mesmos através de
objetos para o mundo exterior. Cada provedor de dados possui características
próprias de implementação para manipular os diferentes tipos de dados, porém todos
os provedores expõem seus dados em uma única forma tabular através de tabelas
virtuais.
Os provedores de serviços são componentes lógicos que encapsulam
funcionalidades de SGBDs. Alguns exemplos que podem ser citados são:
processadores de consultas, processadores de cursor e gerenciadores de transações.
Os sete componentes básicos do modelo de objetos de um provedor OLE DB são
descritos na Tabela B.1.
Tabela B.1. Componentes OLE DB
Componente Descrição
Enumerator Enumeradores listam as fontes de dados disponíveis e outros enumeradores.

Consumidores de dados que não são customizados para utilizar umas fontes
de dados em particular, utilizam enumeradores para pesquisar uma fonte de
dados para sua utilização.
Data Source Objetos de fontes de dados contêm os recursos e propriedades para conexões
com as fontes de dados, tais como um arquivo simples ou um SGBD. Eles são
geradores de sessões.
Session Sessões fornecem um contexto para transações e podem ser implicitamente

ou explicitamente transacionadas. Um simples objeto de fonte de dados pode
criar sessões múltiplas. Sessões são geradoras de transações, comandos e
tabelas virtuais.
Transaction Objetos de transações são utilizados quando transações aninhadas são

abortadas ou empenhadas em níveis superiores ao nível mais baixo.
Command Comandos executam um comando tipo texto, tal como um comando SQL. Se
o comando texto especifica uma tabela virtual, tal como um comando SQL
SELECT, o comando é um gerador da tabela virtual. Uma simples sessão pode
criar múltiplos comandos.
Rowset Tabelas virtuais expõem dados no formato tabular. Um caso especial de

tabela virtual é um índice. Tabelas virtuais podem ser criadas por comandos ou
por sessões.
Error Objetos de Erros podem ser criados por qualquer interface ou por qualquer
objeto OLE DB. Eles contêm informação adicional sobre um erro, incluindo um
objeto de erro customizado.
83
Apêndice C. Detalhes da Implementação
São descritos nos itens seguintes, os detalhes da implementação, incluindo as

modificações realizadas no código fonte do kit de recursos OLE DB DM (MICROSOFT,
2002), necessárias para receber a implementação de um novo algoritmo, bem como
aquelas feitas para possibilitar que o provedor funcione também de forma isolada,
utilizado diretamente por um aplicativo.
C.1 Preparando o Ambiente de Desenvolvimento
A preparação do ambiente de desenvolvimento requer o cumprimento dos

seguintes requisitos:
1. Instalar o sistema operacional Microsoft® Windows® 2000 Advanced Server com
o Service Pack 3
(http://www.microsoft.com/windows2000/downloads/servicepacks/sp3);
2. Instalar o sistema MSSQL 2000 Enterprise com o componente Analysis Services,
bem como os correspondentes componentes do Service Pack 3
(http://www.microsoft.com/sql/downloads/2000/sp3.asp);
3. Instalar os compiladores Microsoft® Visual C++®, Visual Basic® 6.0 e Visual J++®
6.0;
4. Instalar as ferramentas para correção de erros de programação utilizadas na
implementação do visualizador de árvores de decisão:
ü Executar o instalador do Microsoft® Visual Studio® 6.0;
ü Selecionar Server Applications and Tools no dialogo inicial;

ü No dialogo seguinte selecionar Launch BackOffice Installation Wizard, e
pressionar Install;
ü No dialogo BackOffice Business Solutions, selecionar Custom e pressionar
ü Next;
No dialogo BackOffice Programs and Their Components ativar somente a
instalação dos componentes: Remote Machine Debugging e Visual InterDev
ü Server; a instalação e seguir as instruções contidas na documentação Visual
Terminar
InterDev / Using Visual InterDev / Building Integrated Solutions / Integration
Tasks / Debugging Remotely;
5. Instalar o reparador do compilador Visual C++® 6.0 para os arquivos de suporte
do provedor Jet OLE DB Provider 4.0. Este reparador inclui arquivos omitidos nesta
versão do compilador:
ü Carregar o arquivo JetVC.exe de:

http://support.microsoft.com/default.aspx?scid=KB;en-us;q228525;
ü Executar o arquivo JetVC.exe extraindo e copiando todos os arquivos para as
pastas: Microsoft Visual Studio \ VC98 \ Include (arquivos *.h e *.idl) e
Microsoft Visual Studio \ VC98 \ Lib (arquivos *.lib);
6. Instalar o Service Pack 5 dos compiladores Microsoft® Visual C++® e Visual Basic®
6.0 (http://msdn.microsoft.com/vstudio/downloads/updates/sp/vs6/sp5);
84
7. Instalar o kit de desenvolvimento Microsoft® Platform SDK February 2001 Edition
(http://www.microsoft.com/msdownload/platformsdk/sdkupdate) com os
seguintes componentes:
ü Win32 API - Build Environment;

ü Internet Explorer - Build Environment / Web Services;
ü OLE DB (MDAC 2.6) - Build Environment / Data Access Services;
ü RowsetViewer - Sample Code / Data Access Samples / OLE DB Samples.
Versões mais recentes do Platform SDK podem ser utilizadas, porém modificações
adicionais serão necessárias, conforme indicado por KIM (2002).
8. Instalar o Visual Parse++ 4.0 (http://www.sand-stone.com).
ü Incluir a definição VP40 nos parâmetros C/C++ / Preprocessor / Preprocessor

definitions do projeto DMParse;
9. Verificar a lista de arquivos de inclusão em Tools / Options / Directories /
Include files do compilador Microsoft® Visual C++®, que deve conter as
seguintes pastas (com a substituição dos nomes completos dos caminhos da
instalação) nesta ordem:
a. Microsoft Platform SDK \ include
b. Microsoft Visual Studio \ VC98 \ ATL \ include
c. Microsoft Visual Studio \ VC98 \ include
d. Sandstone \ Visual Parse++ 4.0 \ Include
10. Verificar a lista de arquivos de bibliotecas em Tools / Options / Directories /
Library files do compilador Microsoft® Visual C++®, que deve conter as seguintes
pastas (com a substituição dos nomes completos dos caminhos da instalação)
nesta ordem:
a. Microsoft Platform SDK \ lib
b. Microsoft Visual Studio \ VC98 \ LIB
C.2 Kit de Recursos OLE DB DM
Este kit inclui a implementação completa de um exemplo de provedor

agregado, bem como o que segue:
• Todos os objetos OLE DB requeridos (ver Apêndice B), tais como sessão,
comando e tabelas virtuais;
• Analisador de sintaxe dos comandos OLE DB DM;
• Montador dos elementos sintáticos dos dados de entrada;
• Mecanismo de processamento de consultas;
• Classificador Bayesiano Simples para atributos discretos;
• Armazenamento do modelo nos formatos binário e XML.
O código fonte do exemplo de provedor deve ser preparado para receber a
implementação de um novo algoritmo. Esta preparação envolve uma série de
modificações e correções no código fonte original, muitas destas discutidas no fórum
público de debates de DM da Microsoft® (KIM, 2002). Algumas modificações também
85
devem ser feitas para que o provedor de recursos de DM possa funcionar tanto de
forma isolada, utilizado diretamente por um aplicativo, como de forma agregada,
utilizado em conjunto com o MSSQL. Estas modificações são descritas no decorrer
deste apêndice.
A área de trabalho de desenvolvimento do provedor de recursos de DM é
composta por quatorze projetos, sendo que dois deles são formados apenas por
arquivos de inclusão.
C.3 Implementando o Provedor Exemplo
A seguir os passos do procedimento para implementar o provedor exemplo do

kit de recursos OLE DB DM.
1. Carregar o kit OLE DB for Data Mining Sample Provider do endereço

http://www.microsoft.com/Data/oledb/DMResKit.htm. Uma versão atualizada
deste kit, denominada SampleProvider, foi liberada em 23/1/2002. Contudo
somente três arquivos foram ligeiramente modificados nesta nova versão em
relação à primeira:
a. DMBase/dmbslib.cpp foi removido.
b. DMParse/dmparser.cpp foi modificado para suportar a versão 5.0 do Visual
Parse++.
c. TK/DMXMLCaseConsumer.cpp foi corrigido.
2. Abrir o arquivo SampleProvider.zip e extrair todos os arquivos para uma pasta
apropriada. A opção Use folder names deve estar selecionada.
3. Abrir o arquivo DMSample.dsw da pasta SampleProvider. As seguintes mensagens
irão aparecer. Deve ser respondido não para todas elas se não for utilizado o
programa Microsoft® Visual SourceSafe:
ü Unable to connect to source code control project CP.
ü Unable to connect to source code control project DMBase.
ü Unable to connect to source code control project DMCore.
ü Unable to connect to source code control project DMM.
ü Unable to connect to source code control project DMParse.
ü Unable to connect to source code control project DMProv.
ü Unable to connect to source code control project DMQM.
ü Unable to connect to source code control project DMUtl.
ü Unable to connect to source code control project DMXML.
ü Unable to connect to source code control project Putl.
ü Unable to connect to source code control project TK.
ü Project $/DMSample/VP64 was not found.
ü Unable to connect to source code control project $/DMSample/VP64.
4. Definir DMProv como o projeto ativo.
86
5. Copiar todos os arquivos da pasta E: \ Program Files \ Sandstone \ Visual
Parse++ 4.0 \ Source \ C++ para a pasta SampleProvider \ VP64.
6. Construir DMSProv.dll. Durante este processo várias mensagens de erro do
compilador aparecerão. Elas são mostradas a seguir, não necessariamente na
mesma ordem em que aparecem, acompanhadas das instruções para a sua
correção. Após todos os erros terem sido corrigidos, o processo de construção
deve ser invocado novamente.
6.1. ...dmbslib.obj : warning LNK4006: "public: __thiscall SPGlobal::SPGlobal(void)"
(??0SPGlobal@@QAE@XZ) already defined in dmbsglob.obj; second definition
ignored.
ü Remover dmbslib.cpp do projeto DMBase

ü Usar a opção C/C++ Settings/Precompiled Headers do arquivo
dmbsglob.cpp e definir Create precompiled header para dmbslib.h.
6.2. Fatal error C1083: Cannot open include file: 'jetoledb.h': No such file or
directory.
ü Instalar o reparador do compilador Visual C++® 6.0 para os arquivos de
suporte do provedor Jet OLE DB Provider 4.0 (C.1 passo 5).
6.3. Fatal error C1083: Cannot open include file: 'propidl.h': No such file or directory.
ü Instalar o componente Win32 API - Build Environment do Platform SDK (C.1

passo 7).
6.4. Error C2501: ‘DBLENGTH’: missing storage-class or type specifiers. Ocorre porque
a versão incorreta do arquivo oledb.h (residente na pasta Microsoft Visual
Studio \ VC98 \ Include) é utilizada.
ü Instalar o componente OLE DB (MDAC 2.6) - Build Environment / Data
Access Services do Platform SDK (C.1 passo 7).
6.5. Fatal error C1083: Cannot open include file: 'xmldom.idl': No such file or
directory or Fatal error C1083: Cannot open include file: 'xmldso.idl': No such
file or directory.
ü Instalar o componente Internet Explorer - Build Environment / Web Services

do Platform SDK (C.1 passo 7).
6.6. Fatal error C1083: Cannot open include file: 'ssvp.cpp': No such file or directory.
ü Instalar o Visual Parse++ 4.0 (C.1 passo 8).
ü Executar o passo 5.
6.7. DMParse\dmparser.cpp(160) : error C2664: '__thiscall SSLexTable::SSLexTable...
ü Incluir a definição VP40 nos parâmetros C/C++ / Preprocessor /

Preprocessor definitions do projeto DMParse.
6.8. Fatal error C1083: Cannot open include file: 'sslex.hpp': No such file or directory.
ü Verificar a lista de arquivos de inclusão (C.1 passo 9).
6.9. Fatal error LNK1181: cannot open input file "..\VP64\Debug\VP64.lib".
ü Executar o passo 6.6.
6.10. vpm60m32.lib(ssvpvc.obj) : error LNK2001: unresolved external symbol
__afxForceEXCLUDE e outras do mesmo tipo.
ü Usar a opção Link Settings/Object/library modules do projeto DMProv e

incluir as seguintes bibliotecas na lista: OLDNAMES.LIB MFCS42U.LIB
MFCS42UD.LIB.
87
6.11. ...Putl\pnvalio.cpp: warning C4102: 'abort' : unreferenced label e outras
mensagens de alerta sobre variáveis locais não referenciadas no arquivo
Putl\pnvalio.cpp.
ü Abrir este arquivo e colocar comentários nestas linhas.
6.12. ...DMProv\dmglobals.cpp: warning C4102: 'DmErrorHandlerLabel' :
unreferenced label.
ü Abrir o arquivo DMProv/dmglobals.cpp e substituir SP_ERROR_HANDLER da

linha da mensagem de alerta pela definição da macro sem o rótulo não
referenciado: PFAssert(!"This is a <fall through> ! Most likely, you've forgotten
to SP_REPORT_*");
6.13. ...vc98\include\stdexcept(29) : warning C4251: '_Str' : class
'std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >'
needs to have dll-interface to be used by clients of class 'std::logic_error' e
outros alertas do mesmo tipo.
ü Abrir o arquivo E:\Program Files\Microsoft Visual

Studio\VC98\Include\XSTRING e substituir #ifdef _DLL por #if defined (_DLL)
ü || defined
Incluir (_DMDLL).
a definição _DMDLL na opção C/C++ / Preprocessor /
Preprocessor definitions do projeto DMProv. _DLL é definida em todos os
projetos mas no arquivo DMM/dmmlib.h esta definição é desfeita para
forçar o uso de bibliotecas estáticas.
Executando estes passos o arquivo DMProv.dll será construído e registrado e será
mostrada a mensagem: DMSProv.dll - 0 error(s), 0 warning(s). Se o serviço
MSSQLServerOLAPService estiver ativo, ele deve ser desativado e ativado novamente
para reconhecer o novo provedor. Finalmente o novo algoritmo,
Sample_DM_Algorithm, aparecerá na lista de algoritmos das propriedades básicas do
Editor Relacional de Modelos de DM do Gerenciador de Serviços de Análise.
C.4 Nomeando Variáveis
Os nomes de variáveis utilizados no provedor exemplo do kit de recursos

OLE DB DM obedecem a seguinte convenção:
ü variáveis de classes do tipo public, private e protected iniciam com o prefixo

m_. Por exemplo: DM_Count m_cCases (contador de casos definido na classe
SPCaseConsumer).
ü usualmente variáveis possuem outro prefixo relativo ao seu tipo. Por exemplo:
WCHAR m_szName[129] (o prefixo sz é utilizado para variáveis tipo texto). A
Tabela C.1 mostra os prefixos de alguns tipos de variáveis.
88
Tabela C.1. Prefixos de alguns tipos de variáveis
Tipo de variável Prefixo
contador genérico c
ponteiro inteligente para objetos COM (SPComPtr) sp
string sz
variant v
índice genérico i
double dbl
LONG l,i,c
UINT ui
ULONG ul
DWORD dw
Bool f, b
LSTR lp
LPTSTR psz
C.5 Implementando o Modo de Funcionamento Isolado
O kit de recursos OLE DB DM contém a implementação de um provedor de

recursos de DM que funciona de modo agregado ao módulo de Serviços de Análise.
As interfaces IDMASecurityAdvise/IDMASecurityNotify são utilizadas para
implementar um provedor que somente possa funcionar agregado a este módulo.

Quando o processo de agregação é iniciado pelo provedor, o módulo de Serviços de
Análise retorna a este provedor um objeto que implementa os métodos de notificação
de segurança definidos pela interface IDMASecurityNotify.

A implementação de um provedor que também possa funcionar isoladamente e
que ainda continue a funcionar de modo agregado exige algumas modificações no
código fonte do kit de recursos OLE DB DM. Deve ser incluída a implementação de
uma interface fictícia IDMASecurityNotify que retorne apenas o valor apropriado de
sucesso ou verdadeiro para os métodos de retorno de chamada de segurança. Este

objeto deve ser criado na sessão somente quando a função
IDMASecurityAdvise::AdviseSecurity não for invocada nesta sessão. Os seguintes passos
descrevem estas modificações:

1. Abrir o arquivo DMCore/dmaggregator.h e salvar como
DMProv/dmstandalone.hpp. Usar este arquivo como base para definir
#ifndef __dmstandalone_hpp__
IDMASecurityNotifyDummy como segue:
#define __dmstandalone_hpp__
89
#ifndef __cplusplus
#error dmstandalone.hpp requires C++ compilation
#endif
interface IDMASecurityNotifyDummy : public IDMASecurityNotify

{
public:
SP_NO_INTERFACES(IDMASecurityNotifyDummy, IDMASecurityNotify);
HRESULT STDMETHODCALLTYPE PreCreateMiningModel(

/* [string][in] */ wchar_t __RPC_FAR *in_strMiningModelName)
{ return S_OK; };
HRESULT STDMETHODCALLTYPE PreRemoveMiningModel(

/* [string][in] */ wchar_t __RPC_FAR *in_strMiningModelName)
{ return S_OK; };
HRESULT STDMETHODCALLTYPE RenameMiningModel(

/* [string][in] */ wchar_t __RPC_FAR *in_strOldMiningModelName,
/* [string][in] */ wchar_t __RPC_FAR *in_strNewMiningModelName)
{ return S_OK; };
HRESULT STDMETHODCALLTYPE IsSELECTAllowed(

/* [string][in] */ wchar_t __RPC_FAR *in_strMiningModelName,
/* [out] */ boolean __RPC_FAR *out_pfIsAllowed)
{ *out_pfIsAllowed = TRUE;
return S_OK; };
HRESULT STDMETHODCALLTYPE IsMODIFYAllowed(

/* [out] */ boolean __RPC_FAR *out_pfIsAllowed)
{ *out_pfIsAllowed = TRUE;
return S_OK; };
HRESULT STDMETHODCALLTYPE PostCreateMiningModel(

/* [in] */ HRESULT in_hResult)
{ return S_OK; };
HRESULT STDMETHODCALLTYPE PostRemoveMiningModel(

/* [in] */ HRESULT in_hResult)
{ return S_OK; };
};
#endif // __dmstandalone_hpp__
2. Abrir o arquivo DMProv/StdAfx.h e inserir a seguinte linha de comando junto com

os demais comandos de inclusão de arquivos de cabeçalhos do projeto
DMSProv:
#include "dmstandalone.hpp"
3. Abrir o arquivo DMProv/Session.hpp:

ü Inserir as seguintes variáveis privadas na classe SPSession:
bool IsAdviseSecurityCalled;
bool IsSecurityNotifyDummyInstantiated;
ü Substituir a função GetDMASecurityNotify por:

HRESULT GetDMASecurityNotify (IDMASecurityNotify **
out_ppSecurityNotify)
{
if (IsAdviseSecurityCalled)
{
90
if (!m_spSecurityNotify) return E_FAIL;
return m_spSecurityNotify.CopyTo(out_ppSecurityNotify);
}
else
{
if (!IsSecurityNotifyDummyInstantiated)
{
SPObject<IDMASecurityNotifyDummy>::CreateInstance((IDMASecurityNo
tifyDummy **)&m_spSecurityNotify);
if (!m_spSecurityNotify) return E_FAIL;
IsSecurityNotifyDummyInstantiated = true;
}
return m_spSecurityNotify.CopyTo(out_ppSecurityNotify);
}
}
ü Substituir os métodos IDMASecurityAdvise por:

STDMETHOD (AdviseSecurity)(IDMASecurityNotify *
in_pSecurityNotify)
{
m_spSecurityNotify = in_pSecurityNotify;
IsAdviseSecurityCalled = true;
return S_OK;
}
STDMETHOD (UnadviseSecurity)(IDMASecurityNotify *
in_pSecurityNotify)
{
if (m_spSecurityNotify != in_pSecurityNotify) return
E_INVALIDARG;
m_spSecurityNotify.Release();
IsAdviseSecurityCalled = false;
return S_OK;
}
4. Abrir o arquivo DMProv/Session.cpp e inserir a seguinte linha de comando na

função SPSession::Close:
if (m_spSecurityNotify) m_spSecurityNotify.Release();
5. Abrir o arquivo DMProv/Session.inl e inserir as seguintes linhas de comando na

função SPSession::SPSession:
IsAdviseSecurityCalled = false;
IsSecurityNotifyDummyInstantiated = false;
C.6 Criando um Novo Provedor
A criação de um novo provedor, clcMine, a partir do gabarito Data Mining
SampleProvider envolve a execução de um novo conjunto de operações:

1. Copiar todos os arquivos da pasta SampleProvider para a pasta desejada,
DMclcMine, por exemplo.
2. Renomear todos os arquivos DMSample.* para DMclcMine.*, da pasta
DMclcMine.
3. Renomear o arquivo DMM/NaiveBayes.hpp para DMM/MSNaiveBayes.hpp.
4. Renomear o arquivo DMM/NaiveBayes.cpp para DMM/MSNaiveBayes.cpp.
5. Remover o arquivo NaiveBayes.cpp da lista de arquivos fontes do projeto DMM e
inserir o arquivo MSNaiveBayes.cpp nesta mesma lista.
91
6. Abrir o arquivo DMclcMine.dsw (de controle de projetos) com o Microsoft®
Developer Studio.
7. Modificar as pastas de Output de todos os projetos para os arquivos
intermediários e de saída conforme for conveniente.
8. Utilizar a opção Link / General do projeto DMProv:
ü Em Output file name, substituir Debug/DMSProv.dll por Debug/DMclcMine.dll.
ü Em Object/library modules, substituir a pasta de DMQM.lib conforme
modificações do passo 7.
9. Utilizar a opção Browse Info do projeto DMProv e substituir a pasta de
DMProv.bsc, conforme modificações do passo 7, em Browse info file name.
10. Abrir o arquivo DMProv/DMSProv.def e substituir DMSProv.dll por DMclcMine.dll.
11. Utilizar a opção MIDL Settings do arquivo DMProv/DMSProv.idl e substituir Output
filename por “.\ DMclcMine.tlb”.
12. Abrir o arquivo DMProv/DMSProv.rc para edição de texto e substituir:
ü DMSProv por DMclcMine.
ü Sample OLE DB DM Provider por clcMine OLE DB DM Provider.
ü Sample DM Algorithm por MS Naive Bayes.
ü Sample_DM_Algorithm por MS_Naive_Bayes.
13. Abrir os arquivos DMProv/DMSProv.idl, DMProv/DMSProv.rgs e
DMProv/DMErrorLookup.rgs (o arquivo DMSProv.h será modificado pelo
compilador MIDL) e substituir:
ü DMSProv por DMclcMine.
ü Sample por clcMine.
14. Abrir o arquivo DMProv/SchemaRowsets.h e substituir Sample_DM_Algorithm por
MS_Naive_Bayes.
15. Abrir o arquivo DMProv/dmerrorlookup.hpp e substituir
CLSID_DMSProvErrorLookup por CLSID_DMclcMineErrorLookup.
16. Abrir o arquivo DMProv/dmerrorlookup.inl e substituir CLSID_DMSProvErrorLookup
por CLSID_DMclcMineErrorLookup.
17. Abrir o arquivo DMProv/DMSProv.cpp e substituir:
ü CLSID_DMSProv por CLSID_DMclcMine.
ü CLSID_DMSProvErrorLookup por CLSID_DMclcMineErrorLookup.
ü LIBID_DMSProvLib por LIBID_DMclcMineLib.
18. Abrir o arquivo DMProv/DMErrors.cpp e substituir CLSID_DMSProv por
CLSID_DMclcMine.
19. Abrir o arquivo DMProv/DataSrc.hpp e substituir CLSID_DMSProv por CLSID_
20. DMclcMine.
Abrir o arquivo DMProv/dmglobals.cpp e substituir TEXT("DMSProv") por
TEXT("DMclcMine").
21. Abrir o arquivo dmparser.ypw (de controle de projetos) com o Visual Parse. Abrir
o arquivo dmparser.ycc (de definição da gramática da linguagem SQL DM) e
substituir o símbolo T_SampleAlgorithm por MS_Naive_Bayes (o nome do algoritmo
não pode conter espaços em branco).
92
22. O provedor exemplo foi projetado para funcionar somente no modo agregado.
Os passos descritos no item C.3 devem ser executados para que o provedor
funcione também no modo isolado. Se estas modificações extras tiverem sido
feitas, o provedor poderá ser utilizado diretamente através de objetos de dados
ActiveX® (ADO) fornecendo o nome “DMclcMine” como o nome do provedor na
seqüências de caracteres utilizada para conexão com provedor OLE DB.
23. Reconstruir todos os projetos.
C.7 Modificando o Nome de um Algoritmo
O nome de um algoritmo pode ser modificado através dos seguintes passos:
o arquivo dmparser.ycc (de definição da gramática da linguagem SQL DM):
ü Substituir o símbolo T_SampleAlgorithm por '
[Mm][Ss]_[Nn][Aa][Ii][Vv][Ee]_[Bb][Aa][Yy][Ee][Ss]' ("MS_Naive_Bayes"). O
símbolo não pode conter espaços em branco.
ü Substituir T_SampleAlgorithm por T_MSNaiveBayes.
ü Substituir PSampleAlg por PMSNaiveBayesAlg.
ü Executar Debug/Compile.
ü Executar Debug/Generate Files. O Visual Parse emitirá uma mensagem: Auto-
merge failed, your original file is in .\dmreduce.bak00x... O arquivo
dmreduce.cpp deve ser removido pois foi corrompido. O arquivo
dmreduce.bak00x deve ser renomeado para dmreduce.cpp.
2. Abrir o arquivo DMParse/dmreduce.cpp e substituir SP_PSampleAlg por
SP_PMSNaiveBayesAlg.
3. Abrir os arquivos DMProv/SchemaRowsets.h e DMProv/SchemaRowsets.cpp e
substituir:
ü SERVICE_GUID_Sample_Algorithm por SERVICE_GUID_MS_Naive_Bayes.
ü SERVICE_NAME_SAMPLE_ALGORITHM por SERVICE_NAME_MS_NAIVE_BAYES.
4. Abrir o arquivo DMProv/SchemaRowsets.h e substituir o valor da constante
SERVICE_NAME_MS_NAIVE_BAYES pelo texto “MS_Naive_Bayes” (deve ser
exatamente o mesmo texto que a definição do símbolo T_MSNaiveBayes). Este
dado é utilizado pelos editores Relacional e OLAP de Modelos de DM do
Gerenciador de Serviços de Análise para construir as consultas SQL DM.
5. Abrir os arquivos DMProv/DMSProv.rc, DMProv/SchemaRowsets.cpp e
DMBase/dmresource.h e substituir:
ü IDS_SERVICE_SAMPLE_ALGORITHM_DESCRIPTION por
IDS_SERVICE_MS_NAIVE_BAYES_DESCRIPTION.
ü IDS_SERVICE_SAMPLE_ALGORITHM_DISPLAY_NAME por
IDS_SERVICE_MS_NAIVE_BAYES_DISPLAY_NAME.
6. Abrir o arquivo DMProv/DMSProv.rc e substituir os valores das seqüências de
caracteres IDS_SERVICE_MS_NAIVE_BAYES_DISPLAY_NAME e
IDS_SERVICE_MS_NAIVE_BAYES_DESCRIPTION. Estas seqüências são utilizadas na
lista de algoritmos das propriedades básicas dos editores Relacional e OLAP de
Modelos de DM do Gerenciador de Serviços de Análise. Os valores das
seqüências podem ser diferentes daqueles definidos para os símbolos.
7. Abrir os arquivos DMCore/dmmodel.h, DMCore/dmmodel.cpp,
DMParse/dmreduce.cpp, DMProv/dmxbind.cpp e DMProv/dmxmlpersist.cpp e
93
substituir DM_ALGORITHMIC_METHOD_SAMPLE_ALGORITHM por
DM_ALGORITHMIC_METHOD_MS_NAIVE_BAYES.
C.8 Corrigindo os Arquivos de Análise de Comandos
Se algum símbolo novo precisar ser inserido no arquivo de definição da
gramática da linguagem SQL DM - dmparser.ycc, uma extensa correção deve ser
realizada no arquivo dmreduce.cpp. Renomear o arquivo dmreduce.cpp para
dmreduce.back.cpp. Abrir o arquivo dmparser.ypw com o Visual Parse, e executar:

ü Debug/Compile
ü Debug/Generate Files
O Visual Parse irá gerar um arquivo dmreduce.cpp novo e limpo. O início do
arquivo contém uma mensagem alertando para que o arquivo deve ser mantido
limpo, ou seja sem a existência de muito código adicional e sem a existência de
comandos tipo switch. Estes requisitos são exigidos para que o Visual Parse possa
mesclar sem erros, os comandos que forem necessários, para refletir futuras alterações
no arquivo de definição da gramática da linguagem SQL DM. Desta forma sempre
que possível chamadas de funções devem ser incluídas ao invés de linhas de código
O arquivo dmreduce.cpp original não é limpo. Desta maneira qualquer
diretas.
modificação que for realizada no arquivo dmparser.ycc, seguida de uma execução
de Debug/Generate Files irá produzir um arquivo dmreduce.cpp corrompido e
ocasionar a terminação anormal do Visual Parse.

A partir desta versão limpa do arquivo dmreduce.cpp todas as chamadas de
funções necessárias para reproduzir o funcionamento da versão original deste arquivo

deverão ser incluídas, bem como os arquivos correspondentes para esta funções
deverão ser criados e adicionados ao projeto DMParse.
C.9 Implementando um Novo Algoritmo
o arquivo dmparser.ycc (de definição da gramática da linguagem SQL DM):
ü Inserir o símbolo T_SNaiveBayes:
'[Ss][Ii][Mm][Pp][Ll][Ee]_[Nn][Aa][Ii][Vv][Ee]_[Bb][Aa][Yy][Ee][Ss]'
("Simple_Naive_Bayes") depois do símbolo T_MSNaiveBayes. Este símbolo não
pode conter espaços em branco.
ü Inserir a definição PSNaiveBayesAlg depois de PMSNaiveBayesAlg:
dmm_algorithm -> T_SNaiveBayes;
ü Executar Debug/Compile.
ü Executar Debug/Generate Files.
2. Abrir o arquivo DMParse/dmreduce.cpp e mover a linha de comando:
case SP_PMSNaiveBayesAlg:
94
para o mesmo lugar que a linha de comando:
case SP_PMSNaiveBayesAlg:
A mesma função (redSP_PAlgorithm) será utilizada para processar este caso.

3. Abrir o arquivo DMParse/dmredAlgorithm.cpp e modificar a função
redSP_PAlgorithm inserindo a linha de comando:
case SP_PSNaiveBayesAlg: Algorithm =
DM_ALGORITHMIC_METHOD_S_NAIVE_BAYES; break;
dentro do bloco do switch.

4. Abrir o arquivo DMProv/SchemaRowsets.h:
ü Executar guidgen.exe da pasta Microsoft® Visual Studio \ Common \ Tools,
criar um novo GUID (formato static const) e inserir como uma nova constante
externa GUID SERVICE_GUID_S_Naive_Bayes.
ü Inserir a nova constante SERVICE_NAME_S_NAIVE_BAYES com o texto
"Simple_Naive_Bayes" (deve ser exatamente o mesmo texto que a definição
do símbolo T_SNaiveBayes). Este dado é utilizado pelos editores Relacional e
OLAP de Modelos de DM do Gerenciador de Serviços de Análise para
construir as consultas SQL DM.
ü Incrementar uma unidade ao valor da constante DM_NUM_MINING_SERVICES.
ü Incrementar o número de parâmetros utilizados no novo algoritmo ao valor da
constante DM_NUM_MINING_SERVICE_PARAMETERS.
5. Abrir o arquivo DMProv/DMSProv.rc e inserir as seqüências de caracteres
IDS_SERVICE_S_NAIVE_BAYES_DISPLAY_NAME e
IDS_SERVICE_S_NAIVE_BAYES_DESCRIPTION. Estas seqüências são utilizadas na
lista de algoritmos das propriedades básicas dos editores Relacional e OLAP de
Modelos de DM do Gerenciador de Serviços de Análise. Os valores das
seqüências podem ser diferentes daqueles definidos para os símbolos.
6. Abrir o arquivo DMBase/dmresource.h e inserir as definições de
IDS_SERVICE_S_NAIVE_BAYES_DISPLAY_NAME e
IDS_SERVICE_S_NAIVE_BAYES_DESCRIPTION depois da definição de
IDS_SERVICE_MS_NAIVE_BAYES_DESCRIPTION.
7. Abrir o arquivo DMXML/PersistXML.idl e adicionar a constante
DMPI_SNAIVEBAYESMODEL no enumerador DMPERSISTITEM e modificar a
constante DMPI_END para refletir esta alteração.
8. Abrir o arquivo DMXML/PersistXML.cpp e adicionar o valor L"Simple-naive-
bayes-model" em wszTags (vetor de todas as possíveis etiquetas utilizadas nos
9. arquivos XML). DMCore/dmmodel.h e inserir a constante
Abrir o arquivo
DM_ALGORITHMIC_METHOD_S_NAIVE_BAYES no enumerador
10. DM_AlgorithmicMethod.
Abrir o arquivo DMCore/dmmodel.cpp e inserir na função
SPModel::GetDMAlgorithm linhas de comando similares a de outros algoritmos
para o case DM_ALGORITHMIC_METHOD_S_NAIVE_BAYES.
11. Criar o arquivo DMM/ModelUtils.hpp a partir do arquivo DMM/MSNaiveBayes.hpp,
movendo definições que são comuns a todos os algoritmos.
12. Criar o arquivo DMM/SNaiveBayes.hpp a partir do arquivo
DMM/MSNaiveBayes.hpp e substituir MSNaiveBayes por SNaiveBayes.
13. Criar o arquivo DMM/SNaiveBayes.cpp a partir do arquivo
DMM/MSNaiveBayes.cpp e substituir MSNaiveBayes por SNaiveBayes.
14. Abrir o arquivo DMM/dmmlib.h e incluir a linha de comando:
95
#include "SNaiveBayes.hpp"
15. Abrir o arquivo DMProv/dmxbind.cpp e efetuar as modificações necessárias.

Ainda não implementado para o classificador SNBi.
16. Abrir o arquivo DMProv/dmxmlpersist.cpp:
ü Inserir o case DMPI_SNAIVEBAYESMODEL com os procedimentos adequados na
função SPModel::Load.
ü Inserir o case DM_ALGORITHMIC_METHOD_S_NAIVE_BAYES com os
procedimentos adequados na função SPModel:: Save.
17. Abrir o arquivo DMProv/SchemaRowsets.cpp file:
ü Inserir os comandos apropriados para definir SERVICE_NAME_S_NAIVE_BAYES
na tabela _rgDMSERVICES na função SPServicesSchemaRowset::InitClass.
Ainda não implementado de forma adequada para o classificador SNBi.
ü Inserir os comandos apropriados para definir SERVICE_NAME_S_NAIVE_BAYES
na tabela _rgDMSERVICE_PARAMETERS na função
SPServiceParametersSchemaRowset::InitClass. Ainda não implementado de
forma adequada para o classificador SNBi.
C.10 Inserindo Suporte para uma Nova Propriedade
Para inserir suporte para uma nova propriedade, por exemplo name =
INIT_ASYNCH, os passos seguintes devem ser executados:

1. Abrir o arquivo DMInclude/dbs.idl e verificar se a definição da propriedade
DBPROP_<name> (DBPROP_INIT_ASYNCH) existe no enumerador DBPROPENUM.
2. Abrir o arquivo DMBase/dmresource.h e inserir a macro IDS_DBPROP_<name>
(IDS_DBPROP_INIT_ASYNCH) no lugar apropriado.
3. Abrir o arquivo DMProv/DMSProv.rc e inserir a definição da seqüência de
caracteres IDS_DBPROP_<name> (IDS_DBPROP_INIT_ASYNCH) no lugar
apropriado.
4. Abrir o arquivo DMProv/DataSrc.hpp e inserir a informação da propriedade
PROPERTY_INFO_ENTRY(<name>) (PROPERTY_INFO_ENTRY(INIT_ASYNCH)) no
local apropriado.
5. Abrir o arquivo DMProv/Properties.h e inserir as macros <name>_Flags
(INIT_ASYNCH_Flags), <name>_Type (INIT_ASYNCH_Type) and <name>_Value
(INIT_ASYNCH_Value) no local apropriado.
6. Inserir o código necessário para suportar a nova propriedade. No caso da
propriedade INIT_ASYNCH, este código foi inserido no arquivo
DMProv/DataSrc.hpp, função SPDataSource::Initialize.
7. Testar os recursos implementados utilizando uma ferramenta tal como o
visualizador de tabelas virtuais RowsetViewer.
C.11 Inserindo Códigos de Erros
Os passo necessários para a inserção de um novo código de erro são listados a

seguir. Será exemplificado o caso da inserção do erro referente à impossibilidade de
predição de atributos contínuos.
96
1. Abrir o arquivo DMBase/dmerrors_rc.h e inserir a definição do identificador de
recurso do erro, observando a simbologia para cada tipo de erro. Para erros
referentes ao modelo de DM, o identificador será IDS_SPE_DMM_<codigo erro>
(IDS_SPE_DMM_ALG_CANT_PREDICT_CONTINUOUS_ATTRIBUTE).
2. Abrir o arquivo DMProv/dmerrors.rc e inserir a definição da seqüência de
caracteres correspondente a mensagem de erro na tabela correspondente
("This algorithm can't predict continuous attribute").
3. Abrir o arquivo DMBase/dmerrors.h e inserir a definição do código de retorno do
erro de acordo com a sintaxe correspondente ao tipo de erro. Para erros
referentes ao modelo de DM, esta sintaxe será: SPE_DMM_<codigo erro>. Para o
exemplo a seguinte linha de comando deverá ser inserida:
DM_DEFINE_ERROR_HRESULT(SPE_DMM_ALG_CANT_PREDICT_CONTINUOUS_ATTRIBUTE)
4. Abrir o arquivo DMM/DMM.idl e inserir a definição do código de retorno de erro

conforme a sintaxe: DMME_<codigo erro>. Para o exemplo a seguinte linha de
comando deverá ser inserida:
DMM_DEFINE_ERROR_HRESULT(DMME_ALG_CANT_PREDICT_CONTINUOUS_ATTRIBUTE,0x
000D)
5. Abrir o arquivo DMProv/DMErrors.cpp e inserir na função DMMapDMMErrorCode o

código correspondente ao novo erro. Para o exemplo inserido para a definição
do código de retorno de erro conforme a sintaxe: DMME_<codigo erro>.
Outros arquivos que contêm funções para lidar com erros são:
DMBase/DMErrors.hpp, DMBase/DMErrors.inl e DMBase/dmbsglob.cpp.
C.12 Armazenando e Recuperando Arquivos XML
Os modelos de DM podem ser armazenados em formato binário ou em formato

texto através da especificação PMML (DMG, 2002), versão 1.0. Esta é uma linguagem
de marcação para modelos estatísticos e de DM baseada em XML (WC3, 2000).
Para habilitar o armazenamento no formato texto, a variável m_dmpfDefault da
função SPDataSource::SPDataSource, do arquivo DMProv/DataSrc.inl, deve ser
inicializada como DMPF_XML ao invés de DMPF_BIN.

O arquivo texto no padrão PMML 1.0 que contém o modelo de DM possui o
nome <nome do modelo>.sdmm.xml e esta localizado na pasta de dados definida
para o módulo de Serviços de Análise, sub pasta <nome do banco de
dados>\DMA.DMclcMine e pode ser visualizado por qualquer editor de textos ou por

As linhas de comando de número 68 e 222 do arquivo DMProv\dmglobals.cpp
um browser.
também contém informações relativas ao tipo padrão de arquivo de
armazenamento, no entanto, aparentemente, somente a modificação descrita é
necessária.
97
C.13 Corrigindo Erros de Programação
Para construir a versão para correção de erros, simplesmente deve ser utilizada a
configuração Debug existente, já que no kit de recursos OLE DB DM somente existe
esta configuração.
Na opção C/C++ / Preprocessor / Preprocessor definitions de todos os projetos,
as macros DEBUG, _DEBUG, ID_DEBUG e DEBUG_VMALLOC são definidas. Além disso a
macro _DEBUG é definida automaticamente pelo compilador quando as versões para
correção
Parade erros das
corrigir bibliotecas
erros C são utilizadas.
de programação, o provedor de recursos de DM pode ser
executado para funcionar agregado ao módulo de Serviços de Análise ou para atuar
como um servidor isolado.
Para executar o provedor de recursos de DM agregado com o módulo de
Serviços de Análise, o servidor MSOLAP deve ser definido como o programa
executável para a sessão de correção de erros. Usando a opção Project / Settings /
Debug do projeto DMProv, categoria General, definir: “E:\Program Files\Microsoft
Analysis Services\Bin\msmdsrv.exe” como programa executável e -c (console mode)
para argumento do programa. O servidor MSOLAP deve ser parado antes de iniciar a
correção de erros. Deve ser observado que a DLL do provedor de recursos de DM não
será carregada até que a funcionalidade do provedor seja requisitada ou a não ser
que o programa de correção de erros seja configurado para carregar os símbolos da
DLL inicialmente.
Para executar o provedor de recursos de DM com um projeto Visual Basic tal
como o DMSamp (KIM & CARROLL, 2002), o Visual Basic deve ser definido como o
programa executável da sessão. Usando a opção Project / Settings / Debug do
projeto DMProv, categoria General, definir: “E:\Program Files\Microsoft Visual
Studio\VB98\VB6.EXE” como programa executável e
F:\datamining\DMSamp\DMSamp.vbp para argumento do programa. O servidor
MSOLAP Para executar

não o provedor
será utilizado pois de recursos de
o provedor deDM com um
recursos deprograma qualquer,
DM funcionará basta
de modo
definir
isolado.o programa desejado como o programa executável da sessão. Por exemplo,
para utilizar o executável DMSamp (KIM & CARROLL, 2002), usar a opção Project /
Settings / Debug do projeto DMProv, categoria General, definir:
F:\datamining\DMSamp\DMSamp.exe como programa executável e /C "Data
Source=f:\datamining\data\allelet;Provider=DMclcMine" /F
"f:\datamining\data\allelet\SNBi_Queries.xml" /R para argumento do programa.
98
C.13.1 Executando
Executar o servidor MSOLAP ou um aplicativo que utilize o provedor de recursos

de DM.
Se o provedor de recursos de DM estiver sendo utilizado de modo isolado, a DLL
correspondente ao provedor de recursos de DM será imediatamente carregada. Por
outro lado, se o provedor de recursos de DM estiver sendo utilizado de modo
agregado, executar o módulo de Serviços de Análise. Selecionar a pasta do banco de
dados e modelo de DM desejados. As DLLs correspondentes a cada provedor de
recursos de DM registrado serão carregadas.
Quando a DLL é carregada, as seguintes funções serão processadas, entre
outras:
• DllMain (DMProv/DMSProv.cpp)
• DllGetClassObject (DMProv/DMSProv.cpp)
• SPDataSource::Initialize (DMProv/DataSrc.cpp)
• SPModel::Load (DMProv/dmxmlpersist.cpp) chamada pela linha de comando:
SP_CHECK_ERROR(pDataManager->Init(pQC)); (DMProv/DataSrc.cpp).
Esta última função recupera os dados dos modelos de DM existentes lendo os
segmentos: de comandos de criação do modelo (statements); do dicionário de dados
(data-dictionary); das estatísticas globais (global-statistics); e do modelo
propriamente dito (Simple-naive-bayes-model).

A leitura do dicionário de dados envolve as seguintes funções, chamadas para
cada atributo para contabilizar todos os valores dos atributos discretos:
• SPModel::LoadColumn (DMProv/dmxmlpersist.cpp)
• SPQueryManager::DoTrainAttributes (DMQM/DMQueryManager.cpp).
Quando um determinado modelo de DM é selecionado e o processo de
treinamento é ativado, então as seguintes funções são processadas:
• SPQueryManager::DoCreate (DMQM/DMQueryManager.cpp)
• SPDataManager::CreateModel (DMParse/dmtools.cpp)
• SPQueryManager::DoTrainModel (DMQM/DMQueryManager.cpp)
Esta última função por sua vez chama a função de treinamento específica de
cada algoritmo de DM.
C.13.2 Removendo Arquivos Indesejados
Os arquivos gerados pelo módulo de Serviços de Análise ficam armazenados na
pasta Data do servidor utilizado. Para acessar este parâmetro, utilizar
Properties/General no servidor desejado.
99
Nesta pasta são criados os arquivos de log de cada provedor de recursos de
DM. MSDMine.log é o nome do arquivo gerado pelo provedor MSDMine e
DMclcMine.log é o nome do arquivo gerado pelo provedor DMclcMine. Nesta mesma
pasta ainda existem os arquivos que contem os metadados dos bancos de dados,
com os nomes <nome do banco de dados>.odb, bem como pastas para cada banco
de dados criadodo
Na pasta pelo módulo
banco de Serviços
de dados, parade Análise.
cada fonte de dados existe um arquivo de
nome <nome do servidor> – <nome do banco de dados>.src e para cada regra de
acesso existe um arquivo de nome <nome da regra>.role. Ainda nesta pasta estão
armazenados os arquivos que representam os modelos de DM do provedor MSDMine
com o nome <nome do modelo>.dmm e arquivos de nome <nome do
modelo>.dmm.xml, gerados pelo provedor DMclcMine, mas que não têm utilidade
nenhuma pois os arquivos dos modelos deste provedor são armazenados em outro
local. Pastas para cada modelo de DM também são criadas nesta pasta, com o nome
<nome do modelo>. Além disso o provedor DMclcMine cria uma pasta de nome
Nas pastas de cada modelo são armazenados os arquivos de regras de acesso
DMA.DMclcMine. Provedores criados a partir do provedor exemplo criam esta pasta
ao modelo de nome <nome da regra>.dmmsec.
com o nome DMA.<nome da DLL>.
Na pasta DMA.DMclcMine são criados os arquivos de nome <nome do
modelo>.dmm.xml, que contêm os dados de cada modelo de DM criado pelo
provedor DMclcMine. Os arquivos <nome do modelo>.debug.txt, gerados pelas
sessões
Emdesessões
correção
de de erros também
correção são
de erros ouarmazenados nesta pasta.
mesmo em sessões normais interrompidas,
alguns destes arquivos podem ficar eventualmente corrompidos. Assim muitas vezes é
necessário removê-los manualmente para possibilitar o uso do módulo de Serviços de
Análise. Nestes casos os arquivos *.dmm e *.dmm.xml correspondentes devem ser
removidos. Obviamente que os arquivos *.log e *.txt podem ser removidos a qualquer
instante.
Quando o provedor de recursos de DM for utilizado no modo isolado, os arquivos
de dados dos modelos de DM, os arquivos de log e os arquivos gerados pelas sessões
de correção de erros são criados na pasta definida como padrão.
C.14 Construindo a Versão Final
Como no kit de recursos OLE DB DM somente existe a configuração para
correção de erros (Debug), a configuração para construir a versão final (Release)
deve ser criada.
100
Nesta configuração a macro DEBUG, bem como as macros _DEBUG, ID_DEBUG e
DEBUG_VMALLOC devem ser removidas de C/C++ / Preprocessor /
Preprocessor definitions de todos os projetos. O arquivo Putl/pfdebug.h deve ser
modificado para prevenir a definição automática da macro DEBUG.

Utilizar as versões finais das bibliotecas C, pois a macro _DEBUG é definida
automaticamente pelo compilador quando as versões para correção de erros são

utilizadas.
C.15 Arquivos Modificados
A Tabela C.2 lista todos os arquivos que foram modificados a partir do código
fonte do kit de recursos OLE DB DM para implementação do provedor DMclcMine.
Tabela C-2 – Relação de Arquivos Modificados
Projeto Arquivos Motivo
Microsoft XSTRING Incluir verificação da macro _DMDLL.

Visual Studio
\ VC98 \
CP
Include CP.dsp Modificar as pastas de Output.
DMBase.dsp Modificar as pastas de Output e definir o novo

arquivo de cabeçalhos pré-compilados.
dmbslib.cpp Removido por ser desnecessário.

DMBase
dmerrors.h, Incluir novas mensagens de erros.
dmerrors_rc.h
dmresource.h Implementar novos algoritmos de DM e suportar
uma nova propriedade.
DMCommon DMCommon.dsp Modificar as pastas de Output.
DMCore.dsp Modificar as pastas de Output.
dmaggregator_i.c Corrigir o conteúdo do arquivo cujas linhas

DMCore estavam em duplicata.
dmmodel.cpp, Implementar novos algoritmos de DM.
dmmodel.h
DMInclude.dsp Criado para facilitar a visualização de arquivos
de inclusão.
DMInclude
ATLDBDM.H Incluir suporte para uma nova propriedade de nó.
DMM DMM.dsp Modificar as pastas de Output.
Classifier.cpp Corrigir problemas relativos à variável local não

referenciada.
DataMiningModel.hpp, Implementar recurso incremental para o modelo

marginal e para o classificador SNBi.
DataMiningModel.inl,
dmmxml.cpp
dmmlib.h, Implementar novos algoritmos de DM.
ModelUtils.hpp,
DMM.idl Incluir novas mensagens de erros e incluir suporte
ModelUtils.inl
101
para uma nova propriedade de nó.
DMMStatistics.h* Implementar recurso incremental para o modelo

marginal e definir classes utilizadas na estrutura de
dados do classificador SNBi.
MarginalModel.cpp, Implementar recurso incremental para o modelo

marginal.
MarginalModel.h
MarginalModel.cpp Incluir recursos para facilitar a tarefa de correção
de erros de programação.
ModelUtils.inl Incluir suporte para uma nova propriedade de nó.
MSNaiveBayes.cpp, Modificar nome do algoritmo e incluir novas

mensagens de erros.
DMM MSNaiveBayes.hpp
SNaiveBayes.cpp*, Implementar procedimentos do classificador SNBi.
SNaiveBayes.hpp*
DMParse.dsp Modificar as pastas de Output e incluir a
definição VP40.
dmhinode.hpp Corrigir erro de programação.
dmparser.ycc Implementar novos algoritmos de DM.
dmparser.ypw, Modificados pelo Visual Parse para refletir as

modificações na definição da gramática e no
dmparser.llr, projeto.
dmparser.dfa, Possibilitar e implementar novos algoritmos de DM
dmreduce.cpp,
dmpardef.h
dmredAlgorithm.cpp,
dmredBinary.cpp,
dmredCalc.cpp,
dmredCalcPlus.cpp,
dmredCalcScal.cpp,
dmredColumn.cpp,
dmredColumnDef.cpp,
DMParse dmredColumnRef.cpp,
dmredColumnTable.cpp,
dmredColumnTopCount.
cpp, dmredContent.cpp,
dmredCreate.cpp,
dmredDelete.cpp,
dmredDiscMethod.cpp,
dmredDistribution.cpp,
dmredDrop.cpp,
dmredfunc.hpp,
dmredInsert.cpp,
dmredModelFlag.cpp,
dmredOnCol.cpp,
dmredOnList.cpp,
dmredOpenQuery.cpp,
dmredPrediction.cpp,
102
dmredRelated.cpp,
dmredRename.cpp,
dmredSelect.cpp,
dmredSelectExprCol.cpp,
dmredSelectExprList.cpp
, dmredShape.cpp,
dmredSingle.cpp,
dmredSubSelect.cpp,
dmredType.cpp,
dmredValue.cpp,
dmredWhere.cpp
DMProv.dsp Modificar as pastas de Output, Incluir a definição

da macro _DMDLL.
DataSrc.cpp Corrigir erros gerados por determinados valores
DMProv
da propriedade mining location.
DataSrc.inl Modificar tipo de arquivo de armazenamento dos

modelos de DM.
DMErrorLookup.cpp Corrigir erros produzidos pelo uso incorreto de

Locale.
DataSrc.hpp, Implementar novos algoritmos de DM.
DMErrorLookup.hpp,
DMErrorLookup.inl,
DMErrorLookup.rgs,
DMSProv.cpp,
DMSProv.rc,
DMSProv.rgs,
dmxbind.cpp, Implementar suporte para uma nova
DataSrc.hpp,
dmxmlpersist.cpp, propriedade.
DMSProv.rc, Properties.h
SchemaRowsets.cpp, Incluir novas mensagens de erros e corrigir
DMErrors.cpp
DMProv SchemaRowsets.h problemas com a postagem de erros.
dmerrors.rc Incluir novas mensagens de erros.
dmglobals.cpp Corrigir problemas de rótulos não referenciados e

renomear provedor.
DMSProv.cpp, Renomear provedor de recursos de DM.
DMSProv.def,
dmstandalone.hpp, Possibilitar que o provedor possa ser utilizado em
DMSProv.idl
ambos os modos: agregado e isolado.
Session.cpp,
Session.hpp, Session.inl,
SchemaRows.hpp, Incluir suporte para uma nova propriedade de nó.
StdAfx.h
SchemaRowsets.cpp
version.rc, resource.h Incluir dados da versão do provedor de recursos
de DM.
DMQM.dsp Modificar as pastas de Output.

DMQM
DMQueryManager.cpp Incluir recursos para facilitar a tarefa de correção
103
de erros de programação. Implementar recurso
incremental para o modelo marginal e para o
classificador SNBi.
DMUtl DMUtl.dsp Modificar as pastas de Output.
DMXML.dsp Modificar as pastas de Output.

DMXML PersistXML.cpp, Implementar novos algoritmos de DM.
PersistXML.idl
Putl.dsp Modificar as pastas de Output.
pfdebug.h Remover a definição automática de DEBUG.
pflocks.hpp Corrigir erro de comando inexistente que ocorre

na geração da versão final.
Putl
pnvalue.cpp Isolar um trecho de código que provocava
divisão por zero. Ainda sem explicação.
pnvalio.cpp Corrigir problemas relativos à variáveis locais não

referenciadas.
TK TK.dsp Modificar as pastas de Output.
VP64 VP64.dsp Modificar as pastas de Output.

* código fonte incluído
C.16 Listagens
As Listagens C.1, C.2 e C.3 mostram, respectivamente, os arquivos

DMMStatistics.h, SNaiveBayes.cpp e SNaiveBayes.hpp, que são os arquivos principais
da implementação.
Listagem C.1. Arquivo DMMStatistics.h
// This is a part of the Microsoft Data Mining Sample Provider

// Copyright (C) 1992-2000 Microsoft Corporation
// All rights reserved.
//
// Modified by Claudio Luiz Curotto Aug/2002
// to implement incremental support to marginal models and to new algorithms
#ifndef __dmmstatistics_h__
#define __dmmstatistics_h__
class CStateStats
// Description:
// statistics of attribute states computed over all training cases
// will be exist one for each state of each attribute
// the states are numbered starting from 1 (one).
// state 0 is the missing state
// the attributes are numbered starting from 0 (zero)
// DISCRETE:
// one state (0) for missing attribute
// one state (starting from 1) for each distinct value of an attribute
// CONTINUOUS:
// one state (0) for missing attributes
// one state for non-missing attributes
/////////////////////////////////////////////////////////////////////////////
104
{
public:
DOUBLE m_dblSum; // sum of values of CONTINUOUS attributes
// mean = m_vdblSum / m_lCont (count of attributes)
// not used for DISCRETE attributes
DOUBLE m_dblSqrSum; // sum of squares of values of CONTINUOUS attributes
// S2 = m_lCount * mean * mean + m_dblSqrSum - 2 * mean *
m_dblSum
// S2 = m_dblSqrSum - m_dblSum * m_dblSum / m_lCount
// standard deviation = sqrt (S2 / (m_lCount - 1))
// not used for DISCRETE attributes
DOUBLE m_dblMean; // mean of values of CONTINUOUS attributes
DOUBLE m_dblStd; // standard deviation of values of CONTINUOUS attributes
LONG m_lCount; // count of CONTINUOUS and DISCRETE attributes
public:
CStateStats()
{
m_dblSum = 0.;
m_dblSqrSum = 0.;
m_lCount = 0;
}
__forceinline DOUBLE Mean()

{
return (m_lCount > 0 ? m_dblSum / m_lCount : 0.);
}
__forceinline DOUBLE Deviation()

{
if (m_lCount <= 1)
return (0);
DOUBLE dblMean = Mean ();

// DOUBLE S2 = m_lCount * dblMean * dblMean + m_dblSqrSum - 2. * dblMean * m_dblSum;
DOUBLE S2 = m_dblSqrSum - m_dblSum / m_lCount * m_dblSum;
if (S2 <= 0)
return (0);
return (sqrt (S2 / (m_lCount - 1)));

}
};
typedef vector<CStateStats> VSTATESTATS; // vector of statistics of all states of one

attribute
class CAttStats
{
public:
DOUBLE dblMin; // the minimum value of one attribute
DOUBLE dblMax; // the maximum value of one attribute
VSTATESTATS vstatestats; // vector of statistics of all states of one attribute
// the first position (0) will be used to store missing
attribute statistics
// number of elements:
// DISCRETE: number of states + 1 (missing + number of
states)
// CONTINUOUS: 2 (missing + non-missing)
public:
CAttStats()
{
dblMin = DBL_MAX;
dblMax = -DBL_MAX;
}
};
typedef vector<CAttStats> VATTSTATS; // vector of statistics of all attributes
#endif
105
Listagem C.2. Arquivo SNaiveBayes.cpp
//-----------------------------------------------------------------------------
//
// @module SNaiveBayes.cpp | Implementation of Simple Naive Bayes DMM.
//
// Description
//
// DMM_SNaiveBayes implements support for Simple Naive Bayes inference.
//
//
// Created by Claudio Luiz Curotto - apr/2002
// to implement the Simple Naive Bayes incremental algorithm
//
//-----------------------------------------------------------------------------
#pragma once
#include "dmmlib.h"
#include <stack>
#include "wchar.h"
#include "DMM.h"
#include "CaseCache.inl"
#include "DataMiningModel.inl"
#include "ModelUtils.inl"
#include "SNaiveBayes.hpp"
#include "DMXMLUtil.hpp"
class SPM_SNaiveBayesNav : public DMM_DAGNavigation

{
public:
SPM_SNaiveBayesNav()
{
m_pdmmSNaiveBayes = NULL;
m_ulNodeID = NODEID_NAVTOP;
}
~SPM_SNaiveBayesNav()
{
if (m_pdmmSNaiveBayes)
m_pdmmSNaiveBayes->Release();
}
void Init (IAttributeSet* pias, DMM_SNaiveBayes* pdmmSNaiveBayes, ULONG ulNodeStart)

{
m_spias = pias;
if (pdmmSNaiveBayes)
pdmmSNaiveBayes->AddRef();
if (m_pdmmSNaiveBayes)
m_pdmmSNaiveBayes->Release();
m_pdmmSNaiveBayes = pdmmSNaiveBayes;
m_ulNodeID = ulNodeStart;
}
/////////////////////////////////////////////////////////////////////////////
STDMETHOD(GetNodeID)
(ULONG* pulNodeID)
// Description:
// Return the current nodeID.
{
try
{
*pulNodeID = m_ulNodeID;
}
catch(...)
{
106
return (E_POINTER);
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHOD(GetParentCount)
(ULONG* pcParent)
// Description:
// Return the count of parents of the current nodeID.
{
try
{
*pcParent = m_pdmmSNaiveBayes->m_vNode[m_ulNodeID].IsNavTop() ? 0 : 1;
}
catch(...)
{
return (E_POINTER);
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHOD(MoveToParent)
(ULONG iParent)
// Description:
// iParent is ignored since a node must have only one parent (or zero if TOP)
{
try
{
ULONG ulNodeID = m_pdmmSNaiveBayes->m_vNode[m_ulNodeID].m_ulParent;
if (ulNodeID == DMM_UNSPECIFIED)
return (E_FAIL);
else
m_ulNodeID = ulNodeID;
}
catch(...)
{
return (E_FAIL);
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHOD(GetChildCount)
(ULONG* pcChild)
{
try
{
*pcChild = m_pdmmSNaiveBayes->m_vNode[m_ulNodeID].m_cChild;
}
catch(...)
{
return (E_POINTER);
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHOD(MoveToChild)
(ULONG iChild)
{
// the parent stores only the first child
NODEID ulNextID = m_pdmmSNaiveBayes->m_vNode[m_ulNodeID].m_ulChild;
LONG cChild = m_pdmmSNaiveBayes->m_vNode[m_ulNodeID].m_cChild;
107
if (iChild == 0)
{
m_ulNodeID = ulNextID;
return (S_OK);
}
// the others childs must be found searching the siblings

BOOL bWasFound = false;
for (ULONG i = 1; i < cChild; i++)
{
ulNextID = m_pdmmSNaiveBayes->m_vNode[ulNextID].m_ulSibling;
if (iChild == i)
{
bWasFound = true;
break;
}
}
if ((ulNextID == DMM_UNSPECIFIED) || !bWasFound)
return (E_FAIL);
m_ulNodeID = ulNextID;
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHOD(MoveToNextLeaf)
(ULONG iScope)
{
SNBiNodeData& nodeData = m_pdmmSNaiveBayes->m_vNode[m_ulNodeID];
if (nodeData.IsNavTop())
{
m_ulNodeID = NODEID_NAVTOP;
return (S_OK);
}
ULONG ulNextNodeID = nodeData.m_ulSibling;
if (ulNextNodeID == DMM_UNSPECIFIED)
return (S_FALSE);
m_ulNodeID = ulNextNodeID;
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHOD(GetParentNodeID)
(ULONG iParent,
ULONG* pulNodeID)
{
try
{
ULONG ulNodeID = m_pdmmSNaiveBayes->m_vNode[m_ulNodeID].m_ulParent;
if (ulNodeID == DMM_UNSPECIFIED)
return (E_FAIL);
else
*pulNodeID = ulNodeID;
}
catch (...)
{
return (E_POINTER);
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHOD(GetChildNodeID)
(ULONG iChild,
108
ULONG* pulNodeID)
{
try
{
SNBiNodeData& nodeData = m_pdmmSNaiveBayes->m_vNode[m_ulNodeID];
NODEID ulNextID = nodeData.m_ulChild;
for (ULONG i = 0; i < nodeData.m_cChild; i++)

{
if (iChild == i)
break;
SNBiNodeData& nodeData2 = m_pdmmSNaiveBayes->m_vNode[ulNextID];
ulNextID = nodeData2.m_ulSibling;
}
if (iChild > nodeData.m_cChild)
return (E_FAIL);
*pulNodeID = ulNextID;
return (S_OK);
}
catch(...)
{
return (E_POINTER);
}
return (S_OK);
}
private:
CComPtr<IAttributeSet> m_spias;
DMM_SNaiveBayes* m_pdmmSNaiveBayes;
NODEID m_ulNodeID;
};
/////////////////////////////////////////////////////////////////////////////
void DMM_SNaiveBayes::GetModelTreeName
(ULONG in_ulNodeID,
_bstr_t& out_bstrCaption)
// Description:
// Returns model tree name associated with this node.
{
if (m_vNode[in_ulNodeID].IsNavTop())
out_bstrCaption = _T("");
else
{
IATT iPredAtt = GetiPredAttNodeID (in_ulNodeID);
CComBSTR bstrName;
COMCALL(m_spias->GetAttributeDisplayName(iPredAtt, false, &bstrName));
out_bstrCaption = (BSTR)bstrName;
return;
}
}
/////////////////////////////////////////////////////////////////////////////
void DMM_SNaiveBayes::GetCaption
(ULONG in_ulNodeID,
_bstr_t& out_bstrCaption)
// Description:
// Returns caption associated with this node.
{
SNBiNodeData& nodeData = m_vNode[in_ulNodeID];
{
// BEGIN_LOCALIZATION
out_bstrCaption = _T("Model Trees");
// END_LOCALIZATION
return;
109
}
IATT iAtt = GetiAttNodeID (in_ulNodeID);
if (nodeData.IsTreeNode())
{
CComBSTR bstrName;
COMCALL(m_spias->GetAttributeDisplayName(iAtt, false, &bstrName));
return;
}
if (nodeData.IsAttNode())
{
CComBSTR bstrName;
return;
}
if (nodeData.IsValNode())
{
LONG lVal = nodeData.m_lVal;
// Initialize bstrCaption to <AttributeName>.

CComBSTR bstrName;
// Append appropriate attribute value string.

DMMATTFLAGS iAttdmmaf;
COMCALL(m_spias->GetAttributeFlags(iAtt,&iAttdmmaf));
if (lVal == 0)
{
out_bstrCaption += m_cst.m_szIs;
out_bstrCaption += m_est.szMissing;
}
else if (FIsBinary (iAttdmmaf) && (lVal == 1))
{
out_bstrCaption += m_cst.m_szBlank;
out_bstrCaption += m_cst.m_szExists;
}
else if (FIsDiscrete (iAttdmmaf) && !FIsBinary (iAttdmmaf))
{
// Convert discrete value to string.
_variant_t varValue = lVal;
COMCALL(m_spias->GetAttributeValue(iAtt, &varValue));
CComBSTR bstrVal;
COMCALL(DMVariantToString(varValue,LOCALE_USER_DEFAULT, &bstrVal));
ATLASSERT(bstrVal!=NULL);
// Caption = <AttributeName> + " = " + <DiscreteValue>.

out_bstrCaption += m_cst.m_szEQ;
out_bstrCaption += (BSTR)bstrVal;
}
else if (FIsContinuous (iAttdmmaf) && !FIsBinary (iAttdmmaf) && (lVal == 1))
{
out_bstrCaption += m_cst.m_szExists;
DOUBLE dblMean;
GetContinuousInfo (m_spidmmMarginal, iAtt, &dblMean, 0, 0, 0, 0, 0, 0);
_variant_t varMean = dblMean;
CComBSTR bstrMean;
COMCALL(DMVariantToString (varMean, LOCALE_USER_DEFAULT, &bstrMean));
110
out_bstrCaption += _T("\nmean = ");
out_bstrCaption += (BSTR)bstrMean;
}
else
{
ATLASSERT(!"Cannot be!");
out_bstrCaption += _T(" Cannot be!");
}
}
}
/////////////////////////////////////////////////////////////////////////////
void DMM_SNaiveBayes::CalcNodeSummary (
ULONG in_ulNodeID,
LONG in_cMaxCharAttrs, // in_cMaxCharAttrs specifies the maximum
number to return
priority_queue<SNBiSummaryScore>& out_pq) // out_pq receives a sorted list of
characteristic attributes.
// Description:
// Returns the attribute/value pairs which are deemed most characteristic
// of the specified node.
//
// Notes
// 1) Currently, this also returns the attribute/value pairs which exhibit
// the largest gains over marginal. Gain over marginal ranges from zero
// to positive infinity. Gains close to 1 indicate very little change
// from marginal. Gains less than 1 indicate in_iatt,in_iVal is less
// likely to occur given a particular attribute/value pair. Gains greater
// than 1 indicate that in_iatt,in_iVal is more likely to occur given a
// particular attribute/value pair. This algorithm currently only returns
// attribute/value pairs which have Gains greater than 1. It should
// probably show gains less than 1 also.
//
//
/////////////////////////////////////////////////////////////////////////////
{
// Use nbscore as a scratchpad to update out_pq.

SNBiSummaryScore nbscore;

IATT iiPredAtt = nodeData.m_iiPredAtt;
SNBiTree& Tree = m_vTree[iiPredAtt];
IATT iPredAtt = Tree.m_iPredAtt;
IATT iiInpAtt = nodeData.m_iiInpAtt;
IATT iInpAtt = Tree.m_vInputAttNumber[iiInpAtt];
if (lVal == INT_VALUE_MISSING)
lVal = 0;
ULONG ulNodeIDVal =
Tree.m_TreeNodeID.m_vAttNodeID[iiInpAtt].m_vValNodeID[lVal].m_ulNodeID;
COMCALL(m_spias->GetAttributeFlags(iInpAtt, &iAttdmmaf));
ULONG iiContAtt;
// continuous and discrete binary attributes are compute as discrete with two
states: missing and non-missing
BOOL bContAtt = FIsContinuous (iAttdmmaf) && !FIsBinary (iAttdmmaf) && (lVal == 1);
if (bContAtt)
iiContAtt = Tree.m_vContAttIndex[iInpAtt];
// Run over all possible values of ATT[jatt]. (iPredAtt)

for (LONG lClass = 0; lClass < Tree.m_cClasses; lClass++)
{
111
nbscore.m_iAtt = iInpAtt;
nbscore.m_lVal = lVal;
nbscore.m_iPredAtt = iPredAtt;
nbscore.m_lClass = lClass;
// probability of continuous attributes must be computed for two states:

// missing and
// non-missing (exists)
// so this probability for continuous is computed as discrete attribute
LONG lCountTree =
m_vNode[Tree.m_TreeNodeID.m_ulNodeID].m_vClassCount[lClass].m_lCount;
nbscore.m_dblProb = lCountTree == 0 ? (DOUBLE)0. :

(DOUBLE)m_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount / lCountTree; //
probability of the value (missing/non-missing for continuous attributes)
if (bContAtt)
{
CStateStats& ContStat = Tree.m_vClassStat[lClass].m_vContStat[iiContAtt];
nbscore.m_dblMean = ContStat.m_dblMean;
nbscore.m_dblStdDev = ContStat.m_dblStd;
}
// Okay, it looks like this description could be useful. So add it.

if (out_pq.size() < in_cMaxCharAttrs)
{
if (out_pq.size() >= in_cMaxCharAttrs)
out_pq.pop();
out_pq.push(nbscore);
}
}
}
/////////////////////////////////////////////////////////////////////////////
void DMM_SNaiveBayes::GetDescription
(ULONG in_ulNodeID,
_bstr_t& out_bstrDescription)
// Description:
// Returns description associated with this node.
//
// Notes:
// There's a lot fancier methods for constructing a description string.
// For example, I've done some work taking ratios of P(X=x|Y=y)/P(X!=x|Y=y).
{
{
out_bstrDescription = _T("Root of predictive attribute model trees");
// END_LOCALIZATION
return;
}
{
CComBSTR bstr;
COMCALL(m_spias->GetAttributeDisplayName(iAtt, false, &bstr));
out_bstrDescription = _T("Root of ");
out_bstrDescription += (BSTR)bstr;
out_bstrDescription += _T(" predictive attribute model tree");
// END_LOCALIZATION
return;
}
112
{
CComBSTR bstr;
COMCALL(m_spias->GetAttributeDisplayName(iAtt, false, &bstr));
out_bstrDescription = (BSTR)bstr;
out_bstrDescription += _T(" input attribute tree");
return;
}
{
// Calc node summary and then reverse list to put most important
// attributes first.
priority_queue<SNBiSummaryScore> qq;
CalcNodeSummary (in_ulNodeID, SNBi_MAX_CHAR_ATTRS, qq);
/*
stack<SNBiSummaryScore> qq;
while (!pq.empty())
{
qq.push(pq.top());
pq.pop();
}
*/
// Create the description string from the cluster summary.
bool bNotFirst = false;
while (!qq.empty())
{
IATT iAtt = qq.top().m_iAtt;
LONG lVal = qq.top().m_lVal;
IATT iPredAtt = qq.top().m_iPredAtt;
LONG lClass = qq.top().m_lClass;
DMMATTFLAGS iPredAttdmmaf;
COMCALL(m_spias->GetAttributeFlags(iPredAtt, &iPredAttdmmaf));
if (bNotFirst)
out_bstrDescription += _T(";\n");
else
bNotFirst = true;
_bstr_t bstrPredDescription; // predictive attribute description
// Get predictive attribute name

CComBSTR bstrName;
COMCALL(m_spias->GetAttributeDisplayName(iPredAtt, false, &bstrName));
ATLASSERT(bstrName!=NULL);
bstrPredDescription = (BSTR)bstrName;
if (lClass == 0)
{
bstrPredDescription += m_cst.m_szIs;
bstrPredDescription += m_est.szMissing;
}
else if (FIsBinary (iPredAttdmmaf) && (lClass == 1))
{
bstrPredDescription += m_cst.m_szExists;
}
else if (FIsDiscrete (iPredAttdmmaf) && !FIsBinary (iPredAttdmmaf))
{
_variant_t varValue = lClass;
COMCALL(m_spias->GetAttributeValue(iPredAtt, &varValue));
CComBSTR bstrVal;
bstrPredDescription += m_cst.m_szBlank;
bstrPredDescription += m_cst.m_szEQ;
bstrPredDescription += (BSTR)bstrVal;
}
113
else
{
ATLASSERT(!"Cannot be! ");
bstrPredDescription += _T("Cannot be!");
}
COMCALL(m_spias->GetAttributeFlags(iAtt, &iAttdmmaf));
if (FIsContinuous (iAttdmmaf) && !FIsBinary (iAttdmmaf) && (lVal == 1))

{
out_bstrDescription += _T("Mean = ");
_variant_t varTemp = qq.top().m_dblMean;
CComBSTR bstrTemp;
COMCALL(DMVariantToString (varTemp,LOCALE_USER_DEFAULT, &bstrTemp));
ATLASSERT (bstrTemp != NULL);
out_bstrDescription += (BSTR)bstrTemp;
out_bstrDescription += _T(";\nDeviation =");

varTemp = qq.top().m_dblStdDev;
COMCALL(DMVariantToString (varTemp,LOCALE_USER_DEFAULT, &bstrTemp));
ATLASSERT (bstrTemp != NULL);
out_bstrDescription += (BSTR)bstrTemp;
out_bstrDescription += _T(";\nP(");
}
// Get input attribute name

ATLASSERT(bstrName!=NULL);
out_bstrDescription += (BSTR)bstrName;
if (lVal == 0)
{
out_bstrDescription += m_cst.m_szIs;
out_bstrDescription += m_est.szMissing;
}
else if ((FIsBinary (iAttdmmaf) || FIsContinuous (iAttdmmaf)) && (lVal == 1))
{
out_bstrDescription += m_cst.m_szExists;
}
else if (FIsDiscrete (iAttdmmaf))
{
CComBSTR bstrVal;
out_bstrDescription += m_cst.m_szBlank;
out_bstrDescription += m_cst.m_szEQ;
out_bstrDescription += (BSTR)bstrVal;
}
else
{
out_bstrDescription += _T("Cannot be!");
}
out_bstrDescription += _T(" | ");

out_bstrDescription += bstrPredDescription;
out_bstrDescription += _T(")=");
_variant_t varProb = qq.top().m_dblProb;

CComBSTR bstrProb;
COMCALL(DMVariantToString (varProb, LOCALE_USER_DEFAULT, &bstrProb));
ATLASSERT (bstrProb != NULL);
out_bstrDescription += (BSTR)bstrProb;
// Pop this element off the stack.

qq.pop();
}
114
}
// END_LOCALIZATION
}
/////////////////////////////////////////////////////////////////////////////
void DMM_SNaiveBayes::GetMarginalRule
(ULONG in_ulNodeID,
_bstr_t& out_bstrRule)
// Description:
// Returns XML "rule" for this node w.r.t. root node.
{
// MUSTFIX: Not yet implemented.
ATLASSERT(!"!!!NYI!!!");
#if 0
COMCALL(pHandler->BeginNode(DMPI_PREDICATE));
COMCALL(pHandler->AttributeString(DMPI_OP, strOp));
COMCALL(pAttXMLStr->SaveValueString(iattSplit, (LONG) First, pHandler));
COMCALL(pAttXMLStr->SaveXMLString(iattSplit, pHandler, bRaw));
COMCALL(pHandler->EndNode());
#endif
}
/////////////////////////////////////////////////////////////////////////////
void DMM_SNaiveBayes::GetRule
(ULONG in_ulNodeID,
_bstr_t& out_bstrRule)
// Description:
// Returns XML "rule" for this node w.r.t. parent.
{
// MUSTFIX: Not yet implemented.
ATLASSERT(!"!!!NYI!!!");
}
/////////////////////////////////////////////////////////////////////////////
DOUBLE DMM_SNaiveBayes::GetProbability
(ULONG in_ulNodeID)
// Description:
// Returns probability associated with this node.
{
return (GetSupport (in_ulNodeID) / m_cCase);
}
/////////////////////////////////////////////////////////////////////////////
DOUBLE DMM_SNaiveBayes::GetMarginalProbability
(ULONG in_ulNodeID)
// Description:
// Returns probability associated with this node.
{
return (GetSupport (in_ulNodeID) / m_cCase);
}
/////////////////////////////////////////////////////////////////////////////
DOUBLE DMM_SNaiveBayes::GetSupport
(ULONG in_ulNodeID)
// Description:
// Returns count associated with this node.
{
return ((DOUBLE)m_vNode[in_ulNodeID].m_lCountSum);
}
/////////////////////////////////////////////////////////////////////////////
115
BOOL DMM_SNaiveBayes::ResizeIndexVectors
(IATT & out_cPredAtt,
vector<SNBiTree> & out_vTree,
vector<ULONG> & out_vPredAttNumber) // vector of attributes numbers of predictive
attributes
// returns
// out_vTree
// IATT m_iAtt; // attribute number of predictive attribute
// IATT m_cInpAtt; // count of input attributes
// IATT m_cContAtt; // count of continuous attributes
// vector<ULONG> m_vAttIndex; // vector of indexes of attributes
// vector<ULONG> m_vContAttIndex; // vector of indexes of continuous attributes
// vector<ULONG> m_vAttNumber; // vector of attributes numbers of input
attributes
// vector<ULONG> out_vPredAttNumber // vector of attributes numbers of predictive
attributes
{
IATT cAtt; // count of all attributes
COMCALL(m_spias->GetAttributeCount(&cAtt));
// Run through all the attributes

// make sure everything looks ok,
// Count predictive attributes.
out_cPredAtt = 0; // count of predictive attributes
out_vTree.resize (cAtt); // size to maximum
out_vPredAttNumber.resize (cAtt);
for (IATT iAtt = 0; iAtt < cAtt; iAtt++)

{
// if this is not a CASE att or if it's weird, then skip it.

if (!FIsCase (iAttdmmaf) || !FIsOutput (iAttdmmaf))
out_vPredAttNumber [iAtt] = DMM_UNSPECIFIED;
else
{
CHECKRESULT (!(FIsContinuous (iAttdmmaf) && !FIsBinary (iAttdmmaf)),
DMME_ALG_CANT_PREDICT_CONTINUOUS_ATTRIBUTE);
out_vTree[out_cPredAtt].m_iPredAtt = iAtt;
out_vPredAttNumber [iAtt] = out_cPredAtt;
out_cPredAtt++;
}
}
// Make sure there is at least one predictive attribute.

ATLASSERT (out_cPredAtt > 0);
out_vTree.resize (out_cPredAtt); // resize to necessary extent
// Run through the indexes of predictive attributes and

// count input attributes for each predictive attribute
// resize and assemble vectors of input attributes numbers
// resize and assemble vectors of indexes
for (IATT iiPredAtt = 0; iiPredAtt < out_cPredAtt; iiPredAtt++)
{
out_vTree[iiPredAtt].m_vAttIndex.resize (cAtt); // size to necessary extent
out_vTree[iiPredAtt].m_vContAttIndex.resize (cAtt); // size to necessary extent
out_vTree[iiPredAtt].m_vInputAttNumber.resize (cAtt); // size to maximum
SNBiTree& Tree = out_vTree[iiPredAtt];

IATT cInpAtt = 0; // count of input attributes
IATT cContAtt = 0; // count of continuous attributes
// Run through all the attributes ,

116
{
// if this is not a CASE att or if it's weird, then skip it.

if (!FIsCase (iAttdmmaf) || !FIsInput (iAttdmmaf))
continue;
// verify if it is the current predictive attribute

if (iAtt == Tree.m_iPredAtt)
continue;
Tree.m_vAttIndex[iAtt] = cInpAtt;
Tree.m_vInputAttNumber[cInpAtt] = iAtt;
cInpAtt++;
// binary continuous and discrete attributes are compute as discrete with two
if (FIsContinuous (iAttdmmaf) && !FIsBinary (iAttdmmaf))
{
Tree.m_vContAttIndex[iAtt] = cContAtt;
cContAtt++;
}
}
out_vTree[iiPredAtt].m_cInpAtt = cInpAtt;
out_vTree[iiPredAtt].m_cContAtt = cContAtt;
out_vTree[iiPredAtt].m_vInputAttNumber.resize (cInpAtt); // size to necessary
extent
}
return (true);
}
/////////////////////////////////////////////////////////////////////////////
BOOL DMM_SNaiveBayes::AssembleNodeIDs
(IATT cPredAtt,
vector<SNBiNodeData> & out_vNode)
// returns
// out_vTree
// LONG m_cClasses; // count of classes of predictive
attribute
// SNBiTreeNodeID m_TreeNodeID; // node ids
// m_TreeNodeID.m_vAttNodeID[]; // vector of input attributes nodes
// only resize
// vector<SNBiClassStat> m_vClassStat; // vector of statistic of continuous
attributes of classes
// out_vNode
// NODETYPE m_iNodeType; // type of node
// ULONG m_cChild; // count of child nodes
// NODEID m_ulParent; // nodeid of parent node
// NODEID m_ulSibling; // nodeid of the next sibling node
// NODEID m_ulChild; // nodeid of the first child node
// IATT m_iiPredAtt; // index of predictive attribute
// IATT m_iiInpAtt; // index of input attribute
// LONG m_lVal; // value of input attribute
// only resize
// vector<SNBiCount> m_vClassCount; // vector of counts of classes (values of
predictive attribute)
{
// assemble vector of nodeIDs and its references
// resizing vectors
ULONG ulNodeID = NODEID_NAVTOP;
ULONG ulNodeIDTop = ulNodeID;
SNBiNodeData nodeDataTop;
nodeDataTop.m_iNodeType = NODE_TYPE_MODEL;
nodeDataTop.m_cChild = cPredAtt;
// m_ulParent = DMM_UNSPECIFIED;
// m_ulSibling = DMM_UNSPECIFIED;
// m_ulChild = DMM_UNSPECIFIED;
// m_iiPredAtt = DMM_UNSPECIFIED;
117
// m_iiInpAtt = DMM_UNSPECIFIED;
// m_lVal = INT_VALUE_MISSING;
out_vNode.push_back (nodeDataTop);
ULONG ulNodeIDTree = DMM_UNSPECIFIED;
// Run through the indexes of predictive attributes

// resize all vectors of each predictive attribute
// vNode[]; // vector of nodeData
// is resized automatically by the vector push_back operations
for (IATT iiPredAtt = 0; iiPredAtt < cPredAtt; iiPredAtt++)
{
IATT cInpAtt = out_vTree[iiPredAtt].m_cInpAtt;
// get predictive attribute values count (number of classes)

// missing value is included
ULONG cClasses; // count of classes of predictive attribute
COMCALL(m_spias->GetAttributeFlags (out_vTree[iiPredAtt].m_iPredAtt,
&iPredAttdmmaf));
if (FIsBinary (iPredAttdmmaf)) // predictive attribute must not be continuous

cClasses = 2;
else
{
// get attribute values count, missing is included
COMCALL(m_spias->GetAttributeStateCount(out_vTree[iiPredAtt].m_iPredAtt,
&cClasses));
// but if only exists missing values, then count = zero
if (cClasses == 0)
{
CComBSTR bstrName;
COMCALL(m_spias->GetAttributeDisplayName(out_vTree[iiPredAtt].m_iPredAtt,
false, &bstrName));
DMSetLastErrorEx (SPE_DMM_ATT_WITH_ONLY_NULL_VALUES, 1, bstrName);

_com_issue_error(SPE_DMM_ATT_WITH_ONLY_NULL_VALUES); // abort function
return (false);
}
}
out_vTree[iiPredAtt].m_cClasses = cClasses;
out_vTree[iiPredAtt].m_vClassStat.resize (cClasses);
for (ULONG lClass = 0; lClass < out_vTree[iiPredAtt].m_cClasses; lClass++)
out_vTree[iiPredAtt].m_vClassStat[lClass].m_vContStat.resize
(out_vTree[iiPredAtt].m_cContAtt);
ulNodeID++;
// assign sibling node id for previous node
// the last node will not have a sibling
if (ulNodeIDTree != DMM_UNSPECIFIED)
out_vNode[ulNodeIDTree].m_ulSibling = ulNodeID;
// assign current node id
ulNodeIDTree = ulNodeID;
out_vTree[iiPredAtt].m_TreeNodeID.m_ulNodeID = ulNodeIDTree;
// assign child node id for parent node
if (out_vNode[ulNodeIDTop].m_ulChild == DMM_UNSPECIFIED)
out_vNode[ulNodeIDTop].m_ulChild = ulNodeIDTree;
// resize vector of att node ids
out_vTree[iiPredAtt].m_TreeNodeID.m_vAttNodeID.resize (cInpAtt);
SNBiNodeData nodeDataTree;
// if the DMMNODEPROP_TYPE_TREE is used the Data Mining Model Browser shows the
tree,
// but does not fill out the prediction tree list and does not show the
// Content Navigator, Attributes and Node Path panes.
// Besides, when the root node is selected, the MS Management Console (mmc.exe)
// is aborted showing the error message: Runtime Error!
118
// if the DMMNODEPROP_TYPE_INTERIOR is used this problem is avoided.
// So NODE_TYPE_TREE is converted to DMMNODEPROP_TYPE_INTERIOR when Nodetype is
requested
nodeDataTree.m_iNodeType = NODE_TYPE_TREE;
nodeDataTree.m_cChild = out_vTree[iiPredAtt].m_cInpAtt;
nodeDataTree.m_ulParent = NODEID_NAVTOP;
nodeDataTree.m_iiPredAtt = iiPredAtt;
// m_iiInpAtt = DMM_UNSPECIFIED;
// m_lVal = INT_VALUE_MISSING;
out_vNode.push_back (nodeDataTree);
out_vNode[ulNodeIDTree].m_vClassCount.resize (cClasses);
ULONG ulNodeIDAtt = DMM_UNSPECIFIED;
for (ULONG iiInpAtt = 0; iiInpAtt < out_vTree[iiPredAtt].m_cInpAtt; iiInpAtt++)

{
ulNodeID++;
if (ulNodeIDAtt != DMM_UNSPECIFIED)
out_vNode[ulNodeIDAtt].m_ulSibling = ulNodeID;
ulNodeIDAtt = ulNodeID;
out_vTree[iiPredAtt].m_TreeNodeID.m_vAttNodeID[iiInpAtt].m_ulNodeID =
ulNodeIDAtt;
if (out_vNode[ulNodeIDTree].m_ulChild == DMM_UNSPECIFIED)
out_vNode[ulNodeIDTree].m_ulChild = ulNodeIDAtt;
// count of attribute values

IATT iInpAtt = out_vTree[iiPredAtt].m_vInputAttNumber[iiInpAtt];
DMMATTFLAGS iInpAttdmmaf;
COMCALL(m_spias->GetAttributeFlags(iInpAtt, &iInpAttdmmaf));
ULONG cValues;
// binary continuous and discrete attributes are compute as discrete with two
if (FIsContinuous (iInpAttdmmaf) || FIsBinary (iInpAttdmmaf))
cValues = 2; // one for missing values
else
{
COMCALL(m_spias->GetAttributeStateCount(iInpAtt, &cValues));
if (cValues == 0)
{
CComBSTR bstrName;
COMCALL(m_spias->GetAttributeDisplayName(iInpAtt, false, &bstrName));

return (false);
}
}
out_vTree[iiPredAtt].m_TreeNodeID.m_vAttNodeID[iiInpAtt].m_vValNodeID.resize
(cValues);
SNBiNodeData nodeDataAtt;
nodeDataAtt.m_iNodeType = NODE_TYPE_INTERIOR;
nodeDataAtt.m_cChild = cValues;
nodeDataAtt.m_ulParent = ulNodeIDTree;
nodeDataAtt.m_iiPredAtt = iiPredAtt;
nodeDataAtt.m_iiInpAtt = iiInpAtt;
out_vNode.push_back (nodeDataAtt);
out_vNode[ulNodeIDAtt].m_vClassCount.resize (cClasses);
119
ULONG ulNodeIDVal = DMM_UNSPECIFIED;
for (ULONG lVal = 0; lVal < cValues; lVal++)

{
ulNodeID++;
if (ulNodeIDVal != DMM_UNSPECIFIED)
out_vNode[ulNodeIDVal].m_ulSibling = ulNodeID;
ulNodeIDVal = ulNodeID;
out_vTree[iiPredAtt].m_TreeNodeID.m_vAttNodeID[iiInpAtt].m_vValNodeID[lVal].m_ulNodeID
= ulNodeIDVal;
if (out_vNode[ulNodeIDAtt].m_ulChild == DMM_UNSPECIFIED)
out_vNode[ulNodeIDAtt].m_ulChild = ulNodeIDVal;
SNBiNodeData nodeDataVal;
nodeDataVal.m_iNodeType = NODE_TYPE_DISTRIBUTION;
nodeDataVal.m_cChild = 0;
nodeDataVal.m_ulParent = ulNodeIDAtt;
nodeDataVal.m_iiPredAtt = iiPredAtt;
nodeDataVal.m_iiInpAtt = iiInpAtt;
nodeDataVal.m_lVal = lVal;
out_vNode.push_back (nodeDataVal);
out_vNode[ulNodeIDVal].m_vClassCount.resize (cClasses);
}
}
}
return (true);
}
/////////////////////////////////////////////////////////////////////////////
BOOL DMM_SNaiveBayes::CountAttributeStatistics
(IATT cPredAtt,
LONG & out_cCase,
// compute
// LONG cCase; // count of all cases
// vTree
// vector<SNBiClassStat> m_vClassStat; // vector of statistic of continuous
// vNode
{
// Create a data source iterator.

SPM_CaseSetCaseCache<SPM_Case> cscc(m_spias, m_spicsInsertSource, true);
SPM_CaseCacheItr<SPM_Case>* pccitr = cscc.GetIterator();
// Run over the data set computing counts and sums.

out_cCase = 0;
for (pccitr->ResetCache(); !pccitr->fCacheEnd(); pccitr->NextCase())
{
// Increment case count.
out_cCase++;
DM_DEBUG( DM_DMSPROV_LEVEL_ALL, DMSPROV,
TEXT ("\n==> CountAttributeStatistics, cCase: %i\n"), out_cCase);

{
// Tree of predictive attribute
120
COMCALL (m_spias->GetAttributeFlags (iPredAtt, &iPredAttdmmaf));
// Store class value of predictive attribute.

LONG lClass = INT_VALUE_MISSING;
for (pccitr->ResetCase(); !pccitr->fCaseEnd(); pccitr->NextAttr())
{
if (pccitr->Att() == iPredAtt)
{
lClass = pccitr->LongVal();
break;
}
}
// attributes with missing values are not included in case attribute data
if (lClass == INT_VALUE_MISSING)
// this case has missing class
lClass = 0; // value of missing class
else
{
// lClass may be zero and
// since attributes with missing values are not included in case attribute
data
// zero values for lVal may occur in incremental inserts with states not
defined previously in data dictionary
// this kind of error will be verified later in the loop over all attribute
values
if (FIsBinary (iPredAttdmmaf)) lClass = 1; // missing attributes are not

included in case attribute data
// verify if class is valid
ATLASSERT ((lClass >= 0) && (lClass < Tree.m_cClasses)); // continuous
attributes values can be negative, but only discrete attributes can be predicted
}
// Compute counts and sums of each class value.
// Count the ocurrences of each class for all cases

// all missing values are computed since a case have at least one non-missing
attribute
// used to compute prior probabilities
// prior probability[] = m_vClassCount[].m_lCount / m_cCase // since missing
values are considered)
out_vNode[Tree.m_TreeNodeID.m_ulNodeID].m_vClassCount[lClass].m_lCount++;
for (pccitr->ResetCase(); !pccitr->fCaseEnd(); pccitr->NextAttr())

{
// cache case attribute data
IATT iAtt = pccitr->Att();
LONG lVal = pccitr->LongVal(); // continuous attributes values can be
negative or zero
DOUBLE dblVal = pccitr->FloatVal();
// compute only the input attributes

if (iAtt != iPredAtt)
{
if (FIsContinuous (iAttdmmaf) || FIsBinary (iAttdmmaf)) lVal = 1;
if (lVal == 0) // missing attributes are not included in case attribute data

{
// since attributes with missing values are not included in case
attribute data
// zero values for lVal occurs in
// incremental inserts with states not defined previously in data
dictionary
121
// Get attribute display name.
CComBSTR bstrName;
CComBSTR bstrcCase(256);
_stprintf (bstrcCase, TEXT("%ld"), out_cCase);
DMSetLastErrorEx (SPE_DMM_INVALID_STATE, 2, bstrName, bstrcCase);

_com_issue_error(SPE_DMM_INVALID_STATE); // abort function
}
IATT iiAtt = Tree.m_vAttIndex[iAtt];
// ULONG ulNodeIDAtt = Tree.m_TreeNodeID.m_vAttNodeID[iiAtt].m_ulNodeID ;

// count each attribute of each class
// Missing attributes are not computed since attributes with missing
values
// are not included in a case attribute data.
// So they must be evaluated later by computing
// the sum of counts of all values of the attribute
// They can not be computed by exclusion since missing attributes
// can have any class value
// LONG& lCountAtt = vNode[ulNodeIDAtt].m_vClassCount[lClass].m_lCount;
// lCountAtt++;
ULONG ulNodeIDVal;
if (FIsContinuous (iAttdmmaf) && !FIsBinary (iAttdmmaf))

{
// 0 > missing counts
// 1 > non-missing statistics
ulNodeIDVal =
Tree.m_TreeNodeID.m_vAttNodeID[iiAtt].m_vValNodeID[1].m_ulNodeID;
ULONG iiContAtt = Tree.m_vContAttIndex[iAtt];
ContStat.m_dblSum += dblVal;
ContStat.m_dblSqrSum += dblVal * dblVal;
ContStat.m_lCount++;
}
else
{
ulNodeIDVal =
Tree.m_TreeNodeID.m_vAttNodeID[iiAtt].m_vValNodeID[lVal].m_ulNodeID;
}
// Count each attribute of each class
// missing values are not computed since attributes with missing values
// are not included in a case attribute data
// so they must be computed later by exclusion
// continuous attributtes are counted twice
out_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount++;
}
}
}
}
return (true);
}
/////////////////////////////////////////////////////////////////////////////
BOOL DMM_SNaiveBayes::ComputeMissingCounts
(IATT cPredAtt,
// Compute missing counts
// vNode
{
122
{
ULONG ulNodeIDTree = Tree.m_TreeNodeID.m_ulNodeID;
// Compute mean and standard deviation

for (IATT iiContAtt = 0; iiContAtt < Tree.m_cContAtt; iiContAtt++)
{
// run through all classes
{
ContStat.m_dblMean = ContStat.Mean ();

ContStat.m_dblStd = ContStat.Deviation ();
}
}
// Compute missing counts

for (IATT iiInpAtt = 0; iiInpAtt < Tree.m_cInpAtt; iiInpAtt++)
{
// attribute node
ULONG ulNodeIDAtt = Tree.m_TreeNodeID.m_vAttNodeID[iiInpAtt].m_ulNodeID;
// number of value nodes

LONG cAttVal = out_vNode[ulNodeIDAtt].m_cChild;
// missing value node

ULONG ulNodeIDValMissing =
Tree.m_TreeNodeID.m_vAttNodeID[iiInpAtt].m_vValNodeID[0].m_ulNodeID;

{
// compute all counts of missing value node
// sum of counts for each class of all cases
// value missing count

LONG& cValMissingCount =
out_vNode[ulNodeIDValMissing].m_vClassCount[lClass].m_lCount;
cValMissingCount = out_vNode[ulNodeIDTree].m_vClassCount[lClass].m_lCount; //
to compute prior probabilities
// run through other values of the attribute (continuous attributes have 2

values)
for (LONG lVal = 1; lVal < cAttVal; lVal++)
{
// value node
ULONG ulNodeIDVal =
cValMissingCount -= out_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount;
}
// end of compute all counts of missing value node
// compute counts of the attribute node

// attribute count
LONG& cAttCount = out_vNode[ulNodeIDAtt].m_vClassCount[lClass].m_lCount;
cAttCount = 0;
for (lVal = 0; lVal < cAttVal; lVal++)
{
// value node
ULONG ulNodeIDVal =
cAttCount += out_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount;
}
// end of counts of the attribute node
}
123
} // end of Compute missing counts
} // for (IATT iiPredAtt
return (true);
}
/////////////////////////////////////////////////////////////////////////////
BOOL DMM_SNaiveBayes::ComputeAttNodeCounts
(IATT cPredAtt,
// compute counts of the attribute node
// vNode
{
{
// Compute counts of the attribute node

{
// attribute node


{
// attribute count
LONG& cAttCount = out_vNode[ulNodeIDAtt].m_vClassCount[lClass].m_lCount;
cAttCount = 0;
{
// value node
ULONG ulNodeIDVal =
cAttCount += out_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount;
}
}
} // end of Compute counts of the attribute node
return (true);
}
/////////////////////////////////////////////////////////////////////////////
BOOL DMM_SNaiveBayes::ComputeSumCounts
(IATT cPredAtt,
LONG cCase,
// Compute sums of counts.
// vNode
// LONG m_lCountSum; // sum of elements of vector of counts (value
of DMMNODEPROP_SUPPORT property)
{
out_vNode[NODEID_NAVTOP].m_lCountSum = cCase;

{
ULONG ulNodeIDTree = Tree.m_TreeNodeID.m_ulNodeID;
124
// Compute sum of counts
LONG& lCountSumTree = out_vNode[ulNodeIDTree].m_lCountSum;
lCountSumTree = 0;
lCountSumTree +=
out_vNode[ulNodeIDTree].m_vClassCount[lClass].m_lCount;

{
LONG& lCountSumAtt = out_vNode[ulNodeIDAtt].m_lCountSum;
lCountSumAtt = 0;
lCountSumAtt +=
out_vNode[ulNodeIDAtt].m_vClassCount[lClass].m_lCount;

{
ULONG ulNodeIDVal =
LONG& lCountSumVal = out_vNode[ulNodeIDVal].m_lCountSum;
lCountSumVal = 0;
lCountSumVal += out_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount;
}
} // end of compute sum of counts
return (true);
}
/////////////////////////////////////////////////////////////////////////////
BOOL DMM_SNaiveBayes::DoInsertCases
(BOOL bIncremental)
// Description:
//
// Trains the model with the specified case set updating previous training data.
//
// claudio luiz curotto - apr/2002
//
/////////////////////////////////////////////////////////////////////////////
{
#ifdef DEBUG
FILE* pf;
pf = _wfopen(strFileNameTmp, TEXT("awt"));
DM_DEBUG( DM_DMSPROV_LEVEL_ALL, DMSPROV,
TEXT ("\n==> Debug file %s opened in DMM_SNaiveBayes::DoInsertCases.\n"),
strFileNameTmp);
fprintf(pf,"\n\nDMM_SNaiveBayes::DoInsertCases\n\n");
IATT cAtt; // count of all attributes

fprintf(pf,"%ld existing cases, %ld attributes\n\n", m_cCase, cAtt);

fprintf(pf,"Att number\tAtt name (Number of states)\n");
fprintf(pf,"\tState number\tState name\n");
// Run through all the attributes

{
// Get number of states associated with this attribute.
125
ULONG cStates;
COMCALL (m_spias->GetAttributeStateCount (iAtt, &cStates));
if (cStates == 0)
{
CComBSTR bstrName;

return (false);
}
COMCALL(m_spias->GetAttributeFlags (iAtt, &iAttdmmaf));
// Get attribute display name.

CComBSTR bstrName;
fprintf(pf,"%ld\t\t%ls (%ld)\n", iAtt, bstrName, cStates);
// Run through all states of the attribute

for (LONG lVal = 0; lVal < cStates; lVal++)
{
BSTR bstrName = NULL;
if (lVal == 0)
{
bstrName = m_est.szMissing;
}
else if ((FIsContinuous ((iAttdmmaf)) || FIsBinary (iAttdmmaf)) && (lVal == 1))
{
bstrName = m_cst.m_szExists;
}
else if (FIsDiscrete (iAttdmmaf) && !FIsBinary (iAttdmmaf))
{
// Convert discrete value to string.
COMCALL(DMVariantToString(varValue,LOCALE_USER_DEFAULT, &bstrName));
}
else
{
bstrName = _T("Cannot be!");
}
fprintf(pf,"\t%ld\t\t%ls\n", lVal, bstrName);
}
} // end of for (IATT iAtt = 0; iAtt < cAtt; iAtt++)
#endif
// Cache all data locally

LONG cCase; // count of all cases
IATT cPredAtt; // count of predictive attributes
vector<SNBiNodeData> vNode; // vector of NodeIDs
vector<SNBiTree> vTree; // vector of trees of predictive attributes
vector<ULONG> vPredAttNumber; // vector of attributes numbers of predictive
attributes
// vectors to be sized
// vTree[]; // vector of trees of predictive
attributes
// vTree[].m_TreeNodeID.m_vAttNodeID[]; // vector of input attributes
nodes
// vTree[].m_TreeNodeID.m_vAttNodeID[].m_vValNodeID[]; // vector of attributes
values nodes
// vTree[].m_vAttIndex[]; // vector of indexes of
attributes
// vTree[].m_vContAttIndex[]; // vector of indexes of
continuous attributes
// vTree[].m_vAttNumber[]; // vector of attributes numbers
of input attributes
126
// vTree[].m_vClassStat[]; // vector of statistic of
continuous attributes of classes
// vTree[].m_vClassStat[].m_vContStat[]; // vector of statistic of
continuous attributes
// vNode[]; // vector of nodeData

// vNode[].m_vClassCount[]; // vector of counts of classes
if (m_cCase == 0)
{
// to do only in the first insert when the model was created
ResizeIndexVectors (cPredAtt, vTree, vPredAttNumber);
if (!AssembleNodeIDs (cPredAtt, vTree, vNode))
return (false);
}
else
{
cPredAtt = m_cPredAtt; // count of predictive attributes
vNode.swap (m_vNode); // vector of nodeData
vTree.swap (m_vTree); // vector of Trees of predictive attributes
}
if (!CountAttributeStatistics (cPredAtt, cCase, vTree, vNode))

return (false);
ComputeMissingCounts (cPredAtt, vTree, vNode); // and compute counts of the

attribute node and compute mean and standard deviation
ComputeSumCounts (cPredAtt, m_cCase + cCase, vTree, vNode);
// Okay, everything has succeeded. So transfer ownership of all data

// from this method to the DMM_SNaiveBayes object.
m_cCase += cCase; // count of all cases
m_cPredAtt = cPredAtt; // count of predictive attributes
m_vNode.swap (vNode); // vector of nodeData
m_vTree.swap (vTree); // vector of Trees of predictive attributes
m_vPredAttNumber.swap (vPredAttNumber); // vector of attributes numbers of
predictive attributes
#ifdef DEBUG
fprintf(pf,"%ld inserted cases, %ld total cases\n\n", cCase, m_cCase);
fclose(pf);
#endif
// Done!
return (true);
}
/////////////////////////////////////////////////////////////////////////////
void DMM_SNaiveBayes::DoPredict
(ULONG in_cAttVal, // count of attribute values
DMATTVALUE in_rgAttVal[], // vector of attribute values
BOOL in_fContinuousHistograms,
SPM_Predictions& in_preds) // object describing predictions to
make and
// giving a place to store the
predictions.
// Description:
// report learned distributions
//
// Return Values:
//
// Side Effects:
//
// Notes:
//
///////////////////////////////////////////////////////////////////////////////
{
// Make sure we're not learning and that we have a model.
// CHECKRESULT(m_vTree.size()!=0,DMME_MODEL_NOT_TRAINED);
127
// Initialize a Singleton cache for accessing case values.
SPM_SingletonCaseCache<SPM_Case> scc(m_spias,in_cAttVal,in_rgAttVal);
SPM_SingletonCaseCacheItr<SPM_Case> sccitr;
sccitr.Init(&scc);
// Predict all of the requested attributes.

DMMDISTRIBUTION* pdistCurrent = in_preds.m_rgDist;
for (ULONG iPred = 0; iPred < in_preds.m_cDist; iPred++, pdistCurrent++)
{
// Which attribute are we predicting?
IATT iPredAtt = pdistCurrent->lAttribute;
IATT iiPredAtt = m_vPredAttNumber[iPredAtt];

NODEID ulNodeIDTree = Tree.m_TreeNodeID.m_ulNodeID;
// GetAttributeFlags.
// Make sure we can predict this attribute.

// CHECKRESULT (FIsCase (iPredAttdmmaf) && FIsOutput (iPredAttdmmaf),
DMME_ALG_CANT_PREDICT_INPUT_ONLY_ATTRIBUTE);
// CHECKRESULT (!(FIsContinuous (iPredAttdmmaf) && !FIsBinary (iPredAttdmmaf)),
DMME_ALG_CANT_PREDICT_CONTINUOUS_ATTRIBUTE);
// Make sure we have exactly what we expected.

ATLASSERT(FIsCase (iPredAttdmmaf) && FIsOutput (iPredAttdmmaf) && (FIsDiscrete
(iPredAttdmmaf) || FIsBinary (iPredAttdmmaf)));
// Get number of states associated with this attribute.

ULONG cClasses = Tree.m_cClasses; // count of classes of predictive attribute
// Create a vector to hold probabilities.

valarray<DOUBLE> vdblProb;
vdblProb.resize (cClasses,0.0);
// run throught all classes of the predictive attribute

for (LONG lClass = 0; lClass < cClasses; lClass++)
{
// Prior probability of each class P (Att [iPredAtt] == lClass)
// prior probability[] = m_vClassCount[].m_lCount / m_cCase // since missing
values are considered
LONG lCountTree = m_vNode[ulNodeIDTree].m_vClassCount[lClass].m_lCount;

DOUBLE dblProb = (DOUBLE)lCountTree / (DOUBLE)m_cCase;
if (lCountTree == 0) lCountTree = 1; // since dblProb = 0 the result will not
be different
// Calc PROD P (Att[iAtt] == lVal | Att[iPredAtt] == lClass) * P (Att [iPredAtt]

== lClass)
for (sccitr.ResetCase(); dblProb!=0.0 && !sccitr.fCaseEnd();
sccitr.NextAttr())
{
IATT iAtt = sccitr.Att();
LONG lVal = sccitr.LongVal(); // continuous attributes values can be negative
or zero
DOUBLE dblVal = sccitr.FloatVal();
COMCALL(m_spias->GetAttributeFlags (iAtt, &iAttdmmaf));
// If iAtt is iPredAtt or If iAtt is not INPUT, then skip it

if ((iAtt == iPredAtt) || !FIsInput (iAttdmmaf))
continue;
if (FIsContinuous (iAttdmmaf) || FIsBinary (iAttdmmaf)) lVal = 1; // missing

values are not included in case cache
// Calc P (Att[iAtt] == lVal | Att[iPredAtt] == lClass).
128
IATT iiInpAtt = Tree.m_vAttIndex[iAtt];
ULONG ulNodeIDVal =
dblProb *= (DOUBLE)m_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount /
lCountTree; // probability of the value (missing/non-missing for continuous
attributes)
// lVal is already verified and is 0 or 1 for binary or continuous attributes

if (FIsContinuous (iAttdmmaf) && !FIsBinary (iAttdmmaf)) // && (lVal == 1)
always true since missing values are not include in case cache
{
ULONG iiContAtt = Tree.m_vContAttIndex[iAtt];
if (ContStat.m_lCount > 0)
{
DOUBLE dblDiff = (dblVal - ContStat.m_dblMean);
if (ContStat.m_dblStd > STDDEV_ZERO)
{
DOUBLE dblExp = dblDiff / ContStat.m_dblStd;
dblExp *= -dblExp / 2.;
DOUBLE dblDiv = NORM_CONST * ContStat.m_dblStd;
dblProb *= exp (dblExp) / dblDiv;
}
else
if (fabs (dblDiff) > DIFF_ZERO) dblProb = (DOUBLE)0.; // if standard
deviation is zero it can be assumed that all values are equal?
}
else
dblProb = (DOUBLE)0.;
}
}
// Save iVal-th probability.

vdblProb[lClass] = dblProb;
}
// Make sure that we haven't suffered underflow.
DOUBLE dblProbSum = vdblProb.sum();
// ATLASSERT(dblProbSum!=0.0);
// Finally, fill in the predictions.

DMMSTATE* rgStates = pdistCurrent->rgStates;
for (lClass = 0; lClass < cClasses; lClass++)

{
if (lClass == 0) // missing
{
rgStates[lClass].vValue.vt = VT_NULL;
}
else if (FIsBinary (iPredAttdmmaf))
{
if (lClass != 1)
rgStates[lClass].vValue.vt = VT_ILLEGAL;
else
rgStates[lClass].vValue.vt = VT_EMPTY;
}
else if (FIsDiscrete (iPredAttdmmaf))
{
SetVariant (&rgStates[lClass].vValue, (ULONG)lClass);
}
else
{
ATLASSERT(!"NOT YET IMPLEMENTED");
SetVariant (&rgStates[lClass].vValue, (DOUBLE)0.0);
}
rgStates[lClass].dblSupport = m_cCase * vdblProb[lClass];

rgStates[lClass].dblVariance = 0.0;
rgStates[lClass].dblProbability = dblProbSum > 0.0 ? vdblProb[lClass] /
129
dblProbSum : 0;
rgStates[lClass].dblProbabilityVariance = 0.0;
}
}
// Done.
}
/////////////////////////////////////////////////////////////////////////////
ULONG DMM_SNaiveBayes::GetContinuousAttributeStateCount()
// Description:
// Returns number of states associated with continuous attributes.
/////////////////////////////////////////////////////////////////////////////
{
return (2);
}
/////////////////////////////////////////////////////////////////////////////
IATT DMM_SNaiveBayes::GetiAttNodeID
(ULONG in_ulNodeID)
// Description:
// Returns attribute number from nodeID.
/////////////////////////////////////////////////////////////////////////////
{
IATT iiPredAtt = m_vNode[in_ulNodeID].m_iiPredAtt;
if (iiPredAtt == DMM_UNSPECIFIED)
return (DMM_UNSPECIFIED);
IATT iiInpAtt = m_vNode[in_ulNodeID].m_iiInpAtt;
if (iiInpAtt == DMM_UNSPECIFIED)
return (m_vTree[iiPredAtt].m_iPredAtt);
else
return (m_vTree[iiPredAtt].m_vInputAttNumber[iiInpAtt]);
}
/////////////////////////////////////////////////////////////////////////////
IATT DMM_SNaiveBayes::GetiPredAttNodeID
(ULONG in_ulNodeID)
// Description:
// Returns predictive attribute number from nodeID.
/////////////////////////////////////////////////////////////////////////////
{
IATT iiPredAtt = m_vNode[in_ulNodeID].m_iiPredAtt;
if (iiPredAtt == DMM_UNSPECIFIED)
return (DMM_UNSPECIFIED);
return (m_vTree[iiPredAtt].m_iPredAtt);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP DMM_SNaiveBayes::GetNavigator (
ULONG ulNodeIDStart,
IDAGNavigation** ppidagnav)
// Description:
// Implements IDMMDataMiningModel::GetNavigator.
/////////////////////////////////////////////////////////////////////////////
{
HRESULT hr = S_OK;
try
{
// Make sure we're not currently learning and that we have a model.
CHECKRESULT(m_vTree.size()!=0, DMME_MODEL_NOT_TRAINED);
CComObject<SPM_SNaiveBayesNav>* pSNaiveBayesNav = NULL;

CComObject<SPM_SNaiveBayesNav>::CreateInstance(&pSNaiveBayesNav);
130
pSNaiveBayesNav->Init(m_spias, this, (ulNodeIDStart < NODEID_NAVTOP) ?
NODEID_NAVTOP : ulNodeIDStart);
COMCALL(pSNaiveBayesNav->QueryInterface(_uuidof(IDAGNavigation), (void**)
ppidagnav));
}
catch (_com_error &e)
{
hr = e.Error();
}
catch (...)
{
hr = E_FAIL;
}
return (hr);
}
/////////////////////////////////////////////////////////////////////////////
inline LONG ConvertNodeType (
NODETYPE in_NodeType)
// NODE_TYPE_MODEL (1) > DMMNODEPROP_TYPE_MODEL (1)
// NODE_TYPE_TREE (2) > DMMNODEPROP_TYPE_INTERIOR (3)
// NODE_TYPE_INTERIOR (3) > DMMNODEPROP_TYPE_INTERIOR (3)
// NODE_TYPE_DISTRIBUTION (4) > DMMNODEPROP_TYPE_DISTRIBUTION (4)
// other (6) > DMMNODEPROP_TYPE_UNKNOWN (6)
{
if (in_NodeType == NODE_TYPE_MODEL)
return (DMMNODEPROP_TYPE_MODEL);
if (in_NodeType == NODE_TYPE_TREE)
return (DMMNODEPROP_TYPE_INTERIOR);
if (in_NodeType == NODE_TYPE_INTERIOR)
return (DMMNODEPROP_TYPE_INTERIOR);
if (in_NodeType == NODE_TYPE_DISTRIBUTION)
return (DMMNODEPROP_TYPE_DISTRIBUTION);
return (DMMNODEPROP_TYPE_UNKNOWN);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP DMM_SNaiveBayes::GetNodeProperties (
ULONG in_ulNodeID,
DBPROPSET *pPropertySet)
// Description:
// Provides support for GetNodeProperties.
//
// Notes
// 1) We need to decide what makes most sense to spit out for
// DMMPROPSET_DISTRIBUTION. Since all variables are continuous,
// they will only have two states. It won't really be very
// interesting for the dude to get information about the
// DMMPROPSET_DISTRIBUTION as it's currently defined, since all he'll
// get back is the mean value. Perhaps we should have another
// property which allows the user to get coefficients of the polynomial.
// We could return these through DMMPROPSET_DISTRIBUTION, but we'd need
// to make it look like there's more than one state associated with
// a continuous variable, which probably won't make much sense and
// some frontends may not be expecting such behavior.
/////////////////////////////////////////////////////////////////////////////
{
_variant_t varEmpty;
// Initialize the PropSet, end result is that any allocated memory belongs to
pPropertySet
PFPropSets propsetsRequest;
InitNodePropSet(pPropertySet, propsetsRequest);
if (pPropertySet->guidPropertySet == DMMPROPSET_DISTRIBUTION)
{
return (S_OK);
131
IATT iiPredAtt = nodeData.m_iiPredAtt;
IATT iPredAtt = m_vTree[iiPredAtt].m_iPredAtt;
ULONG cClasses = m_vTree[iiPredAtt].m_cClasses; // Number of states involved.
// Initialize a bunch of VSAV's for output.

VARIANT varAtts; varAtts.vt = VT_EMPTY;
VARIANT varValues; varValues.vt = VT_EMPTY;
VARIANT varValueTypes; varValueTypes.vt = VT_EMPTY;
VARIANT varSupports; varSupports.vt = VT_EMPTY;
VARIANT varProbabilities; varProbabilities.vt = VT_EMPTY;
VARIANT varVariances; varVariances.vt = VT_EMPTY;
VSAV vsavAtts(&varAtts);
VSAV vsavValues(&varValues);
VSAV vsavValueTypes(&varValueTypes);
VSAV vsavSupports(&varSupports);
VSAV vsavProbabilities(&varProbabilities);
VSAV vsavVariances(&varVariances);
vsavAtts.Resize(cClasses);
vsavValues.Resize(cClasses);
vsavValueTypes.Resize(cClasses);
vsavSupports.Resize(cClasses);
vsavProbabilities.Resize(cClasses);
vsavVariances.Resize(cClasses);
LONG iCount;
iCount = nodeData.m_lCountSum;
// Get count information for all listed attributes w.r.t. iAtt,iVal.

ULONG iEntry = 0;
COMCALL(m_spias->GetAttributeFlags (iPredAtt, &iPredAttdmmaf));
for (LONG lClass = 0; lClass < cClasses; lClass++)

{
DMMSTATE dmmstate;
if (lClass == 0)
{
dmmstate.vValue.vt = VT_NULL;
}
else if (FIsBinary (iPredAttdmmaf))
{
if (lClass != 1)
dmmstate.vValue.vt = VT_ILLEGAL;
else
dmmstate.vValue.vt = VT_EMPTY;
}
else if (FIsDiscrete (iPredAttdmmaf))
{
SetVariant(&dmmstate.vValue,(ULONG)lClass);
}
else
{
SetVariant(&dmmstate.vValue,(ULONG)lClass);
}
dmmstate.dblVariance = 0.0;
dmmstate.dblSupport = nodeData.m_vClassCount[lClass].m_lCount;
if (iCount == 0)
{
ATLASSERT(dmmstate.dblSupport==0.0);
dmmstate.dblProbability = 0.0;
}
else
dmmstate.dblProbability = dmmstate.dblSupport/iCount;
dmmstate.dblProbabilityVariance = 0.0;
dmmstate.dblAdjustedProbability = 0.0;
132
DMMStateToDistributionVSAVs(iPredAtt, m_spias, iEntry, &dmmstate,
vsavAtts, vsavValues, vsavValueTypes, vsavSupports, vsavProbabilities,
vsavVariances,
&m_est);
iEntry++;
}
// Stuff the VSAV's into the request.

for (ULONG iProperty = 0; iProperty < pPropertySet->cProperties; iProperty++)
{
DBPROP* pPropCurrent = &(pPropertySet->rgProperties[iProperty]);
switch (pPropCurrent->dwPropertyID)
{
case DMMDISTPROP_ATTRIBUTES:
COMCALL(propsetsRequest.SetPropValue(DMMPROPSET_DISTRIBUTION,
DMMDISTPROP_ATTRIBUTES, &varAtts));
break;
case DMMDISTPROP_VALUES:
DMMDISTPROP_VALUES, &varValues));
break;
case DMMDISTPROP_VALUETYPES:
DMMDISTPROP_VALUETYPES, &varValueTypes));
break;
case DMMDISTPROP_SUPPORTS:
DMMDISTPROP_SUPPORTS, &varSupports));
break;
case DMMDISTPROP_PROBABILITIES:
DMMDISTPROP_PROBABILITIES, &varProbabilities));
break;
case DMMDISTPROP_VARIANCES:
DMMDISTPROP_VARIANCES, &varVariances));
break;
}
}
}
else if (pPropertySet->guidPropertySet == DMMPROPSET_NODE)
{
for (ULONG iProperty = 0; iProperty < pPropertySet->cProperties; iProperty++)
{
DBPROP* pPropCurrent = &(pPropertySet->rgProperties[iProperty]);
switch (pPropCurrent->dwPropertyID)
{
case DMMNODEPROP_ATTRIBUTES:
COMCALL(propsetsRequest.SetPropValue(DMMPROPSET_NODE, pPropCurrent-
>dwPropertyID, (VARIANT*)&varEmpty));
else
{
VSAV vsavAttributes;
BSTR bstrName = NULL;
COMCALL(m_spias->GetAttributeDisplayName(GetiPredAttNodeID (in_ulNodeID),
false, &bstrName));
vsavAttributes.PushBack(bstrName);
COMCALL(propsetsRequest.SetPropValue(DMMPROPSET_NODE,
DMMNODEPROP_ATTRIBUTES, (VARIANT*)vsavAttributes));
}
break;
case DMMNODEPROP_TYPE:
133
COMCALL(propsetsRequest.SetPropValue(DMMPROPSET_NODE, DMMNODEPROP_TYPE,
ConvertNodeType (nodeData.m_iNodeType)));
break;
case DMMNODEPROP_CONDITION_XML:
DMMNODEPROP_CONDITION_XML, _bstr_t()));
break;
case DMMNODEPROP_RULE_XML:
COMCALL(propsetsRequest.SetPropValue(DMMPROPSET_NODE, DMMNODEPROP_RULE_XML,
_bstr_t()));
break;
case DMMNODEPROP_PROBABILITY:
DMMNODEPROP_PROBABILITY, GetProbability(in_ulNodeID)));
break;
case DMMNODEPROP_MARGINAL_PROBABILITY:
DMMNODEPROP_MARGINAL_PROBABILITY, GetMarginalProbability(in_ulNodeID)));
break;
case DMMNODEPROP_SHORTCAPTION:
case DMMNODEPROP_CAPTION:
{
_bstr_t bstrCaption;
GetCaption(in_ulNodeID, bstrCaption);
>dwPropertyID, bstrCaption));
}
break;
/*
case DMMNODEPROP_MSOLAP_NODE_SHORT_CAPTION:
{
DMMNODEPROP_MSOLAP_NODE_SHORT_CAPTION, _bstr_t()));
}
else
{
_bstr_t bstrCaption;
GetCaption(in_ulNodeID, bstrCaption);
>dwPropertyID, bstrCaption));
}
break;
*/
case DMMNODEPROP_SUPPORT:
COMCALL(propsetsRequest.SetPropValue(DMMPROPSET_NODE, DMMNODEPROP_SUPPORT,
GetSupport (in_ulNodeID)));
break;
case DMMNODEPROP_MODEL_COLUMN_NAME:
{
DMMNODEPROP_MODEL_COLUMN_NAME, _bstr_t()));
}
else
{
BSTR bstrColumnName = NULL;
COMCALL(m_spias->GetFullyQualifiedColumnName(GetiAttNodeID
(in_ulNodeID),&bstrColumnName));
DMMNODEPROP_MODEL_COLUMN_NAME, bstrColumnName));
}
134
break;
case DMMNODEPROP_DESCRIPTION:
{
_bstr_t bstrDescription;
GetDescription (in_ulNodeID, bstrDescription);

DMMNODEPROP_DESCRIPTION, bstrDescription));
}
break;
case DMMNODEPROP_SCORE:
// case DMMNODEPROP_MSOLAP_NODE_SCORE:
>dwPropertyID, (DOUBLE)0));
// MUSTFIX: Need to implement support.
// ATLASSERT(0);
break;
case DMMNODEPROP_NODE_TREE:
COMCALL(propsetsRequest.SetPropValue(DMMPROPSET_NODE, DMMNODEPROP_NODE_TREE,
(LONG)(nodeData.IsTreeNode () ? 1 : 0)));
break;
/*
case DMMNODEPROP_MSOLAP_MODEL_COLUMN:
{
_bstr_t bstrColumnName;
GetModelTreeName(in_ulNodeID, bstrColumnName);
DMMNODEPROP_MSOLAP_MODEL_COLUMN, bstrColumnName));
}
break;
*/
}
}
}
else
{
CHECKARG(0);
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP DMM_SNaiveBayes::ValidateNodeID
(ULONG in_ulNodeID)
// Description:
// Implements IDMMDataMiningModel::ValidateNodeID.
////////////////////////////////////////////////////////////////////////////
{

IATT cAtt;
return (S_OK);
return (iAtt < cAtt);
return (iAtt < cAtt);
135
{
return (iAtt < cAtt
&& lVal <
m_vTree[nodeData.m_iiPredAtt].m_TreeNodeID.m_vAttNodeID[nodeData.m_iiInpAtt].m_vValNod
eID.size ());
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP DMM_SNaiveBayes::NodeSupportsPropertySet(
ULONG in_ulNodeID,
GUID* guidSet,
boolean* pfSupported)
// Description:
// Implements IDMMDataMiningModel::NodeSupportsPropertySet
/////////////////////////////////////////////////////////////////////////////
{
try
{
// Make sure that we're not learning and that we have a model.
CHECKRESULT(m_vTree.size() != 0, DMME_MODEL_NOT_TRAINED);
*pfSupported = false;
if (DMMPROPSET_NODE == *guidSet || DMMPROPSET_DISTRIBUTION == *guidSet)

*pfSupported = true;
}
{
return e.Error();
}
catch (...)
{
return (E_POINTER);
}
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP DMM_SNaiveBayes::GetNodeUniqueName(
ULONG in_ulNodeID,
BSTR* pbstrUniqueName)
// Description:
// Implements IDMMDataMiningModel::GetNodeUniqueName
/////////////////////////////////////////////////////////////////////////////
{
try
{
wchar_t wsz[20];
swprintf(wsz,L"%ld",in_ulNodeID);
*pbstrUniqueName = SysAllocString(wsz);
}
{
return e.Error();
}
catch (...)
{
return E_FAIL;
}
return (NOERROR);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP DMM_SNaiveBayes::GetNodeIDFromUniqueName(
BSTR bstrUniqueName,
136
ULONG* pulNodeID)
// Description:
// Implements IDMMDataMiningModel::GetNodeIDFromUniqueName
/////////////////////////////////////////////////////////////////////////////
{
try
{
*pulNodeID = wcstol(bstrUniqueName, NULL, 10);
}
{
return e.Error();
}
catch (...)
{
return (E_POINTER);
}
return (S_OK);
}
// The following def'ns use or replace methods in DMM\DMMXML.CPP.
extern bool CheckNodeAttributeValue(IDMPersistenceReader* piReader, DMPERSISTITEM

tagCheck, LPWSTR pstrCheck);
extern void WriteInfoNameValue(IDMPersistenceWriter* piWriter, LPWSTR strName,

LONG lValue, DMPERSISTITEM tag);

DOUBLE dblValue, DMPERSISTITEM tag);

LPWSTR strValue, DMPERSISTITEM tag);
extern void LoadDistribution (IDMPersistenceReader* piReader, IAttributeSet* pias,

ULONG cStatesMax, DMMDISTRIBUTION** ppdist);
/////////////////////////////////////////////////////////////////////////////
inline void WriteMissingStateEx (
IDMPersistenceWriter* piWriter,
DOUBLE in_dblSupport,
BOOL in_fClose = true)
// Description:
// This method replaces .\DMMXML.CPP\WriteMissingState.
/////////////////////////////////////////////////////////////////////////////
{
COMCALL(piWriter->OpenScope(DMPI_STATE)); // Open state tag
COMCALL(piWriter->SetBoolAttribute(DMPI_MISSING, true));
COMCALL(piWriter->SetDoubleAttribute(DMPI_SUPPORT, in_dblSupport));
if (in_fClose)
COMCALL(piWriter->CloseScope()); // Close state tag
}
/////////////////////////////////////////////////////////////////////////////
inline void WriteDiscreteStateEx (
DOUBLE dblSupport,
IATT iAtt,
DMMATTFLAGS dmmaf,
ULONG iAttState,
IDMPersistAttribute* pattxml,
BOOL fCloseTag=true)
// Description:
// This method replaces .\DMMXML.CPP\WriteDiscreteState.
/////////////////////////////////////////////////////////////////////////////
{
if (dmmaf & DMMAF_BINARY)
137
{
COMCALL(piWriter->SetBoolAttribute(DMPI_MISSING, false));
}
else
{
COMCALL(pattxml->SaveValue(iAtt, iAttState, piWriter));
}
COMCALL(piWriter->SetDoubleAttribute(DMPI_SUPPORT, dblSupport));
if (fCloseTag)
COMCALL(piWriter->CloseScope());
}
/////////////////////////////////////////////////////////////////////////////
inline void WriteContinuousStateEx (
IATT iAtt,
DOUBLE dblSupport,
DOUBLE dblMean,
DOUBLE dblStd,
DOUBLE dblMin,
DOUBLE dblMax,
IDMPersistAttribute* pattxml,
BOOL fCloseTag = true,
BOOL bMinMax = true,
BOOL bMean = true,
BOOL bStd = true)
// Description:
// This method replaces .\DMMXML.CPP\WriteMissingState.
/////////////////////////////////////////////////////////////////////////////
{
if (bMinMax)
{
COMCALL(pattxml->SaveContValue(iAtt, DMPI_MINIMUM, dblMin, LOCALE_NEUTRAL,
piWriter));
COMCALL(pattxml->SaveContValue(iAtt, DMPI_MAXIMUM, dblMax, LOCALE_NEUTRAL,
piWriter));
}
COMCALL(piWriter->SetDoubleAttribute(DMPI_SUPPORT, dblSupport));
if (bMean)
COMCALL(pattxml->SaveContValue(iAtt, DMPI_MEAN, dblMean, LOCALE_NEUTRAL,
piWriter));
if (bStd)
COMCALL(piWriter->SetDoubleAttribute(DMPI_STANDARDDEVIATION, dblStd));
if (fCloseTag)
}
// The following definitions are specific to DMM_SNaiveBayesModel.

static LPWSTR strcCase = L"Count of Cases";
static LPWSTR strcPredAtt = L"Count of Trees";
static LPWSTR strcNMCase = L"Count of Non Missing Cases";
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP DMM_SNaiveBayes::Load (IDMPersistenceReader* piReader)
// Description:
// Implements IDMPersist::Load.
// Loads DMM_SNaiveBayes object from XML repository.
//
//
/////////////////////////////////////////////////////////////////////////////
{
// Cache all data locally
LONG cCase; // count of all cases
IATT cPredAtt; // count of predictive attributes
vector<SNBiNodeData> vNode; // vector of NodeIDs
vector<SNBiTree> vTree; // vector of trees of predictive attributes
vector<ULONG> vPredAttNumber; // vector of attributes numbers of predictive
138
attributes
try
{
// Make sure we have a context.
CHECKRESULT(m_spias!=NULL, DMME_XML_LOADING_FAILURE);
CHECKRESULT(m_spidmmMarginal!=NULL, DMME_XML_LOADING_FAILURE);
// Make sure model hasn't already been initialized.

CHECKRESULT(m_vTree.size()==0, DMME_MODEL_ALREADY_TRAINED);
// Get the "<Simple-naive-bayes-model>" node.

CHECKRESULT(piReader->OpenPropertyScope(DMPI_SNAIVEBAYESMODEL) == S_OK,
DMME_XML_LOADING_FAILURE);
BOOL bVectorsNotResized = true;

IATT iiPredAtt = -1;
HRESULT hrNext;
// Iterate over the children of the "<SNaiveBayes-Model>" node.

COMCALL(hrNext = piReader->OpenFirstPropertyScope());
while (hrNext == S_OK)

{
// Get the current child's type.
DMPERSISTITEM tag;
COMCALL(piReader->GetScopeType(&tag));
// Load all DMM_SNaiveBayes persistent members.

if (tag == DMPI_INFO)
{
if (CheckNodeAttributeValue(piReader, DMPI_NAME, strcCase))
COMCALL(piReader->GetLongAttribute(DMPI_VALUE, (LONG*)&cCase));
else if (CheckNodeAttributeValue(piReader, DMPI_NAME, strcPredAtt))

COMCALL(piReader->GetLongAttribute(DMPI_VALUE, (LONG*)&cPredAtt));
else
ATLASSERT(!"Invalid tag found in XML file! ");
}
else if (tag == DMPI_DATADISTRIBUTION)
{
// data to be loaded
// vTree
// vector<SNBiClassStat> vClassStat; // vector of statistic of continuous
// vNode
// vector<SNBiCount> vClassCount; // vector of counts of classes (values of
if (bVectorsNotResized)
{
// resize vectors and assemble NodeIDs when the first data distribution is
found
ResizeIndexVectors (cPredAtt, vTree, vPredAttNumber);
AssembleNodeIDs (cPredAtt, vTree, vNode);
// clear m_iAtt initialized by ResizeIndexVectors that will be assigned by

the load process
for (IATT iiAtt = 0; iiAtt < cPredAtt; iiAtt++)
vTree[iiAtt].m_iPredAtt = DMM_UNSPECIFIED;
bVectorsNotResized = false;
}
iiPredAtt++;
// Make sure this attribute is valid!

CHECKRESULT (iiPredAtt < cPredAtt, DMME_XML_LOADING_FAILURE);
139
SNBiTree& Tree = vTree[iiPredAtt];
// Iterate over the children of the "<data-distribution>" node.
// Get the first child of the "<data-distribution>" node.

COMCALL (hrNext = piReader->OpenFirstPropertyScope());
CHECKRESULT (hrNext == S_OK, DMME_XML_LOADING_FAILURE);
// Make sure the first child is an "<...-attribute>" node.

CHECKRESULT (!(tag!=DMPI_SIMPLEATTRIBUTE && tag!=DMPI_COMPOUNDATTRIBUTE &&
tag!=DMPI_DERIVEDATTRIBUTE), DMME_XML_LOADING_FAILURE);
// Okay, this is an "<...-attribute>" node. Get attribute number.

IATT iCurrentClassAtt = DMM_UNSPECIFIED;
COMCALL(m_spias->ResolveAttributeReference(piReader, &iCurrentClassAtt));
// Make sure we haven't loaded this attribute already!

CHECKRESULT (Tree.m_iPredAtt == DMM_UNSPECIFIED, DMME_XML_LOADING_FAILURE);
Tree.m_iPredAtt = iCurrentClassAtt;
COMCALL(m_spias->GetAttributeFlags(iCurrentClassAtt, &iPredAttdmmaf));
// Load the states of the predictive attribute.

while (piReader->MoveToNextSiblingScope() == S_OK)
{
// Make sure this is a "<state ...>" node.
CHECKRESULT(tag == DMPI_STATE, DMME_XML_LOADING_FAILURE);
// Calc ulClass and fMissing.

ULONG ulClass; // class of predictive attribute
BOOL fMissing;
if (piReader->GetBoolAttribute(DMPI_MISSING, &fMissing) == S_OK)

{
// Missing state for all types, non-missing for binary.
ulClass = fMissing ? 0 : 1;
}
else if (FIsContinuous (iPredAttdmmaf))
{
// Non-missing state for a continuous variable.
ulClass = 1;
}
else
{
// Make sure this is a DISCRETE attribute!
ATLASSERT (FIsDiscrete (iPredAttdmmaf));
// Map value to state number.
_variant_t varValue;
if (piReader->GetVariantAttribute (DMPI_VALUE, &varValue) == S_OK)
{
// Calc ulClass.
COMCALL (m_spias->ResolveStateNumber(iCurrentClassAtt, varValue,
&ulClass));
}
else
{
// Value attribute is missing and not the missing state.
ulClass = 1;
}
}
CHECKRESULT (ulClass < Tree.m_cClasses, DMME_XML_LOADING_FAILURE);
// Load support.
DOUBLE dblSupport;
COMCALL(piReader->GetDoubleAttribute(DMPI_SUPPORT, &dblSupport));
140
vNode[ulNodeIDTree].m_vClassCount[ulClass].m_lCount = dblSupport;
if (dblSupport > 0)
{
// only attribute classes with non zero counts have distributions
// Load the counts of all states of all input attributes

COMCALL(hrNext = piReader->OpenFirstPropertyScope());
while (hrNext == S_OK)
{
// Make sure this is a "<data-distribution>" node.
CHECKRESULT(tag==DMPI_DATADISTRIBUTION, DMME_XML_LOADING_FAILURE);
// Load correlation counts for one attribute.

DMMDISTRIBUTION* pdmmdist = NULL;
LoadDistribution (piReader, m_spias, DMM_UNSPECIFIED, &pdmmdist);
// Append any non-empty counts

if (pdmmdist != NULL)
{
IATT iInpAtt = pdmmdist->lAttribute;
IATT iiInpAtt = Tree.m_vAttIndex[iInpAtt];
DMMSTATE* pdmmstate = &pdmmdist->rgStates[0];

for (LONG lVal = 0; lVal < pdmmdist->cStates; lVal++, pdmmstate++)
{
if (pdmmstate->dblSupport!=0.0)
{
// NOTE: LoadDistribution doesn't init correctly!
// ATLASSERT (pdmmstate->vValue.vt != VT_EMPTY);
// Initialize SNBiAttValStat for this non-empty state.
ULONG ulNodeIDVal =
vNode[ulNodeIDVal].m_vClassCount[ulClass].m_lCount = pdmmstate-
>dblSupport;
if (FIsContinuous (iInpAttdmmaf) && !FIsBinary (iInpAttdmmaf) &&

(lVal == 1))
{
ULONG iiContAtt = Tree.m_vContAttIndex[iInpAtt];
CStateStats& ContStat =
Tree.m_vClassStat[ulClass].m_vContStat[iiContAtt];
// S2 = m_lCount * mean * mean + m_dblSqrSum - 2 * mean *

m_dblSum
// standard deviation = sqrt (S2 / (m_lCount - 1))
ContStat.m_dblMean = pdmmstate->vValue.dblVal;
DOUBLE dblStd2 = pdmmstate->dblVariance; // Variance = square of
standard deviation
ContStat.m_lCount = pdmmstate->dblSupport;
ContStat.m_dblSum = ContStat.m_dblMean * ContStat.m_lCount;
if (ContStat.m_lCount == 1)
ContStat.m_dblSqrSum = ContStat.m_dblSum * ContStat.m_dblSum;
else
ContStat.m_dblSqrSum = dblStd2 * (ContStat.m_lCount - 1) -
ContStat.m_lCount * ContStat.m_dblMean * ContStat.m_dblMean + 2. * ContStat.m_dblMean
* ContStat.m_dblSum;
ContStat.m_dblStd = ContStat.Deviation ();
}
}
}
// Free up this distribution.
::CoTaskMemFree (pdmmdist);
}
COMCALL(hrNext = piReader->MoveToNextSiblingScope());
}
141
// close scope of counts of states of input attributes
COMCALL(piReader->CloseScope());
}
}
// close scope of data distribution (tree model)
}
// Unexpected node. Fail immediately.
else
{
CHECKRESULT(0, DMME_XML_LOADING_FAILURE);
}
// search to next data distribution (new tree model)
COMCALL(hrNext = piReader->MoveToNextSiblingScope());
}
// close scope of child of model

// close scope of <Simple-naive-bayes-model> node

}
catch (_com_error& e)
{
return (e.Error());
}
catch (...)
{
return (E_FAIL);
}
ComputeAttNodeCounts (cPredAtt, vTree, vNode);
ComputeSumCounts (cPredAtt, cCase, vTree, vNode);
// Success! Initialize DMM_SNaiveBayes from loaded data.

m_cCase = cCase; // count of all cases
m_cPredAtt = cPredAtt; // count of predictive attributes
m_vNode.swap (vNode); // vector of nodeData
m_vTree.swap (vTree); // vector of Trees of predictive attributes
m_vPredAttNumber.swap (vPredAttNumber); // vector of attributes numbers of
return (S_OK);
}
/////////////////////////////////////////////////////////////////////////////
STDMETHODIMP DMM_SNaiveBayes::Save (IDMPersistenceWriter* piWriter)
// Description:
// Implements IDMPersist::Save.
// Saves DMM_SNaiveBayes object to XML repository.
//
// Syntax for SNaiveBayes-model ...
//
// <Simple-naive-bayes-model>
// <info name="Count of Cases" value="number of cases" />
// <info name="Count of Trees" value="number of predictive attributes" />
// <data-distribution>
// <simple-attribute name="predictive attribute name 1">
// <state missing="true" support="...">
// <simple-attribute name="input attribute name 1">
// <state missing="true" support=... />
// <state value="state value 1" support=... />
// ...
// </data-distribution>
142
// ...
// ...
// </state>
// <state value ="state value 1" support="...">
// ...
// ...
// ...
// </state>
// ...
// <simple-attribute name="predictive attribute name 2">
// <state missing=true support=... />
// ...
// </Simple-naive-bayes-model>
/////////////////////////////////////////////////////////////////////////////
{
try
{
// Make sure we're not learning and that we actually have a model.
CHECKRESULT(m_vTree.size()!=0, DMME_MODEL_NOT_TRAINED);
// Open the "<Simple-naive-bayes-model>" node.

COMCALL(piWriter->OpenScope(DMPI_SNAIVEBAYESMODEL));
// Save out all "<Simple-naive-bayes-model>" properties.

// LONG m_cCase; // count of all cases
// IATT m_cPredAtt; // count of predictive attributes
WriteInfoNameValue(piWriter,strcCase,(long)m_cCase,DMPI_INFO);
WriteInfoNameValue(piWriter,strcPredAtt,(long)m_cPredAtt,DMPI_INFO);
// Save out all trees.

// In the Simple-naive-bayes-model does not exist trees in the strict sense of
the word
// Does exist data distributions that can be represented by trees
// So to agree with XML standard are used <data-distribution> nodes to represent
the model
for (IATT iiPredAtt = 0; iiPredAtt < m_cPredAtt; iiPredAtt++)
{
// COMCALL(piWriter->OpenScope(DMPI_TREEMODEL));
// Save model id
// CComBSTR bstrName;
// COMCALL(m_spias->GetAttributeDisplayName(iCurrentClassAtt, false, &bstrName));
// COMCALL(piWriter->SetStringAttribute(DMPI_MODELID, bstrName));
// Open a "<data-distribution>" node for iiPredAtt.

COMCALL(piWriter->OpenScope(DMPI_DATADISTRIBUTION));
// Save out all attributes.

CComPtr<IDMPersistAttribute> spAttXMLString;
143
COMCALL(m_spias->QueryInterface(&spAttXMLString));
// Save out a "<...-attribute>" node for iPredAtt.

COMCALL(spAttXMLString->SaveAttributeName(iPredAtt, piWriter, false));
// run through all classes of the predictive attribute

{
// Save out a "<state ...>" node for ATT[iAtt]==iVal.
if (lClass == 0)
{
// value missing count
WriteMissingStateEx (piWriter,
m_vNode[ulNodeIDTree].m_vClassCount[lClass].m_lCount, false);
}
else if (FIsDiscrete (iPredAttdmmaf) || (FIsBinary (iPredAttdmmaf) && (lClass
== 1))) // all continuous binary attributes can be predicted since it have only two
states
{
// sum of counts for each class of all cases
WriteDiscreteStateEx (piWriter,
m_vNode[ulNodeIDTree].m_vClassCount[lClass].m_lCount, iPredAtt, iPredAttdmmaf, lClass,
spAttXMLString.p, false);
}
else
{
// predictive attributes can only be missing or discrete or binary
COMCALL(E_FAIL);
}
if (m_vNode[ulNodeIDTree].m_vClassCount[lClass].m_lCount > 0)
{
// only attribute classes with non zero counts have distributions
// run throught all input attributes
{
IATT iInpAtt = Tree.m_vInputAttNumber[iiInpAtt];
// attribute node

LONG cAttVal = m_vNode[ulNodeIDAtt].m_cChild;
// Open a "<data-distribution>" node for iInpAtt.

COMCALL(piWriter->OpenScope(DMPI_DATADISTRIBUTION));
// Save out all attributes.

CComPtr<IDMPersistAttribute> spAttXMLString;
COMCALL(m_spias->QueryInterface(&spAttXMLString));
// Save out a "<...-attribute>" node for iInpAtt.

COMCALL(spAttXMLString->SaveAttributeName(iInpAtt, piWriter, false));
// run through all values of the input attribute (binary and continuous
attributes have 2 values)
{
ULONG ulNodeIDVal =
if (m_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount > 0)
{
// Save out "<state ...>" node for lVal.
if (lVal == 0)
144
{
WriteMissingStateEx (piWriter,
m_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount, true);
}
else if (FIsDiscrete (iInpAttdmmaf) || (FIsBinary (iInpAttdmmaf) &&
(lVal == 1))) // all binary attributes are computed as discrete with two states
{
WriteDiscreteStateEx (piWriter,
m_vNode[ulNodeIDVal].m_vClassCount[lClass].m_lCount, iInpAtt, iInpAttdmmaf, lVal,
spAttXMLString.p, true);
}
else if (FIsContinuous (iInpAttdmmaf) && !FIsBinary (iInpAttdmmaf) &&
(lVal == 1))
{
ULONG iiContAtt = Tree.m_vContAttIndex[iInpAtt];
CStateStats& ContStat =
Tree.m_vClassStat[lClass].m_vContStat[iiContAtt];
WriteContinuousStateEx (piWriter, iInpAtt, ContStat.m_lCount,

ContStat.m_dblMean, ContStat.m_dblStd, 0, 0, spAttXMLString.p, true, false, true,
true);
}
else
{
COMCALL(E_FAIL);
}
}
} // run through all values of the input attribute
// Close the "<data-distribution>" node for iInpAtt.
} // run throught all input attributes
}
// Close the "<state ...>" node
} // run through all classes of the predictive attribute
// Close the "<tree-model>" node.

// Close the "<data-distribution>" node for iiPredAtt.
}
// Close the "<Simple-naive-bayes-model>" node.

}
{
return (e.Error());
}
catch (...)
{
return (E_FAIL);
}
// Success!
return (S_OK);
}
Listagem C.3. Arquivo SNaiveBayes.hpp
//-----------------------------------------------------------------------------
//
// @module SNaiveBayes.hpp | Implementation of Simple Naive Bayes DMM.
//
// Description
//
// DMM_SNaiveBayes implements support for Simple Naive Bayes inference.
//
//
145
// Created by Claudio Luiz Curotto - Jan/2002
// to implement Simple Naive Bayes incremental algorithm
//
//-----------------------------------------------------------------------------
#ifndef __SNaiveBayes_HPP_
#define __SNaiveBayes_HPP_
#include "ModelUtils.inl"
#include "DMMStatistics.h"
typedef BYTE NODETYPE;

typedef ULONG NODEID;
const NODETYPE NODE_TYPE_MODEL = 1; // const ULONG DM_NODE_TYPE_MODEL

= 1;
const NODETYPE NODE_TYPE_TREE = 2; // const ULONG DM_NODE_TYPE_TREE
= 2;
const NODETYPE NODE_TYPE_INTERIOR = 3; // const ULONG DM_NODE_TYPE_INTERIOR
= 3;
const NODETYPE NODE_TYPE_DISTRIBUTION = 4; // const ULONG DM_NODE_TYPE_DISTRIBUTION
= 4;
// const ULONG DM_NODE_TYPE_CLUSTER
= 5;
const NODETYPE NODE_TYPE_UNKNOWN = 6; // const ULONG DM_NODE_TYPE_UNKNOWN
= 6;
const double NORM_CONST = sqrt (2. * 3.141593);
const double DIFF_ZERO = 1E-5;

const double STDDEV_ZERO = 1E-5;
////////////////////////////////////////////////////////////////////////////
class SNBiCaseAttData
// Description:
// attribute data of each case (used to create cases on the fly).
////////////////////////////////////////////////////////////////////////////
{
public:
IATT m_iAtt; // attribute number
LONG m_lVal; // integer attribute value (discrete attributes)
DOUBLE m_dblVal; // float attribute value (continuous attributes)
SNBiCaseAttData ()
{
m_iAtt = DMM_UNSPECIFIED;
m_lVal = INT_VALUE_MISSING;
m_dblVal = FLOAT_VALUE_MISSING;
}
};
////////////////////////////////////////////////////////////////////////////
class SNBiCount
// Description:
// count for one class (value of predictive attribute).
////////////////////////////////////////////////////////////////////////////
{
public:
LONG m_lCount; // count for one class (value of predictive attribute)
SNBiCount ()
{
m_lCount = 0;
}
};
/////////////////////////////////////////////////////////////////////////////
class SNBiNodeData
146
// Description:
// node data.
////////////////////////////////////////////////////////////////////////////
{
public:
NODETYPE m_iNodeType; // type of node
// model node: DMMNODEPROP_TYPE_MODEL for
NODEID_NAVTOP
// tree node: DMMNODEPROP_TYPE_TREE for
// attribute node: DMMNODEPROP_TYPE_INTERIOR for
input attributes
// value node: DMMNODEPROP_TYPE_DISTRIBUTION
for values of input attributes
ULONG m_cChild; // count of child nodes
NODEID m_ulParent; // nodeid of parent node
NODEID m_ulSibling; // nodeid of the next sibling node
NODEID m_ulChild; // nodeid of the first child node
IATT m_iiPredAtt; // index of predictive attribute
// model node: DMM_UNSPECIFIED
IATT m_iiInpAtt; // index of input attribute
// model and tree nodes: DMM_UNSPECIFIED
LONG m_lVal; // value of input attribute
// model tree and attribute nodes:
INT_VALUE_MISSING
vector<SNBiCount> m_vClassCount; // vector of counts of classes (values of
// model node: unused
// tree node: sum of counts for each class
of all cases
// used to compute prior
probabilities
// prior probability[] =
m_vClassCount[].m_lCount / m_cCase // since missing values are considered
// attribute node: sum of the counts of each
class of all attribute values
// must be equal of the value of tree node for
all attributes
// value node: counts of each class
LONG m_lCountSum; // sum of elements of vector of counts (value of
DMMNODEPROP_SUPPORT property)
// model node: number of cases
// tree node: must be equal of number of
cases
// attribute node: must be equal of number of
cases
// value node: sum of counts of all classes
SNBiNodeData ()
{
m_iNodeType = NODE_TYPE_MODEL;
m_cChild = 0;
m_ulParent = DMM_UNSPECIFIED;
m_ulSibling = DMM_UNSPECIFIED;
m_ulChild = DMM_UNSPECIFIED;
m_iiPredAtt = DMM_UNSPECIFIED;
m_iiInpAtt = DMM_UNSPECIFIED;
m_lCountSum = 0;
}
__forceinline BOOL IsNavTop ()
{
return (m_iNodeType==NODE_TYPE_MODEL);
}
__forceinline BOOL IsTreeNode ()
{
return (m_iNodeType==NODE_TYPE_TREE);
}
__forceinline BOOL IsAttNode ()
{
return (m_iNodeType==NODE_TYPE_INTERIOR);
147
}
__forceinline BOOL IsValNode ()
{
return (m_iNodeType==NODE_TYPE_DISTRIBUTION);
}
};
////////////////////////////////////////////////////////////////////////////
class SNBiValNodeID
// Description:
// node id of leaf nodes (input attributes values nodes).
////////////////////////////////////////////////////////////////////////////
{
public:
ULONG m_ulNodeID; // NodeID
SNBiValNodeID ()
{
m_ulNodeID = DMM_UNSPECIFIED;
}
};
////////////////////////////////////////////////////////////////////////////
class SNBiAttNodeID
// Description:
// node ids of input attributes nodes.
////////////////////////////////////////////////////////////////////////////
{
public:
vector<SNBiValNodeID> m_vValNodeID; // vector of attributes values node ids
SNBiAttNodeID ()
{
}
};
////////////////////////////////////////////////////////////////////////////
class SNBiTreeNodeID
// Description:
// tree of node ids.
////////////////////////////////////////////////////////////////////////////
{
public:
vector<SNBiAttNodeID> m_vAttNodeID; // vector of input attributes nodes
SNBiTreeNodeID ()
{
}
};
/////////////////////////////////////////////////////////////////////////////
class SNBiClassStat
// Description:
// statistics record of each class (predictive attribute value).
/////////////////////////////////////////////////////////////////////////////
{
public:
vector<CStateStats> m_vContStat; // vector of statistics of input continuous
attributes
};
/////////////////////////////////////////////////////////////////////////////
class SNBiTree
148
// Description:
// model tree for each predictive attribute.
////////////////////////////////////////////////////////////////////////////
{
public:
IATT m_iPredAtt; // attribute number of predictive attribute
LONG m_cClasses; // count of classes of predictive attribute
IATT m_cInpAtt; // count of input attributes
IATT m_cContAtt; // count of continuous attributes
SNBiTreeNodeID m_TreeNodeID; // node ids
vector<ULONG> m_vAttIndex; // vector of indexes of attributes
vector<ULONG> m_vContAttIndex; // vector of indexes of continuous attributes
vector<ULONG> m_vInputAttNumber; // vector of attributes numbers of input
attributes
vector<SNBiClassStat> m_vClassStat; // vector of statistic of continuous
SNBiTree ()
{
m_iPredAtt = DMM_UNSPECIFIED;
m_cClasses = 0;
m_cInpAtt = 0;
m_cContAtt = 0;
}
};
/////////////////////////////////////////////////////////////////////////////
class SNBiSummaryScore
// Description:
// Class used during ::GetDescription.
/////////////////////////////////////////////////////////////////////////////
{
public:
IATT m_iAtt; // attribute number of input attribute
LONG m_lVal; // integer attribute value (discrete attributes)
DOUBLE m_dblMean; // mean of continuous attributes
DOUBLE m_dblStdDev;// standard deviation of continuous attributes
IATT m_iPredAtt; // attribute number of predictive attribute
LONG m_lClass; // class (attribute value) of predictive attribute
DOUBLE m_dblProb;
public:
SNBiSummaryScore ()
{
m_iAtt = DMM_UNSPECIFIED;
m_dblMean = 0;
m_dblStdDev = 0;
m_iPredAtt = DMM_UNSPECIFIED;
m_lClass = INT_VALUE_MISSING;
m_dblProb = 0.;
}
bool operator < (const SNBiSummaryScore& elem) const

{
// sort by class of predictive attribute
// to sort in ascending order must return true if value is greater than the
parameter value
return (m_lClass > elem.m_lClass);
}
};
#define SNBi_MAX_CHAR_ATTRS (20)
class ATL_NO_VTABLE DMM_SNaiveBayes :

public DMM_DataMiningModel<DMM_SNaiveBayes>
{
public:
149
DMM_SNaiveBayes()
{
m_cCase = 0; // must be initialized with zero instead of INT_VALUE_MISSING to
support incremental update;
ATLASSERT(m_vTree.size()==0);
}
~DMM_SNaiveBayes()
{
}
BOOL ResizeIndexVectors (
IATT & out_cPredAtt,
vector<ULONG> & out_vPredAttNumber); // vector of attributes numbers of
BOOL AssembleNodeIDs (
IATT cPredAtt,
vector<SNBiNodeData> & out_vNode);
BOOL CountAttributeStatistics (
IATT cPredAtt,
LONG & out_cCase,
BOOL ComputeMissingCounts (
IATT cPredAtt,
BOOL ComputeSumCounts (
IATT cPredAtt,
LONG cCase,
BOOL ComputeAttNodeCounts (
IATT cPredAtt,
BOOL DoInsertCases (
BOOL bIncremental);
void DoPredict (
ULONG in_cAttVal,
DMATTVALUE in_rgAttVal[],
BOOL in_fContinuousHistograms,
SPM_Predictions& in_preds);
ULONG GetContinuousAttributeStateCount (
void);
IATT GetiAttNodeID (
ULONG in_ulNodeID);
IATT GetiPredAttNodeID (
ULONG in_ulNodeID);
STDMETHOD(GetNavigator) (
ULONG in_iNodeStart,
IDAGNavigation ** ppidagnav);
STDMETHOD(GetNodeProperties) (
ULONG in_ulNodeID,
DBPROPSET* pPropertySet);
STDMETHOD(ValidateNodeID) (
ULONG in_ulNodeID);
150
STDMETHOD(NodeSupportsPropertySet) (
ULONG in_ulNodeID,
GUID* guidSet,
boolean* pfSupported);
STDMETHOD(GetNodeUniqueName) (
ULONG in_ulNodeID,
BSTR* pbstrUniqueName);
STDMETHOD(GetNodeIDFromUniqueName) (
BSTR bstrUniqueName,
ULONG* pulNodeID);
STDMETHOD(Load) (
IDMPersistenceReader* piReader);
STDMETHOD(Save) (
IDMPersistenceWriter* piWriter);
protected:
void GetModelTreeName (
ULONG in_ulNodeID,
_bstr_t& out_bstrCaption);
void GetCaption (
ULONG in_ulNodeID,
_bstr_t& out_bstrCaption);
void CalcNodeSummary (
ULONG in_ulNodeID,
LONG in_cMaxCharAttrs,
priority_queue<SNBiSummaryScore>& out_pq);
void GetDescription (
ULONG in_ulNodeID,
_bstr_t& out_bstrDescription);
void GetMarginalRule (
ULONG in_ulNodeID,
_bstr_t& out_bstrRule);
void GetRule (
ULONG in_ulNodeID,
_bstr_t& out_bstrRule);
DOUBLE GetProbability (
ULONG in_ulNodeID);
DOUBLE GetMarginalProbability (
ULONG in_ulNodeID);
DOUBLE GetSupport (
ULONG in_ulNodeID);
public:
LONG m_cCase; // count of all cases
IATT m_cPredAtt; // count of predictive attributes
vector<SNBiNodeData> m_vNode; // vector of NodeData
vector<SNBiTree> m_vTree; // vector of trees of predictive attributes
vector<ULONG> m_vPredAttNumber; // vector of attributes numbers of predictive
attributes
};
#endif // __SNaiveBayes_HPP_
151
Apêndice D. Parâmetros do Classificador MSDT
As descrições destes parâmetros foram extraídas da documentação do MSSQL

(MICROSOFT, 20001) e do material publicado no fórum público de debates de DM da
Microsoft® (KIM, 2002).
D.1 COMPLEXITY_PENALTY
Este parâmetro é um número real que pode variar entre 0 e 1 (exclusive), que
atua como um restringente ao crescimento da árvore. A aplicação dele é realizada
em cada divisão adicional da árvore. O valor de 0 significa nenhuma penalidade,
enquanto que o valor próximo de 1 (já que 1 fica fora do intervalo permitido) significa
penalidade máxima e crescimento mínimo da árvore. A aplicação desta penalidade
limita a profundidade e a complexidade das árvores de aprendizado, o que evita
desajustes. Entretanto o uso de valores elevados de penalidade prejudica a
capacidade preditiva do modelo. O efeito deste parâmetro é dependente de cada
modelo, assim experimentos e observações devem ser realizados para obter o melhor
resultado com cada modelo de DM. O valor padrão é baseado no número de
atributos de dados para um dado modelo: para 1 a 9 atributos, o valor é 0,5; para 10
até 99 atributos, o valor é 0,9; para 100 ou mais atributos o valor adotado é 0,99.
D.2 MINIMUM_LEAF_CASES
É um inteiro não negativo que pode variar no intervalo entre 0 e 2.147.483.647.

Ele determina o número mínimo de casos de uma folha necessários para gerar uma
divisão na árvore. Valores baixos ocasionam maiores divisões na árvore de decisão,
mas pode aumentar a probabilidade de desajuste. Valores altos reduzem o número
de divisões na árvore de decisão, mas podem inibir o crescimento da árvore de
decisão. O valor padrão é igual a 10.
D.3 SCORE_METHOD
Identifica o algoritmo utilizado para controlar o crescimento de uma árvore de

decisão. Este algoritmo seleciona os atributos que constituem a árvore, a ordem no
qual estes atributos são usados, o modo pelo qual os valores dos atributos devem ser
divididos e o ponto no qual a árvore deve parar o crescimento. Os valores válidos são:
1, 2, 3, 4, que correspondem aos seguintes algoritmos:
1. Entropia: baseado no ganho de entropia do classificador;
152
2. Ortogonal: método baseado na ortogonalidade da distribuição de estados no
classificador. Este método produz somente divisões binárias resultando em
árvores de grande profundidade;
3. Bayesiano com K2: baseado no escore Bayesiano com K2 a priori;
4. Bayesiano Dirichlet Equivalente com Uniforme a priori: método padrão
(CHICKERING, GEIGER & HECKERMAN, 1994).
D.4 SPLIT_METHOD
Descreve as várias formas que o algoritmo definido pelo parâmetro

SCORE_METHOD deve considerar para dividir valores de atributos. Por exemplo, se um
atributo tem 5 potenciais valores, os valores podem ser divididos em galhos binários
(valor 3 e valores 1, 2, 4, 5) ou os valores podem ser divididos em 5 galhos separados,
ou ainda uma outra combinação qualquer pode ser considerada. O valor 1 para este
parâmetro resulta em árvores de decisão que podem ter apenas galhos binários. O
valor 2 resulta em árvores de decisão com múltiplos galhos, enquanto que o valor 3
(padrão) permite que o algoritmo escolha divisões binárias ou múltiplas de acordo
com o necessário.
153
Apêndice E. Detalhes dos Experimentos Computacionais
São mostrados a seguir os detalhes dos dados e do processamento dos

experimentos tais como: programas geradores, arquivos de scripts SQL para criação
dos bancos de dados, comandos SQL DM para criação dos modelos de DM e para
predição dos dados, utilitários DTS gerenciadores dos processos de importação de
dados e de processamento das tarefas de treinamento e predição de dados.
E.1 Utilitários DTS
Como todos os dados utilizados nos experimentos residem no MSSQL, torna-se

necessária a utilização de utilitários apropriados para o processamento destes
experimentos neste ambiente. A ferramenta indicada para o desenvolvimento destes
utilitários é o DTS.
Figura E.1. Meteo – DTS – Importação de dados
O DTS se constitui em um conjunto de ferramentas gráficas e objetos

programáveis utilizados para transformação de dados no ambiente do MSSQL.
Através de uma interface gráfica, objetos de conexões de dados e de tarefas
são utilizados para montar procedimentos de transformação (transferência e
154
processamento) de dados. esta conexões de dados podem ser de arquivos texto,
dados do MSSQL, arquivos do Microsoft Access®, entre outros. As tarefas podem ser
para transferência de dados da Internet, transformação de dados, execução de
processos externos, execução de comandos SQL, processamento de tarefas de DM,
execução de tarefas de predição de DM e execução de outros utilitários DTS, entre
outras (MICROSOFT, 20001). Os utilitários DTS podem ser executados no ambiente do
gerenciador do MSSQL ou isoladamente através de comandos diretos ou incluídos em
arquivos de comandos. Estes utilitários podem ainda ser programados para ser
executados em horários pré-determinados uma única vez ou em intervalos regulares.
A Figura E.1 mostra a tela do editor de utilitários DTS contendo os objetos
programáveis utilizados para a importação de dados do experimento de Previsão do
Tempo. Esta figura ilustra claramente o fluxo de processamento utilizado para executar
a tarefa, bem como todos os objetos necessários, que serão descritos no item E.3.2.
E.2 Waveform - Reconhecimento de Formas de Onda
Este exemplo é um problema de três classes baseado em formas de onda

lineares denominadas h1(t), h2(t) e h3(t), mostradas pelas Figuras E.2, E.3 e E.4,
conforme descrição original de BREIMAN et alii (1984).
Figura E.2. Forma de onda 1
Cada classe consiste em uma combinação randômica convexa de duas destas

formas de onda, amostrada aos valores inteiros, com adição de distúrbios. Os 21
atributos contínuos são os valores dos vetores de medição (casos). As Figuras E.5, E.6 e
E.7 mostram os três primeiros casos de cada classe extraídos dos 5.000 casos originais
155
existente no repositório de dados da Universidade da Califórnia em Irvine (BLAKE &
MERZ, 1998).
156
Figura E.5. Waveform – Primeiros 3 casos da classe 0
157
E.2.1 Geração de Dados
O dados de treinamento foram gerados pelo programa mostrado pela Listagem
E.1, sendo que os números randômicos foram gerados pelo utilitário probdist de
PERLMAN (1986). Deve ser observado que, apesar de existir uma versão DOS
executável deste utilitário, este deve ser compilado novamente para ficar compatível
com o ambiente onde será utilizado.
Listagem E.1. Waveform - Programa gerador de dados
/*=====================================================================
David Aha
August 1988
Creates Waveform domain data
Usage: create-Waveform number num-attributes
See CART book, page 49 for details
This is for the 21-attribute problem.
Modified by Claudio Luiz Curotto - August 2002

to used with Windows
===================================================================== */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define NUMBER_OF_ARGS 3
#define NUMBER_OF_ATTRIBUTES 21
#define NUMBER_OF_CLASSES 3
void initialize();
void execute();
158
/*==== Inputs ==== */
int num_instances;
unsigned seed;
/*==== Main array of info ====*/

float h[NUMBER_OF_CLASSES][NUMBER_OF_ATTRIBUTES];
int main(argc,argv)
int argc;
char *argv[];
{
if (argc != NUMBER_OF_ARGS)
{
printf("Usage: num-instances seed\n");
return(0);
}
num_instances = atoi(argv[1]);
seed = atoi(argv[2]);
initialize();
execute();
return (1);
}
void initialize()
{
int i,j;
char command[100];
srand(seed);
/*==== Setup for Waveform of types 1 through 3 ====*/

for(i=0; i<3; i++)
for(j=0; j<21; j++)
h[i][j] = 0.0;
/*==== Waveform 1 ====*/

for(i=1; i<=6; i++)
h[0][i] = (float)i;
j=1;
for(i=11; i>=7; i--)
{
h[0][i] = (float)j;
j++;
}
/*==== Waveform 2 ====*/

j = 1;
for(i=9; i<=14; i++)
{
h[1][i] = (float)j;
j++;
}
j=1;
for(i=19; i>=15; i--)
{
h[1][i] = (float)j;
j++;
}
/*==== Waveform 3 ====*/

j = 1;
for(i=5; i<=10; i++)
{
h[2][i] = (float)j;
j++;
}
j=1;
for(i=15; i>=11; i--)
{
h[2][i] = (float)j;
159
j++;
}
/*==== Create the required random values ====*/
sprintf(command,"probdist -s %u ran z %d > g:\\temp\\randnum.txt\n",
seed,num_instances*NUMBER_OF_ATTRIBUTES);
system(command);
}
void execute()
{
int num_instance, num_attribute;
int Waveform_type, choice[2];
FILE *fopen(), *fp;
float random_attribute_value, multiplier[2];
char line[100];
float val[40];
fp = fopen("g:\\temp\\randnum.txt","r");
for(num_instance=0; num_instance<num_instances; num_instance++)
{ /*==== Set up class type ====*/
Waveform_type = (rand() % 3);
switch (Waveform_type)
{
case 0: choice[0] = 0; choice[1] = 1; break;
}
/*==== Set up u and (1-u) for this call ====*/

multiplier[0] = (float)(rand() % 1001)/(float)1000.0;
multiplier[1] = (float)1.0 - multiplier[0];
/*==== Create the instance ====*/

for(num_attribute=0; num_attribute<NUMBER_OF_ATTRIBUTES;
num_attribute++)
{ /*==== Get the base random attribute value ====*/
fgets(line,100,fp);
sscanf(line,"%f",&random_attribute_value);
/*==== Calculate the value ====*/

val[num_attribute] =
(multiplier[0] * h[choice[0]][num_attribute]) +
(multiplier[1] * h[choice[1]][num_attribute]) +
random_attribute_value;
}
/*==== Print the instance to the current output ====*/

if (num_instance > 0) printf ("\n");
printf("%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,"
"%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,"
"%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%d",
val[0], val[1], val[2], val[3], val[4],
val[15], val[16], val[17], val[18], val[19], val[20],
Waveform_type);
}
fclose(fp);
}
As sementes para geração dos números randômicos utilizadas foram 3, 50, 100,
1.000 e 10.000, para gerar respectivamente os 300, 5.000, 10.000, 100.000 e 1.000.000
casos utilizados para treinamento.
160
E.2.2 Criação do Banco de Dados
O banco de dados com todos os objetos pertinentes, tais como tabelas, vistas e
procedimentos armazenados foi criado através de um script mostrado pela Listagem
E.2.
Listagem E.2. Waveform - Script gerador do banco de dados
USE master
GO
CREATE DATABASE Waveform

GO
USE Waveform
GO
CREATE PROC Create_Blocks AS

DECLARE @Block AS integer
SELECT RAND (1)
DECLARE Block_cursor CURSOR FOR
SELECT Block FROM Waveform ORDER BY Class, NumReg
OPEN Block_cursor
FETCH NEXT FROM Block_cursor INTO @Block
WHILE @@FETCH_STATUS = 0
BEGIN
SET @Block = 10 * RAND() + 1
UPDATE Waveform SET Block = @Block WHERE CURRENT OF Block_cursor
END
CLOSE Block_cursor
DEALLOCATE Block_cursor
RETURN
GO
CREATE PROC Create_Data_Views AS

IF EXISTS (SELECT TABLE_NAME FROM INFORMATION_SCHEMA.VIEWS
WHERE TABLE_NAME = 'Train')
DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM Waveform WHERE (Train = 1)')
WHERE TABLE_NAME = 'Test')
DROP VIEW Test
EXEC ('CREATE VIEW Test AS SELECT * FROM Waveform WHERE (Train = 0)')
RETURN
GO
CREATE PROC Create_Data_Views_Block @active_block int AS

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM Waveform ' +
'WHERE (Block <> ' + @active_block + ')')
DROP VIEW Test
EXEC ('CREATE VIEW Test AS SELECT * FROM Waveform ' +
'WHERE (Block = ' + @active_block + ')')
RETURN
GO
CREATE PROC Create_Results_Table @table_name varchar(80) AS

EXEC ('CREATE TABLE ' + @table_name + '(T1_NumReg int NULL, ' +
'T1_Class varchar (1) NULL, Class varchar (1) NULL) ON [PRIMARY]')
RETURN
GO
161
CREATE PROC Create_View_Data_Error @algorithm_name varchar(80),
@data_name varchar(80) AS
EXEC (
'CREATE VIEW ' + @algorithm_name + '_' + @data_name + '_Errors AS ' +
'SELECT ' + @data_name + '.NumReg, ' + @data_name + '.Class, ' +
@algorithm_name + '_' + @data_name +
'_Results.Class AS ClassResult ' +
'FROM ' + @data_name + ' INNER JOIN ' + @algorithm_name + '_' +
@data_name + '_Results ' +
'ON ' + @data_name + '.NumReg = ' + @algorithm_name + '_' +
@data_name + '_Results.T1_NumReg AND ' +
'CAST(' + @data_name + '.Class AS varchar(1)) <> ' +
'CAST(' + @algorithm_name + '_' + @data_name +
'_Results.Class AS varchar(1))')
EXEC (
'CREATE VIEW ' + @algorithm_name + '_' + @data_name +
'_Errors_Count AS ' +
'SELECT ''' + @algorithm_name + ''' AS Algorithm, COUNT(*) AS ' +
@data_name + '_Errors FROM ' +
@algorithm_name + '_' + @data_name + '_Errors')
RETURN
GO
CREATE PROC Create_Views_Tables @algorithm_name varchar(80) AS

-- Results tables are created only to avoid error messages
-- concerning views that use these tables
-- These tables are created by Data Mining Query Tasks
DECLARE @temp as varchar (80)
SELECT @temp = @algorithm_name + '_Train_Results'
EXEC create_results_table @temp
SELECT @temp = @algorithm_name + '_Test_Results'
EXEC create_view_data_error @algorithm_name, 'Train'
EXEC create_view_data_error @algorithm_name, 'Test'
EXEC (
'CREATE VIEW ' + @algorithm_name + '_Errors AS ' +
'SELECT Train_Count.Algorithm, ProcessingTimes.Block, ' +
'Train_Count.Train_Cases, ' +
'ProcessingTimes.Train_Time, ProcessingTimes.Train_Pred_Time, ' +
'CAST(CAST(' + @algorithm_name +
'_Train_Errors_Count.Train_Errors AS float) ' +
'/ CAST(Train_Count.Train_Cases AS float) * 100. AS ' +
'decimal(10, 2)) AS Train_Error, ' +
'CAST((CAST(Train_Count.Train_Cases AS float) ' +
'- CAST(' + @algorithm_name +
'_Train_Errors_Count.Train_Errors AS float)) / ' +
'CAST(Train_Count.Train_Cases AS float) * 100. AS ' +
'decimal(10, 2)) AS Train_Accuracy, ' +
'Test_Count.Test_Cases, ProcessingTimes.Test_Pred_Time, ' +
'_Test_Errors_Count.Test_Errors AS float) / ' +
'CAST(Test_Count.Test_Cases AS float) * 100. AS ' +
'decimal(10, 2)) AS Test_Error, ' +
'CAST((CAST(Test_Count.Test_Cases AS float) ' +
'_Test_Errors_Count.Test_Errors AS float)) / ' +
'decimal(10, 2)) AS Test_Accuracy, ' +
'(ProcessingTimes.Train_Time + ' +
'ProcessingTimes.Train_Pred_Time + ' +
'ProcessingTimes.Test_Pred_Time) AS Total_Time ' +
'FROM Train_Count ' +
'INNER JOIN Test_Count ON Train_Count.Algorithm = ' +
'Test_Count.Algorithm ' +
'INNER JOIN ' + @algorithm_name +
'_Train_Errors_Count ON Train_Count.Algorithm = ' +
@algorithm_name +
'_Train_Errors_Count.Algorithm ' +
'_Test_Errors_Count ON Train_Count.Algorithm = ' +
@algorithm_name +
162
'_Test_Errors_Count.Algorithm ' +
'INNER JOIN ProcessingTimes ON Train_Count.Algorithm = ' +
'ProcessingTimes.Algorithm')
RETURN
GO
CREATE PROC Init_TrainTime @algorithm_name varchar(80),

@active_block int AS
DELETE FROM ProcessingTimes
WHERE Algorithm = @algorithm_name AND Block = @active_block
INSERT ProcessingTimes (Block, Algorithm, Train_Start_Time)
VALUES (@active_block, @algorithm_name, GetDate())
RETURN
GO
CREATE PROC Init_TrainPredTime @algorithm_name varchar(80),

UPDATE ProcessingTimes SET Train_End_Time = GetDate()
UPDATE ProcessingTimes
SET Train_Time = datediff (second, Train_Start_Time, Train_End_Time)
UPDATE ProcessingTimes SET Train_Pred_Start_Time = GetDate()
RETURN
GO
CREATE PROC Init_TestPredTime @algorithm_name varchar(80),

UPDATE ProcessingTimes SET Train_Pred_End_Time = GetDate()
SET Train_Pred_Time = datediff (second, Train_Pred_Start_Time,
Train_Pred_End_Time)
UPDATE ProcessingTimes SET Test_Pred_Start_Time= GetDate()
RETURN
GO
CREATE PROC End_TestPredTime @algorithm_name varchar(80),

UPDATE ProcessingTimes SET Test_Pred_End_Time = GetDate()
SET Test_Pred_Time = datediff (second, Test_Pred_Start_Time,
Test_Pred_End_Time)
RETURN
GO
CREATE TABLE Waveform (

NumReg int PRIMARY KEY NOT NULL,
X1 real NULL, X2 real NULL, X3 real NULL, X4 real NULL,
X21 real NULL, Class varchar (1) NULL, Train bit NOT NULL,
Block int NOT NULL
) ON [PRIMARY]
GO
CREATE TABLE ProcessingTimes (

Algorithm char (10) NULL, Block int NULL,
Train_Start_Time datetime NULL, Train_End_Time datetime NULL,
Train_Pred_Start_Time datetime NULL, Train_Pred_End_Time datetime NULL,
Test_Pred_Start_Time datetime NULL, Test_Pred_End_Time datetime NULL,
Train_Time float NULL, Train_Pred_Time float NULL,
Test_Pred_Time float NULL, Model_Size int NULL
) ON [PRIMARY]
163
GO
CREATE TABLE Results (

Train_Cases int NULL, Train_Time float NULL, Train_Pred_Time float NULL,
Train_Error float NULL, Train_Accuracy float NULL,
Test_Cases int NULL, Test_Pred_Time float NULL,
Test_Error float NULL, Test_Accuracy float NULL,
Total_Time float NULL
) ON [PRIMARY]
GO
EXEC Create_Data_Views
GO
CREATE VIEW All_Count AS

SELECT COUNT(*) AS All_Cases FROM Waveform
GO
CREATE VIEW Class_Train_Statistics AS

SELECT TOP 100 PERCENT Class, COUNT(Class) AS Count_Classes, Train
FROM Waveform GROUP BY Class, Train ORDER BY Class
GO
CREATE VIEW Train_Count AS

SELECT 'MSDT1' AS Algorithm, COUNT(*) AS Train_Cases FROM Train UNION
SELECT 'MSDT2d' AS Algorithm, COUNT(*) AS Train_Cases FROM Train UNION
SELECT 'SNBi' AS Algorithm, COUNT(*) AS Train_Cases FROM Train UNION
SELECT 'SNBid' AS Algorithm, COUNT(*) AS Train_Cases FROM Train
GO
CREATE VIEW Test_Count AS

SELECT 'MSDT1' AS Algorithm, COUNT(*) AS Test_Cases FROM Test UNION
SELECT 'MSDT2d' AS Algorithm, COUNT(*) AS Test_Cases FROM Test UNION
SELECT 'SNBi' AS Algorithm, COUNT(*) AS Test_Cases FROM Test UNION
SELECT 'SNBid' AS Algorithm, COUNT(*) AS Test_Cases FROM Test
GO
EXEC Create_Views_Tables 'MSDT1'

GO
EXEC Create_Views_Tables 'MSDT2'

GO
EXEC Create_Views_Tables 'MSDT2d'

GO
EXEC Create_Views_Tables 'SNBi'

GO
EXEC Create_Views_Tables 'SNBid'

GO
CREATE VIEW Resume AS

SELECT Algorithm, COUNT(Block) AS Num_Blocks,
AVG(Train_Cases) AS Mean_Train_Cases,
SUM(Train_Time) AS [Total_Train_Time (s)],
SUM(Train_Pred_Time) AS [Total_Train_Pred_Time (s)],
CAST (AVG(Train_Error) AS decimal(10, 2)) AS [Mean_Train_Error (%)],
CAST (STDEV(Train_Error) AS decimal(10, 2)) AS
[StdDev_Train_Error (%)],
CAST (AVG(Train_Accuracy) AS decimal(10, 2)) AS
[Mean_Train_Accuracy (%)],
AVG(Test_Cases)AS Mean_Test_Cases, SUM(Test_Pred_Time) AS
[Total_Test_Pred_Time (s)],
CAST (AVG(Test_Error) AS decimal(10, 2)) AS [Mean_Test_Error (%)],
CAST (STDEV(Test_Error) AS decimal(10, 2)) AS
[StdDev_Test_Error (%)],
CAST (AVG(Test_Accuracy) AS decimal(10, 2)) AS
164
[Mean_Test_Accuracy (%)],
SUM(Total_Time) AS [Total_Time (s)]
FROM Results
GROUP BY Algorithm
GO
CREATE VIEW Count_Cases_Block AS

SELECT TOP 100 PERCENT COUNT(Block) AS Count_Cases, Block
FROM Waveform GROUP BY Block ORDER BY Block
GO
CREATE VIEW Class_Block_Statistics AS

SELECT TOP 100 PERCENT Class, COUNT(Class) AS Count_Classes, Block
FROM Waveform GROUP BY Class, Block ORDER BY Block, Class
GO
CREATE VIEW Train_Test_Count AS

SELECT Train, COUNT(Train) AS [Count],
CAST(CAST(COUNT(Train) AS float) /
(SELECT All_Cases FROM All_Count) * 100 AS decimal(5, 2)) AS
[Percent] FROM Waveform GROUP BY Train
GO
E.2.3 Utilitários DTS
Este experimento emprega uma série de utilitários DTS para: importação de

dados, processamento das tarefas de treinamento e predição e processamento do
procedimento de validação cruzada, os quais serão descritos no decorrer deste item.
Figura E.8. Waveform – Processamento completo do primeiro procedimento
165
O primeiro procedimento do experimento foi realizado para cinco grupos de
dados, sendo que o processamento completo para cada conjunto de dados foi
executado através do utilitário DTS mostrado pela Figura E.8. Esta figura mostra todos
os objetos programáveis que compõem o utilitário, sendo que os mais importantes
serão detalhados. Deve ser observada a existência de duas tarefas de execução de
comandos simples, c45exe.bat e wekaNaive.bat, correspondentes à execução do
processamento dos classificadores C45 e WEKA.

A Figura E.9 mostra o fluxo de importação de dados deste experimento, onde
pode ser observada a existência de duas massas de dados distintas, de treinamento e
de teste. Estes dados são acessados através de dois objetos de conexão de dados
para arquivos texto, denominados Train Data, que permite a leitura dos dados de
treinamento e Test Data, que possibilita a leitura dos dados de teste . Esta figura mostra
ainda a existência de um objeto duplo de conexão de dados, denominado Waveform,
que permite o acesso, através do provedor SQLOLEDB, aos dados armazenados no

MSSQL.
Figura E.9. Waveform – Importação de dados
Inicialmente os dados pré-existentes no MSSQL são removidos através de um

comando SQL contido na tarefa de execução de comandos SQL:
DELETE FROM Waveform
Em seguida uma tarefa de execução de scripts, composta por comandos Visual

Basic®, inicializa o contador de registros, conforme mostra o código fonte da Listagem
E.3.
Listagem E.3. Script de inicialização do contador de registros
Function Main()
DTSGlobalVariables("NumReg").Value = 0
Main = DTSTaskExecResult_Success
End Function
166
No passo seguinte os dados de treinamento do arquivo texto são armazenados
no MSSQL através de uma tarefa de transformação de dados definida por um outro
script Visual Basic® mostrado pela Listagem E.4. Uma tarefa semelhante se encarrega
de transferir os dados de teste.
Listagem E.4. Waveform - Importação de dados do arquivo texto
Function Main()
dim i, NumReg
NumReg = CLng( DTSGlobalVariables("NumReg").Value)

NumReg = NumReg + 1
DTSGlobalVariables("NumReg").Value = NumReg
DTSDestination("NumReg") = NumReg
DTSDestination("Train") = 1
DTSDestination("Block") = 1
for i = 1 to 21
DTSDestination("X" + CStr(i)) = DTSSource("Col" + Right (CStr(1000+i),3))
next
DTSDestination("Class") = DTSSource("Col022")
Main = DTSTransformStat_OK
End Function
A Figura E.10 mostra o fluxo de processamento das tarefas de treinamento e

predição do classificador MSDT1. Deve ser observada a existência das tarefas de
controle do tempo de execução, realizadas através de chamadas de procedimentos
armazenados definidos na Listagem E.2. O fluxo de processamento dos demais
classificadores utilizados é semelhante a este.
Figura E.10. Waveform – Processamento do treinamento e predição do classificador MSDT1
O procedimento de validação cruzada possui um fluxo de processamento

próprio, mostrado pela Figura E.11. Por outro lado a Figura E.12 mostra o fluxo de
processamento da importação dos dados em blocos. A transferência de dados é
realizada por um script de comandos Visual Basic® semelhante aquela mostrada pela
Listagem E.4, enquanto que o procedimento armazenado de criação dos blocos,
denominado Create_Blocks, invocado pela tarefa de execução de comandos SQL
Create Blocks, pode ser visto na Listagem E.2.
167
Figura E.11. Waveform – Processamento da validação cruzada
Todas as tarefas compreendidas entre as tarefas Create Views e Inc ActiveBlock
são repetidas N vezes, com N=10, sendo o controle desta repetição efetuado pela
tarefa Inc ActiveBlock conforme mostra o script da Listagem E.5.
Figura E.12. Waveform – Importação de dados em blocos
Listagem E.5. Waveform - Script de repetição das tarefas da validação cruzada
Function Main()
If DTSGlobalVariables("active_block").Value <
DTSGlobalVariables("num_blocks").Value Then
DTSGlobalVariables("active_block").Value =
DTSGlobalVariables("active_block").Value + 1
Set oPkg = DTSGlobalVariables.Parent
'Set previous step status to waiting.
oPkg.Steps("DTSStep_DTSExecuteSQLTask_1").ExecutionStatus =
DTSStepExecStat_Waiting
End If
End Function
E.2.4 Comandos SQL DM
Os comandos SQL DM utilizados para a criação dos modelos de DM dos diversos

classificadores são mostrados na Tabela E.1. Por sua vez a Listagem E.6 mostra o
comando SQL DM necessário para efetuar a predição dos dados de teste do
classificador SNBi. Os comandos respectivos dos demais classificadores são
168
semelhantes. As repetições extensas de itens nestes comandos são omitidas e
representadas por três pontos consecutivos (...).
Tabela E.1. Waveform - Comandos SQL DM para criação do modelo de DM
Classificador Comando
SNBi CREATE MINING MODEL [Waveform_SNBi] ([NumReg] LONG KEY, [X1] DOUBLE
CONTINUOUS, [X2] DOUBLE CONTINUOUS, ..., [X21] DOUBLE CONTINUOUS,
[Class] TEXT DISCRETE PREDICT_ONLY) USING Simple_Naive_Bayes
SNBid CREATE MINING MODEL [Waveform_SNBid] ([NumReg] LONG KEY, [X1] DOUBLE
DISCRETIZED, [X2] DOUBLE DISCRETIZED, ..., [X21] DOUBLE DISCRETIZED,
MSDT1 CREATE MINING MODEL [Waveform_MSDT1] ([NumReg] LONG KEY, [X1] DOUBLE
[Class] TEXT DISCRETE PREDICT_ONLY) USING Microsoft_Decision_Trees
(COMPLEXITY_PENALTY = 0.9, MINIMUM_LEAF_CASES = 10, SCORE_METHOD = 4,
SPLIT_METHOD = 3)
MSDT2 CREATE MINING MODEL [Waveform_MSDT2] ([NumReg] LONG KEY, [X1] DOUBLE
(COMPLEXITY_PENALTY=0, MINIMUM_LEAF_CASES=1, SCORE_METHOD=4,
SPLIT_METHOD=2)
MSDT2d CREATE MINING MODEL [Waveform_MSDT2d] ([NumReg] LONG KEY, [X1] DOUBLE
DISCRETIZED, [X2] DOUBLE DISCRETIZED, ..., [X21] DOUBLE DISCRETIZED,
(COMPLEXITY_PENALTY=0, MINIMUM_LEAF_CASES=1, SCORE_METHOD=4,
SPLIT_METHOD=2)
Listagem E.6. Waveform - Comando SQL DM para predição dos dados de teste, classificador SNBi
SELECT FLATTENED [T1].[NumReg], [T1].[X1], [T1].[X2], ... [T1].[X21],

[Waveform_SNBi].[Class] as Class
FROM [Waveform_SNBi] PREDICTION JOIN
OPENROWSET ('SQLOLEDB.1', 'Provider=SQLOLEDB.1;Integrated Security=SSPI;
Persist Security Info=False;Initial Catalog=Waveform;Data Source=CLC',
'SELECT "NumReg", "X1", "X2", ..., "X21" FROM "Test" ORDER BY "NumReg"') AS [T1]
ON
[Waveform_SNBi].[NumReg] = [T1].[NumReg] AND
[Waveform_SNBi].[X1] = [T1].[X1] AND
[Waveform_SNBi].[X2] = [T1].[X2] AND
... AND
[Waveform_SNBi].[X21] = [T1].[X21]
E.3 Meteo - Previsão de Tempo
A Tabela E.2 mostra a descrição dos atributos meteorológicos do conjunto de

dados utilizado neste problema, de acordo com o trabalho de COSTA (1999). Além
destes atributos, mais um foi utilizado para identificar unicamente cada caso,
conforme exigência dos classificadores implementados como provedores de recursos
de DM.
169
O atributo de predição do estado atual do tempo (Class) poderia assumir
originalmente valores de 0 a 9, indicando as seguintes situações: nada a relatar (0);

precipitação à vista (1); névoa seca ou fumaça (2); areia ou poeira (3); névoa úmida
ou nevoeiro (4); chuvisco (5); chuva (6); neve (7); trovoada ou relâmpago (8); e,
granizo (9). Após a preparação dos dados este atributo passou a ter 7 possíveis valores
com a exclusão do valor 9, que ocorreu em um único caso e dos valores 3 e 7 que não
tiveram nenhuma ocorrência.
Tabela E.2. Meteo - Descrição dos atributos dos dados meteorológicos
Nome Tipo Valores Descrição

distintos
Date_Year inteiro 10 Ano
Date_Month inteiro 12 Mês

Data da coleta dos dados
Date_Day inteiro 31 Dia
Date_Hour inteiro 24 Hora
Tot_Cloud inteiro 7 Total de nuvens - observação do aspecto da

nebulosidade
Wind_Dir inteiro 37 Direção (graus)

Vento de superfície
Wind_Vel inteiro 17 Velocidade (nós)
Hor_Vis inteiro 53 Visibilidade horizontal (metros)
Cloud1_Qty inteiro 7 Quantidade

Observação de nuvens da
Cloud1_Typ inteiro 6 Tipo primeira altura
Cloud1_Alt inteiro 59 Altitude (m)
Cloud2_Qty inteiro 8 Quantidade

Observação de nuvens da
Cloud2_Typ inteiro 8 Tipo segunda altura
Cloud2_Alt inteiro 61 Altitude (m)
Altimeter inteiro 246 Ajuste do altímetro (milibares)
Dew_Point inteiro 11 Ponto de orvalho

Temperatura (graus
Dry_Temp inteiro 189 Ar – Bulbo seco centígrados)
Moist_Temp inteiro 118 Ar – Bulbo úmido
Class texto(1) 7 Estado atual do tempo
A Listagem E.7 mostra o script gerador do banco de dados com todos os objetos
pertinentes, tais como tabelas, vistas e procedimentos armazenados.
170
Listagem E.7. Meteo - Script gerador do banco de dados
USE master
GO
CREATE DATABASE Meteo

GO
USE Meteo
GO

SELECT RAND (1)
SELECT Block FROM Meteo ORDER BY Class, NumReg
OPEN Block_cursor
BEGIN
UPDATE Meteo SET Block = @Block WHERE CURRENT OF Block_cursor
END
CLOSE Block_cursor
RETURN
GO
CREATE PROC Create_Test_Data AS

DECLARE @Train AS bit
DECLARE @i AS integer
SELECT RAND (1)
DECLARE Train_cursor CURSOR FOR
SELECT Train FROM Meteo ORDER BY Class
OPEN Train_cursor
FETCH NEXT FROM Train_cursor INTO @Train
BEGIN
SET @i = 100 * RAND()
-- select 30 % of cases to test set
IF @i <= 30
UPDATE Meteo SET Train = 0 WHERE CURRENT OF Train_cursor
END
CLOSE Train_cursor
DEALLOCATE Train_cursor
RETURN
GO
CREATE PROC create_data_views AS

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM Meteo WHERE (Train = 1)')
DROP VIEW Test
EXEC ('CREATE VIEW Test AS SELECT * FROM Meteo WHERE (Train = 0)')
RETURN
GO
CREATE PROC create_data_views_block @active_block int AS

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM Meteo ' +
'WHERE (Block <> ' + @active_block + ')')
171
DROP VIEW Test
EXEC ('CREATE VIEW Test AS SELECT * FROM Meteo ' +
'WHERE (Block = ' + @active_block + ')')
RETURN
GO
CREATE PROC create_results_table @table_name varchar(80) AS

EXEC ('CREATE TABLE ' + @table_name +
'(T1_NumReg int NULL, T1_Class varchar (1) NULL, ' +
'Class varchar (1) NULL) ON [PRIMARY]')
RETURN
GO
CREATE PROC create_view_data_error @algorithm_name varchar(80),

EXEC (
'FROM ' + @data_name + ' INNER JOIN ' + @algorithm_name + '_' +
@data_name + '_Results ' +
EXEC (
@data_name + '_Errors FROM ' +
@algorithm_name + '_' + @data_name + '_Errors')
RETURN
GO
CREATE PROC create_views_tables @algorithm_name varchar(80) AS

EXEC (
172
'CAST(Test_Count.Test_Cases AS float) * 100. ' +
'AS decimal(10, 2)) AS Test_Accuracy, ' +
'(ProcessingTimes.Train_Time + ProcessingTimes.Train_Pred_Time' +
' + ProcessingTimes.Test_Pred_Time) AS Total_Time ' +
@algorithm_name + '_Train_Errors_Count.Algorithm ' +
@algorithm_name + '_Test_Errors_Count.Algorithm ' +
RETURN
GO

EXEC (
'DELETE FROM ProcessingTimes WHERE Algorithm = ''' + @algorithm_name +
''' AND Block = ' + @active_block)
EXEC (
'INSERT ProcessingTimes (Block, Algorithm, Train_Start_Time) ' +
'VALUES (' + @active_block + ',''' +
@algorithm_name + ''', GetDate())')
RETURN
GO

EXEC (
'UPDATE ProcessingTimes SET Train_End_Time = GetDate() ' +
'WHERE Algorithm = ''' +
@algorithm_name + ''' AND Block = ' + @active_block)
EXEC (
'UPDATE ProcessingTimes SET ' +
'Train_Time = datediff (second, Train_Start_Time, Train_End_Time) ' +
'WHERE Algorithm = ''' + @algorithm_name + ''' AND Block = ' +
@active_block)
EXEC (
'UPDATE ProcessingTimes SET Train_Pred_Start_Time = GetDate() ' +
'WHERE Algorithm = ''' +
RETURN
GO

EXEC (
'UPDATE ProcessingTimes SET Train_Pred_End_Time = GetDate() ' +
'WHERE Algorithm = ''' + @algorithm_name +
EXEC (
'UPDATE ProcessingTimes SET Train_Pred_Time = ' +
'datediff (second, Train_Pred_Start_Time, ' +
'Train_Pred_End_Time) WHERE Algorithm = ''' +
EXEC (
'UPDATE ProcessingTimes SET Test_Pred_Start_Time= GetDate() ' +
RETURN
GO

EXEC (
'UPDATE ProcessingTimes SET Test_Pred_End_Time = GetDate() ' +
173
EXEC (
'UPDATE ProcessingTimes SET Test_Pred_Time = ' +
'datediff (second, Test_Pred_Start_Time, Test_Pred_End_Time) ' +
RETURN
GO
CREATE PROC assemble_attribute_statistics AS

DECLARE @Attribute_Name varchar (80)
DECLARE column_cursor CURSOR READ_ONLY FOR
SELECT column_name FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_NAME = 'Meteo'
OPEN column_cursor
FETCH NEXT FROM column_cursor INTO @Attribute_Name
BEGIN
EXEC (
'INSERT INTO Attribute_Statistics SELECT ''' +
@Attribute_Name + ''' AS Attribute_Name, ' +
'COUNT(*) AS Attribute_Count ' +
'FROM (SELECT ' + @Attribute_Name +
' FROM Meteo GROUP BY ' + @Attribute_Name + ') DERIVEDTBL')
END
CLOSE column_cursor
DEALLOCATE column_cursor
RETURN
GO
CREATE TABLE Meteo (

Date_Year int NULL, Date_Month int NULL, Date_Day int NULL,
Date_Hour int NULL, Tot_Cloud int NULL,
Wind_Dir int NULL, Wind_Vel int NULL, Hor_Vis int NULL,
Cloud1_Qty int NULL, Cloud1_Typ int NULL, Cloud1_Alt int NULL,
Cloud2_Qty int NULL, Cloud2_Typ int NULL, Cloud2_Alt int NULL,
Altimeter int NULL, Dew_Point int NULL, Dry_Temp int NULL,
Moist_Temp int NULL, Class varchar (1) NULL, Train bit NOT NULL,
Block int NOT NULL
) ON [PRIMARY]
GO

Test_Pred_Time float NULL
) ON [PRIMARY]
GO

) ON [PRIMARY]
GO
CREATE TABLE Attribute_Statistics (

Attribute_Name varchar (30),
Attribute_Count int NULL
) ON [PRIMARY]
GO
EXEC create_data_views
174
GO

SELECT COUNT(*) AS All_Cases FROM Meteo
GO

FROM Meteo GROUP BY Class, Train ORDER BY Class, Train
GO

SELECT 'SNBi1' AS Algorithm, COUNT(*) AS Train_Cases FROM Train UNION
SELECT 'SNBi2' AS Algorithm, COUNT(*) AS Train_Cases FROM Train
GO

SELECT 'SNBi1' AS Algorithm, COUNT(*) AS Test_Cases FROM Test UNION
SELECT 'SNBi2' AS Algorithm, COUNT(*) AS Test_Cases FROM Test
GO
EXEC create_views_tables 'MSDT1'

GO

GO
EXEC create_views_tables 'SNBi1'

GO
EXEC create_views_tables 'SNBi2'

GO

CAST (AVG(Train_Error) AS decimal(10, 2)) AS
[Mean_Train_Error (%)],
AVG(Test_Cases)AS Mean_Test_Cases, SUM(Test_Pred_Time) AS
[Total_Test_Pred_Time (s)],
FROM Results
GROUP BY Algorithm
GO

FROM Meteo GROUP BY Block ORDER BY Block
GO

FROM Meteo GROUP BY Class, Block ORDER BY Block, Class
GO
CREATE VIEW cAttribute_Statistics AS
175
SELECT TOP 100 PERCENT Attribute_Name, Attribute_Count
FROM Attribute_Statistics ORDER BY Attribute_Count, Attribute_Name
GO

SELECT Train, COUNT(Train) AS Count,
(SELECT All_Cases FROM All_Count) * 100 AS decimal(5, 2))
AS [Percent]
FROM Meteo GROUP BY Train
GO
Figura E.13. Meteo – Processamento completo do primeiro procedimento
Figura E.14. Meteo – DTS – Importação de dados
Assim como o experimento anterior, este também possui utilitários DTS para o
processamento de suas tarefas.
176
O primeiro procedimento deste experimento utiliza a massa de dados separada
em duas partes, sendo que uma foi utilizada para treinamento e outra para testar o
modelo gerado por este treinamento. A Figura E.13 mostra o fluxo de processamento
com os objetos programáveis utilizados.
A Figura E.14 ilustra os objetos componentes do processamento de importação
de dados. Existe um objeto duplo de conexão de dados, denominado Meteo, que
permite o acesso, através do provedor SQLOLEDB, aos dados armazenados no MSSQL.

Existem três objetos de conexão de dados para arquivos texto, denominados
All Data, que permite a leitura dos dados texto originais; Train Data, que permite a
gravação dos dados texto dos dados de treinamento e Test Data que possibilita a
gravação dos dados texto dos dados de teste. Estes dados no formato texto são
utilizados pelo classificador C45.
Inicialmente os dados pré-existentes no MSSQL são removidos através de um
comando SQL contido na tarefa de execução de comandos SQL:
DELETE FROM Meteo
Em seguida uma tarefa de execução de scripts, composta por comandos Visual

Basic®, inicializa o contador de registros, conforme mostra o código fonte da Listagem
E.3 do experimento anterior.
No passo seguinte os dados do arquivo texto original são armazenados no
MSSQL através de uma tarefa de transformação de dados definida por um outro script
Visual Basic® conforme mostra a Listagem E.8.
Após o armazenamento dos dados, estes são divididos em duas partes, através
do campo Train, pela tarefa de execução de um procedimento armazenado,
Create_Test_Data, mostrado na Listagem E.7 e invocado pela tarefa Create Test Data.
Listagem E.8. Meteo - Importação de dados do arquivo texto
Function Main()
dim NumReg
NumReg = CLng( DTSGlobalVariables("NumReg").Value)
NumReg = NumReg + 1
DTSGlobalVariables("NumReg").Value = NumReg
DTSDestination("NumReg") = NumReg
DTSDestination("Date_Year") = DTSSource("Col001")
DTSDestination("Date_Month") = DTSSource("Col002")
DTSDestination("Date_Day") = DTSSource("Col003")
DTSDestination("Date_Hour") = DTSSource("Col004")
DTSDestination("Tot_Cloud") = DTSSource("Col005")
DTSDestination("Wind_Dir") = DTSSource("Col006")
DTSDestination("Wind_Vel") = DTSSource("Col007")
DTSDestination("Hor_Vis") = DTSSource("Col008")
DTSDestination("Cloud1_Qty") = DTSSource("Col009")
DTSDestination("Cloud1_Typ") = DTSSource("Col010")
DTSDestination("Cloud1_Alt") = DTSSource("Col011")
DTSDestination("Cloud2_Qty") = DTSSource("Col012")
DTSDestination("Cloud2_Typ") = DTSSource("Col013")
177
DTSDestination("Cloud2_Alt") = DTSSource("Col014")
DTSDestination("Altimeter") = DTSSource("Col015")
DTSDestination("Dew_Point") = DTSSource("Col016")
DTSDestination("Dry_Temp") = DTSSource("Col017")
DTSDestination("Moist_Temp") = DTSSource("Col018")
DTSDestination("Class") = DTSSource("Col019")
DTSDestination("Train") = 1 ' train set
DTSDestination("Block") = 1
Main = DTSTransformStat_OK
End Function
Por fim, através de duas tarefas simples de transferência de dados os dados de

treinamento e de teste são armazenados em arquivos texto. Estas tarefas simplesmente
utilizam dois comandos SQL distintos como fonte de dados, conforme pode ser visto
nas duas linhas seguintes:
SELECT * FROM Meteo WHERE Train=1 -- dados de treinamento
SELECT * FROM Meteo WHERE Train=0 -- dados de teste
O fluxo de processamento das tarefas de treinamento e predição dos

classificadores utilizados é semelhante aquela mostrada no experimento anterior pela
Figura E.10.
Também os utilitários empregados no procedimento da validação cruzada são
semelhantes àqueles mostrados no experimento anterior.
Os comandos SQL DM utilizados para a criação dos modelos de DM dos diversos

classificadores são mostrados na Tabela E.3. Por sua vez a Listagem E.9 mostra o
comando SQL DM necessário para efetuar a predição dos dados de teste do
classificador SNBi1. Os comandos respectivos dos demais classificadores são
semelhantes.
Tabela E.3. Meteo - Comandos SQL DM para criação do modelo de DM
SNBi1 CREATE MINING MODEL [Meteo_SNBi1] ([NumReg] LONG KEY, [Date_Year] LONG
CONTINUOUS, [Date_Month] LONG CONTINUOUS, [Date_Day] LONG CONTINUOUS,
[Date_Hour] LONG CONTINUOUS, [Tot_Cloud] LONG CONTINUOUS, [Wind_Dir]
LONG CONTINUOUS, [Wind_Vel] LONG CONTINUOUS, [Hor_Vis] LONG CONTINUOUS,
[Cloud1_Qty] LONG CONTINUOUS, [Cloud1_Typ] LONG CONTINUOUS, [Cloud1_Alt]
LONG CONTINUOUS, [Cloud2_Qty] LONG CONTINUOUS, [Cloud2_Typ] LONG
CONTINUOUS, [Cloud2_Alt] LONG CONTINUOUS, [Altimeter] LONG CONTINUOUS,
[Dew_Point] LONG CONTINUOUS, [Dry_Temp] LONG CONTINUOUS, [Moist_Temp]
LONG CONTINUOUS, [Class] TEXT DISCRETE PREDICT_ONLY) USING
Simple_Naive_Bayes
178
SNBi2 CREATE MINING MODEL [Meteo_SNBi2] ([NumReg] LONG KEY, [Date_Year] LONG
CONTINUOUS, [Date_Month] LONG DISCRETE, [Date_Day] LONG DISCRETE,
[Date_Hour] LONG DISCRETE, [Tot_Cloud] LONG DISCRETE, [Wind_Dir] LONG
DISCRETE, [Wind_Vel] LONG DISCRETE, [Hor_Vis] LONG CONTINUOUS,
[Cloud1_Qty] LONG DISCRETE, [Cloud1_Typ] LONG DISCRETE, [Cloud1_Alt]
LONG CONTINUOUS, [Cloud2_Qty] LONG DISCRETE, [Cloud2_Typ] LONG DISCRETE,
[Cloud2_Alt] LONG CONTINUOUS, [Altimeter] LONG CONTINUOUS, [Dew_Point]
LONG DISCRETE, [Dry_Temp] LONG CONTINUOUS, [Moist_Temp] LONG CONTINUOUS,
MSDT1 CREATE MINING MODEL [Meteo_MSDT1] ([NumReg] LONG KEY , [Date_Year] LONG
CONTINUOUS, [Date_Month] LONG CONTINUOUS, [Date_Day] LONG CONTINUOUS,
[Date_Hour] LONG CONTINUOUS, [Tot_Cloud] LONG CONTINUOUS, [Wind_Dir]
LONG CONTINUOUS, [Wind_Vel] LONG CONTINUOUS, [Hor_Vis] LONG CONTINUOUS,
[Cloud1_Qty] LONG CONTINUOUS, [Cloud1_Typ] LONG CONTINUOUS, [Cloud1_Alt]
LONG CONTINUOUS, [Cloud2_Qty] LONG CONTINUOUS, [Cloud2_Typ] LONG
CONTINUOUS, [Cloud2_Alt] LONG CONTINUOUS, [Altimeter] LONG CONTINUOUS,
[Dew_Point] LONG CONTINUOUS, [Dry_Temp] LONG CONTINUOUS, [Moist_Temp]
LONG CONTINUOUS, [Class] TEXT DISCRETE PREDICT_ONLY) USING
Microsoft_Decision_Trees
MSDT2 CREATE MINING MODEL [Meteo_MSDT2] ([NumReg] LONG KEY, [Date_Year] LONG
CONTINUOUS, [Date_Month] LONG DISCRETE, [Date_Day] LONG DISCRETE,
[Date_Hour] LONG DISCRETE, [Tot_Cloud] LONG DISCRETE, [Wind_Dir] LONG
DISCRETE, [Wind_Vel] LONG DISCRETE, [Hor_Vis] LONG CONTINUOUS,
[Cloud1_Qty] LONG DISCRETE, [Cloud1_Typ] LONG DISCRETE, [Cloud1_Alt]
LONG CONTINUOUS, [Cloud2_Qty] LONG DISCRETE, [Cloud2_Typ] LONG
DISCRETE, [Cloud2_Alt] LONG CONTINUOUS, [Altimeter] LONG CONTINUOUS,
[Dew_Point] LONG DISCRETE, [Dry_Temp] LONG CONTINUOUS, [Moist_Temp] LONG
CONTINUOUS, [Class] TEXT DISCRETE PREDICT_ONLY) USING
Microsoft_Decision_Trees
Listagem E.9. Meteo - Comando SQL DM para predição dos dados de teste, classificador SNBi1
SELECT FLATTENED [T1].[NumReg], [T1].[Date_Year], [T1].[Date_Month], [T1].[Date_Day],

[T1].[Date_Hour], [T1].[Tot_Cloud], [T1].[Wind_Dir], [T1].[Wind_Vel],
[T1].[Hor_Vis], [T1].[Cloud1_Qty], [T1].[Cloud1_Typ], [T1].[Cloud1_Alt],
[T1].[Cloud2_Qty], [T1].[Cloud2_Typ], [T1].[Cloud2_Alt], [T1].[Altimeter],
[T1].[Dew_Point], [T1].[Dry_Temp], [T1].[Moist_Temp], [T1].[Class],
[Meteo_SNBi1].[Class] as Class
FROM [Meteo_SNBi1] PREDICTION JOIN
Persist Security Info=False;Initial Catalog=Meteo;Data Source=CLC',
'SELECT "NumReg", "Date_Year", "Date_Month", "Date_Day", "Date_Hour", "Tot_Cloud",
"Wind_Dir", "Wind_Vel", "Hor_Vis", "Cloud1_Qty", "Cloud1_Typ", "Cloud1_Alt",
"Cloud2_Qty", "Cloud2_Typ", "Cloud2_Alt", "Altimeter", "Dew_Point", "Dry_Temp",
"Moist_Temp", "Class" FROM "Test" ORDER BY "NumReg"') AS [T1]
ON
[Meteo_SNBi1].[NumReg] = [T1].[NumReg] AND [Meteo_SNBi1].[Date_Year] =
[T1].[Date_Year] AND [Meteo_SNBi1].[Date_Month] = [T1].[Date_Month] AND
[Meteo_SNBi1].[Date_Day] = [T1].[Date_Day] AND [Meteo_SNBi1].[Date_Hour] =
[T1].[Date_Hour] AND [Meteo_SNBi1].[Tot_Cloud] = [T1].[Tot_Cloud] AND
[Meteo_SNBi1].[Wind_Dir] = [T1].[Wind_Dir] AND [Meteo_SNBi1].[Wind_Vel] =
[T1].[Wind_Vel] AND [Meteo_SNBi1].[Hor_Vis] = [T1].[Hor_Vis] AND
[Meteo_SNBi1].[Cloud1_Qty] = [T1].[Cloud1_Qty] AND [Meteo_SNBi1].[Cloud1_Typ] =
[T1].[Cloud1_Typ] AND [Meteo_SNBi1].[Cloud1_Alt] = [T1].[Cloud1_Alt] AND
[Meteo_SNBi1].[Cloud2_Qty] = [T1].[Cloud2_Qty] AND [Meteo_SNBi1].[Cloud2_Typ] =
[T1].[Cloud2_Typ] AND [Meteo_SNBi1].[Cloud2_Alt] = [T1].[Cloud2_Alt] AND
[Meteo_SNBi1].[Altimeter] = [T1].[Altimeter] AND [Meteo_SNBi1].[Dew_Point] =
[T1].[Dew_Point] AND [Meteo_SNBi1].[Dry_Temp] = [T1].[Dry_Temp] AND
[Meteo_SNBi1].[Moist_Temp] = [T1].[Moist_Temp]
179
E.4 Insurance - Dados de Seguro de Vida
A Figura E.15 mostra os relacionamentos existentes entre as 10 tabelas originais

distribuídas para a competição KDD Sisyphus I (KIETZ & STAUDT, 1998). A Tabela E.4
mostra a descrição de todos os atributos destas tabelas originais, indicando os
atributos utilizados para cada parte do experimento.
Os arquivos disponibilizados pela companhia descrevem o relacionamento entre
clientes, contratos de seguro e componentes de tarifa. A tabela part contém todos os
clientes, ou parceiros como são chamados. As tabelas eadr e padr contêm
respectivamente os endereços eletrônicos (fax, telefone, etc.) e os endereços postais

dos parceiros. Os dados sobre as unidades familiares em que os parceiros moram são
armazenados na tabela hhold. Os parceiros realizam transações, registradas pela
tabela parrol, adquirindo apólices de seguro, contidas na tabela vvert. Quando o
parceiro é a pessoa segurada da apólice a tabela tfrol registra algumas propriedades
adicionais desta apólice. Uma apólice de seguro pode ter vários componentes de
tarifa (por exemplo a parte principal mais um componente por assegurar o caso em
que o segurado fica inválido), cada um dos quais registrados na tabela tfkomp que
também esta relacionada com a tabela tfrol. As tabelas prod, que relaciona produtos
e lvtarf, que relaciona tarifas não foram distribuídas. As tabelas taska e taskb, contêm,
respectivamente, classes atribuídas para parceiros e para unidades familiares.
Figura E.15. Insurance - Diagrama de relacionamentos entre as tabelas originais
180
Tabela E.4. Insurance - Descrição dos atributos
Nome Nome Tipo/ Valor Mínimo/ Descrição

prep. original Tipo no Valor Máximo/
Tabela Modelo de Número Valores
original DM12 Distintos
(1 prep., Dados Dados
2 originais)
prep. originais
sem ptid inteiro sem uso 1013 identificador de parceiro

uso ignorado 778523
17267
sem hhid inteiro sem uso 13 identificador de unidade
uso ignorado 16368 familiar
12935
A1 epberuf inteiro 0 0 código de profissão
contínuo12 99 99
86 88
A2 eperweart inteiro 0 0 estado profissional
discreto12 3 3 (autônomo, empregado,
4 5 aposentado, etc.)
A3 epgebudat inteiro 1919 1889 ano de nascimento
part contínuo12 1978 1997
(Parceiro) 60 91
A4 epsta inteiro 0 0 estado pessoal (vivo, morto,
discreto12 2 1 desaparecido, etc.)
3 3
sem eplnamecd inteiro sem uso 0 nome código para pessoas
uso discreto2 2 casadas
4
A5 epsexcd inteiro 1 1 sexo (masculino, feminino)
discreto12 2 2
2 3
A6 epzivstd inteiro 0 0 estado civil (desconhecido,
discreto12 5 5 solteiro, casado,
6 7 divorciado, etc.)
12934
A7 attr2 inteiro 0 0
contínuo12 89 89
26 28
contínuo12 99 99
58 59
discreto12 8 8
3 4
hhold contínuo12 98 98
(Família) informações confidenciais
24 26
que caracterizam a
A11 attr6 inteiro 201 3 unidade familiar
contínuo12 688 688
74 75
discreto12 68 68
13 14
discreto12 8 8
3 4
sem attr9 texto sem uso 03
uso discreto2 LL
50
181
2 originais)
prep. originais

discreto12 8 8
3 4
sem attr11 inteiro sem uso 1
uso discreto2 8
4
discreto12 10 10
6 7
uso discreto2 15
12
uso discreto2 8
7
uso discreto2 3
4
A16 Attr16 inteiro 1 1
contínuo12 9895 99350
1376 1473
A17 Attr17 inteiro 3 3
contínuo12 88938 98839
301 304
sem Attr18 inteiro sem uso 3
uso contínuo2 738
32
A18 Attr19 inteiro 0 0 informações confidenciais
hhold discreto12 9 9 que caracterizam a
(Família) 7 8 unidade familiar
uso contínuo2 99
24
uso contínuo2 3460
72
discreto12 9 9
8 8
contínuo12 232 445
188 256
contínuo12 290 501
235 291
contínuo12 19 318
20 59
contínuo12 84 304
80 120
uso discreto2 350
15
uso discreto2 Q
15
182
2 originais)
prep. originais

uso discreto2 F
7
discreto12 8 8
4 4
discreto12 9 9
9 10
discreto12 3 3
4 4
discreto12 8 8
5 5
contínuo12 88 88
11 12
discreto12 8 8
4 5
A30 attr36 inteiro 1 1 informações confidenciais
hhold discreto12 9 9 que caracterizam a
(Família) 5 6 unidade familiar
discreto12 9 9
6 6
discreto12 8 8
5 5
discreto12 8 8
5 5
discreto12 8 8
4 4
discreto12 9 9
7 8
discreto12 8 8
5 5
discreto12 8 8
4 4
uso ignorado 776820
264
sem azart eadr inteiro sem uso 3 tipo de endereço
uso (endereço ignorado 9 (residencial, comercial)
eletrônico) 3
sem eatyp inteiro sem uso 1 tipo de endereço (fax,
uso ignorado 5 telefone, etc)
5
uso
padr ignorado 778523
(endereço
17267
postal)
183
2 originais)
prep. originais
A38 azart inteiro 1 1 tipo de endereço

discreto1 5 6 (residencial, comercial)
3 4
sem kanton padr texto sem uso AG distrito (dentro da Suiça)
uso (endereço ignorado ZH
postal) 29
sem gbeadmgeb inteiro sem uso 81206 região
uso ignorado 93711
545
sem prid inteiro sem uso 1106 identificador de função do
uso ignorado 3126714 parceiro
111077
uso ignorado 778523
17267
sem vvid parrol inteiro sem uso 1032 identificador da apólice de
uso (função do ignorado 740126 seguro de vida
parceiro) 34986
A39 prtyp inteiro 9 6 tipo de função (agente
discreto12 17 18 especial, pagador,
5 9 beneficiário, etc.)
A40 prtypnr inteiro 0 0 número de função
discreto12 2 4
3 5
sem trid inteiro sem uso 1380 identificador de função de
uso ignorado 2077325 tarifa
73332
sem prid inteiro sem uso 52216 identificador de função do
uso ignorado 3126714 parceiro
37613
sem tkid inteiro sem uso 1384 identificador de
uso ignorado 2077344 componente de tarifa
73332
A41 trteceinal inteiro 0 0 idade do segurado na
contínuo12 81 81 assinatura do contrato
tfrol 81 82
A42 truntcd (função de inteiro 0 0 indica verificação de risco
tarifa) discreto12 2 2 médico (sim, não,
3 3 desconhecido)
A43 trklauscd inteiro 0 0 indica cláusula especial de
discreto12 1 1 contrato (sim, não)
2 2
sem trstafcd inteiro sem uso 1 indica pagamento
uso ignorado 2 duvidoso (sim, não,
3 desconhecido)
sem trricd inteiro sem uso 0 indica sobretaxa de prêmio
uso discreto2 1 para alto risco (sim, não,
2 desconhecido)
sem vvid inteiro sem uso 1032 identificador da apólice de
uso ignorado 740126 seguro de vida
34986
sem pdid vvert inteiro sem uso 2177 identificador do produto
uso (apólice de ignorado 2505
seguro de 185
vida)
A44 vvstacd inteiro 4 4 código de estado de
discreto12 5 5 contrato
2 2
184
2 originais)
prep. originais
A45 vvinkzwei inteiro 0 0 forma de pagamento do

discreto12 5 5 prêmio
6 6
sem vvbeg inteiro sem uso 1943 ano do início do contrato
uso ignorado 1998
56
sem vvend inteiro sem uso 1800 ano do final do contrato
uso ignorado 2064
70
sem vvinkprl real sem uso 0 prêmio anual a ser pago
uso ignorado 200000
7366
sem vvinkpre real sem uso 0 prêmio a ser pago no início
uso ignorado 5106530 do contrato
4148
sem vvwae inteiro sem uso 756 moeda para pagamentos
uso discreto2 954
2
A46 vvversart inteiro 1 1 tipo do contrato de seguro
discreto12 6 6 (capital, pensão)
3 4
A47 vvaendart vvert inteiro 2 2 tipo da última modificação
(apólice de contínuo12 1059 1059
seguro de 67 80
vida)
sem vvaendat inteiro 1968 ano da última modificação
uso ignorado 1997
31
sem vvabvb inteiro sem uso 1076 agente responsável
uso ignorado 778014
1629
sem vvabga inteiro sem uso 1811 agência responsável
uso ignorado 17490
18
A48 vvstifcd inteiro 0 0 lugar de armazenamento
discreto12 2 2 da apólice
3 3
A49 vvvorscd inteiro 0 0 tipo de precaução do
discreto12 3 3 contrato
3 4
A50 vvbvgcd inteiro 0 0 indica se o segurado possui
discreto12 3 3 fundo de pensão
4 4
A51 vveucd inteiro 0 0 código para inclusão de
discreto12 1 1 seguro por invalidez
2 2
sem Tkid inteiro sem uso 1384 identificador do
uso ignorado 2077344 componente da tarifa
73502
sem vvid tfkomp inteiro sem uso 16949 identificador da apólice de
uso (compone ignorado 740126 seguro de vida
ntes da 34670
A52 tknr tarifa) inteiro 1 1 número do componente
discreto1 13 26 do contrato
ou 13 26
contínuo2
185
2 originais)
prep. originais
sem Tfid inteiro sem uso 1680 identificador da tarifa

uso ignorado 2053
239
A53 Tkbeg inteiro 1958 1943 ano inicial do componente
contínuo12 1998 1998 da tarifa
41 55
sem Tkend inteiro sem uso 1800 ano final do componente
uso ignorado 2064 da tarifa
72
sem Tkexkzwei inteiro sem uso 0 modo de pagamento
uso ignorado 5
7
sem Tkstacd inteiro sem uso 0 estado do componente
uso ignorado 2 (regular ou simples)
4
A54 Tkleist real 0 -109944 benefícios segurados do
contínuo12 203667 2854190 componente
11282 14819
A55 Tkinkprl real 0 -20767.3 prêmio regular do
contínuo12 7798.8 180602 componente
15007 18855
sem Tkinkpre real sem uso -2000000 prêmio único do
uso ignorado 5106530 componente
2442
sem tktarpra real sem uso 0 prêmio calculado
uso ignorado 5106530
11164
sem tkuebvwsysp tfkomp inteiro sem uso 0 benefício gasto para
uso (compone contínuo2 3033 contratos em andamento
ntes da 49
tarifa)
A56 tkuebvwsysl inteiro 11 11 benefício gasto durante
contínuo12 3005 3005 pagamento de pensão
60 63
A57 tkprfin inteiro 0 0 estado do componente
discreto12 2 2 atual
3 3
A58 tkdyncd inteiro 0 0 indica se componente é
discreto12 2 2 dinâmico
3 3
sem tkausbcd inteiro sem uso 0 indica a existência de
uso ignorado 8 extensão de garantia
8
sem tkrauv inteiro sem uso 1 informação para o caso
uso ignorado 8 especial de extensão de
8 risco
sem tksmed inteiro sem uso 1 indica caso de risco
uso ignorado 1 médico especial
2
A59 tkrizucd inteiro 0 0 custo extra de prêmio para
discreto12 1 1 casos de risco
2 2
sem tklfleist real sem uso null pagamento atual
uso ignorado null
1
A60 tktodleista real 0 -109944 pagamento por morte do
contínuo12 260000 5757830 segurado
12641 16167
186
2 originais)
prep. originais
A61 Tkerlleista inteiro 0 0 pagamento por

contínuo12 258204 5757830 terminação normal de
16588 21213 contrato
sem tkrenleista real sem uso -109944 pagamento em caso de
uso ignorado 1115050 aposentadoria
tfkomp
985
(compone
A62 tkeuleista ntes da real 0 0 pagamento em caso de
tarifa) contínuo12 24000 178304 invalidez
7299 8460
A63 tkunfleista inteiro 0 0 pagamento em caso de
contínuo12 50000 1000000 acidente
156 318
uso ignorado 778523
17267
taska
Class class (tarefa a) texto 1 0 classe pré-definida (0 - não,
discreto12 2 2 1 - sim, 2 - não aplicável)
2 3
12934
taskb
Class class (tarefa b) sem uso sem uso 0 classe pré-definida (0 - não,
2 1 - sim, 2 - não aplicável)
3
As Listagens E.10 e E.11 mostram respectivamente os scripts geradores dos

bancos de dados preparados e originais, com todos os objetos pertinentes, tais como
tabelas, vistas e procedimentos armazenados. Esta última Listagem contém a consulta
taska1 que foi utilizada para obter o conjunto de dados não preparados a partir dos
relacionamentos originais.
Listagem E.10. Insurance - Script gerador do banco de dados preparados
USE master
GO
CREATE DATABASE Insurance

GO
USE Insurance
GO

SELECT RAND (1)
SELECT Block FROM Insurance ORDER BY Class, NumReg
OPEN Block_cursor
BEGIN
187
UPDATE Insurance SET Block = @Block WHERE CURRENT OF Block_cursor
END
CLOSE Block_cursor
RETURN
GO

SELECT RAND (1)
SELECT Train FROM Insurance ORDER BY Class
OPEN Train_cursor
BEGIN
SET @i = 100 * RAND()
IF @i <= 30
UPDATE Insurance SET Train = 0 WHERE CURRENT OF Train_cursor
END
CLOSE Train_cursor
RETURN
GO

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM Insurance WHERE (Train = 1)')
DROP VIEW Test
EXEC ('CREATE VIEW Test AS SELECT * FROM Insurance WHERE (Train = 0)')
RETURN
GO

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM Insurance WHERE (Block <> ' +
@active_block + ')')
DROP VIEW Test
EXEC ('CREATE VIEW Test AS SELECT * FROM Insurance WHERE (Block = ' +
RETURN
GO

'Class varchar (1) NULL) ON [PRIMARY]')
RETURN
GO

EXEC (
'FROM ' + @data_name +
' INNER JOIN ' + @algorithm_name + '_' + @data_name +
188
'_Results ' +
EXEC (
@data_name +
'_Errors FROM ' + @algorithm_name + '_' + @data_name + '_Errors')
RETURN
GO

EXEC (
RETURN
GO

189
INSERT ProcessingTimes (Block, Algorithm, Train_Start_Time) VALUES
(@active_block, @algorithm_name, GetDate())
RETURN
GO

RETURN
GO

RETURN
GO

Test_Pred_End_Time)
RETURN
GO
CREATE PROC assemble_attribute_statistics AS

WHERE TABLE_NAME = 'Insurance'
OPEN column_cursor
BEGIN
EXEC (
'MIN(' + @Attribute_Name + ') AS Att_Min, ' +
'MAX(' + @Attribute_Name + ') AS Att_Max, ' +
' FROM Insurance GROUP BY ' + @Attribute_Name + ') DERIVEDTBL')
END
CLOSE column_cursor
RETURN
GO
CREATE TABLE Insurance (

A1 int NULL, A2 int NULL, A3 int NULL, A4 int NULL, A5 int NULL,
190
A51 int NULL, A52 int NULL, A53 int NULL,
A54 float NULL, A55 float NULL,
A56 int NULL, A57 int NULL, A58 int NULL, A59 int NULL,
A60 float NULL,
A61 int NULL,
A62 float NULL,
A63 int NULL,
Class varchar (1) NULL, Train bit NOT NULL, Block int NOT NULL
) ON [PRIMARY]
GO

) ON [PRIMARY]
GO

) ON [PRIMARY]
GO

Att_Min varchar (50) NULL, Att_Max varchar (50) NULL,
) ON [PRIMARY]
GO
GO

SELECT COUNT(*) AS All_Cases FROM Insurance
GO

FROM Insurance GROUP BY Class, Train ORDER BY Class
GO

SELECT 'SNBi' AS Algorithm, COUNT(*) AS Train_Cases FROM Train
GO

SELECT 'SNBi' AS Algorithm, COUNT(*) AS Test_Cases FROM Test
GO

GO
191
GO
EXEC create_views_tables 'SNBi'

GO

AVG(Test_Cases)AS Mean_Test_Cases,
SUM(Test_Pred_Time) AS [Total_Test_Pred_Time (s)],
FROM Results
GROUP BY Algorithm
GO

FROM Insurance GROUP BY Block ORDER BY Block
GO

FROM Insurance GROUP BY Class, Block ORDER BY Block, Class
GO

SELECT TOP 100 PERCENT Attribute_Name, Att_Min, Att_Max, Attribute_Count
FROM Attribute_Statistics
ORDER BY Attribute_Count, Attribute_Name
GO

[Percent]
FROM Insurance GROUP BY Train
GO
Listagem E.11. Insurance - Script gerador do banco de dados original
USE master
GO
CREATE DATABASE sisyphus

GO
USE sisyphus
GO
CREATE PROC assemble_attribute_statistics @table_name varchar(80) AS

WHERE TABLE_NAME = @table_name
DELETE FROM Attribute_Statistics
192
OPEN column_cursor
BEGIN
EXEC (
'MIN(' + @Attribute_Name + ') AS Att_Min, ' +
'MAX(' + @Attribute_Name + ') AS Att_Max, ' +
' FROM ' + @table_name + ' GROUP BY ' + @Attribute_Name +
') DERIVEDTBL')
END
CLOSE column_cursor
RETURN
GO
CREATE PROC Assemble_sisyphus AS

DECLARE @NumReg as integer
DELETE FROM sisyphus
ALTER TABLE sisyphus DROP CONSTRAINT [PK_sisyphus]
DECLARE NumReg_cursor CURSOR FOR
SELECT NumReg FROM sisyphus
INSERT INTO sisyphus SELECT * FROM taska1
OPEN NumReg_cursor
FETCH NEXT FROM NumReg_cursor INTO @NumReg
SET @i = 0
BEGIN
SET @i = @i + 1
UPDATE sisyphus SET NumReg = @i WHERE CURRENT OF NumReg_cursor
FETCH NEXT FROM NumReg_cursor INTO @NumReg
END
CLOSE NumReg_cursor
DEALLOCATE NumReg_cursor
ALTER TABLE sisyphus
ADD CONSTRAINT [PK_sisyphus] PRIMARY KEY CLUSTERED ([NumReg])
RETURN
GO

SELECT RAND (1)
SELECT Block FROM sisyphus ORDER BY Class, NumReg
OPEN Block_cursor
BEGIN
UPDATE sisyphus SET Block = @Block WHERE CURRENT OF Block_cursor
END
CLOSE Block_cursor
RETURN
GO

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM sisyphus WHERE (Train = 1)')
DROP VIEW Test
193
EXEC ('CREATE VIEW Test AS SELECT * FROM sisyphus WHERE (Train = 0)')
RETURN
GO

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM sisyphus WHERE (Block <> ' +
DROP VIEW Test
EXEC ('CREATE VIEW Test AS SELECT * FROM sisyphus WHERE (Block = ' +
RETURN
GO

'Class varchar (1) NULL)')
RETURN
GO
CREATE PROC Create_Table_Char AS

DECLARE @AttNum int
DECLARE @StrTemp as varchar (8000)
SET @AttNum = 1
SET @StrTemp = 'CREATE TABLE sisyphus_char (Train bit NOT NULL'
WHILE (@AttNum < 80)
BEGIN
SET @AttNum = @AttNum + 1
SET @StrTemp = @StrTemp + ', Expr' +
CAST (@AttNum AS varchar(3)) + ' varchar (50) NULL'
END
SET @StrTemp = @StrTemp + ') ON [PRIMARY]'
EXEC (@StrTemp)
RETURN
GO

SELECT RAND (1)
SELECT Train FROM sisyphus ORDER BY Class
OPEN Train_cursor
BEGIN
SET @i = 100 * RAND()
IF @i <= 30
UPDATE sisyphus SET Train = 0 WHERE CURRENT OF Train_cursor
END
CLOSE Train_cursor
RETURN
GO

EXEC (
'FROM ' + @data_name +
' INNER JOIN ' + @algorithm_name + '_' + @data_name +
194
'_Results ' +
EXEC (
@data_name +
'_Errors FROM ' + @algorithm_name + '_' + @data_name + '_Errors')
RETURN
GO

EXEC (
RETURN
GO

195
INSERT ProcessingTimes (Block, Algorithm, Train_Start_Time) VALUES
(@active_block, @algorithm_name, GetDate())
RETURN
GO

RETURN
GO

RETURN
GO

Test_Pred_End_Time)
RETURN
GO
CREATE TABLE eadr (

ptid int NULL, azart tinyint NULL, eatyp tinyint NULL,
CONSTRAINT [FK_eadr_part] FOREIGN KEY
(ptid) REFERENCES part (ptid)
) ON [PRIMARY]
GO
CREATE TABLE hhold (

hhid smallint PRIMARY KEY NOT NULL,
attr2 tinyint NULL, attr3 tinyint NULL, attr4 tinyint NULL,
attr5 tinyint NULL, attr6 smallint NULL, attr7 tinyint NULL,
attr8 tinyint NULL, attr9 varchar (2) NULL, attr10 tinyint NULL,
attr14 tinyint NULL, attr15 tinyint NULL, attr16 int NULL,
attr17 int NULL, attr18 smallint NULL, attr19 tinyint NULL,
attr23 smallint NULL, attr24 smallint NULL, attr25 smallint NULL,
attr26 smallint NULL, attr27 smallint NULL, attr28 varchar (1) NULL,
attr29 varchar (1) NULL, attr30 tinyint NULL, attr31 tinyint NULL,
attr41 tinyint NULL, attr42 tinyint NULL, attr43 tinyint NULL
) ON [PRIMARY]
GO
CREATE TABLE padr (

ptid int NULL, azart tinyint NULL, kanton varchar (2) NULL,
gbeadmgeb int NULL,
CONSTRAINT [FK_padr_part] FOREIGN KEY
196
) ON [PRIMARY]
GO
CREATE TABLE parrol (

prid int PRIMARY KEY NOT NULL, ptid int NULL, vvid int NULL,
prtyp tinyint NULL, prtypnr tinyint NULL,
CONSTRAINT [FK_parrol_part] FOREIGN KEY
(ptid) REFERENCES part (ptid),
CONSTRAINT [FK_parrol_vvert] FOREIGN KEY
(vvid) REFERENCES vvert (vvid)
) ON [PRIMARY]
GO
CREATE TABLE part (

ptid int PRIMARY KEY NOT NULL, hhid smallint NULL,
epberuf tinyint NULL, eperweart tinyint NULL, epgebudat smallint NULL,
epsta tinyint NULL, eplnamecd tinyint NULL, epsexcd tinyint NULL,
epzivstd tinyint NULL,
CONSTRAINT [FK_part_hhold] FOREIGN KEY
(hhid) REFERENCES hhold (hhid)
) ON [PRIMARY]
GO
CREATE TABLE taska (

ptid int PRIMARY KEY NOT NULL, class tinyint NULL,
CONSTRAINT [FK_taska_part] FOREIGN KEY
) ON [PRIMARY]
GO
CREATE TABLE taskb (

hhid smallint PRIMARY KEY NOT NULL, class tinyint NULL,
CONSTRAINT [FK_taskb_hhold] FOREIGN KEY
(hhid) REFERENCES hhold (hhid)
) ON [PRIMARY]
GO
CREATE TABLE tfkomp (

tkid int PRIMARY KEY NOT NULL,
vvid int NULL, tknr tinyint NULL, tfid int NULL,
tkbeg smallint NULL, tkend smallint NULL, tkexkzwei tinyint NULL,
tkstacd tinyint NULL, tkleist float NULL, tkinkprl float NULL,
tkinkpre float NULL, tktarpra float NULL, tkuebvwsysp int NULL,
tkuebvwsysl int NULL, tkprfin int NULL, tkdyncd int NULL,
tkausbcd int NULL, tkrauv int NULL, tksmed int NULL,
tkrizucd tinyint NULL, tklfleist float NULL, tktodleista float NULL,
tkerlleista int NULL, tkrenleista float NULL,
tkeuleista float NULL, tkunfleista int NULL,
CONSTRAINT [FK_tfkomp_vvert] FOREIGN KEY
(vvid) REFERENCES vvert (vvid)
) ON [PRIMARY]
GO
CREATE TABLE tfrol (

trid int PRIMARY KEY NOT NULL, prid int NULL, tkid int NULL,
trteceinal tinyint NULL, truntcd tinyint NULL,
trklauscd tinyint NULL, trstafcd tinyint NULL,
trricd tinyint NULL,
CONSTRAINT [FK_tfrol_parrol] FOREIGN KEY
(prid) REFERENCES parrol (prid),
CONSTRAINT [FK_tfrol_tfkomp] FOREIGN KEY
(tkid) REFERENCES tfkomp (tkid)
) ON [PRIMARY]
GO
CREATE TABLE vvert (

vvid int PRIMARY KEY NOT NULL, pdid smallint NULL, vvstacd tinyint NULL,
vvinkzwei tinyint NULL, vvbeg smallint NULL, vvend smallint NULL,
vvinkprl float NULL, vvinkpre float NULL, vvwae smallint NULL,
vvversart tinyint NULL, vvaendart smallint NULL,
197
vvaendat smallint NULL, vvabvb int NULL, vvabga int NULL,
vvstifcd tinyint NULL, vvvorscd tinyint NULL, vvbvgcd tinyint NULL,
vveucd tinyint NULL
) ON [PRIMARY]
GO
CREATE TABLE sisyphus (

NumReg int NOT NULL,
epberuf tinyint NULL, eperweart tinyint NULL, epgebudat smallint NULL,
epsta tinyint NULL, eplnamecd tinyint NULL, epsexcd tinyint NULL,
epzivstd tinyint NULL,
attr8 tinyint NULL, attr9 varchar (2) NULL, attr10 tinyint NULL,
attr14 tinyint NULL, attr15 tinyint NULL, attr16 int NULL,
attr17 int NULL, attr18 smallint NULL, attr19 tinyint NULL,
attr23 smallint NULL, attr24 smallint NULL, attr25 smallint NULL,
attr26 smallint NULL, attr27 smallint NULL, attr28 varchar (1) NULL,
attr29 varchar (1) NULL, attr30 tinyint NULL, attr31 tinyint NULL,
prtyp tinyint NULL, prtypnr tinyint NULL,
trteceinal tinyint NULL, truntcd tinyint NULL,
trklauscd tinyint NULL, trricd tinyint NULL,
vvstacd tinyint NULL, vvinkzwei tinyint NULL, vvwae smallint NULL,
vvversart tinyint NULL, vvaendart smallint NULL,
vvstifcd tinyint NULL, vvvorscd tinyint NULL, vvbvgcd tinyint NULL,
vveucd tinyint NULL,
tknr tinyint NULL, tfid int NULL,
tkbeg smallint NULL, tkleist float NULL, tkinkprl float NULL,
tkuebvwsysp int NULL, tkuebvwsysl int NULL, tkprfin int NULL,
tkdyncd int NULL, tkrizucd tinyint NULL, tktodleista float NULL,
tkerlleista int NULL, tkeuleista float NULL, tkunfleista int NULL,
class varchar (1), Train bit NOT NULL, Block int NOT NULL,
CONSTRAINT PK_sisyphus PRIMARY KEY CLUSTERED (NumReg) ON [PRIMARY]
) ON [PRIMARY]
GO

Att_Min varchar (50) NULL, Att_Max varchar (50) NULL,
) ON [PRIMARY]
GO

) ON [PRIMARY]
GO

) ON [PRIMARY]
GO
CREATE VIEW taska_count AS

SELECT COUNT(*) AS Count_Cases
198
FROM taska
GO
CREATE VIEW taskb_count AS

SELECT COUNT(*) AS Count_Cases
FROM taskb
GO
CREATE VIEW taska1 AS

SELECT 1 AS NumReg,
part.epberuf, part.eperweart, part.epgebudat, part.epsta,
part.eplnamecd, part.epsexcd, part.epzivstd, hhold.attr2,
hhold.attr3, hhold.attr4, hhold.attr5, hhold.attr6, hhold.attr7,
hhold.attr43,
parrol.prtyp, parrol.prtypnr,
tfrol.trteceinal, tfrol.truntcd, tfrol.trklauscd, tfrol.trricd,
vvert.vvstacd, vvert.vvinkzwei, vvert.vvwae, vvert.vvversart,
vvert.vvaendart, vvert.vvstifcd, vvert.vvvorscd, vvert.vvbvgcd,
vvert.vveucd,
tfkomp.tknr, tfkomp.tfid, tfkomp.tkbeg, tfkomp.tkleist,
tfkomp.tkinkprl, tfkomp.tkuebvwsysp, tfkomp.tkuebvwsysl,
tfkomp.tkprfin, tfkomp.tkdyncd, tfkomp.tkrizucd, tfkomp.tktodleista,
tfkomp.tkerlleista, tfkomp.tkeuleista, tfkomp.tkunfleista,
taska.class,
1 AS Train, 1 AS Block
FROM
taska INNER JOIN
part ON taska.ptid = part.ptid LEFT OUTER JOIN
hhold ON part.hhid = hhold.hhid LEFT OUTER JOIN
tfrol INNER JOIN
tfkomp ON tfrol.tkid = tfkomp.tkid RIGHT OUTER JOIN
parrol INNER JOIN
vvert ON parrol.vvid = vvert.vvid
ON tfkomp.vvid = vvert.vvid AND tfrol.prid = parrol.prid
ON part.ptid = parrol.ptid
GO
CREATE VIEW taska1_count AS

SELECT COUNT(*) AS Expr1
FROM taska1
GO
CREATE VIEW sisyphus_expr AS

SELECT epberuf AS Expr2, eperweart AS Expr3, epgebudat AS Expr4,
epsta AS Expr5, eplnamecd AS Expr6, epsexcd AS Expr7,
epzivstd AS Expr8, attr2 AS Expr9, attr3 AS Expr10, attr4 AS Expr11,
attr5 AS Expr12, attr6 AS Expr13, attr7 AS Expr14, attr8 AS Expr15,
attr9 AS Expr16, attr10 AS Expr17, attr11 AS Expr18,
attr42 AS Expr49, attr43 AS Expr50, prtyp AS Expr51,
prtypnr AS Expr52, trteceinal AS Expr53, truntcd AS Expr54,
trklauscd AS Expr55, trricd AS Expr56, vvstacd AS Expr57,
vvinkzwei AS Expr58, vvwae AS Expr59, vvversart AS Expr60,
vvaendart AS Expr61, vvstifcd AS Expr62, vvvorscd AS Expr63,
vvbvgcd AS Expr64, vveucd AS Expr65, tknr AS Expr66, tfid AS Expr67,
199
tkbeg AS Expr68, tkleist AS Expr69, tkinkprl AS Expr70,
tkuebvwsysp AS Expr71, tkuebvwsysl AS Expr72, tkprfin AS Expr73,
tkdyncd AS Expr74, tkrizucd AS Expr75, tktodleista AS Expr76,
tkerlleista AS Expr77, tkeuleista AS Expr78, tkunfleista AS Expr79,
class AS Expr80, Train
FROM sisyphus
GO
EXEC Create_Table_Char
GO
GO

SELECT COUNT(*) AS All_Cases FROM sisyphus
GO

FROM sisyphus GROUP BY Class, Train ORDER BY Class
GO

SELECT 'SNBi' AS Algorithm, COUNT(*) AS Train_Cases FROM Train
GO

SELECT 'SNBi' AS Algorithm, COUNT(*) AS Test_Cases FROM Test
GO

GO

GO
EXEC create_views_tables 'SNBi'

GO

AVG(Test_Cases)AS Mean_Test_Cases,
SUM(Test_Pred_Time) AS [Total_Test_Pred_Time (s)],
FROM Results
GROUP BY Algorithm
GO

FROM sisyphus GROUP BY Block ORDER BY Block
GO
200
FROM sisyphus GROUP BY Class, Block ORDER BY Block, Class
GO

SELECT TOP 100 PERCENT Attribute_Name, Att_Min, Att_Max, Attribute_Count
FROM Attribute_Statistics
ORDER BY Attribute_Count, Attribute_Name
GO

[Percent]
FROM sisyphus GROUP BY Train
GO
A primeira parte deste experimento, relativa aos dados preparados, possui

semelhança total com o experimento de previsão do tempo, desta forma todos os
utilitários DTS são semelhantes, com diferenças ínfimas na operação de importação de
dados e por este motivo não serão reproduzidos aqui.
A segunda parte do experimento, relativa aos dados originais, possui diferenças
nas tarefas de importação e montagem dos dados, que são realizadas pelos utilitários
mostrados, respectivamente, pelas Figuras E-16 e E-17.
201
Figura E.16. Insurance – DTS – Dados Originais - Importação de dados
Figura E.17. Insurance – DTS – Dados Originais - Montagem dos dados
O utilitário de montagem dos dados, através do objeto Create Test Data executa
os procedimentos armazenados Assemble_sisyphus, que cria uma tabela única,
202
utilizando a consulta taska1 e Create_Test_Data, que separa os dados de treinamento
e de teste. Os outros objetos transformam esta tabela, identificando o campos nulos, e

exportam os dados para uso pelo classificador C45.
Os comandos SQL DM utilizados para a criação dos modelos de DM dos

classificadores da primeira parte do experimento são mostrados na Tabela E.5,
enquanto que a Listagem E.12 mostra o comando SQL DM necessário para efetuar a
predição dos dados de teste do classificador SNBi. Os comando respectivo do
classificador MSDT é semelhante. As repetições extensas de itens nestes comandos são
omitidas e representadas por três pontos consecutivos (...). Por sua vez a Tabela E.6 e a
Listagem E.13 mostram os comandos SQL DM respectivos para a segunda parte do
experimento.
Tabela E.5. Insurance - dados preparados - Comandos SQL DM para criação do modelo de DM
SNBi CREATE MINING MODEL [Insurance_SNBi] ([NumReg] LONG KEY, [A1] LONG
CONTINUOUS, [A2] LONG DISCRETE, [A3] LONG CONTINUOUS, [A4] LONG
DISCRETE, [A5] LONG DISCRETE, [A6] LONG DISCRETE, [A7] LONG CONTINUOUS,
[A8] LONG CONTINUOUS, [A9] LONG DISCRETE, [A10] LONG CONTINUOUS, [A11]
LONG CONTINUOUS, [A12] LONG DISCRETE, [A13] LONG DISCRETE, [A14] LONG
DISCRETE, [A15] LONG DISCRETE, [A16] LONG CONTINUOUS, [A17] LONG
CONTINUOUS, [A18] LONG DISCRETE, [A19] LONG DISCRETE, [A20] LONG
CONTINUOUS, [A21] LONG CONTINUOUS, [A22] LONG CONTINUOUS, [A23] LONG
CONTINUOUS, [A24] LONG DISCRETE, [A25] LONG DISCRETE, [A26] LONG
DISCRETE, [A27] LONG DISCRETE, [A28] LONG DISCRETE, [A29] LONG DISCRETE,
[A30] LONG DISCRETE, [A31] LONG DISCRETE, [A32] LONG DISCRETE, [A33]
LONG DISCRETE, [A34] LONG DISCRETE, [A35] LONG DISCRETE, [A36] LONG
[A40] LONG DISCRETE, [A41] LONG CONTINUOUS, [A42] LONG DISCRETE, [A43]
LONG DISCRETE, [A44] LONG DISCRETE, [A45] LONG DISCRETE, [A46] LONG
DISCRETE, [A47] LONG CONTINUOUS, [A48] LONG DISCRETE, [A49] LONG
[A53] LONG CONTINUOUS, [A54] DOUBLE CONTINUOUS, [A55] DOUBLE CONTINUOUS,
[A56] LONG CONTINUOUS, [A57] LONG DISCRETE, [A58] LONG DISCRETE, [A59]
LONG DISCRETE, [A60] DOUBLE CONTINUOUS, [A61] LONG CONTINUOUS, [A62]
DOUBLE CONTINUOUS, [A63] LONG CONTINUOUS, [Class] TEXT DISCRETE
PREDICT_ONLY) USING Simple_Naive_Bayes
MSDT1 idêntico ao anterior com diferenças em CREATE MINING MODEL

[Insurance_MSDT1] e USING Microsoft_Decision_Trees
(COMPLEXITY_PENALTY=0.9, MINIMUM_LEAF_CASES=10, SCORE_METHOD=4,
SPLIT_METHOD=3)

[Insurance_MSDT2] e USING Microsoft_Decision_Trees
SPLIT_METHOD=3)
203
Listagem E.12. Insurance - dados preparados - Comando SQL DM para predição dos dados de teste,
classificador SNBi
SELECT FLATTENED [T1].[NumReg], [T1].[A1], [T1].[A2], ... [T1].[A63],

[Insurance_SNBi].[Class] as Class
FROM [Insurance_SNBi] PREDICTION JOIN
OPENROWSET ('SQLOLEDB', 'Provider=SQLOLEDB;Integrated Security=SSPI;
Persist Security Info=False;Initial Catalog=Insurance;Data Source=CLC',
'SELECT "NumReg", "A1", "A2", ..., "A63" FROM "Test" ORDER BY "NumReg"') AS [T1]
ON
[Insurance_SNBi].[NumReg] = [T1].[NumReg] AND
[Insurance_SNBi].[A1] = [T1].[A1] AND
[Insurance_SNBi].[A2] = [T1].[A2] AND
... AND
[Insurance_SNBi].[A63] = [T1].[A63]
Tabela E.6. Insurance - dados originais - Comandos SQL DM para criação do modelo de DM
SNBi CREATE MINING MODEL [sisyphus_SNBi] ([NumReg] LONG KEY, [epberuf] LONG
CONTINUOUS, [eperweart] LONG DISCRETE, [epgebudat] LONG CONTINUOUS,
[epsta] LONG DISCRETE, [eplnamecd] LONG DISCRETE, [epsexcd] LONG
DISCRETE, [epzivstd] LONG DISCRETE, [attr2] LONG CONTINUOUS, [attr3]
LONG CONTINUOUS, [attr4] LONG DISCRETE, [attr5] LONG CONTINUOUS, [attr6]
LONG CONTINUOUS, [attr7] LONG DISCRETE, [attr8] LONG DISCRETE, [attr9]
TEXT DISCRETE, [attr10] LONG DISCRETE, [attr11] LONG DISCRETE, [attr12]
LONG DISCRETE, [attr13] LONG DISCRETE, [attr14] LONG DISCRETE, [attr15]
LONG DISCRETE, [attr16] LONG CONTINUOUS, [attr17] LONG CONTINUOUS,
[attr18] LONG CONTINUOUS, [attr19] LONG DISCRETE, [attr20] LONG
CONTINUOUS, [attr21] LONG CONTINUOUS, [attr22] LONG DISCRETE, [attr23]
LONG CONTINUOUS, [attr24] LONG CONTINUOUS, [attr25] LONG CONTINUOUS,
[attr26] LONG CONTINUOUS, [attr27] LONG DISCRETE, [attr28] TEXT
DISCRETE, [attr29] TEXT DISCRETE, [attr30] LONG DISCRETE, [attr31] LONG
DISCRETE, [attr32] LONG DISCRETE, [attr33] LONG DISCRETE, [attr34] LONG
DISCRETE, [prtyp] LONG DISCRETE, [prtypnr] LONG DISCRETE, [trteceinal]
LONG CONTINUOUS, [truntcd] LONG DISCRETE, [trklauscd] LONG DISCRETE,
[trricd] LONG DISCRETE, [vvstacd] LONG DISCRETE, [vvinkzwei] LONG
DISCRETE, [vvwae] LONG DISCRETE, [vvversart] LONG DISCRETE, [vvaendart]
LONG CONTINUOUS, [vvstifcd] LONG DISCRETE, [vvvorscd] LONG DISCRETE,
[vvbvgcd] LONG DISCRETE, [vveucd] LONG DISCRETE, [tknr] LONG CONTINUOUS,
[tfid] LONG CONTINUOUS, [tkbeg] LONG CONTINUOUS, [tkleist] DOUBLE
CONTINUOUS, [tkinkprl] DOUBLE CONTINUOUS, [tkuebvwsysp] LONG CONTINUOUS,
[tkuebvwsysl] LONG CONTINUOUS, [tkprfin] LONG DISCRETE, [tkdyncd] LONG
DISCRETE, [tkrizucd] LONG DISCRETE, [tktodleista] DOUBLE CONTINUOUS,
[tkerlleista] LONG CONTINUOUS, [tkeuleista] DOUBLE CONTINUOUS,
[tkunfleista] LONG CONTINUOUS, [Class] TEXT DISCRETE PREDICT_ONLY) USING
Simple_Naive_Bayes

[sisyphus_MSDT1] e USING Microsoft_Decision_Trees
SPLIT_METHOD=3)

[sisyphus_MSDT2] e USING Microsoft_Decision_Trees
SPLIT_METHOD=3)
204
Listagem E.13. Insurance - dados originais - Comando SQL DM para predição dos dados de teste,
classificador SNBi
SELECT FLATTENED [T1].[NumReg], [T1].[epberuf], [T1].[eperweart], [T1].[epgebudat],

[T1].[epsta], [T1].[eplnamecd], [T1].[epsexcd], [T1].[epzivstd], [T1].[attr2],
[T1].[attr3], ... [T1].[attr43], [T1].[prtyp], [T1].[prtypnr], [T1].[trteceinal],
[T1].[truntcd], [T1].[trklauscd], [T1].[trricd], [T1].[vvstacd], [T1].[vvinkzwei],
[T1].[vvwae], [T1].[vvversart], [T1].[vvaendart], [T1].[vvstifcd], [T1].[vvvorscd],
[T1].[vvbvgcd], [T1].[vveucd], [T1].[tknr], [T1].[tfid], [T1].[tkbeg], [T1].[tkleist],
[T1].[tkinkprl], [T1].[tkuebvwsysp], [T1].[tkuebvwsysl], [T1].[tkprfin],
[T1].[tkdyncd], [T1].[tkrizucd], [T1].[tktodleista], [T1].[tkerlleista],
[T1].[tkeuleista], [T1].[tkunfleista], [sisyphus_SNBi].[Class] as Class
FROM [sisyphus_SNBi] PREDICTION JOIN
Persist Security Info=False;Initial Catalog=sisyphus;Data Source=CLC',
'SELECT "NumReg", "epberuf", "eperweart", "epgebudat", "epsta", "eplnamecd",
"epsexcd", "epzivstd", "attr2", "attr3", ..., "attr43", "prtyp", "prtypnr",
"trteceinal", "truntcd", "trklauscd", "trricd", "vvstacd", "vvinkzwei", "vvwae",
"vvversart", "vvaendart", "vvstifcd", "vvvorscd", "vvbvgcd", "vveucd", "tknr", "tfid",
"tkbeg", "tkleist", "tkinkprl", "tkuebvwsysp", "tkuebvwsysl", "tkprfin", "tkdyncd",
"tkrizucd", "tktodleista", "tkerlleista", "tkeuleista", "tkunfleista"
FROM "Test" ORDER BY "NumReg"') AS [T1]
ON
[sisyphus_SNBi].[NumReg] = [T1].[NumReg] AND
[sisyphus_SNBi].[epberuf] = [T1].[epberuf] AND
[sisyphus_SNBi].[eperweart] = [T1].[eperweart] AND
[sisyphus_SNBi].[epgebudat] = [T1].[epgebudat] AND
[sisyphus_SNBi].[epsta] = [T1].[epsta] AND
[sisyphus_SNBi].[eplnamecd] = [T1].[eplnamecd] AND
[sisyphus_SNBi].[epsexcd] = [T1].[epsexcd] AND
[sisyphus_SNBi].[epzivstd] = [T1].[epzivstd] AND
[sisyphus_SNBi].[attr2] = [T1].[attr2] AND
... AND
[sisyphus_SNBi].[prtyp] = [T1].[prtyp] AND
[sisyphus_SNBi].[prtypnr] = [T1].[prtypnr] AND
[sisyphus_SNBi].[trteceinal] = [T1].[trteceinal] AND
[sisyphus_SNBi].[truntcd] = [T1].[truntcd] AND
[sisyphus_SNBi].[trklauscd] = [T1].[trklauscd] AND
[sisyphus_SNBi].[trricd] = [T1].[trricd] AND
[sisyphus_SNBi].[vvstacd] = [T1].[vvstacd] AND
[sisyphus_SNBi].[vvinkzwei] = [T1].[vvinkzwei] AND
[sisyphus_SNBi].[vvwae] = [T1].[vvwae] AND
[sisyphus_SNBi].[vvversart] = [T1].[vvversart] AND
[sisyphus_SNBi].[vvaendart] = [T1].[vvaendart] AND
[sisyphus_SNBi].[vvstifcd] = [T1].[vvstifcd] AND
[sisyphus_SNBi].[vvvorscd] = [T1].[vvvorscd] AND
[sisyphus_SNBi].[vvbvgcd] = [T1].[vvbvgcd] AND
[sisyphus_SNBi].[vveucd] = [T1].[vveucd] AND
[sisyphus_SNBi].[tknr] = [T1].[tknr] AND
[sisyphus_SNBi].[tfid] = [T1].[tfid] AND
[sisyphus_SNBi].[tkbeg] = [T1].[tkbeg] AND
[sisyphus_SNBi].[tkleist] = [T1].[tkleist] AND
[sisyphus_SNBi].[tkinkprl] = [T1].[tkinkprl] AND
[sisyphus_SNBi].[tkuebvwsysp] = [T1].[tkuebvwsysp] AND
[sisyphus_SNBi].[tkuebvwsysl] = [T1].[tkuebvwsysl] AND
[sisyphus_SNBi].[tkprfin] = [T1].[tkprfin] AND
[sisyphus_SNBi].[tkdyncd] = [T1].[tkdyncd] AND
[sisyphus_SNBi].[tkrizucd] = [T1].[tkrizucd] AND
[sisyphus_SNBi].[tktodleista] = [T1].[tktodleista] AND
[sisyphus_SNBi].[tkerlleista] = [T1].[tkerlleista] AND
[sisyphus_SNBi].[tkeuleista] = [T1].[tkeuleista] AND
[sisyphus_SNBi].[tkunfleista] = [T1].[tkunfleista]
205
E.5 Estudo de Desempenho
Os dados deste experimento são totalmente artificiais e foram gerados por um

programa. Os detalhes desta geração e dos utilitários utilizados no processamento do
experimento são descritos a seguir.
E.5.1 Geração de Dados
Para ser utilizado no sistema operacional utilizado, o programa DATGEN (MELLI,
1999) precisou ser ligeiramente modificado. As funções drand48 e srand48 foram
criadas conforme mostra a Listagem E.14. A Tabela E.7 lista os parâmetros utilizados
neste programa para gerar os dados para os diferentes procedimentos do
experimento.
Listagem E.14. Funções para o programa DATGEN
double drand48 (void)

{
/*
Function drand48() return double-precision floating-point
values uniformly distributed over the interval [0.0, 1.0)
*/
return ((double)rand () / ((double)RAND_MAX + 1.0));
}
void srand48 (long seedval)
{
srand (seedval);
}
Tabela E.7. Parâmetros para o programa DATGEN
Procedimento Descrição Parâmetros
VarInpAtt Variação do Número -r1 -A200 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 -d25 -O1000000
de Atributos de
Dados
VarNumCases Variação do Número -r1 -A20 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 –d25 -O2000000
de Casos
VarStates Variação do Número -r1 -A20 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 -d2 -O1000000
de Estados dos -r1 -A20 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 -d5 -O1000000
Atributos de Dados
-r1 -A20 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 -d10 -O1000000
-r1 -A20 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 -d25 -O1000000
-r1 -A20 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 -d50 -O1000000
-r1 -A20 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 -d75 -O1000000
-r1 -A20 -e0.0 -m0.0 -I0 -M0 -R5 -C10 -T1 –d100 -O1000000
VarPredAtt Variação do Número -r1 -A39 -e0.0 -m0.0 -I0 -M0 -R25 -C40 -T1 -d25 -O1000000
206
de Atributos de
Predição
As Listagens E.15, E.16, E.17 e E.18 mostram os scripts geradores dos bancos de
dados com todos os objetos pertinentes, tais como tabelas, vistas e procedimentos
armazenados, para os quatro procedimentos deste experimento.
Listagem E.15. VarInpAtt - Script gerador do banco de dados
USE master
GO
CREATE DATABASE VarInpAtt

GO
USE VarInpAtt
GO
CREATE PROC Create_Data_Views AS

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM VarInpAtt')
RETURN
GO
CREATE PROC Init_TrainTime @algorithm_name varchar(80) AS

DELETE FROM ProcessingTimes WHERE Algorithm = @algorithm_name
INSERT ProcessingTimes (Algorithm, Train_Start_Time)
VALUES (@algorithm_name, GetDate())
RETURN
GO
CREATE PROC End_TrainTime @algorithm_name varchar(80) AS

WHERE Algorithm = @algorithm_name
RETURN
GO
CREATE PROC Create_Table AS

DECLARE @AttNum int
SET @AttNum = 0
SET @StrTemp = 'CREATE TABLE VarInpAtt (NumReg int PRIMARY KEY NOT NULL, '
BEGIN
SET @StrTemp = @StrTemp + 'A' +
CAST (@AttNum AS varchar(3)) + ' varchar (1) NULL, '
END
SET @StrTemp = @StrTemp + 'Class varchar (3) NULL) ON [PRIMARY]'
EXEC (@StrTemp)
RETURN
GO

Algorithm varchar (80) PRIMARY KEY NOT NULL,
Train_Time float NULL
) ON [PRIMARY]
GO
207
EXEC Create_Table
GO
EXEC Create_Data_views
GO

SELECT COUNT(*) AS Train_Cases FROM Train
GO
Listagem E.16. VarNumCases - Script gerador do banco de dados
USE master
GO
CREATE DATABASE VarNumCases

GO
USE VarNumCases
GO
CREATE PROC Create_Train_View @num_cases int AS

DROP VIEW Train
DELETE FROM Train_Count
INSERT Train_Count (Train_Cases) VALUES (@num_cases)
EXEC ('CREATE VIEW Train AS SELECT * FROM VarNumCases ' +
'WHERE NumReg <= ' + @num_cases)
RETURN
GO
CREATE PROC Create_Train_Part_View @algorithm_name varchar (80),

@ind_view int, @inc_reg int, @num_cases int AS
DECLARE @ini_reg AS int
DECLARE @end_reg AS int
SET @ini_reg = @inc_reg * (@ind_view - 1) + 1
SET @end_reg = @ini_reg + @inc_reg - 1
IF @end_reg > @num_cases
SET @end_reg = @num_cases
DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM VarNumCases ' +
'WHERE (NumReg >= ' + @ini_reg +
' AND NumReg <= ' + @end_reg + ')')
UPDATE ProcessingTimes SET Train_Cases = @end_reg
RETURN
GO

DECLARE @Train_Cases AS int
SET @Train_Cases = (SELECT Train_Cases FROM Train_Count)
IF NOT EXISTS (SELECT Train_Cases FROM ProcessingTimes
WHERE Algorithm = @algorithm_name)
INSERT ProcessingTimes (Algorithm) VALUES (@algorithm_name)
SET Train_Cases = @Train_Cases, Train_Start_Time = GetDate ()
RETURN
GO

208
RETURN
GO
CREATE PROC Init_TrainPredTime @algorithm_name varchar(80) AS

IF NOT EXISTS (SELECT Train_Cases FROM ProcessingTimes
WHERE Algorithm = @algorithm_name)
INSERT ProcessingTimes (Algorithm) VALUES (@algorithm_name)
RETURN
GO
CREATE PROC End_TrainPredTime @algorithm_name varchar(80) AS

SET Train_Pred_Time =
datediff (second, Train_Pred_Start_Time, Train_Pred_End_Time)
RETURN
GO
CREATE PROC Insert_Results AS

INSERT INTO Test_Results SELECT * FROM Train_Results
RETURN
GO

DECLARE @AttNum int
SET @AttNum = 0
SET @StrTemp = 'CREATE TABLE VarNumCases ' +
'(NumReg int PRIMARY KEY NOT NULL, '
BEGIN
CAST (@AttNum AS varchar(3)) + ' varchar (1) NULL, '
END
EXEC (@StrTemp)
RETURN
GO
CREATE PROC Create_TableC AS

DECLARE @AttNum int
SET @AttNum = 0
SET @StrTemp = 'CREATE TABLE VarNumCases ' +
BEGIN
CAST (@AttNum AS varchar(3)) + ' float NULL, '
END
EXEC (@StrTemp)
RETURN
GO
CREATE PROC Set_Model_Size @algorithm_name varchar (80),

@model_size integer AS
UPDATE ProcessingTimes SET Model_Size = @model_size
RETURN
GO

Algorithm varchar (80) PRIMARY KEY NOT NULL, Train_Cases int NULL,
209
Train_Time float NULL,
Train_Pred_Time float NULL,
Model_Size int NULL
) ON [PRIMARY]
GO
CREATE TABLE Train_Count (

Train_Cases int NULL
) ON [PRIMARY]
GO
EXEC Create_Table
GO
EXEC Create_Train_View 100

GO

SELECT COUNT(*) AS All_Cases FROM VarNumCases
GO
EXEC ('CREATE VIEW Train1 AS SELECT * FROM VarNumCases ' +

'WHERE NumReg <= 10000')
GO

'WHERE NumReg > 10000 AND NumReg <= 25000')
GO

GO

GO

GO

GO

GO

GO
Listagem E.17. VarStates - Script gerador do banco de dados
USE master
GO
CREATE DATABASE VarStates

GO
USE VarStates
GO
CREATE PROC Create_Train_View @num_states int AS

DECLARE @table_name AS varchar (20)
210
DROP VIEW Train
SET @table_name = 'VarStates' + CAST (@num_states as varchar (10))
EXEC ('CREATE VIEW Train AS SELECT * FROM ' + @table_name)
RETURN
GO

INSERT ProcessingTimes (Algorithm, Train_Start_Time)
VALUES (@algorithm_name, GetDate())
RETURN
GO

RETURN
GO
CREATE PROC Create_Table @num_states int AS

DECLARE @AttNum AS int
DECLARE @StrTemp AS varchar (8000)
SET @AttNum = 0
SET @StrTemp = 'CREATE TABLE VarStates' +
CAST(@num_states AS varchar (10)) +
' (NumReg int PRIMARY KEY NOT NULL, '
BEGIN
CAST (@AttNum as varchar (2)) + ' varchar (2) NULL, '
END
EXEC (@StrTemp)
RETURN
GO

) ON [PRIMARY]
GO
EXEC Create_Table 2
GO
EXEC Create_Table 5
GO
EXEC Create_Table 10
GO
GO
GO
GO

GO
EXEC Create_Train_View 2
GO
211
GO
Listagem E.18. VarPredAtt - Script gerador do banco de dados
USE master
GO
CREATE DATABASE VarPredAtt

GO
USE VarPredAtt
GO
CREATE PROC Create_Train_View AS

DROP VIEW Train
EXEC ('CREATE VIEW Train AS SELECT * FROM VarPredAtt')
RETURN
GO

INSERT ProcessingTimes (Algorithm, Train_Start_Time) VALUES
(@algorithm_name, GetDate())
RETURN
GO

SET Train_End_Time = GetDate() WHERE Algorithm = @algorithm_name
RETURN
GO

DECLARE @AttNum int
SET @AttNum = 0
SET @StrTemp = 'CREATE TABLE VarPredAtt ' +
BEGIN
CAST (@AttNum as varchar (2)) + ' varchar (2) NULL, '
END
SET @StrTemp = @StrTemp + 'A40 varchar (2) NULL) ON [PRIMARY]'
EXEC (@StrTemp)
RETURN
GO

Train_Start_Time datetime NULL,
Train_End_Time datetime NULL,
) ON [PRIMARY]
GO
EXEC Create_Table
GO
EXEC Create_Train_View
212
GO

GO
Este experimento possui uma série de utilitários DTS que na sua maioria são
semelhantes aos descritos anteriormente, a não ser por alguns que possuem
características relevantes e que serão reproduzidos a seguir.
Figura E.18. VarNumCases – Tarefa de predição por partes do classificador SNBi
Figura E.19. VarNumCases – Processamento das tarefas de predição por partes do classificador
SNBi
A Figura E.18 mostra o fluxo de processamento da tarefa de predição por partes
do Classificador SNBi. As tarefas Create Train View, Train Prediction e Inc View são
repetidas tantas vezes quanto necessário para completar a predição de todos os
casos desejados. O script de comandos Visual Basic®, invocado pela tarefa Init View
processa as inicializações necessárias para a execução das tarefas que serão
213
repetidas a seguir, conforme mostra o código fonte da Listagem E.19. O controle desta
repetição é efetuado pela tarefa Inc View conforme mostra o script da Listagem E.20.
Este utilitário possui ainda variáveis globais definidas para permitir a sua utilização
para todas as tarefas de predição desejadas. Assim existe variáveis para o índice da
vista ativa, para o incremento do número de casos, para o número total de casos,
para o nome da tarefa sendo processada e também para o número de vistas que é
calculada pela tarefa Init View, conforme mostra o script da Listagem E.19. A Figura
E.19 mostra o utilitário empregado para o processamento de todas as tarefas de

predição por partes do Classificador SNBi, que através de definições adequadas para
as variáveis globais descritas faz uso do mesmo utilitário mostrado pela Figura E.18 para
executar todas as tarefas.
Listagem E.19. Script de inicialização de repetição de tarefas
Function Main()
DTSGlobalVariables("ind_view").Value = 1
DTSGlobalVariables("num_views").Value = CInt (DTSGlobalVariables("num_cases").Value
/ DTSGlobalVariables("inc_reg").Value)
if (DTSGlobalVariables("num_views").Value * DTSGlobalVariables("inc_reg").Value <
DTSGlobalVariables("num_cases").Value) then
DTSGlobalVariables("num_views").Value = DTSGlobalVariables("num_views").Value + 1
end if
DTSStepExecStat_Inactive
End Function
Listagem E.20. Script de repetição de tarefas
Function Main()
If DTSGlobalVariables("ind_view").Value < DTSGlobalVariables("num_views").Value
Then
DTSGlobalVariables("ind_view").Value = DTSGlobalVariables("ind_view").Value + 1
Else
End If
End Function
214
Figura E.20. VarNumCases – Tarefa de treinamento do classificador SNBi
A Figura E.20 mostra o utilitário empregado para a tarefa de treinamento do

Classificador SNBi, que também possui variáveis globais definidas de forma que um
outro utilitário semelhante ao utilizado para o processamento das tarefas de predição,
proceda a execução de todas as tarefas de treinamento.
As tabelas seguintes mostram os comandos SQL DM utilizados neste experimento.

Como já foi feito anteriormente, é utilizado o recurso de representar as repetições
extensas de itens destes comandos por três pontos consecutivos (...).
A Tabela E.8 mostra os comandos SQL DM utilizados para a criação dos modelos
de DM de 12 atributos do procedimento de Variação do Número de Atributos de
Dados. Os comandos para os outros números de atributos são semelhantes. Este
procedimento do experimento não tem tarefa de predição.
Tabela E.8. VarInpAtt - Comandos SQL DM para criação do modelo de DM com 12 atributos de
dados
SNBi CREATE MINING MODEL [SNBi_12att] ([NumReg] LONG KEY, [A1] TEXT DISCRETE,
[A2] TEXT DISCRETE, ... [A12] TEXT DISCRETE, [Class] TEXT DISCRETE
PREDICT_ONLY) USING Simple_Naive_Bayes
MSDT CREATE MINING MODEL [MSDT_12att] ([NumReg] LONG KEY, [A1] TEXT DISCRETE,
[A2] TEXT DISCRETE, ... [A12] TEXT DISCRETE, [Class] TEXT DISCRETE
PREDICT_ONLY) USING Microsoft_Decision_Trees
Tabela E.9. VarNumCases - Comandos SQL DM para criação do modelo de DM
215
SNBi CREATE MINING MODEL [SNBi_DiscAtt] ([NumReg] LONG KEY, [A1] TEXT
DISCRETE, [A2] TEXT DISCRETE, ... [A20] TEXT DISCRETE, [Class] TEXT
DISCRETE PREDICT_ONLY) USING Simple_Naive_Bayes
MSDT CREATE MINING MODEL [MSDT_DiscAtt] ([NumReg] LONG KEY, [A1] TEXT
DISCRETE PREDICT_ONLY) USING Microsoft_Decision_Trees
A Tabela E.9 mostra os comandos SQL DM utilizados para a criação dos modelos
de DM para o estudo de Variação do Número de Casos. A Listagem E.21 mostra o
comando para a tarefa de predição dos dados de teste do classificador SNBi.
A Tabela E.10 mostra os comandos SQL DM utilizados para a criação dos
modelos de DM do procedimento de Variação do Número de Estados dos Atributos
de Dados. Por outro lado a Tabela E.11 mostra os comandos SQL DM utilizados para a
criação dos modelos de DM do procedimento de Variação do Número de Atributos
de Predição para 32 atributos. Os comandos para outros números de atributos são
semelhantes. Estes dois últimos procedimentos do experimento também não possuem
tarefa de predição.
Listagem E.21. VarNumCases - Comando SQL DM para predição dos dados de teste, classificador
SNBi
SELECT FLATTENED [T1].[NumReg], [T1].[A1], [T1].[A2], ... [T1].[A20],

[SNBi_DiscAtt].[Class] as Class
FROM [SNBi_DiscAtt] PREDICTION JOIN
OPENROWSET ('SQLOLEDB.1', 'Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist
Security Info=False;Initial Catalog=VarNumCases;Data Source=CLC',
'SELECT "NumReg", "A1", "A2", ... "A20" FROM "Train" ORDER BY "NumReg"') AS [T1]
ON
[SNBi_DiscAtt].[NumReg] = [T1].[NumReg] AND [SNBi_DiscAtt].[A1] = [T1].[A1] AND
[SNBi_DiscAtt].[A2] = [T1].[A2] AND ... [SNBi_DiscAtt].[A20] = [T1].[A20]
Tabela E.10. VarStates - Comandos SQL DM para criação do modelo de DM
SNBi CREATE MINING MODEL [VarStates_SNBi] ([Num Reg] LONG KEY, [A1] TEXT
DISCRETE PREDICT_ONLY) USING Simple_Naive_Bayes
MSDT CREATE MINING MODEL [VarStates_MSDT] ([Num Reg] LONG KEY, [A1] TEXT
DISCRETE PREDICT_ONLY) USING Microsoft_Decision_Trees
216
Tabela E.11. VarPredAtt - Comandos SQL DM para criação do modelo de DM com 32 atributos de
predição
SNBi CREATE MINING MODEL [SNBi_40att_32pred] ([Num Reg] LONG KEY, [A1] TEXT
DISCRETE, [A2] TEXT DISCRETE, ... [A8] TEXT DISCRETE, [A9] TEXT DISCRETE
PREDICT, [A10] TEXT DISCRETE PREDICT, ... [A40] TEXT DISCRETE PREDICT)
USING Simple_Naive_Bayes
MSDT CREATE MINING MODEL [MSDT _40att_32pred] ([Num Reg] LONG KEY, [A1] TEXT
DISCRETE, [A2] TEXT DISCRETE, ... [A8] TEXT DISCRETE, [A9] TEXT DISCRETE
PREDICT, [A10] TEXT DISCRETE PREDICT, ... [A40] TEXT DISCRETE PREDICT)
USING Microsoft_Decision_Trees
217
Tese de Doutorado

http://curotto com
http://curotto.com
Conteúdo
 I t d ã
Introdução
 Trabalhos Correlatos
 Processo de KDD
 Classificador Incremental Bayesiano

y Simples
p
 Provedor de DM
 Experimentos Computacionais
 Conclusão
 T b lh Futuros
Trabalhos F t
Maio, 2003 Integração de Recursos de Data Mining com Gerenciadores de Bancos de Dados Relacionais 2
Introdução
ç
 M ti ã (desenvolvimento
Motivação (d l de
d tecnologia
l de
d KDD))
 Crescimento explosivo dos bancos de dados
 A li ã das
Ampliação d áreas
á de
d aplicação
li ã
 Exemplos:
 Comerciais:
 Wal-Mart – armazena 20 milhões de transações diárias
 Mobil Oil – capacidade 100 terabytes de dados de exploração de petróleo
 Científicos:
 Projeto Genoma – coletou gigabytes de dados do código

ó genético
é humano
 Projeto EOS (sistema de observação terrestre) da NASA – produz 528

gigabytes de dados por dia
Sistema EOS
Áreas de aplicação
p ç - Comerciais
 C
Comercialização:
i li ã segmentação,
t ã localização
l li ã ded consumidores,
id hábitos
hábit
de consumo
 Financeira: apoio para investimentos, controle de carteira de ações
 Bancária: política de aprovação de crédito
 Segurança: detecção de bombas, icebergs e fraudes
 Manufatura: modelagem e controle de processos

processos, controle de
qualidade, alocação de recursos
 Internet: ferramentas de busca,

busca navegação
navegação, extração de dados
 Gerencial: tomadas de decisão, gerenciamento de documentos
Áreas de aplicação
p ç - Científicas
 Ciências e Medicina: descoberta de hipóteses, predição, classificação

e diagnóstico
 Engenharia: simulação, reconhecimento de padrões, processamento

de sinais, planejamento, ?
Cenário
 Microsoft® SQL Server™ + microcomputadores:
 terabytes
y de dados com p
processamento paralelo
p de consultas
(usando múltiplos servidores com multiprocessadores)
 Serviços de Análise: OLAP (processamento analítico em tempo real)

e de DM (mineração de dados)
 Tecnologia OLE DB DM (conjunto de interfaces que permite a

integração de recursos de DM entre aplicativos)
Conjuntura
j
Sugere
g a integração
g ç da tecnologia
g de
DM usando gerenciadores de bancos
de dados a baixo custo
Conteúdo
 I t d ã
Introdução
 Processo de KDD

y Simples
p
 Provedor de DM
 Conclusão
 T b lh Futuros
Trabalhos F t
Trabalhos Correlatos
 Projeto Quest (IBM®)

 AGRAWAL & SHIM (1995) apresentaram uma metodologia para acoplamento
de um aplicativo de DM com um SGBD relacional baseada na utilização de
funções SQL criadas pelo usuário e procedimentos armazenados
 SARAWAGI, THOMAS & AGRAWAL (1998) consideraram várias alternativas de

arquitetura para realizar esse acoplamento
 Projeto dbMiner
 HAN et alii (1996) liderou um grupo de pesquisa que desenvolveu uma série de
trabalhos de integração de técnicas de DM com OLAP. Este projeto evoluiu
para um produto comercial (DBMINER, 2002).
 JOHN (1997) forneceu sugestões relativas ao uso de SQL por

algoritmos de ML (aprendizado de máquina)
 FREITAS & LAVINGTON (1996 e 1997) definiram primitivas de SQL

adequadas ao uso por algoritmos de DM
 SOUSA,, MATTOSO & EBECKEN (1998)

( ) implementaram
p um
classificador de árvores de decisão usando PL/SQL em um servidor
de processamento paralelo da Oracle®
 BEZERRA & XEXÉO (1998) implementaram funcionalidades

internas p
para extração
ç e armazenamento de regras
g em um SGBD
de uso experimental
 Tecnologia OLE DB DM
 Julho de 2000, publicação da especificação desta tecnologia
 Setembro de 2000, lançamento do módulo de Serviços de Análise do MSSQL

2000 com o primeiro provedor de DM, incluindo algoritmos para classificação
ã
através de árvores de decisão e para clusterização
 Março de 2001,
2001 lançamento do recurso de agregação de provedores de DM
DM,
incluído no SP1
 Junho de 2001, disponibilidade do kit de recursos, contendo o código fonte de

um exemplo de provedor. Atualizado em Março de 2002
 NETZ et alii (2000, 2001) e FAYYAD, CHAUDHURI & BRADLEY (2000)

apresentaram trabalhos descrevendo esta tecnologia.
tecnologia SEIDMAN (2001)
publicou um excelente manual de referência para o uso desta tecnologia.
Conteúdo
 I t d ã
Introdução
 Processo de KDD

y Simples
p
 Provedor de DM
 Conclusão
 T b lh Futuros
Trabalhos F t
Processo de KDD
Processo de KDD
Problema Conhecimento
Ident ificação do O ciclo virtuoso Ação baseada no

problema conheciment o
Estratégia Mensuração do efeit o Resultados

da ação
O Processo
P de
d KDD no contexto
t t d de solução
l ã d de um problema
bl (SILVER
(SILVER, 1998)
Processo de KDD
Interpretação e avaliação
Conheciment o
Mineração dos dados
p(x)=0.02
Seleção e pré-processamento
é
Padrões e Modêlos
ç
Consolidação de dados
Warehouse Dados Preparados
Dados Consolidados
Fontes de Dados
Etapas do processo de KDD (FAYYAD, PIATETSKY-SHAPIRO & SMYTH, 1996)
Conteúdo
 I t d ã
Introdução
 Processo de KDD

y Simples
p
 Provedor de DM
 Conclusão
 T b lh Futuros
Trabalhos F t
Implementações
p ç incrementais
 CRAWFORD (1989) - versão incremental do CART (Classification
g
and Regression Trees)) (BREIMAN
( et alii,, 1984))
 UTGOFF (1989, 1994) - resultado obtido a partir da árvore

atualizada por novos dados igual à árvore produzida pelo conjunto
t t ld
total de d
dados
d
 KALLES (1994) – árvore de decisão para aplicações de

reconhecimento de padrões (transformação da representação
gráfica de caracteres para um código seqüencial)
 VAILAYA & JAIN (1999) - classificador Bayesiano para classificar

imagens
 CRAVEN et alii ((2000)) - classificador Bayesiano

y p
para formação
ç de
uma base de conhecimento a partir de extração de dados textuais
da Internet
Classificador Bayesiano
y Simples
p
 Apresenta resultados melhores do que algoritmos mais sofisticados
(FRANK et alii
alii, 2000).
2000)
 DOMINGOS & PAZZANI (1996, 1997) mostraram que mesmo para
problemas com presença de forte dependência entre atributos ele
apresentou
t b bons resultados
lt d
 LANGLEY, IBA & THOMPSON (1992) demonstraram através de
uma análise formal o excelente comportamento deste classificador
em comparação com outros mais sofisticados e frente a problemas
complexos e com distúrbio de dados
 Redes Bayesianas - abordagens que procuram traduzir a

dependência entre atributos (HANSON, STUTZ & CHEESEMAN,
1991; CHEESEMAN & STUTZ
STUTZ, 1995)
 MADIGAN & RIDGEWAY (2002) - características dos algoritmos
Bayesianos
y p
para aplicações
p ç de DM
Teorema de Thomas Bayes
y
P(B | A ) P( A )
P( A | B ) =
P(B )
onde:
P(A|B) probabilidade de ocorrência do evento A dado que o evento B

já tenha ocorrido
P(B|A) probabilidade de ocorrência do evento B dado que o evento A
já tenha ocorrido
P(A) probabilidade de ocorrência do evento A
P(B) probabilidade de ocorrência do evento B
P(A) e P(B) são probabilidades a priori, pois independem de qualquer
conhecimento anterior, por outro lado, P(A|B) e P(B|A) são probabilidades a posteriori,
pois dependem de conhecimento anterior (da ocorrência de outros fatos).
Algoritmo
g de Treinamento do Classificador SNB – parte 1
Se houver dados de t reinament o ant erior
Recupere v (número de casos de t reinament o)
Recupere p (número de at ribut os de predição)
Para t = 1, p
Recupere mt (número de classes para o at ribut o de predição t)
Para j = 0, mt
R
Recupere s tj (número
( ú d
de casos d
de classe
l c tj , para o att ribut
ib t o de di ã t)
d predição
Para i = 1, n
Recupere oit (número de at ribut os possíveis para cada at ribut o ait , para o at ribut o
di ã t
d predição
de
Para h = 1, oit Recupere rjith (número de casos de classe c tj t endo o valor x ij , de
ordem h, para o at ribut o ait , para o at ribut o de predição t)
Recupere z tji (somat ória dos valores x ij para o at ribut o ait dos casos de classe c tj ,
para o at ribut o de predição t)
Recupere qtjji (somat ória dos quadrados dos valores x ij para o at ribut o ait dos
casos de classe c tj , para o at ribut o de predição t)
Fim de Se houver dados de t reinament o ant erior
Algoritmo
g de Treinamento do Classificador SNB – parte 2
Para cada caso de t reinament o novo

Increment e vn (número de casos de t reinament o novos)
Para t = 1 at e p
Defina j da classe c tj do caso at ual (j = 0 para classe ausent e)
Increment e s tj
Para i = 1, n (número de at ribut os de dados)
Defina a ordem h do at ribut o at ual (h = 0 para at ribut o ausent e)
Increment e rjith
Se o at ribut o for cont ínuo
Adicione x ij a ztji
Adicione ( x ij )2 a qtji
Fim de Se o at ribut o for cont ínuo
Fim de Para t = 1 at e p
Fim de Para cada caso de t reinament o novo
Adicione vn a v
Algoritmo
g de Predição
ç do Classificador SNB – parte 1
P
Para t = 1,
1 p (número
( ú de
d att ribut
ib t os de
d predição)
di ã )
Para j = 0, mt (número de classes para o at ribut o de predição t)
s tj
F
Faça Pjt = ( b bilid d a priori
(probabilidade i i das
d classes)
l )
r
Para i = 1, n (número de at ribut os de dados)
Defina a ordem h do at ribut o at ual ((h = 0 p
para at ribut o ausent e))
Comput e a probabilidade correspondent e ao at ribut o
Escolha o maior valor ent re os valores de Pjt para j = 0, mt definindo o valor de j
Defina a classe do caso desconhecido Yt como sendo a de índice j

Algoritmo
g de Predição
ç do Classificador SNB – parte 2
Computo da probabilidade correspondente ao atributo
Se o at ribut o for discret o

rjith
Mult iplique Pjt por
s tj
Senão (o at ribut o é cont ínuo)

z tji
Faça μ jit = (fórmula IV
IV-5)
5)
rjit1
t2
t z ji
q ji −
rjit1
Faça σ jit = (fórmula IV-6)
rjit1 −1
2
t t
1  yi − μ ji 
−
1 2  σ jit 
Mult iplique Pjt por e   (fórmula IV-4)
2πσ jit
Fim de Se o at ribut o for discret o
Conteúdo
 I t d ã
Introdução
 Processo de KDD

y Simples
p
 Provedor de DM
 Conclusão
 T b lh Futuros
Trabalhos F t
Sistemas de Integração
g ç com SGBDs
 BEZERRA, MATTOSO & XEXÉO (2000) – classificação
 Sistemas Externos
 SGBD como repositório de dados
 Vantagens: portabilidade
 Desvantagens: elevado tráfego de dados; isolamento do aplicativo em relação
à desenvolvimentos futuros; não uso das facilidades do SGBD
 Exemplo: dbMiner (HAN & KAMBER,
KAMBER 2001; DBMINER,
DBMINER 2002) pode ser
enquadrado nesta categoria
 Sistemas Internos
 Integração total com o SGBD
 Vantagens: potencial para melhores resultados de processamento;
armazenamento do modelo de DM
 Desvantagens: total falta de portabilidade; duplicação de esforço de
desenvolvimento
 Exemplo: BEZERRA & XEXÉO (1998, 1999) – implementação de
funcionalidades internas para extração e armazenamento de regras em um
SGBD de uso experimental
Sistemas de Integração
g ç com SGBDs – Sistemas Acoplados
 Acoplamento Íntimo
 Usa comandos SQL e extensões da linguagem
 Vantagem: aproveita características internas tais como paralelismo e
distribuição
 Desvantagem: falta de portabilidade e elevado custo de desenvolvimento; uso
indiscriminado de SQLs produz baixa performance
 Exemplo: SOUSA, MATTOSO & EBECKEN (1998)
 Acoplamento por API
 Usa comandos SQL quando conveniente sem utilizar recursos proprietários
 Vantagens: pode aproveitar características internas tais como paralelismo e
distribuição
 Desvantagens: se for utilizada API proprietária terá falta de portabilidade
 Exemplo: BERNHARDT, CHAUDHURI S. & FAYYAD (1999) implementaram um
aplicativo para classificação de árvores de decisão (MSDT)
Tecnologia
g OLE DB DM
 Acoplamento por API padrão

 Usa comandos SQL quando conveniente sem utilizar recursos proprietários
 SGBD pode gerenciar diferentes aplicativos desenvolvidos por desenvolvedores
distintos para cada tarefa que constitui o processo de KDD
 T t l
Totalmente t iindependente
d d t d de qualquer
l fabricante,
f bi t d de qualquer
l software
ft ou d
de
qualquer provedor de dados
 Armazenamento do modelo de DM realizado através da especificação PMML
 Vantagens: pode aproveitar características internas tais como paralelismo e
distribuição; padronização possibilita total portabilidade; possibilita integração
entre as diversas etapas do processo de KDD; possibilita funcionamento com
aplicativo
p independente,
p , isolado de qualquer
q q SGBD.
 Desvantagens: possível perda de performance em relação aos sistemas
internos
 Exemplos: MSDT; SNB
Arquitetura MDAC
Consumidores de
Aplicativo dados Browser
IIS – Internet Information Services
ADO - ActiveX Data Objects
OLE DB Service Providers
Cursor Engine Query Engines MSOLAP Others
OLE DB
DB, DB ffor OLAP & DB for
f DM Data
D t Providers
P id
SQLOLEDB MSJet MSOLAP MSDMine DMclcMine Others
Jet (Access & Other

MOLAP & Data Mining Data Mining
SQL Server other)) databases or
ROLAP cubes Models Models
databases files
Data Stores
Ferramentas
 Microcomputador IBM® PC compatível, Intel® Pentium III 500

MHz 512 Mb RAM
MHz, RAM, 30 MB HD
HD, Mem
Mem. Virtual 768 Mb inicial,
inicial 2048
Mb máxima
 Windows 2000 Advanced Server SP3
 MS SQL Server 2000 Enterprise SP3
 MS Visual Studio 6.0 SP5 com Visual C++,, Visual J++ e Visual
Basic
 MS Platform SDK February 2001 Edition
 Sandstone Visual++ Parse 4.00
 OLE DB for DM Resource Kit
 Visualizadores de tabelas virtuais DMSamp e RowsetViewer
Provedor DMclcMine
 Desenvolvido a partir do código fonte do kit de recursos OLE DB

DM
 Todos os objetos OLE DB requeridos, tais como sessão, comando e tabelas
virtuais;
 Analisador de sintaxe dos comandos OLE DB DM;
 Montador dos elementos sintáticos dos dados de entrada;
 Mecanismo de processamento de consultas;
 Classificador Bayesiano Simples para atributos discretos;
 Armazenamento do modelo nos formatos binário e XML.
 Área de trabalho Visual C++ com:
 14 projetos
 541 arquivos fonte com ~10 MB
AllElet - Dados de treinamento
Caso Valores dos atributos

1 <=30 high no fair no

2 <=30
30 high no excellent no
3 31-40 high no fair yes
4 >40 medium no fair yes
5 >40 low yes fair yes
6 >40 l
low yes excellent
ll t no
7 31-40 low yes excellent yes
8 <=30 medium no fair no
9 <=30 low yyes fair yyes
10 >40 medium yes fair yes
11 <=30 medium yes excellent yes
12 31-40 medium no excellent yes
13 31 40
31-40 high yes
es fai
fair yes
es
14 >40 medium no excellent no
Operações
p ç Fundamentais do Provedor de DM - NETZ et alii ((2000, 2001))
1. Criar o modelo de DM, identificando o conjunto de atributos de

dados a serem preditos
preditos, o conjunto de atributos de dados a
serem utilizados para predição e o algoritmo utilizado para
construir o modelo de DM.
2. Povoar o modelo de DM utilizando o algoritmo especificado com
os dados de treinamento.
3. Predizer os atributos para novos dados utilizando o modelo de
DM que foi povoado.
4. Exibir o modelo de DM para aplicativos de visualização e de
geração de relatórios.
Criando o Modelo de DM
Consulta gerada pelo Editor Relacional de Modelos de DM do

Gerenciador de Serviços de Análise:
CREATE MINING MODEL [AllElet_SNB]
([NumReg] LONG KEY,
KEY
[Age] TEXT DISCRETE,
[Income] TEXT DISCRETE,
DISCRETE
[Student] TEXT DISCRETE PREDICT,
[CreditRating] TEXT DISCRETE,
DISCRETE
[BuysComputer] TEXT DISCRETE PREDICT)
USING Si
Simple_Naive_Bayes
l N i B
AllElet - Arquivo
q XML de criação
ç do modelo de DM
<pmml name = "AllElet_SNB" GUID = "{4888A64B-C5A3-4CF8-AFB7-593495434496}"
creation-time
ti ti = "2003
"2003-05-03T01:35:34"
05 03T01 35 34" modified-time
difi d ti = "2003-05-03T01:35:34">
"2003 05 03T01 35 34"
<statements>
<statement type = "CREATE" value = "CREATE MINING MODEL [AllElet_SNB]
[St d t] TEXT DISCRETE PREDICT
[Student] PREDICT, [C
[CreditRating]
ditR ti ] TEXT DISCRETE,
DISCRETE
</statements>
<k name = "NumReg"
<key "N R " d datatype
t t = "LONG" iisinput
i t = "true"
"t " column-ordinal
l di l = "0"/>
<categorical name = "Age" isinput = "true" datatype = "TEXT"
column-ordinal = "1"/>
<categorical name = "Income" isinput = "true" datatype = "TEXT"
column-ordinal
l di l = "2"/>
<categorical name = "CreditRating" isinput = "true" datatype = "TEXT"
column ordinal = "4"/>
column-ordinal
</data-dictionary>
<Simple naive bayes model/>
<Simple-naive-bayes-model/>
</pmml>
Povoando o Modelo de DM
Consulta gerada pelo Editor Relacional de Modelos de DM do

Gerenciador de Serviços de Análise:
INSERT INTO [AllElet_SNB'S] (SKIP, [Age], [Income],
[Student] [CreditRating],
[Student], [CreditRating] [BuysComputer])
OPENROWSET ('SQLOLEDB.1','Provider=SQLOLEDB;
Integrated Security=SSPI;Persist Security
Info=False;Initial Catalog=AllElet;Data Source=CLC',
'SELECT "NumReg", "Age", "Income", "Student",
"CreditRating" "BuysComputer" FROM "AllEletTrain"')
"CreditRating",
AllElet - Arquivo
q XML do modelo completo
p de DM – parte 1
<pmml name = "AllElet_SNB" GUID = "{4888A64B-C5A3-4CF8-AFB7-593495434496}"
<statements>
<statement type = "CREATE" value = "CREATE MINING MODEL [AllElet_SNB]
</statements>
AllElet - Arquivo
p de DM – parte 2
<categorical
t i l name = "Age"
"A " isinput
i i t = "true"
"t "
<category value = "<=30"/>
<category
t value
l = "31
"31-40"/>
40"/
<category value = ">40"/>
</categorical>
…
</categorical>
…
</ t
</categorical>
i l>
…
</categorical>
<categorical name = "BuysComputer" isinput = "true" ispredict = "true“
…
</categorical>
</data-dictionary>
AllElet - Arquivo
p de DM – parte 3
<global-statistics>
<data-distribution>
</data distribution>
<data-distribution>
…
<data-distribution>
…
<data-distribution>
…
<data-distribution>
…
</global-statistics>
AllElet - Arquivo
p de DM – parte 4
<Simple-naive-bayes-model>
<info name = "Count of Cases" value = "14"/>
<info
i f name = "Count
"C t off T
Trees"" value
l = "2"/
"2"/>
<data-distribution>
<state
t t value
l = ""no"" supportt = "7" "7">
<data-distribution>
< t t value
<state l = "31"31-40"
40" supportt = "2"/>
…
</ t t >
</state>
…
<data-distribution>
<simple attribute name = "BuysComputer"/>
<simple-attribute
…
</Simple naive bayes model>
</Simple-naive-bayes-model>
</pmml>
Predizendo Atributos
Consulta criada com o auxílio do DTS do MS SQL Server ou do
utilitário DMSamp:
SELECT FLATTENED [T1].[NumReg], [T1].[Age], [T1].[Income],
[T1].[Student], [T1].[CreditRating], [T1].[BuysComputer],
[AllElet SNB] [BuysComputer] as BuysComputer FROM
[AllElet_SNB].[BuysComputer]
[AllElet_SNB] PREDICTION JOIN OPENROWSET ('SQLOLEDB.1',
'Provider=SQLOLEDB.1;Integrated Security=SSPI;Persist
Security Info=False;Initial
Info False;Initial Catalog=allelet;Data
Catalog allelet;Data Source=CLC'
Source CLC ,
'SELECT "NumReg", "Age", "Income", "Student",
"CreditRating", "BuysComputer" FROM "AllElet" ORDER BY
"NumReg"')
NumReg ) AS [T1] ON [AllElet_SNB].[NumReg]
[AllElet SNB].[NumReg] =
[T1].[NumReg] AND [AllElet_SNB].[Age] = [T1].[Age] AND
[AllElet_SNB].[Income] = [T1].[Income] AND
[[AllElet_SNB].[Student]
_ ][ ] = [T1].[Student]
[ ][ ] AND
[AllElet_SNB].[CreditRating] = [T1].[CreditRating] AND
[AllElet_SNB].[BuysComputer] = [T1].[BuysComputer]
Expondo
p o Modelo de DM
Tabelas virtuais
 recuperadas por clientes do provedor de DM
através de comandos SQLQ DM do tipo
p Select
 diretamente através de chamadas de função de
recuperação das propriedades dos nós das
árvores de predição.
AllElet - Árvores do modelo p
para os atributos de predição
p ç
AllElet - Conteúdo da tabela virtual do modelo de DM
AllElet – Árvore do atributo de predição BuysComputer exibida pelo Internet Explorer
Conteúdo
 I t d ã
Introdução
 Processo de KDD

y Simples
p
 Provedor de DM
 Conclusão
 T b lh Futuros
Trabalhos F t
Experimentos
p Computacionais
p
 O primeiro deles, um problema clássico de DM, utiliza

um conjunto
j de
d dados
d d artificial
ifi i l para verificar
ifi a acurácia
á i
dos resultados e a velocidade de processamento em
comparação com outros classificadores
classificadores.
 Os dados de previsão do tempo e de seguro de vida
possibilitam estudar o comportamento do classificador
SNB perante dados reais.
 Os dados artificiais do q
quarto experimento
p são
utilizados para avaliar a escalabilidade e a performance
do classificador SNB considerando os fatores de
cardinalidade,
d l d d número
ú de
d atributos
b de
d dados,
d d número
ú
de estados dos atributos e número dos atributos de
predição
predição.
Waveform - Funções
Waveform - Medidas
Waveform - datasets
 Teste
 5000 casos repositório UCI
 Treinamento
 a, b, c, d, e: respectivamente 300, 5.000,
10.000,, 100.000 e 1.000.000 de casos
gerados randomicamente por um programa
Waveform - Classificadores utilizados
Classificador Descrição Parâmetros
SNB Classificador Incremental todos atributos de dados contínuos

Bayesiano do Provedor
SNBd DMclcMine todos atributos de dados discretizados
MSDT1 COMPLEXITY_PENALTY = 0.9,

MINIMUM_LEAF_CASES
MINIMUM LEAF CASES = 10, SCORE
SCORE_METHOD
METHOD =
4, SPLIT_METHOD = 3; todos atributos de dados
contínuos
MSDT2 COMPLEXITY_PENALTY=0,
MSDT (CHICKERING, GEIGER & MINIMUM LEAF CASES=1 SCORE_METHOD=4,
MINIMUM_LEAF_CASES=1, SCORE METHOD=4
HECKERMAN, 1994) SPLIT_METHOD=2; todos atributos de dados
contínuos
MSDT2d COMPLEXITY_PENALTY=0,
MINIMUM_LEAF_CASES=1,
MINIMUM LEAF CASES=1 SCORE_METHOD=4,
SCORE METHOD=4
SPLIT_METHOD=2; todos atributos de dados
discretizados
WEKA Implementação WEKA do todos atributos de dados contínuos;

Cl ifi d B
Classificador Bayesiano
i probabilidades
b bilid d não ã normalizadas
li d
(WITTEN & FRANK, 2000)
C45 C4.5 (Quinlan, 19932) todos atributos de dados contínuos; resultados

antes da poda
Waveform - Tempos de processamento (s)
Etapa Grupo SNB WEKA SNBd MSDT1 MSDT2 MSDT2d C45
a 5 3 2 3 4 3 1
b 5 58 4 13 46 6 6
Treinamento c 8 107 6 25 85 8 13
d 47 981 45 307 912 69 282
e 428 9629 429 ? ? 934 12684
a 1 2 2 1 1 1 0
b 22 40 22 18 19 19 0
Predição do
Treinamento
c 45 74 44 35 35 37 0
d 430 693 413 333 328 352 1
e 4111 6704 4079 ? ? 3801 13
a 23 64 21 18 18 18 1
b 22 64 22 19 18 17 1
Predição do
Teste
c 22 63 22 18 19 17 1
d 21 61 22 17 20 17 1
e 29 59 36 ? ? 23 1
a 29 69 25 22 23 22 2
b 49 165 48 50 83 42 7
Total c 75 244 72 78 139 62 14
d 498 1735 480 657 1260 438 284
e 4568 16392 4544 ? ? 4758 12698
Waveform - Tempo de treinamento x Número de casos
14000
C45
12000
T em p o d e T re in a m en t o (s)
WEKA
10000
8000
6000
4000
2000
MSDT2d
MSDT2 SNBd
0 SNB
MSDT1
0 200000 400000 600000 800000 1000000
N ú m ero d e C a sos
Waveform - Acurácia (%)
Dados Set SNB WEKA SNBd MSDT1 MSDT2 MSDT2d C45
a 81,00 81,00 82,67 76,33 100,00 80,67 97,67

b 81,76 81,76 81,52 79,54 98,62 78,60 95,64
Treinamento c 80,39 80,39 80,43 80,47 96,79 79,19 95,80
d 80,55 80,55 80,47 81,87 90,25 80,31 94,19
e 81,41 81,41 81,75 ? ? 85,37 94,24
a 80,94 80,94 79,26 67,72 68,78 67,72 71,24
b 80,86 80,86 80,78 74,42 76,16 74,42 76,18
Teste c 81 08
81,08 81 08
81,08 80 46
80,46 76 04
76,04 75 58
75,58 76 04
76,04 77 76
77,76
d 80,86 80,86 80,60 79,66 79,60 79,66 80,18
e 81,14 81,14 80,64 ? ? 79,66 80,60
Waveform – validação cruzada
Tempos de processamento (s)
Etapa SNB MSDT2
Treinamento 41 356
T t l
Total 266 540
Acurácia (%)
Dados SNB MSDT2
Treinamento 81,01±0,15 97,80±0,82

Teste 80,83±1,56 74,72±1,43
Meteo - Previsão de Tempo
De 1951 a 1960 - Instituto de Pesquisas Meteorológicas

da UNESP coletou dados meteorológicos no Aeroporto
Internacional do Rio de Janeiro p
para elaboração
ç de um
modelo para previsão de nevoeiro
Dados, coletados diariamente, hora a hora, compostos
por 36 atributos perfazendo um total aproximado de
87600 casos. Existiram falhas na coleta
COSTA (1999) realizou um trabalho intensivo de
preparação
p p ç de dados que q resultou num conjunto
j de
dados composto por 26482 casos com 18 atributos de
dados e um atributo de predição (classe)
Meteo - Classificadores utilizados
SNB1 Classificador Incremental todos atributos de dados contínuos

SNB2 DMclcMine alguns atributos de dados discretos (ver
Apêndice E, item E.2)

MINIMUM_LEAF_CASES = 10, SCORE_METHOD =
4 SPLIT_METHOD
4, SPLIT METHOD = 3;
3 todos
t d atributos
t ib t ded dados
d d
MSDT (CHICKERING, GEIGER & contínuos
HECKERMAN, 1994)
MINIMUM_LEAF_CASES = 10, SCORE_METHOD =
4, SPLIT_METHOD = 3; alguns atributos de dados
discretos (ver Apêndice E, item E.2)
C45 C4.5 (Quinlan, 19932) todos atributos de dados contínuos; resultados

antes da poda
Meteo - Resultados
Etapa SNB1 SNB2 MSDT1 MSDT2 C45
Treinamento 10 10 28 20 19
Predição do Treinamento 72 69 58 59 0
Predição do Teste 33 32 26 27 1
Total 115 111 112 106 20
Acurácia (%)
Dados SNB1 SNB2 MSDT1 MSDT2 C45
Treinamento 57,81 64,99 80,61 79,93 95,53

Teste 56,17 63 30 79,44
56 17 63,30 79 44 78,44
78 44 78,97
78 97
Meteo – Resultados da validação cruzada
Etapa SNB2 MSDT1
Treinamento 156 496

Total 1368 1694
Acurácia (%)
Dados SNB2 MSDT1
Treinamento 64,72±0,11 80,72±0,19

Teste 64,02±0,61 80,39±0,87
Insurance - Dados de Seguro de Vida
Conjunto de dados extraído do data warehouse MASY

(STAUDT, KIETZ & REIMER, 1998) da companhia de
seguros
g européia
p SwissLife com a finalidade de servir
para uma competição denominada KDD Sisyphus I
(KIETZ & STAUDT, 1998)
Problema de grande dimensão e complexidade, tendo
sido exaustivamente preparado e estudado por COSTA
(1999)
Também foi objeto
j de estudo por
p BLOCKEEL & STRUYF
(2001), GÄRTNER (2001) e GÄRTNER, WU & FLACH
(2001)
Insurance - Diagrama
g de relacionamentos entre as tabelas originais
g
Insurance - Classificadores utilizados
SNB Classificador Incremental nenhum

DMclcMine

MINIMUM LEAF CASES = 10,
MINIMUM_LEAF_CASES 10 SCORE_METHOD
SCORE METHOD =
MSDT (CHICKERING, GEIGER & 4, SPLIT_METHOD = 3
HECKERMAN, 1994)
MINIMUM LEAF CASES = 10, SCORE_METHOD
MINIMUM_LEAF_CASES SCORE METHOD =
1, SPLIT_METHOD = 3
C45 C4.5 (Quinlan, 19932) resultados antes da poda
Dados preparados
p p
conjunto de dados preparados possui 130143

casos com 63 atributos
t ib t d
de dados
d d e um atributo
t ib t
de predição (classe)
Insurance - dados preparados
Etapa SNB MSDT1 MSDT2 C45
Treinamento 127 838 27396 270

Total 1049 1524 28220 279
Acurácia (%)
Dados SNB MSDT1 MSDT2 C45
Treinamento 70,88 89,50 93,87 99,02

Teste 70 88
70,88 87 96
87,96 90 24
90,24 92 57
92,57
Insurance – dados preparados - validação cruzada
Etapa SNB MSDT1

Total 10986 18926
Acurácia (%)
Dados SNB MSDT1
Treinamento 70,83±0,08 91,02±0,65

Teste 70,83±0,57 89,52±0,68
Dados originais
g
dados originais sem nenhuma preparação -

massa de
d dados
d d com 146796 registros
i t
Insurance - dados originais
Tempos de Processamento (s)
Etapa SNB MSDT1 MSDT2 C45
Treinamento 164 1158 90339 421

Total 1643 2588 91881 434
Acurácia (%)
Dados SNB MSDT1 MSDT2 C45
Treinamento 63.51 84,28 60,99 97,29

Teste 63 27
63,27 83 08
83,08 60 78
60,78 88 99
88,99
Insurance – dados originais - validação cruzada
Tempos de Processamento (s)
Etapa SNB MSDT1

Total 20015 31738
Acurácia (%)
Dados SNB MSDT1
Treinamento 65,01±0,48 86,46±0,88

Teste 64,97±0,80 85,45±1,01
Estudo de Performance
 SONI, TANG & YANG (2002) - estudo de performance para o
classificador MSDT
 Avaliar a escalabilidade e a performance do classificador SNB,

comparados com o classificador MSDT:
 Variação do Número de Atributos de Dados
 Variação do Número de Casos
 Variação do Número de Estados dos Atributos de Dados
 Variação
ç do Número de Atributos de Predição
ç
 Gerador de dados artificial (MELLI, 1999) para obtenção dos dados

de treinamento
 Em cada procedimento do experimento é medido o tempo de

treinamento para uma variável
Performance - Classificadores utilizados
SNB Classificador Incremental nenhum

B
Bayesiano
i d
do PProvedor
d
DMclcMine
MSDT MSDT (CHICKERING, GEIGER & COMPLEXITY_PENALTY = 0.9,

HECKERMAN 1994)
HECKERMAN, MINIMUM LEAF CASES = 10,
MINIMUM_LEAF_CASES 10 SCORE_METHOD
SCORE METHOD =
4, SPLIT_METHOD = 3
Variação
ç do Número de Atributos de Dados
M SD T ( 8 6 7 3 )
9000
8000
m p o d e T rrein a m en tto (s)
7000
SN B ( 6 2 8 5 )
6000
5000
4000
3000
2000
T em
1000
0
0 50 100 150 200
N ú m ero d e A t rib u t os
Variação
ç do Número de Casos - treinamento
8000
M SD T ( 7626)
7500
7000
SN B ( 6476)
6500
6000
m p o d e T rein a m en to (s) 5500
5000
4500
4000
3500
3000
T em
2500
2000
1500
1000
500
0
0 2000000 4000000 6000000 8000000 10000000
Variação
ç do Número de Casos - predição
M SD T p ( 1 1 0 0 2)
11000
10000 SN B ( 9 71 9 )
SN Bp
B ( 9 2 7 3)
9000
ed içã o (s) 8000
7000
6000
em p o d e P re
M SD T ( 4 9 87 )
5000
4000
Te
3000
2000
1000
0
0 500000 1000000 1500000 2000000
Variação
ç do Número de Casos - predição
Falta de
M SD T p ( 1 1 0 0 2)
11000
memória
10000 SN B ( 9 71 9 )
SN Bp
B ( 9 2 7 3)
Predição
9000 p/ partes
ed içã o (s) 8000
7000
Excedeu
6000 tempo limite
em p o d e P re
M SD T ( 4 9 87 )
5000
4000
Te
3000
2000
1000
0
0 500000 1000000 1500000 2000000
Variação
ç do Número de Casos – treinamento incremental
9500
a
SN B ( 8 94 0)
9000
8500
8000
7500
7000
SN B(( 6 47 6))
6500
T em p o d e T rein a m en to (s)
6000
5500
i
5000 SN B ( 6 314 )
4500
4000
3500
3000
2500
2000
1500
1000
500
0
0 2000000 4000000 6000000 8000000 10000000
Variação
ç do Número de Estados dos Atributos de Dados
800
SN B ( 7
716)
16 )
700
M SD T ( 6 72 )
o (s)
600
T em p o d e T rein a m en to
500
400
300
200
100
0
0 25 50 75 100
N ú m ero d e E st a d os
Variação
ç do Número de Atributos de Predição
ç
14000
M SD T ( 12330)
12000
o (s)
10000
T em p o d e T rein a m en to
8000
6000
SN B ( 4 6 0 7 )
4000
2000
0
0 4 8 12 16 20 24 28 32
N ú m ero d e A t rib u t os d e P red içã o
Conteúdo
 I t d ã
Introdução
 Processo de KDD

y Simples
p
 Provedor de DM
 Conclusão
 T b lh Futuros
Trabalhos F t
Conclusão
 O classificador SNB apresentou excelente escalabilidade dentro das
limitações do equipamento utilizado nos experimentos.
experimentos
 Os bons resultados de acurácia do classificador SNB no primeiro

experimento e os resultados razoáveis nos outros dois permitem
concluir que, de acordo com experiências já relatadas por outros
pesquisadores (HAN & KAMBER, 2001), os classificadores mais
simples sempre devem ser incluídos entre outros classificadores
mais elaborados, em estudos para escolha do melhor classificador
para um determinado problema de DM
 Os baixos tempos de processamento e a sua total escalabilidade

perante grandes massas de dados permite concluir que o
classificador SNB é uma opção
pç obrigatória
g no estudo de problemas
p
deste tipo. O uso do recurso incremental, aliado ao uso da
predição por partes permite, virtualmente, o estudo de problemas
de qualquer ordem de grandeza
Conclusão
 A tecnologia OLE DB DM mostrou eficiência na implementação de
algoritmos de DM,
DM alcançando a completa integração com um
SGBD relacional de uso comercial.
 O experimento de estudo de performance utilizou massas de dados

que excedem grande parte das aplicações da vida real,
comprovando que a abordagem utilizada disponibiliza recursos
agrupados de KDD com custo acessível.
 Finalmente pode se concluir que foi dada uma contribuição

substancial ao desenvolvimento de ferramentas para extração de
conhecimento de dados, particularmente em relação ao
desenvolvimento e implementação de classificadores incrementais,
bem como em relação
ç ao estudo da integração
g ç de recursos DM
com SGBDs relacionais e à utilização de microcomputadores.
Conteúdo
 I t d ã
Introdução
 Processo de KDD

y Simples
p
 Provedor de DM
 Conclusão
 T b lh Futuros
Trabalhos F t
Trabalhos Futuros
 A performance inferior do classificador SNB durante as tarefas de
predição
p ç de dados sugere
g um aperfeiçoamento
p ç da implementação
p ç
desta tarefa, tal como foi realizado por LEUNG & SZE (1998).
 O comportamento não linear dos classificadores perante um

granded número
ú de
d casos justifica
j tifi a execução ã de
d experimentos
i t que
utilizem equipamentos com maior capacidade, incluindo entre
estes o uso de federações de servidores de bancos de dados, bem
como equipamentos dotados de multiprocessadores.
multiprocessadores
 O sucesso da experiência de implementação de um classificador

p , utilizando a tecnologia
simples, g OLE DB DM,, serve de incentivo
para a implementação de classificadores e algoritmos mais
complexos.
 A implementação
i l t ã de
d procedimentos
di t para avaliação
li ã do
d
conhecimento obtido é uma tarefa altamente desejável e
promissora.

Cla 2003 Ufrj DSC Tese

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Cla 2003 Ufrj DSC Tese

Enviado por

Direitos autorais:

Formatos disponíveis

INTEGRAÇÃO DE RECURSOS DE DATA MINING COM

GERENCIADORES DE BANCOS DE DADOS RELACIONAIS

Claudio Luiz Curotto

TESE SUBMETIDA AO CORPO DOCENTE DA COORDENAÇÃO DOS PROGRAMAS DE PÓS-

RIO DE JANEIRO, RJ – BRASIL

INTEGRAÇÃO DE RECURSOS DE DATA MINING COM

Claudio Luiz Curotto

Orientador: Nelson Francisco Favilla Ebecken

O processo de descoberta de conhecimento em bancos de dados é abordado

INTEGRATION OF DATA MINING RESOURCES WITH RELATIONAL

Claudio Luiz Curotto

Advisor: Nelson Francisco Favilla Ebecken

The process of knowledge discovery in databases is approached from the

Ao professor Nelson Francisco Favilla Ebecken pela amizade, incentivo e

Figura III.1. Etapas do processo de KDD............................................................................................................................ 8

Tabela V.1. AllElet - Dados de treinamento.................................................................................................................... 24

Listagem IV.1. Algoritmo de treinamento do classificador SNBi .................................................................................. 15

Internet Textos em itálico indicam palavras de outros idiomas.

DMclcMine Fonte utilizada para representar hyperlinks (vínculos de

API (interface de programação As siglas (acrônimos) são descritas entre parênteses na

1 Fonte utilizada para representar valores constantes de

n Fonte utilizada para representar variáveis de fórmulas.

clcMine Fonte utilizada para nomes em geral, incluindo nomes de

void initialize() Fonte utilizada para listagem de programas em geral,

Sigla Descrição em inglês Descrição

ADO ActiveX Data Objects Interface de programação entre

API Application Programming Interface Interface de Programação entre

C45 C4.5 Classifier Classificador de Árvores de Decisão

CRISP-DM CRoss-Industry Standard Process for Padrão interindustrial para o

DM Data Mining Mineração de Dados

DMclcMine clcMine OLE DB Data Mining Provider Provedor OLE DB de Recursos de

DMQL Data Mining Query Language Linguagem Estruturada de Consultas

DTS Data Transformation Services Conjunto de ferramentas gráficas e

EOS Earth Observing System Sistema de Observação Terrestre

IIS Internet Information Services Servidor de Informações Internet

KDD Knowledge Discovery in Databases Descoberta de Conhecimento em

MDAC Microsoft® Data Access Components Componentes de Acesso de Dados

MSDT Microsoft® Decision Trees Classificador de Árvores de Decisão

ML Machine Learning Aprendizado de Máquina

MOLAP Multidimensional OLAP Modo de armazenamento

MSDMine Microsoft® OLE DB Provider for Data Provedor OLE DB de recursos de

MSJet Microsoft® Jet OLE DB Provider Provedor OLE DB de dados do

MSOLAP Microsoft® OLE DB Provider for Analysis Provedor OLE DB de serviços de

MSSQL Microsoft® SQL Server™ Sistema Gerenciador de Banco de

NASA National Aeronautics & Space Instituto de Pesquisa Espacial e

OCI Oracle® Call Interface Interface de chamadas de

OLAP Online Analytical Processing Processamento Analítico em Tempo

OLE Object Linking and Embedding Tecnologia de objeto de sistemas

OLE DB Object Linking and Embedding Conjunto de interfaces que permite a

OLE DB DM Object Linking and Embedding Conjunto de interfaces que permite a

PL Programming Language Linguagem de Programação

PMML Predictive Model Markup Language Linguagem de marcação para

ROLAP Relational OLAP Modo de armazenamento relacional

SNBi Simple Naïve Bayes Incremental Classificador Incremental Bayesiano

SGBD Database management system Sistema Gerenciador de Banco de

SQL Structured Query Language Linguagem Estruturada de Consultas

SQL DM Structured Query Language for Data Linguagem Estruturada de Consultas

UDA Universal Data Access Acesso Universal de Dados

XML Extensible Markup Language Linguagem de Marcação Extensível

WEKA Waikato Environment for Knowledge Ambiente de Análise de

O explosivo crescimento dos bancos de dados científicos e comerciais, bem

II.1 Projeto Quest

Vários trabalhos foram desenvolvidos dentro do contexto do Projeto Quest