i

UM SISTEMA PARA INDUÇÃO DE MODELOS DE PREDIÇÃO BASEADOS EM

ÁRVORES

Paulo Sérgio de Souza Coelho

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. Gerson Lachtermacher, Ph.D.

_________________________________________________ Prof. Estevam Rafael Hruschka Junior, D.Sc.

_________________________________________________ Prof. Marta Lima Queirós Mattoso, D.Sc.

RIO DE JANEIRO, RJ – BRASIL

ABRIL DE 2005

ii

COELHO, PAULO SÉRGIO DE SOUZA

Um Sistema Para Indução de Modelos

de Predição Baseados em Árvores [Rio

de Janeiro] 2005

XIV, 252 p. 29,7 cm (COPPE/UFRJ,

D.Sc., Engenharia Civil, 2005)

Tese – Universidade Federal do Rio

de Janeiro, COPPE

1. Árvores de Regressão

2. Indução de Modelos de Predição

3. Aprendizado de Máquina

4. Mineração de dados

I. COPPE/UFRJ II. Título (série)

iii

Dedicatória

à Camila, que mesmo ainda não presente já tem o poder de me fazer sonhar. E à Bia,

que, dentre tudo o mais, me ofereceu o próprio sonho.

iv

Agradecimentos

Agradeço ao Professor Nelson, não só pelo conhecimento fornecido, mas

também pela paciência, confiança e liberdade que me foram creditados ao longo destes

anos. Se eu não tivesse podido contar com isto, certamente este trabalho não teria

acabado.

Agradeço aos professores que compõem a banca de avaliação por se disporem a

ler o meu texto o que certamente irá me auxiliar aprimorando-o. Em especial, agradeço

ao Professor Gerson, que foi também padrinho da idéia, pois foi com quem dividimos as

idéias iniciais que nortearam este texto – desde aqueles dias em Bologna, e também pela

confiança e motivação que me foram imprescindíveis. Agradeço também ao professor

Alexandre, que foi fonte de importantes informações e referências.

Um agradecimento especial para Estela, pessoa que me salvou de desgastes

burocráticos, e que nunca me enganou com aquela cara de brava. A galera do Nelson

que sempre, formal ou informalmente, prestaram grandes auxílios: Célia, Guilherme,

Fábio, Maurício, Gilberto, Valéria, entre tantos outros que nos conhecemos de maneira

tão informal.

Agradeço a Bia, por toda a paciência da qual usei e abusei durante todo este

tempo, e por todo o cuidado que sempre me foi dispensado. Sua compreensão e

companheirismo foram fundamentais. Agradeço, com muito amor e carinho, ao meu pai

e à minha mãe, pois foi como tudo começou, e a semente plantada vira uma árvore

finalmente adulta. Às tias Nize, Neuza e Zélia, que sempre estiveram alertas desde o

início desta trajetória, o desembarque na minha Normandia – Rio de Janeiro. A Lero

v

(ainda que resista!), Álvaro, Antonia e Vânia, que são uma sempre uma grande

referência.

Os amigos são sempre uma referência e uma oportunidade de repouso, mesmo

os mais distantes fisicamente, mas que não são, de maneira nenhuma, menos queridos,

também ofereceram esta referência e este repouso: Cremildo, Adalberto, Nivaldo,

Wannise e Henrique. Também Lílian, Murilo e Lucas, que estão distantes agora, mas

presenciaram o início desta jornada. E Rita Binho, que chegou um pouquinho antes do

projeto começar.

Aos amigos mais chegados que estiveram ao meu lado durante este período,

sendo a minha eterna fonte de desopilação: Ítalo e Márcia, Daniela, Marcelo e Naira,

Valdir, Márcia, Roberta, Elane e Jardel. A Seu Armando e D. Maria, Seu Fernando, Tia

Lili, Fernando (filho) e tia Landinha, Seu Carlos, D. Dora e Tia Lourdes, pela

possibilidade de repouso nas suas casas. Aos amigos conquistados aqui no Rio e que a

dinâmica do mundo não nos afastou, Valentim e Alessandra, Fagundes e Mônica. Ao

amigo Antonio Alberto, que se tornou um elemento norteador. Um agradecimento

muito especial meus queridos Lindemberg e Ângela, pois os finais de semana em Cabo

Frio além de serem divertidos e relaxantes me ensinaram a ver o mundo por outro

ângulo.

As vezes ajudando – diversificando as atividades, o tempo de trabalho era

melhor utilizado, as vezes atrapalhando – o tempo de trabalho era efetivamente

reduzido. Mesmo nesta dúvida toda, agradeço à galera do mergulho: Luis, meu guru,

Mallet, importante referência. E mais: Raul (Prof. Hector), Rauzinho, Ceci, Isabela,

Carol, Felipe e Felipe, André e André, Luiz, Marcelo e Carla, Sérgio, e todo o grupo da

Topdivers. Agradeço também ao amigo Rodolpho, colega do squash, que além do

vi

próprio esporte me ajudou com um eterno incentivo, afinal dividimos o desespero de

prazos na COPPE.

Aos colegas da Faculdade, por ordem de andar, porque estando próximos estão

sempre apoiando: Anninha, Gisele, Solange, Ivando, Nonato, Luíza, Machadão,

Simone, Sander, Fiorencio, Autran, Valter, Oscar e Montezano. Aos companheiros da

faculdade, que a profissão não nos fez colegas, mas que também são grandes amigos:

Sandra, Tereza, Selma, Kelly, Alexandre e Renato. Em especial à Delfina, não só pelo

apoio moral, mas também pelo apoio técnico.

Agradeço a Alexandre (Soneca), Rogério e Dudú e à Cyrnel International, pela

disponibilização dos dados e pela atenção que me foi dispensada nos momentos

necessários. Ao Soneca ainda por uma luz num momento em que não via saída.

Um agradecimento muito especial, e muito sentido, ao amigo que por ventura

tenha sido esquecido. Na hora de concluir este trabalho é bem fácil que eu tenha

esquecido algum nome a quem eu gostaria, sinceramente, de agradecer. Sinta-se

agradecido e me desculpe!

Finalmente, agradeço ao CNPq pelo suporte financeiro dado durante o

projeto.

vii

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.) UM SISTEMA PARA INDUÇÃO DE MODELOS DE PREDIÇÃO BASEADOS EM

ÁRVORES

Paulo Sérgio de Souza Coelho

Abril/2005

Orientador: Nelson Francisco Favilla Ebecken

Programa: Engenharia Civil

Este trabalho apresenta o algoritmo de indução de modelos de previsão baseados

em árvore chamado M5.5’. Este algoritmo foi desenvolvido com base na teoria

estatística de estimação de regressão baseada no Método de Mínimos Quadrados. Foi

feita uma implementação em linguagem Java, dentro da suíte de código aberto Weka.

Algumas bases de dados acadêmicas são utilizadas para mostrar que os modelos

induzidos apresentam boas medidas de qualidade. Os resultados obtidos são

comparados com os provenientes de ferramentas famosas tanto em nível acadêmico

quanto comercial.

viii

Abstract of Thesis presented to COPPE/UFRJ as a partial fulfillment of the requirements for the degree of Doctor of Science (D.Sc.)

A SYSTEM TO INDUCT TREE BASED PREDICTION MODELS

Paulo Sérgio de Souza Coelho

April/2005

Advisor: Nelson Francisco Favilla Ebecken

Department: Civil

This work presents the algorithm for induction of tree based prediction models

called M5.5’. This algorithm was developed using foundations of statistic theory of

regression estimation based on Minimum Squares Method. An implementation in Java

language inside the open-code suite weka was made. Some academic databases are used

to show the induced models have good quality measures. The results are compared with

results from famous academic and commercial tools.

ix

Índice

1 Introdução .................................................................................................................1 1.1 Desenvolvimento da tecnologia de informação.....................................................1

1.2 Mineração de dados e KDD ..................................................................................6

1.3 Objetivos e limitações .........................................................................................10

1.4 Motivação e relevância........................................................................................12

1.5 Estrutura de capítulos ..........................................................................................14

2 Modelos de classificação e previsão.......................................................................16 2.1 Classificação e previsão.......................................................................................18

2.2 Modelos de previsão............................................................................................20

2.2.1 Modelos de regressão ...................................................................................21

2.2.2 Redes neurais ................................................................................................28

2.2.3 Previsão baseada em memória......................................................................32

2.2.4 Previsão fuzzy...............................................................................................34

2.3 Árvores de previsão.............................................................................................35

2.3.1 CART............................................................................................................39

2.3.2 M5.................................................................................................................48

2.3.3 Retis ..............................................................................................................52

2.3.4 CORE............................................................................................................54

2.3.5 Árvore de regressões locais ..........................................................................57

2.4 Aplicações ...........................................................................................................60

3 Árvores de modelos – algoritmo M5’ ....................................................................63 3.1 Descrição pública ................................................................................................65

3.1.1 Atributos categóricos ....................................................................................65

3.1.2 Valores faltantes ...........................................................................................68

3.1.3 Pseudo-código ..............................................................................................69

3.2 Descrição técnica.................................................................................................72

3.2.1 Valores faltantes ...........................................................................................74

3.2.2 Busca do melhor teste de divisão de registros ..............................................74

3.2.3 Eliminação de atributos ................................................................................75

x

3.2.4 Suavização dos coeficientes .........................................................................78

4 Análise de ferramentas de previsão baseadas em árvores ..................................80 4.1 Base de dados ......................................................................................................81

4.2 Comparação de modelos de previsão ..................................................................82

4.3 Ferramentas .........................................................................................................86

4.3.1 CART............................................................................................................86

4.3.2 Clementine....................................................................................................88

4.3.3 Mineset .........................................................................................................89

4.3.4 WEKA ..........................................................................................................90

4.3.5 RT .................................................................................................................91

4.4 Características dos sistemas ................................................................................92

4.4.1 Entrada dos dados.........................................................................................92

4.4.2 Output dos sistemas ......................................................................................98

4.5 Resultados..........................................................................................................101

4.5.1 Modelos ......................................................................................................101

4.5.2 Precisão.......................................................................................................104

5 Uma revisão para o M5’ .......................................................................................107 5.1 Processos a revisar.............................................................................................107

5.1.1 Critério de parada .......................................................................................107

5.1.2 Escolha do teste de divisão.........................................................................109

5.1.3 Fator multiplicativo na função de erro........................................................110

5.1.4 Pré-seleção dos atributos ............................................................................111

5.1.5 Simplificação dos modelos .........................................................................112

5.1.6 Suavização dos coeficientes .......................................................................114

5.2 Implementação das revisões ..............................................................................116

6 Testes e resultados.................................................................................................122 6.1 Bases de dados usadas .......................................................................................122

6.2 Critérios .............................................................................................................127

6.3 Testes das revisões ............................................................................................128

6.3.1 Pré-seleção dos atributos ............................................................................128

6.3.2 Sobre a eliminação atributos colineares .....................................................129

6.3.3 Função de dispersão no cálculo do SDR ....................................................130

6.3.4 Uso de medidas de off-set no cálculo do SDR............................................131

6.3.5 Fator de ponderação na função de erro para poda da árvore ......................132

xi

6.3.6 Constante de suavização dos modelos de regressão...................................134

6.3.7 Critério de parada no crescimento da árvore ..............................................136

6.4 Testes comparativos – modelo final ..................................................................137

6.5 Testes de escalabilidade.....................................................................................138

6.5.1 Base idh ......................................................................................................139

6.5.2 Base comp-activ..........................................................................................140

6.5.3 Base abalone...............................................................................................142

7 Conclusão...............................................................................................................144 7.1 Trabalhos futuros...............................................................................................147

Referências Bibliográficas ..........................................................................................149

Apêndice I.....................................................................................................................154

Apêndice II ...................................................................................................................160

Apêndice III .................................................................................................................165

Apêndice IV..................................................................................................................177

xii

Índice de Figuras

Figura 1: Etapas do KDD ................................................................................................. 7

Figura 2: Formato dos dados de entrada para estimar uma regressão multivariada....... 24

Figura 3: Matrizes necessárias para o algoritmo de estimação pelo método dos mínimos

quadrados................................................................................................................ 25

Figura 4: Parâmetros a serem estimados ........................................................................ 25

Figura 5: Resíduos da regressão ..................................................................................... 25

Figura 6: Exemplo de Rede Neural multicamadas feedforward..................................... 29

Figura 7: Uma visão de uma unidade j ........................................................................... 31

Figura 8: Exemplo de árvore .......................................................................................... 35

Figura 9: Árvore de Regressão. Adaptado de Breiman (1984) ...................................... 41

Figura 10: exemplo de árvore de regressão .................................................................... 51

Figura 11: Pseudo-código detalhado para o algoritmo M5’. Adaptado de Witten &

Frank (2000) ........................................................................................................... 69

Figura 12: Pseudo-código da descrição técnica (implementação) do M5’..................... 73

Figura 13: tela inicial do CART Fonte: CART (2003b)................................................. 87

Figura 14: Ponto de corte para escolha da árvore podada. ............................................. 87

Figura 15: navegador de resultados do CART. Fonte: CART (2003b).......................... 88

Figura 16: interface do Clementine. ............................................................................... 89

Figura 17: visualização de uma árvore no Mineset. ....................................................... 90

Figura 18: Interface do Weka – algoritmo de classificação baseado no C4.5................ 91

Figura 19: formato arff ................................................................................................... 96

Figura 20: Entrada de parâmetros do M5’ – Weka ........................................................ 97

xiii

Figura 21: modelo gerado pelo CART ......................................................................... 103

Figura 22: modelo gerado pelo Clementine, com opção de Impurity = 10-6................ 103

Figura 23: Parâmetros implementados ......................................................................... 118

Figura 24: Percentual de escolha para os métodos de pré-seleção dos atributos. ........ 128

Figura 25: Percentual de preferência da não pré-seleção. ............................................ 129

Figura 26: Percentual de escolha para Eliminar ou não os Atributos Colineares. ....... 130

Figura 27: Contagem de preferência de cada método considerando cada critério ....... 130

Figura 28: escolha da função para o cálculo do SDR................................................... 131

Figura 29: comparação entre o ganho de precisão e de complexidade ........................ 133

Figura 30: Avaliação da Melhor Constante de Suavização para algumas bases de dados

.............................................................................................................................. 134

xiv

Índice de Tabelas

Tabela 1: Variáveis auxiliares para codificação de atributos categóricos ...................... 66

Tabela 2: estatísticas da variável de reposta................................................................... 82

Tabela 3: medidas de performance para previsão fornecidas na suíte Weka ............... 100

Tabela 4: variáveis segundo sua importância. Resultado obtido do CART. ................ 102

Tabela 5: precisão dos softwares .................................................................................. 105

Tabela 6: classes que compõem o pacote m5_5........................................................... 117

Tabela 7: características das bases de dados ................................................................ 123

Tabela 8: Siglas para as estatísticas de precisão........................................................... 127

Tabela 9: off-sets selecionados por bases de dados ...................................................... 132

Tabela 10: características das bases de dados e constante de suavização (k)............... 135

Tabela 11: Correlações das características das bases com a constante de suavização . 135

Tabela 12: regressão estimada para definir uma expressão para a constante de

suavização............................................................................................................. 136

Tabela 13: testes do critério de parada usando a base servo ........................................ 137

Tabela 14: testes comparativos – modelo final ............................................................ 137

Tabela 15: descrição dos atributos da base idh ............................................................ 139

Tabela 16: teste com a base escalada idh ..................................................................... 140

Tabela 17: atributos da base comp-activ....................................................................... 141

Tabela 18: testes com a base escalada comp-activ ....................................................... 142

Tabela 19: atributos da base abalone ........................................................................... 142

Tabela 20: testes com a base escalada abalone ............................................................ 143

1

1 Introdução

O cenário científico no qual está inserido este estudo é composto por

diversas ciências, como Estatística, Matemática e Computação (principalmente as áreas

de Banco de Dados, Otimização e Inteligência Artificial – especialmente o grupo de

aprendizado de máquina ou Machine Learning). A reunião destas ciências em torno do

objeto de estudo que é a manipulação de grandes volumes de dados para modelar

padrões de informação ou de tendência de comportamento dos dados pode ser

considerada uma área do conhecimento humano que está ficando conhecida como

Mineração de Dados – Data Mining em inglês, ou mais holisticamente Descoberta de

Conhecimento em Banco de Dados – Knowledge Discovery in Databases também

indicado como KDD.

Os conceitos relativos a este cenário são fundamentais para o

desenvolvimento deste texto e estão aqui definidos apesar de não serem, em essência, o

objeto de estudo. O objetivo desta revisão rápida destes conceitos é fornecer um

embasamento único para os conceitos que são manipulados mais profundamente nos

capítulos seguintes e que são, por sua vez, fundamentais para compreender o estudo ora

realizado.

1.1 Desenvolvimento da tecnologia de informação

Cientistas históricos determinam que o desenvolvimento da civilização

humana se dá em função da posse da comunicação (Cf. Habermas, 2002). A conquista

da comunicação permite que os aprendizados e as conquistas de uma geração sejam

transmitidos para as gerações seguintes. Assim, as ciências avançam, pois as

2

descobertas e invenções formam uma base de conhecimentos que é utilizada para a

projeção dos novos aprendizados e conquistas, que irão incorporar o conjunto do

conhecimento. Este é o processo cíclico de desenvolvimento da civilização, e é

completamente dependente da comunicação das experiências, sejam elas bem ou mal

sucedidas.

A maior parte dos dados gerados atualmente pelas atividades realizadas

nos mais diversos setores da ação humana está sendo armazenado em dispositivos

eletrônicos, geralmente relacionados a computadores. Pode-se dizer que a sociedade

está se digitalizando.

O nível de informatização tem aumentado de maneira sistemática. É

possível garantir inclusive que esta informatização se dá em todas as áreas do

conhecimento humano. Uma conseqüência importante, sobretudo para o conteúdo desta

dissertação, refere-se ao armazenamento dos dados que surgem através das operações

cotidianas que são realizadas nas atividades humanas. O volume de dados armazenados

também apresenta um crescimento constante.

No caso das organizações, todas as atividades são geradoras de diversos

tipos de dados que podem ser armazenados. Estes dados serão armazenados somente se

o sistema de informação que os manipula assim o determinar. Por exemplo, os dados de

uma organização podem incluir os cadastros de produtos/serviços, clientes,

fornecedores e parceiros, que muito provavelmente estarão armazenados. Além disso, as

transações que são realizadas entre a organização e os clientes, fornecedores e/ou

parceiros também podem ser armazenadas: vendas, pedidos de entrega ou de

fornecimento, alterações no estoque, etc. Outro tipo de dado que também é muito

freqüente refere-se ao nível dos registros financeiros e contábeis em geral.

3

O avanço da tecnologia de informação acelerou bastante a dinâmica das

organizações, de maneira que o volume de atividades que são realizadas tem crescido.

Além disso, as operações tornam-se mais complexas, de maneira que mais detalhes

tornam-se importantes. O volume de dados tem aumentado não só pelo volume de

registros, mas também pela variedade de tipos de dados que precisam (e podem) ser

armazenados. A questão da complexidade dos tipos de dados que estão sendo

armazenados também tem sido uma forte restrição que a tecnologia de informação tenta

resolver. Documentos em forma de desenhos, figuras, imagens, áudios e até vídeos, por

exemplo, também estão sendo armazenados e requerem tratamento bem especial. Não

só para a o armazenamento e consulta, mas sobretudo para a análise.

O armazenamento dos dados é feito, originalmente, para registro dos

acontecimentos e futuras consultas (queries). Estas consultas aos bancos de dados são

realizadas no nível de tabelas e registros específicos (por exemplo, os registros de uma

determinada tabela que atendem a uma determinada restrição, ou algumas estatísticas

como média ou desvio padrão dos valores de determinado atributo). Para realizar

consultas como estas foram desenvolvidas linguagens específicas, das quais a mais

utilizada é conhecida como SQL – Structured Query Language, ou Linguagem

Estruturada de Consulta (Cf. Date, 1999).

Diante do crescimento do volume dos bancos de dados, torna-se

necessário realizar análises mais profundas das informações armazenadas através de

uma pesquisa informatizada aos registros eletrônicos. Convém distinguir os conceitos

consulta e análise, pois este último deve ser considerado uma metodologia que permitirá

não apenas a recuperação de informações (que é a consulta), mas também o

estabelecimento de modelos que representarão o que está sendo chamado de

conhecimento. Observe que é a análise dos dados que permite realizar uma projeção de

4

valores desconhecidos, ainda que limitada e passiva de erros. Por exemplo, a partir de

uma análise de uma série histórica de dados é possível fazer previsões1 de fatos (índices,

taxas, valores em geral) que ainda não são conhecidos ou que ainda não aconteceram (e,

dependendo da metodologia de análise empregada, esta previsão pode vir acompanhada

de todo um aparato estatístico para definir margens de erro e índices de qualidade). O

objetivo destas análises é obter o conhecimento contido numa base de dados. Esta

modelagem está relacionada a medidas de similaridade, co-ocorrência (correlação),

relações de dependência, de ordem, etc. Devido ao grande volume de dados que são

armazenados nestes bancos de dados, a descoberta do conhecimento não pode ser

conseguida a partir de simples consultas ao banco de dados. Torna-se necessário o

desenvolvimento de modelos matemáticos e estatísticos específicos. Uma nova área de

conhecimento se forma a partir da fusão da Matemática e Estatística com a Computação

e a Inteligência Artificial e está sendo chamada de Mineração de Dados (Data Mining)

e reúne todas estas ferramentas de análise (Cf. Han & Kamber, 2001). Este conceito está

mais profundamente discutido na seqüência deste.

Convém comentar que os dados podem ou não ser registrados ao longo

do tempo. Um sistema de informações envolvido diretamente com as atividades

operacionais da organização costuma armazenar apenas os dados específicos destas

operações, como por exemplo o estoque de determinado produto e os pedidos deste

produto que estão sendo processados. O procedimento operacional pode ser, por

exemplo, processar cada um dos pedidos, um por vez. Quando um pedido é processado

o estoque é atualizado. Do ponto de vista operacional basta armazenar apenas as

informações de qual é o novo estoque e eliminar do conjunto de pedidos aquele que já

foi processado. Entretanto, do ponto de vista gerencial pode ser fundamental saber quais

1 Para os propósitos deste texto, os termos previsão e predição são sinônimos, e serão usados indistintamente

5

pedidos já foram processados – incluindo outras informações como tempo de

processamento, número de série dos produtos que foram destinados ao pedido, etc. E,

do ponto de vista estratégico, é importante guardar informações de como o estoque varia

ao longo do tempo, do histórico dos pedidos. Estas informações podem permitir análises

que indiquem possíveis falhas operacionais ou simplesmente a percepção de que

determinadas modificações podem aumentar a eficiência dos processos da organização.

Assim, do ponto de vista operacional, basta um sistema que registre os valores dos

dados atuais. Do ponto de vista estratégico/gerencial pode ser importante guardar estas

mesmas informações num contexto temporal.

Neste sentido, o desenvolvimento da tecnologia de armazenamento e

acesso de dados diferencia os sistemas de banco de dados operacionais (dinâmicos) e

os Data Warehouses, ou armazéns de dados (estáticos). Os Data Warehouses tornam-se

importantes (ainda não são imprescindíveis) para a otimização dos recursos

computacionais para as atividades de análise. Os bancos de dados operacionais

(geralmente relacionais) são projetados para facilitar as atividades de armazenagem,

consulta e alteração de informações. O volume e a freqüência que estas operações são

realizadas não permitem operações de análise nos bancos operacionais. Os Data

Warehouses possuem uma estrutura de armazenamento de dados que privilegia a

análise, ao contrário dos bancos operacionais que privilegiam a velocidade de

processamento e evitam a duplicidade das informações (Cf. Han e Kamber, 2001).

Os Data Warehouses oferecem as mesmas ferramentas de consulta que o

sistema de banco de dados operacional e uma facilidade a mais: os dados podem ficar

estruturados em forma de um cubo que é uma estrutura que facilita a observação dos

dados. Esta estrutura é chamada de OLAP – On Line Analytical Process, ou cubo

OLAP. Estes sistemas têm sido enquadrados em um grupo de ferramentas

6

computacionais para administração chamado de BI – Business Intelligence, ou

Inteligência dos Negócios. A interface ao usuário que é oferecida por estes sistemas

costuma ser muito avançada, permitindo uma poderosa manipulação dos dados a partir

de uma interação com o sistema bastante simplificada, sem exigir conhecimentos

avançados de tecnologia.

As ferramentas OLAP são úteis para as análises de segmentos que podem

ser representadas através das dimensões do cubo (tipicamente centros de custo,

localidades, departamentos, produtos). Entretanto estas ferramentas não são capazes de

fazer a extração de todo o conhecimento contido nos Data Warehouses. Uma das

dificuldades das ferramentas OLAP é a dependência da forma que o Data Warehouse

tenha sido estruturado, pois as análises estão limitadas a operações de agrupamento de

valores em função das dimensões do cubo. Estas limitações tornam as estruturas OLAP

dos Data Warehouses insuficientes para as atividades de modelagem do conhecimento.

1.2 Mineração de dados e KDD

As ferramentas de Mineração de Dados (Data Mining) buscam modelar

as informações a partir das massas de dados, vindas de qualquer origem e em

“qualquer” forma, gerando conhecimento. Naturalmente que a forma como os dados

estão codificados nas estruturas de arquivo está diretamente ligado à capacidade de

interpretação da ferramenta computacional que se está usando. O que se quer indicar é

que é possível realizar Data Mining em dados multidimensionais, temporais ou não,

com variáveis de qualquer natureza, o que inclui as estruturas de texto, gráficas, de

áudio e até vídeo.

A modelagem é um conceito que extrapola o agrupamento realizado

pelas ferramentas de Data Warehouse, pois permite a estruturação das informações

7

contidas na massa de dados na forma de conhecimento. Este conhecimento pode ser

expresso através de um conjunto de regras, de equações ou ainda estruturas gráficas

como grafos, redes ou árvores. O tipo de conhecimento que pode ser obtido e a maneira

como ele é expresso depende da técnica e da metodologia de análise empregada. O

processo total, que vai da localização e extração dos dados até a compreensão do

conhecimento modelado, passando pela etapa de construção do modelo de

conhecimento – Mineração dos dados, é chamado de Knowledge Discovery in

Databases (KDD), ou Descoberta de Conhecimento em Banco de Dados (Cf. Berry,

1997, Berson, 1999, Han & Kamber, 2001 e Weiss, 1998).

O conceito de KDD fica aqui diferenciado do conceito de Mineração de

Dados. Convém observar que esta diferenciação não está bem definida na literatura.

Para alguns autores, os conceitos podem ser considerados os mesmos. A Mineração de

Dados é, nesta análise, apenas uma das fases do KDD que, ao todo, compreende cinco

segmentos de trabalho: definição do problema (seleção dos dados); limpeza e

preparação dos dados; transformação do formato do arquivo; Mineração de Dados e

finalmente, interpretação e análise de resultados. A Figura 1 apresenta um esquema com

as etapas contidas no processos de KDD.

Figura 1: Etapas do KDD

A primeira etapa é a atividade de seleção das informações contidas na

fonte de dados. Observe que esta fonte não é necessariamente um banco de dados ou um

Data Warehouse. É possível extrair conhecimento a partir de um conjunto de dados que

esteja em outras fontes, como planilhas, tabelas construídas a partir de questionários,

8

pesquisa na internet, etc. De qualquer maneira, é necessário coletar todos os dados que

são considerados relevantes e eliminar aqueles que forem considerados desnecessários.

A eliminação pode parecer desnecessária, mas realmente não é. Duas razões principais

devem ser consideradas. A primeira está ligada à não relevância de algumas das

informações armazenadas para o problema que está sendo analisado. A segunda razão

está ligada ao volume de dados existente. Muitas vezes a análise da totalidade dos dados

pode ser proibitiva em termos de tempo e da capacidade computacional disponível para

o processo. E então, uma seleção dos dados mais relevantes se faz necessária. A título

de exemplo quando a fonte de dados é um Data Warehouse é comum descartar uma

grande quantidade de dados, já que a redundância nestes sistemas é, geralmente, muito

grande.

A segunda etapa do processo de descoberta de conhecimento é

possivelmente a etapa mais importante de todo o processo. O pré-processamento é

fundamental para a etapa de modelagem do conhecimento (Mineração de Dados). Um

pré-processamento ineficiente pode reduzir ou até eliminar as chances de uma

modelagem eficiente (Cf. Pyle, 1999). Nesta etapa os dados são preparados para a

modelagem, resolvendo-se problemas como os de redundância, inconsistência e

ausência de valores, sendo por isso chamada de etapa de preparação ou de limpeza.

Observe que se estes problemas não forem resolvidos, ou se o forem, mas de forma

incompleta, a etapa de modelagem de dados poderá apresentar resultados insatisfatórios,

contraditórios ou inválidos. Um outro importante aspecto sobre a etapa de preparação de

dados é que na maioria dos casos não há nenhuma maneira de estimar a qualidade do

resultado. Quando valores desconhecidos estão sendo substituídos é comum que não se

tenha uma estimativa da precisão dos valores que estão sendo substituídos, ou que se

tenha uma estimativa muito fraca.

9

A partir dos dados limpos e pré-processados, a etapa de modelagem só

pode ser aplicada se houver uma compatibilidade entre o formato dos dados e os

requisitos do software que fará a modelagem. A etapa de transformação é responsável

por garantir esta compatibilidade, que geralmente não ocorre naturalmente. É

importante considerar que diferentes técnicas ou diferentes ferramentas computacionais

podem ser empregadas na etapa de modelagem, e o formato de entrada dos dados

depende das restrições do sistema a ser utilizado. A etapa de transformação parte dos

dados limpos e os adapta ao formato especificado pela ferramenta de modelagem que

será utilizada. Se for necessário modelar os dados utilizando ferramentas diferentes (o

que foi feito para comparação dos resultados, por exemplo), a etapa de transformação

tomará sempre como entrada o resultado do pré-processamento (único), gerando

diferentes formatos, um para cada uma das ferramentas que será utilizada.

A etapa de Mineração de Dados é a captação e estruturação das

características e padrões dos dados que estão sendo analisados em forma de algum

modelo matemático-estatístico. Estas características e padrões podem, dentro de limites

estimados através de intervalos de confiança e testes de hipóteses, ser utilizadas para

projeções de fatos não observados. Esta etapa realiza além da construção dos modelos,

as avaliações deste modelo através de estimações. Pode-se considerar que esta etapa

está efetivamente relacionada com a descoberta do conhecimento. As técnicas de

Mineração de Dados podem ser classificadas em três grupos principais: Regras de

Associação (análise de similaridade), Indução de Modelos (Classificação e Previsão) e

Clustering ou Segmentação (análise de grupos).

Finalmente, a última etapa, chamada de interpretação, é responsável pela

adequação da saída da ferramenta de modelagem às necessidades do usuário. Algumas

ferramentas de visualização e de navegação em dados podem ser utilizadas.

10

Observe que estas atividades têm uma ordem bem estabelecida.

Entretanto, em alguma etapa podem ser evidenciados problemas ocorridos em alguma

etapa anterior. Assim, o processo de KDD pode incluir a repetição de alguma(s)

etapa(s). Um exemplo típico é a etapa de preparação de dados. É possível que algum

problema nos dados só venha a ser percebido na fase de interpretação do modelo gerado

depois da fase de Mineração de Dados. A preparação de dados teria de ser refeita assim

como todas as etapas subseqüentes.

Uma outra alteração comum no fluxo do KDD é quando alguma etapa

pode ser suprimida como, por exemplo, a etapa de transformação dos dados. Existem

algumas ferramentas que fazem todo o processo de KDD, desde a extração dos dados

até a interpretação do modelo. Nestes casos não é preciso fazer a transformação dos

dados, pois a própria ferramenta o fez no momento da importação dos dados.

1.3 Objetivos e limitações

Uma leitura do algoritmo de indução de modelos de previsão baseados

em árvore chamado M5’ chama a atenção em função da falta de integração com as

teorias estatísticas de Análise de Variância e Método dos Mínimos Quadrados para

Estimação de Modelos de Regressão. O algoritmo em questão chega a estimar diversos

modelos de regressão, usando os resultados obtidos pelo Método dos Mínimos

Quadrados. Entretanto, em diversas passagens pode-se perceber o uso de heurísticas e

métodos outros que não aqueles encontrados nas teorias estatísticas ou que estão sempre

relacionados na literatura sobre o assunto, principalmente Análise de Variância.

Como pode ser visto no desenvolvimento deste texto, algumas das

heurísticas que são utilizadas no algoritmo original podem ser justificadas em função da

notável economia de esforço computacional obtida. Entretanto, não foi encontrada

11

nenhuma indicação explícita disso. Ou seja, não se conhece nenhum estudo comparativo

entre as questões de qualidade do modelo em função de variações destas heurísticas. Os

critérios de qualidade também estão melhor definidos no texto, mas em termos da

comparação que se deseja, traduz-se principalmente pelo esforço computacional

(rapidez e escalabilidade) e precisão.

Os estudos que foram realizados também passaram pela leitura da

implementação do algoritmo M5’. Esta implementação foi feita dentro da suíte Weka

(Cf. Witten & Frank, 2000), desenvolvida em plataforma Java, nas condições do projeto

GNU (Cf. GNU, 2005), tendo, portanto, código aberto. Durante esta leitura, foram

descobertas outras heurísticas e técnicas que não foram encontradas em âmbito

acadêmico, e para as quais também existem alternativas baseadas nas técnicas

estatísticas. De maneira geral, o quadro comparativo que procurou-se traçar estabelece

índices de qualidade referente a alternativas a estas heurísticas e técnicas que pareceram

possíveis de retratar.

Este estudo não poderia ficar no nível da teoria, e a maneira mais

adequada de experimentá-lo é realizando a implementação do algoritmo modificado.

Foi então desenvolvido um novo algoritmo, chamado de M5.5’, a partir da formulação

do algoritmo original, adicionando as heurísticas revisadas. O nome foi escolhido numa

tentativa de dar a noção histórica que este algoritmo tem. De fato, analisando a

produção de Quinlan (Cf. Coelho 2002), um dos primeiros algoritmos de indução de

modelos que ele criou foi chamado de ID3 (Induction of Decision Trees) (Quinlan,

1986). Este algoritmo foi revisado e ampliado em um novo algoritmo, que se tornou

muito mais importante para a comunidade de Machine Learning, chamado de C4.5

(Quinlan, 1993). Ambos são sistemas para indução de modelos de classificação. Quando

cria um modelo de previsão, Quinlan cria a primeira Árvore de Modelos, e o algoritmo

12

de indução fica conhecido como M5 (Quinlan, 1992). O algoritmo que foi o ponto de

partida deste estudo não foi criado por Quinlan, e sim por Wang e Witten (1997), e seu

nome já acrescentava o apóstrofo no final, o que pode indicar que o algoritmo foi

implementado, e mais importante do que isso, que as dicas de implementação estão

disponíveis.

Este algoritmo foi implementado dentro da própria suíte Weka, criando

um pacote que está indicado como m5_5. A classe principal deste pacote chama-se

M5_5P, o sufixo P tomando o lugar do apóstrofo – exatamente como foi feito com o

algoritmo M5’ que foi desenvolvido através do pacote m5, cuja classe principal era

M5P. O P é abreviação para Prime (linha).

O objetivo desta implementação é fundamentalmente acadêmico, pois

este é o método que coube para verificar a hipótese de que o algoritmo pode ser

melhorado. Não foi intenção obter um código pronto, em sua versão final, de publicação

e disponibilização imediata. Este é um objetivo futuro, que requer uma revisão e

adaptação completa nos códigos que foram desenvolvidos, respeitando os preceitos da

Engenharia de Software e de desenvolvimento integrado para projetos de código aberto.

1.4 Motivação e relevância

As Árvores de Modelos são uma teoria relativamente nova (em torno de

20 anos de existência desde seus primórdios), e apresentam em geral uma grande

aceitação como ferramenta de previsão, considerando os principais critérios de

comparação de modelos.

Do ponto de vista da abrangência, os modelos de regressão são os mais

utilizados para previsões em geral. As possibilidades de uso dos modelos de regressão

não lineares, estimados através dos métodos Mínimos Quadrados ou Máxima

13

Verossimilhança tornam-os bem ajustáveis aos dados. Entretanto, estes modelos são

muito pouco robustos, principalmente para o caso de valores faltando. A robustez é uma

característica presente nos algoritmos mais modernos de mineração de dados, como

Redes Neurais e métodos baseados em memória.

Do ponto de vista da precisão, as Redes Neurais se mostram modelos

muito bons. Mas quando a aplicação requer treinamento rápido esta técnica não pode ser

considerada, pois seus algoritmos de treinamento não são escaláveis. Além disso,

apresentam um nível de interpretabilidade muito baixo. Em oposição, os algoritmos

baseados em memória têm um treinamento muito rápido (talvez até instantâneo), mas

deixam a desejar em precisão e interpretabilidade.

Seguindo estes critérios, as Árvores são algoritmos bem comportados,

apresentando simultaneamente níveis aceitáveis de precisão, interpretabilidade,

robustez, velocidade e escalabilidade. Como são muitos os modelos e os algoritmos que

treinam os modelos, é sempre possível escolher um algoritmo que privilegie mais um ou

outro critério, reforçando assim o aspecto mais importante para a aplicação.

O ineditismo deste estudo está na comparação feita entre as principais

ferramentas computacionais que implementam algoritmos famosos de indução de

modelos baseadas em árvore. Esta comparação foi fundamental para desvendar aspectos

positivos e negativos destes algoritmos. Além disso, as propostas feitas das

modificações do algoritmo M5’ demonstram que este pode ser melhorado, no caminho

do que está sendo proposto e chamando de M5.5’. A implementação que foi feita é um

ponto de partida para uma versão estável, que possa ser publicada e disponibilizada para

a comunidade acadêmica.

De uma maneira geral, a área de previsão é uma das áreas dentro

daquelas de Data Mining que tem sido pouco desenvolvida. Curiosamente, é uma área

14

que tem muita aplicabilidade prática. Esta dicotomia sugere que todos os estudos feitos

nesta área serão bem vindos e aproveitados pela comunidade academica. Uma

popularização ainda maior das técnicas de modelagem baseadas em árvore propiciará o

fortalecimento desta área, de maneira que o seu uso torne-se freqüente entre diversas

áreas de conhecimento.

1.5 Estrutura de capítulos

O presente trabalho foi dividido em um total de 7 seções principais

(capítulos), incluindo a Introdução e a Conclusão, cujo sentido e conteúdo são óbvios. A

revisão bibliográfica está divida entre os Capítulos 2, 3 e parte do 4. Os demais

capítulos tratam do desenvolvimento da tese proposta e trazem os elementos que

justificam-na.

O Capítulo 2 traz uma revisão bibliográfica da técnica de Data Mining

chamada de Indução de Modelos, com foco principal nos modelos de previsão, com

uma descrição de alguns dos mais importantes algoritmos de previsão. Este capítulo traz

ainda uma seção com algumas aplicações reais destas técnicas.

A revisão bibliográfica do algoritmo M5’ está no capítulo 3. Do ponto de

vista estritamente técnico, é um algoritmo de previsão. Parece portanto estranho que

este algoritmo não esteja descrito no Capítulo 2 como os demais algoritmos de previsão.

Optou-se por separar a descrição deste algoritmo em um capítulo exclusivo por duas

razões que tornam este algoritmo especial. Primeiro, ele é o ponto de partida da tese e,

portanto, é necessário enfatizar a sua descrição, que ficaria perdida dentro do Capítulo

2. Segundo, e mais importante, a descrição deste algoritmo vai além da revisão

bibliográfica disponível na literatura. Este capítulo contém detalhes do algoritmo que

não foram publicados em nenhum artigo ou livro que se tenha consultado. Assim, a sua

15

descrição é feita a uma profundidade muito maior do que os demais descritos no

Capítulo 2.

O Capítulo 4 realiza uma comparação prática dos algoritmos de indução

de modelos, e dos modelos induzidos, implementados em algumas ferramentas

computacionais disponíveis comercial e academicamente. Parte deste capítulo descreve

estas ferramentas – realiza uma revisão bibliográfica das ferramentas de previsão

baseadas em árvore. O restante do capítulo faz a comparação propriamente dita, com a

descrição dos critérios e da base de dados utilizadas.

O Capítulo 5 apresenta os pontos no algoritmo M5’ que são carentes de

uma roupagem estatística melhor. Em geral, algumas heurísticas empregadas no

algoritmo são diferentes das que seriam esperadas à luz da Teoria de Regressão

(Método dos Mínimos Quadrados). No capítulo são apresentadas ainda algumas

alternativas para cada uma destas heurísticas, e os detalhes da implementação das

alternativas propostas no capítulo anterior no ambiente Weka. O Capítulo 6 mostra uma

comparação dos resultados encontrados ao usar estas heurísticas, incluindo aí uma

comparação com o algoritmo original.

A tese tem ainda quatro apêndices. O Apêndice I traz uma saída do

sistema Weka, para os testes que foram realizados e estão descritos no Capítulo 4. O

Apêndice II traz a listagem de uma base de dados sintéticas que foi criada a partir de

descrições da literatura, e que está descrita no Capítulo 6. O Apêndice III contém todas

as tabelas que foram geradas durante a fase de testes do sistemas e que estão

representadas no Capítulo 6 através de Gráficos. Finalmente, o Apêndice IV contém a

documentação em Javadoc das classes e pacote criadas e descritas no Capítulo 5.

16

2 Modelos de classificação e previsão

De uma maneira geral, os algoritmos de indução de modelos de

classificação ou previsão buscam modelar uma determinada variável chamada de

variável de resposta ou variável dependente através da relação desta com um

conjunto de outras variáveis chamadas de variáveis explicativas ou variáveis

independentes. A ação modelar refere-se à busca da percepção do comportamento da

variável, o que pode permitir realizar previsão (ou classificação) dos valores da variável

dependente.

A indução de modelos é um problema antigo, e muitas técnicas foram

desenvolvidas na busca de soluções viáveis. Por exemplo, as Redes Neurais são

desenvolvidas desde 1943 (Cf. McCulloch e Pitts, 1943), e a teoria estatística de decisão

surge a partir dos anos 1940 (Cf. Pearl, 1988), dentre outras. As técnicas que foram

desenvolvidas (e que ainda continuam sendo) dão origem a um grande conjunto de

ferramentas computacionais, que são de grande utilidade para aqueles que precisam

analisar cenários que envolvem alguma variável que não se conhece o valor, mas que

pode ser obtido a partir do valor de um conjunto de outras que se conheça. Atualmente

são muitas as ferramentas disponíveis no âmbito comercial – sistemas que estão à

venda, referenciados por empresas com respaldo, que oferecem serviços de suporte,

treinamento, etc. Existem também muitos sistemas no âmbito acadêmico – softwares

gratuitos que foram desenvolvidos para testes e que podem ser utilizados a baixo custo

ou até mesmo de graça. Sistemas acadêmicos costumam ser eficientes do ponto de vista

da qualidade da modelagem (precisão, custo computacional, interpretabilidade do

modelo, etc.), mas costumam apresentar, via de regra, algum tipo de falha nos aspectos

17

de escalabilidade ao tamanho da base de dados, interface ao usuário, documentação,

suporte etc.

De uma maneira geral, estas ferramentas (tanto comerciais quanto

acadêmicas) diferem-se no aspecto da metodologia da técnica de modelagem que está

sendo utilizada. Algumas tecnologias já bem conhecidas estão disponíveis em diversas

ferramentas. Neste caso, as ferramentas vão se diferenciar em pequenos detalhes da

própria tecnologia, na interface com o usuário, ou na capacidade computacional. Por

exemplo, considere a tecnologia de previsão chamada de Regressão Linear. Esta

tecnologia é muito conhecida (Cf. Neter, 1996 e Draper, 1998), e está disponível em

diversos softwares desde simples planilhas eletrônicas como o Excel ®, até sofisticadas

suítes de Mineração de Dados como o SAS ®. Naturalmente, existem algumas

diferenças em alguns detalhes da implementação da metodologia. Por exemplo, a

ferramenta que se apresenta no Excel é bastante limitada em volume de dados, o que já

não ocorre com as implementações específicas para propósitos de Data Mining. Veja

que isso não representa uma deficiência do Excel, posto que sua implementação tem um

propósito específico de automação de escritório e, portanto, está voltado para manuseio

de pequenas massas de dados – planilhas. A metodologia para esta técnica de indução

de modelos está absolutamente consolidada (veja na Seção 2.2.1) e não há, neste

aspecto, nenhuma diferença entre as duas implementações citadas e entre nenhuma

outra.

No universo das técnicas de indução de modelos destacam-se os modelos

baseados em árvores, tanto por sua eficiência quanto por sua eficácia. Estes modelos

tornaram-se populares e têm sido desenvolvidos nos últimos 20 anos, desde os trabalhos

de Breiman (1984). Diferentemente dos Modelos de Regressão, que é uma

metodologia consolidada, muitas metodologias diferentes foram desenvolvidas usando

18

estruturas de árvores. Neste cenário, muitas ferramentas computacionais foram

desenvolvidas e diferem não só no aspecto de implementação (escalabilidade, interface,

etc.), mas também em detalhes metodológicos.

A fim de compreender melhor estas questões e delimitar o objetivo deste

trabalho, serão definidos alguns conceitos, baseados nas definições do próprio Breiman

(1984). Na seqüência serão examinados alguns modelos clássicos de previsão, a saber,

Modelos de Regressões, Redes Neurais, Previsão Baseada em Memória, Sistemas de

Regras Fuzzy e, com mais profundidade, os modelos de previsão baseados em árvore.

Os algoritmos clássicos de previsão baseados em árvore também serão examinados, mas

o algoritmo mais importante para o objetivo deste texto, o M5’, será detalhado apenas

no capítulo seguinte. Este capítulo se encerra com uma revisão bibliográfica de algumas

aplicações dos algoritmos descritos.

2.1 Classificação e previsão

É importante definir que a técnica de Indução de Modelos pode realizar

duas ações que para o propósito deste texto precisam ser distinguidas pela natureza da

variável dependente (variável de resposta), que são as ações de classificação ou

previsão. Diz-se que o modelo induzido é um Modelo de Classificação quando a

variável dependente é uma variável categórica, e que é um Modelo de Previsão quando

a variável dependente é uma variável numérica.

As variáveis numéricas assumem valores em um conjunto numérico,

que por natureza é ordenado e é potencialmente infinito. Por outro lado, quando os

valores que a variável pode assumir estão em um conjunto finito sem ordenação natural

ou suficientemente pequeno considera-se que é uma variável categórica. O termo

categórico está relacionado a categorias ou classes que possivelmente não devem ser

19

representadas numericamente pois não é possível explicar qualquer posicionamento em

um eixo. Categorias podem não admitir ordenação como, por exemplo, cor, bairro ou

dia da semana. Observe, entretanto que algumas variáveis numéricas podem ser

consideradas categóricas em duas situações. Primeiro quando o conjunto de valores que

a variável resposta puder assumir for naturalmente pequeno, por exemplo, uma escala

de valores inteiros de 1 a 8 que poderia indicar o nível de um determinado fator. Neste

caso, apesar da ordenação existir, considerar a variável como numérica pode levar a

problemas com as questões dos limites e da continuidade. A ferramenta de modelagem

pode supor que o valor 7,5 é possível, apesar de não estar representado no conjunto de

dados. A segunda situação, que é bem comum, é a transformação de variáveis

numéricas em categóricas, criando faixas de valores ou categorias. Esta operação,

conhecida como discretização ou categorização, é utilizada para simplificar a

representação da variável e pode ser necessária como exigência da ferramenta

computacional que está sendo utilizada. É uma alternativa para modelar uma variável

que é originalmente numérica em uma ferramenta de indução de modelos de

classificação (ou seja, que trabalha com variável categórica).

Pode-se dizer então que um modelo de classificação ou um

classificador é um modo sistemático para prever a qual classe (ou categoria) um caso

(registro) pertence. Pode-se dizer também que um classificador define uma partição do

espaço de possíveis casos em conjuntos disjuntos, de maneira que todos os elementos de

cada conjunto pertençam à mesma classe. Já um modelo de previsão ou um previsor é

um modo sistemático para determinar o valor numérico da variável dependente de

resposta (Cf. Breiman, 1984).

Alguns autores preferem chamar os modelos de previsão de modelos de

regressão. Outros (Cf. Han & Kamber, 2001) discordam desta definição e uma razão

20

suficiente para isto é que modelos de regressão são uma conhecida técnica específica de

modelagem de dados (é uma técnica de previsão) baseado na Teoria de Regressão

Estatística. Esta nomenclatura provoca uma certa confusão, que só pode ser evitada em

situações específicas ou quando alguma descrição acompanhar o conceito, devendo

portanto ser evitada. Assim, o termo “Modelo de Regressão” será usado unicamente

para referir à técnica estatística específica de regressão, e pode ser dito sem nenhum

receio de confusão que o Modelo de Regressão é um Modelo de Previsão.

Existe também uma certa confusão no termo previsão, que pode

significar a aplicação do modelo induzido (tanto modelo de classificação quanto modelo

de previsão) em dados desconhecidos, de maneira a projetar o valor da variável de

resposta. Entretanto, o termo completo Modelo de Previsão exclui, por si só, quaisquer

dúvidas de que se está referindo a um tipo de modelo – em oposição ao Modelo de

Classificação, e que não é uma referência ao uso de especificamente um modelo

induzido.

O objetivo deste texto não permite maiores comentários sobre

ferramentas de classificação, que são possivelmente mais diversas do que as ferramentas

de previsão. Maiores detalhes sobre as técnicas de classificação, inclusive uma

comparação de ferramentas pode ser vista em Coelho & Ebecken (2002).

2.2 Modelos de previsão

De uma maneira simplificada, pode-se definir que os modelos de

previsão tentam modelar o comportamento da variável dependente fazendo uso de um

conjunto de casos onde os valores da variável dependente são conhecidos. Este conjunto

de casos costuma ser chamado de conjunto de treinamento do modelo. Quanto maior o

conjunto de treinamento, mais aleatória a sua composição e mais extenso o seu espectro,

21

melhores chances se têm de obter um melhor modelo, pois este depende, de uma

maneira geral, da representatividade da amostra. O uso do conjunto de treinamento para

estimar os parâmetros do modelo é comumente chamado de treinamento do modelo.

Os métodos de previsão diferenciam-se a partir da estrutura do modelo.

Estruturas diferentes são treinadas de maneira diferente, e a partir daí cada método

possui suas próprias peculiaridades. Os modelos de previsão mais conhecidos são as

regressões. Estruturas baseadas em árvores são importantes, não só para previsão como

para classificação também, assim como os modelos baseados em Redes Neurais (Cf.

Haykin, 2000 e Lachtermacher 1992 e 1993). Existem também os modelos baseados em

similaridade de exemplos conhecidos. São métodos derivados do algoritmo de

classificação conhecido como KNN – K-Nearest Neighbourhood (K vizinhos mais

próximos) (Cf. Han & Kamber, 2001).

Quando os tomadores de decisão estão diante de cenários, notadamente o

planejamento, que exigem a previsão de valores desconhecidos, e quando esta previsão

é possível, entra em ação alguma ferramenta computacional. Questões relativas à

qualidade técnica do modelo previsor (precisão, velocidade, escalabilidade, robustez e

interpretabilidade) são misturadas com questões de interface ao usuário (que muitas

vezes desconhece os detalhes técnicos envolvidos nos modelos) e preço no processo de

seleção de qual ferramenta será aplicada.

2.2.1 Modelos de regressão

Os modelos de previsão mais conhecidos são os Modelos de Regressão.

Uma Regressão é uma equação que relaciona matematicamente os valores de um

conjunto de variáveis independentes, que são chamadas de explicativas, na tentativa de

estabelecer o valor da variável dependente, ou variável de resposta. Considere a forma

geral de um Modelo de Regressão:

22

( ) ( ) ( ) εββββ +Φ++Φ+Φ+= kkk xxxy K2221110 , (1)

onde a variável dependente y está sendo explicada por k variáveis independentes xi. As

funções ( )⋅Φ i são transformações sobre as variáveis independentes, como operações de

potência, raiz, logaritmo, etc. Os coeficientes iβ são chamados de parâmetros da

regressão, e são estimados em função do conjunto de dados que está sendo usado no

processo de modelagem. O termo ε refere-se ao resíduo, ou erro, da regressão, e são

definidos como a parte aleatória da regressão, em oposição à parte determinística. Mais

especificamente tem-se:

( ) ( ) ( )kkk xxxy Φ++Φ+Φ+= ββββ K2221110 (2)

sendo a parte determinística, e

yy ˆ−=ε (3)

sendo a parte aleatória.

Se as variáveis explicativas são combinadas linearmente, diz-se que o

modelo é de Regressão Linear. Neste caso, em sua forma mais simples, tem-se:

( ) kixx iii ,...,2,1, ==Φ , (4)

mantendo-se os resultados encontrados anteriormente.

Para realizar completamente a modelagem dos dados, torna-se necessário

estimar os parâmetros (coeficientes) da regressão. O mais conhecido método de

estimação é o de mínimos quadrados sobre os resíduos da regressão. Este método pode

ser aplicado sempre que algumas propriedades importantes são observadas na amostra

de resíduos. Quando estas propriedades não são verificadas, é possível usar outro

método, como o método da máxima verossimilhança (Cf. Neter, 1996 e Draper, 1998).

23

Quando o método dos mínimos quadrados é usado, os parâmetros são

obtidos a partir de expressões bem definidas, com base nos valores das variáveis

independentes e da variável independente. Por exemplo, para o caso de uma regressão

linear com apenas uma variável independente:

εββ ++= xy 10 , (5)

os parâmetros podem ser determinados fazendo:

xy 10 ββ −=

221 xnxyxnxy

−

−=

∑∑β , (6)

sendo y a média amostral da variável dependente, x a média amostral da variável

independente e n o tamanho da amostra (quantidade de casos). As transformações ( )⋅Φ i

podem ser aplicadas antes da estimação dos parâmetros, e os parâmetros podem ser

obtidos da mesma maneira.

O modelo de regressão é bastante desenvolvido e diversos estudos

estatísticos podem ser empregados para compreender melhor o relacionamento entre

a(s) variável(is) independente(s) e a variável dependente. Estes estudos incluem

medidas de ajustamento do modelo aos dados, intervalos de confiança para as previsões

e para os parâmetros e testes de hipóteses. Para estes estudos estatísticos é importante

considerar se houve transformações nos dados, pois estas transformações alteram, via de

regra, a distribuição amostral das variáveis.

O resultado descrito é extensivo a várias variáveis, e pode ser descrito

através de equações matriciais, colocando os dados em matrizes com um determinado

aspecto. Suponha que o modelo linear a ser estimado é:

εββββ +++++= kk xxxy K22110 , (7)

24

lembrando que, para estimar um modelo não linear em uma determinada variável vi

basta aplicar a transformação ( )iii vx Φ= , onde ( )⋅Φ i é a função não linear que se

deseja aplicar sobre a variável vi.

Para estimar uma regressão multivariada, é necessário que se tenha uma

amostra com n registros, contendo cada um deles um valor para a variável dependente y

e para cada uma das variáveis independentes xi, que seria uma tabela na forma descrita

na Figura 2:

xknx2nx1nynn

......

......

xk2x22x12y12xk1x21x11y11xk...x2x1yObs

Figura 2: Formato dos dados de entrada para estimar uma regressão multivariada

Os dados dão origem a duas matrizes Y e X, que possuem a forma

demonstrada na Figura 3. É importante chamar atenção ao formato da matriz X, que

pode induzir ao erro, pois o elemento na linha i e coluna j está indicado como xji, ao

invés de xij, como é de costume nos textos de álgebra. Isto foi necessário por que a

notação xji foi usada para indicar o i-ésimo elemento da j-ésima variável, como pode ser

comparado com a Figura 2. Além disso, observe que a matriz X possui k + 1 colunas,

pois a primeira delas foi criada com valor constante e igual a 1. Isto equivale a

considerar que cada observação possui uma variável (ou atributo) a mais, que possui

sempre valor unitário. Este valor está relacionado com o termo constante da equação de

regressão, β0. É então considerada a existência de uma variável x0 = 1, para todas as

observações. Como resultado, a matriz X tem quantidade de colunas igual à quantidade

de coeficientes a serem estimados.

25

=

ny

yy

YM2

1

=

knnn

k

k

xxx

xxxxxx

X

L

MMMM

L

L

21

22212

12111

1

11

Figura 3: Matrizes necessárias para o algoritmo de estimação pelo método dos mínimos quadrados

Os parâmetros que se deseja estimar também são colocados na forma de

uma matriz, que é como pode ser visto na Figura 4. Observe que a quantidade de linhas

da matriz β definida é igual à quantidade de colunas da matriz X.

=

kβ

ββ

βM1

0

Figura 4: Parâmetros a serem estimados

Com isto, é possível escrever o modelo de regressão através da expressão

matricial Y = X β + ε, onde ε é também uma matriz coluna, só que com as dimensões da

matriz Y, ou seja, com n elementos, que representam os resíduos de cada observação,

que é a parte aleatória da regressão. A forma de e pode ser vista na Figura 5.

=

nε

εε

εM2

1

Figura 5: Resíduos da regressão

O algoritmo de estimação da regressão pelo método dos mínimos

quadrados é dada pela minimização da soma dos quadrados dos resíduos (que pode ser

indicado como o produto escalar da matriz coluna ε com ela mesma), e pode ser

26

facilmente mostrado (Cf. Mendenhall & Sincich, 1996) que se resolve através da

solução do sistema de equações lineares dado por

( ) YXXX '' =β , (8)

onde 'X indica a matriz transposta de X. A solução é então encontrada:

( ) YXXX '' 1−=β , (9)

onde ( ) 1' −XX será chamada de C. Prova-se ainda que o somatório dos quadrados dos

resíduos, SSE, pode ser obtido através da equação:

YXYYSSE ''' β−= , (10)

e que a variância destes resíduos é estimada através do modelo pela equação:

( )12

+−=

knSSEs , (11)

sendo o denominador desta última os graus de liberdade para a estimação, dado pelo

número de observações menos o número de parâmetros estimados.

A matriz C, definida a partir da Equação 9 é utilizada também para

estimar os erros padrões das distribuições amostrais dos parâmetros βi. Tem-se que:

iiicss =β , (12)

onde s é o desvio padrão dos resíduos, obtido pela raiz quadrada da variância estimada

acima, e cii é o i-ésimo elemento da diagonal principal da matriz C.

Outros importantes resultados da estimação da regressão multivariada

pelo método dos mínimos quadrados em versão matricial podem ser obtidos na

literatura, (Cf. Mendenhall & Sincich, 1996).

A Análise de Variância (ANOVA – ANalysis Of VAriance) é um teste de

hipóteses que pode ser feito em função da divisão que a regressão estabelece na

27

dispersão da variável dependente. Este teste é comumente chamado de teste da utilidade

global do modelo, ou teste de validação do modelo.

Para entender como funciona este teste de hipóteses, considere que um

modelo de regressão tem a forma:

kk xxxy ββββ ++++= K22110ˆ , (13)

onde y é a variável dependente (variável de resposta), ix são as variáveis independentes

(atributos) e iβ são os parâmetros (coeficientes) da regressão, que foram estimados

através do Método dos Mínimos Quadrados. Tem-se então que

ε+= yy ˆ , (14)

onde y são os valores previstos pelo modelo de regressão para a variável de resposta e

ε são os resíduos (erros) do modelo.

Três importantes medidas de variação relacionadas à variável de resposta

e à regressão são definidas:

Variação Total: ( )∑ −= 2yySST , (15)

Variação não Explicada: ( )∑ −= 2yySSE , (16)

Variação Explicada: ( )∑ −= 2ˆ yySSR , (17)

É relativamente fácil mostrar que: SSRSSESST += , (18)

o que significa que a regressão explica uma parte da dispersão da variável dependente.

O teste descrito utiliza estas partes da dispersão da variável dependente para se

posicionar diante de duas hipóteses:

H0: 0=iβ , para todo i; H1: 0≠iβ , para algum i.

28

Define-se então uma estatística F dada pela razão

( )1+−

=

knSSE

kSSR

F , (19)

que tem no numerador a chamada variação média do modelo e no denominador a

variação média dos resíduos. A estatística calculada é comparada com um valor crítico,

que pode ser obtido através de tabelas estatísticas da distribuição de Fisher, que são

definidas em termos dos graus de liberdade do numerador e denominador (no caso k e n

– (k + 1), respectivamente) e em função de um nível de confiança. A Hipótese H0 deve

ser rejeitada se a estatística calculada é maior do que o valor crítico obtido. Neste caso,

pode-se garantir que, como algum dos coeficientes é não nulo, existe uma relação

estatisticamente válida entre a variável dependente e o conjunto de variáveis

independentes.

Estes resultados aqui demonstrados são o esboço inicial da teoria, e são

importantes para o algoritmo desenvolvido e sobre o qual discorreu-se ao longo do

Capítulo 5.

2.2.2 Redes neurais

Uma rede neural é um modelo simplificado da estrutura cerebral através

de uma estrutura de um grafo, onde os nós são chamados de unidades e as arestas são

chamadas de sinapses, em uma forte alusão aos neurônios, unidades cerebrais. As redes

neurais mais comuns, e as que interessam para o objeto deste estudo, são as redes em

que as unidades podem ser classificadas como pertencentes a camadas. Estas redes são

chamadas de redes multicamadas feedforward sem ciclos, pois possuem pelo menos

duas camadas: uma de entrada e uma de saída. Além destas, a rede pode possuir

29

camadas intermediárias, que são chamadas de camadas ocultas. As redes multicamadas

podem possuir qualquer quantidade de camadas ocultas, apesar de ser possível provar

que mais de uma camada oculta não traz vantagens à capacidade da rede (Cf. Haykin,

2000). As unidades são conectadas por estruturas chamadas sinapses, onde cada uma

das sinapses possui um peso associado. As redes feedforward puras apresentam sinapses

apenas entre as camadas adjacentes, evitando que a camada de entrada se conecte

diretamente com a camada de saída, por exemplo. Veja a Figura 6.

x1

x2

xi

wijOj

wkj

Ok

Camada de Entrada

Camada Intermediária

Camada de Saída

... ...

Figura 6: Exemplo de Rede Neural multicamadas feedforward

A Rede Neural desenhada na Figura 6 possui duas camadas além da

camada de entrada. Portanto, diz-se que é uma Rede Neural com duas camadas.

Semelhantemente, sobre uma rede contendo duas camadas intermediárias, diz-se ser

uma rede com três camadas e assim por diante. A estrutura é dita totalmente conectada,

o que ocorre quando cada unidade de uma camada possui uma sinapse para cada

unidade da camada seguinte.

Quando utilizadas para indução de modelos, que a Inteligência Artificial

chama de aprendizado de máquina – machine learning – a camada de entrada deve

possuir tantas unidades quantas forem as variáveis independentes. De fato, cada unidade

será responsável por captar e propagar o valor de cada variável independente. Da

30

mesma maneira, a camada de saída se relaciona com o conjunto de variáveis

dependentes, que para o caso da classificação e previsão costuma ser um conjunto

unitário. Ou seja, a camada de saída das redes neurais aplicadas para modelos de

classificação e previsão costuma possuir apenas uma unidade na camada de saída, posto

que geralmente apenas uma variável está sendo modelada. É possível uma mesma rede

ser utilizada para modelagem simultânea de duas ou até mais variáveis dependentes,

porém este modelo geralmente pode ser dividido em dois modelos independentes. A

camada intermediária pode possuir uma quantidade aleatória de unidades. A escolha

desta quantidade conclui a definição da topologia da rede.

A Figura 7 mostra o funcionamento de uma unidade chamada de unidade

j. Os quadrados à esquerda são os valores das saídas das unidades que se conectam à

unidade j (x0, ..., xk). Neste exemplo, se a rede for uma multicamada feedforward, está se

considerando que a camada anterior tinha k unidades. Os valores que estão entrando na

unidade (x0, ..., xk) são ponderados – multiplicados – pelos pesos das sinapses (w0j, ...,

wkj) e então somados. Este somatório inclui um termo independente, que está

armazenado na unidade, e é chamado de bias. O valor deste somatório é submetido a

uma função de ativação que determinará qual será a saída final da unidade. Com esta

função de ativação é possível controlar a saída da unidade, numa atividade conhecida

como normalização. São funções conhecidas como função de esmagamento, que

mapeiam um domínio grande de entrada em um pequeno intervalo de saída. Para

garantir saídas com valor 0 ou 1 (discretos), é comum o uso da função degrau. Para

garantir saídas com valores entre 0 e 1, costuma-se usar a função logística. A função

tangente hiperbólica costuma ser usada para garantir saídas entre –1 e 1 (Cf. Haykin,

2000).

31

Σ

x0x0

x1x1

xkxk

...

w0j

w1j

w2j

ff Saída

θjbias

Figura 7: Uma visão de uma unidade j

Uma rede como esta funciona como um somatório ponderado dos valores

das variáveis de entrada. As redes multicamadas feedforward são consideradas

aproximadoras universais de funções, sendo portanto bastante utilizadas para a atividade

de aprendizado de máquina – e indução de modelos.

O treinamento equivale a propagar os valores das variáveis

independentes na entrada da rede até a unidade de saída. O valor de saída da rede é

comparado com o valor da variável dependente, e em função disso a rede sofre ajustes

nos valores dos pesos e dos bias de cada unidade, que podem ter sido (geralmente são)

iniciados com valores aleatórios. Este ajustamento visa reduzir o erro entre o valor real

da variável dependente e o valor que é previsto pela rede. Duas medidas de erro

costumam ser utilizadas: o erro de treinamento e o erro de teste. O erro de teste refere-se

a um conjunto separado de casos conhecidos que não é utilizado no treinamento. O

algoritmo mais utilizado para treinamento de redes como esta é o algoritmo de

backpropagation, ou retropropagação, que utiliza como critério de parada uma condição

múltipla sobre estas medidas de erro. Este nome é devido ao movimento de propagação

do erro, de trás para frente, da camada de saída para a camada de entrada. Maiores

detalhes do algoritmo podem ser vistos em Haykin (2000).

32

No algoritmo de retropropagação é possível que o valor inicial dos pesos

afete a exatidão dos resultados. Se a rede tiver sido treinada e a precisão não for

considerada aceitável, é comum repetir o processo de treinamento com uma topologia

de rede diferente ou então com um conjunto inicial de valores para os pesos diferentes.

As Redes Neurais têm sido bastante criticadas devido a sua dificuldade

de interpretação, uma vez que fica difícil interpretar o significado simbólico através dos

pesos aprendidos. Este aspecto fez com que inicialmente as Redes Neurais fossem

menos desejáveis no exercício de Data Mining. As vantagens das Redes Neurais

incluem uma alta tolerância a dados com ruídos assim como uma grande habilidade de

classificar padrões ou prever valores para os quais ela não tenha sido treinada.

Recentemente estão sendo desenvolvidos diversos algoritmos para a extração de regras

a partir de Redes Neurais treinadas. Isto têm contribuído para o crescimento do uso das

Redes para as atividades de Mineração de Dados (Cf. Han & Kamber, 2001).

2.2.3 Previsão baseada em memória

Esta técnica de previsão é baseada no aprendizado por analogia. Os casos

de treinamento são descritos pelos valores de suas variáveis independentes, através de

vetores numéricos n-dimensionais (ou seja, n valores numéricos). Assim, cada caso é

representado por um ponto em um espaço n-dimensional, chamado de espaço de

padrões (pattern space). Uma revisão do assunto pode ser vista em Aha (1997).

Um dos métodos mais famosos obtém o valor da variável dependente de

um determinado caso fazendo uma busca no espaço de padrões por k casos que sejam

mais semelhantes ao caso em questão. Estes k casos são os k-vizinhos mais próximos,

que dá o nome ao método (KNN – k-nearest neighborhood).

A semelhança entre os casos é definida em termos da distância entre os

pontos do espaço de padrões. Esta distância depende de alguma métrica. Ou seja, dados

33

dois pontos em um espaço n-dimensional ( )nxxxX ,,, 21 K= e ( )nyyyY ,,, 21 K= , a distância

entre eles pode ser dada por:

( ) ( )∑ =−=

n

i ii yxYXd1

2, Métrica Euclidiana; ( ) ∑ =

−=n

i ii yxYXd1

, Métrica de Manhatan; ( ) ( )q n

iq

ii yxYXd ∑ =−=

1, Métrica de Minkowski;

sendo que a mais comum é a Métrica Euclidiana.

O algoritmo inicialmente desenvolvido era para modelos de classificação.

De acordo com o algoritmo original, o caso era classificado pelo valor mais comum

entre seus k-vizinhos mais próximos. A adaptação do algoritmo para modelos de

previsão deve levar em consideração que possivelmente os k-vizinhos terão valores

distintos para a variável dependente. Neste caso, é necessário tomar uma média

aritmética entre os k valores obtidos. Esta média pode ser simples ou ponderada em

função do inverso da distância entre o caso que se está prevendo e os casos

armazenados no espaço de padrões.

Os modelos baseados em vizinhos são considerados modelos de

aprendizado “preguiçosos” (lazy learners), no sentido de que nenhum modelo é

construído. As amostras de treinamento são armazenadas e consultadas quando um caso

novo e desconhecido é fornecido a fim de ser previsto/classificado. Estas técnicas

mostram-se muito rápidas na etapa de treinamento (que representa apenas o

armazenamento dos dados), mas consomem bastante tempo para obter a previsão de um

caso não rotulado. Normalmente, são requeridas técnicas de indexação eficientes para

agilizar esta consulta. Além disso, se a memória principal do computador não for

suficiente para o armazenamento dos dados de treinamento, o procedimento pode ficar

muito mais demorado.

34

2.2.4 Previsão fuzzy

Os sistemas fuzzy podem expressar o processo de razão humana através

de relacionamentos entre conceitos com regras. Eles mantêm-se verbalmente

(lingüisticamente) interpretáveis, que é uma das características mais procuradas nas

técnicas de Inteligência Artificial, sendo que alguns autores consideram que os sistemas

baseados em regras fuzzy são potencialmente mais promissores que as redes neurais

(Cf. Bárdossy & Duckstein, 1995).

O seu desenvolvimento foi dado dentro da modelagem simbólica da

Inteligência Artificial, que apresentava algumas desvantagens, pois sendo construído

por dados originados por humanos – especialistas – perdia facilmente a sustentação

empírica, e por que, sendo simbólico, sua validação é difícil de manter, pois os dados

empíricos são geralmente numéricos.

As técnicas de modelagem baseadas em Regras Fuzzy buscam reconciliar

o rigor empírico de modelos matemáticos clássicos e a interpretabilidade dos modelos

simbólicos da Inteligência Artificial. O leque de aplicabilidade dos modelos baseados

em regras fuzzy é muito grande, em função da gama de funções não lineares que podem

ser descritas. Potencialmente, estas funções são aproximadores universais. Além disso,

os modelos mantêm-se simples porque cada modelo fuzzy é composto por um conjunto

de modelos locais simples com procedimentos para ir suavemente de um domínio para

outro;

Uma pequena revisão dos sistemas fuzzy, sob a ótica holística do

problema de identificação de sistemas pode ser visto em Evsukoff, Branco & Galichet

(2002).

35

2.3 Árvores de previsão

Uma árvore, no sentido computacional, é uma estrutura de representação

gráfica de objetos (dados, condições, informações, etc.). Uma definição formal é

fornecida por Szwarcfiter & Markenzon (1994): Uma árvore T é um conjunto finito de

elementos denominados nós ou vértices tais que existe um nó especial, r, chamado raiz

da árvore; os restantes constituem um único conjunto vazio ou são divididos em m ≥ 1

conjunto(s) disjunto(s) não vazio(s), as sub-árvores de r, cada qual por sua vez uma

árvore.

A

B C

D E F

IG H

Figura 8: Exemplo de árvore

Existem diversas maneiras de representar uma árvore, mas a

representação hierárquica é, de longe, a mais utilizada, pela forma clara como exibe as

relações entre os nós. Nesta representação, os nós são ligados através de estruturas que

são chamadas de arestas ou arcos. Uma árvore aleatória pode ser vista na Figura 8. A

raiz da árvore é o nó A, que possui duas sub-árvores, cujas raízes são os nós B e C. A

sub-árvore cuja raiz é o nó B não possui sub-árvores.

Seja v o nó raiz da sub-árvore Tv de T. Os nós raízes w1, w2, ..., wj das

sub-árvores de Tv são chamados filhos de v; v é chamado pai de w1, w2, ..., wj. Os nós

36

w1, w2, ..., wj são irmãos. Se z é filho de w1, então w2 é tio de z e v é avô de z. O número

de filhos de um nó é chamado de grau de saída desse nó. Quando o grau de saída dos

nós da árvore é limitado a uma determinada quantidade n, diz-se que esta árvore é nária.

São muito conhecidas e utilizadas as árvores binárias, ou seja, as árvores onde cada nó

possui no máximo dois filhos. Na Figura 8 vê-se uma árvore possivelmente ternária.

Se x pertence à sub-árvore Tv, x é descendente de v, e v é ancestral de x.

Nesse caso, sendo x diferente de v, x é descendente próprio de v, e v é ancestral

próprio de x. Um nó que não possui descendentes próprios é chamado folha. Toda

árvore com n > 1 nós possuí no mínimo 1 e no máximo n – 1 folhas. Um nó que não é

folha é dito interior. Na Figura 8 tem-se que o nó C é pai de D, E e F, e avô de G, H e I.

Os nós D, E e F são irmãos, e o nó B é tio deles todos. Todos estes nós são descendentes

próprios de A. A árvore possui 9 nós, dos quais 5 são folhas (B, E, G, H e I) e 4 são

internos (A, C, D e F).

Uma seqüência de nós distintos v1, v2, ..., vk, tal que existe sempre entre

nós consecutivos (v1 e v2, v2 e v3, ..., vk –1 e vk) a relação “é filho de” ou “é pai de”, é

denominada um caminho na árvore. Diz-se que v1 alcança vk e vice-versa. Um

caminho de k vértices é obtido pela seqüência de k –1 pares da relação. O valor k –1 é o

comprimento do caminho. O nível de um nó v é o número de nós do caminho da raiz

até o nó v. O nível da raiz é, portanto, igual a 1. A altura de um nó v é o número de nós

do maior caminho de v até um de seus descendentes. As folhas têm altura 1. A altura

da árvore T é igual ao nível máximo de seus nós. A árvore da Figura 8 apresenta altura

igual a 4.

Existem diversas ferramentas computacionais para realizar atividades de

previsão e classificação utilizando estruturas de árvore, ou estruturas tão similares que

possam ser expressas em forma de árvores. São as ferramentas de indução de modelos

37

baseados em árvores. Estas ferramentas apresentam metodologias diferentes para

detalhes dos algoritmos envolvidos, mas a maneira que as estruturas de árvores são

usadas reúne algumas características que são as mesmas para todas as metodologias.

Um nó interno é sempre um teste sobre um conjunto de atributos e uma

folha representa sempre um valor para a variável dependente. Quando se está tentando

estabelecer o valor da variável dependente para um determinado caso, ele é

primeiramente testado na raiz. Este teste determina qual sub-árvore o nó deve seguir. Se

esta sub-árvore possuir apenas um nó, então este nó é uma folha, e será obtido o valor

desejado. Se esta sub-árvore possuir mais de um nó, então haverá uma raiz para a sub-

árvore, que será um novo teste. Como a árvore é um conjunto finito de nós, tem-se que

este processo resulta em uma folha e, portanto, num valor para a variável dependente.

Os processos de construção dos modelos baseados em árvores também

apresentam características comuns para as mais diferentes metodologias de previsão (ou

de classificação). O procedimento são normalmente recursivos. O passo recursivo ou

cria um nó interno – um teste que realiza a divisão do conjunto de registros (casos)

usando alguma característica dos atributos, ou cria um nó folha – determina um valor

para a variável dependente (ou um modelo, como visto posteriormente) – quando uma

condição de parada é observada. As condições de parada (parada do crescimento da

árvore) mais comumente utilizadas são duas: 1) quando um limite para a função

objetivo é alcançado; 2) quando o conjunto de casos é menor que um limite pré-

definido.

A divisão do conjunto de atributos pode ser em dois subconjuntos ou em

uma quantidade maior de subconjuntos. O tipo da divisão varia de acordo com o método

que está sendo utilizado, e determinará se a árvore será binária, ternária, etc. São bem

comuns as árvores binárias (Cf, Quinlan, 1986, 1993 e Breiman, 1984), mas não são as

38

únicas. Além disso, a escolha de qual será o atributo usado na divisão e de qual teste

será aplicado é crítico para o resultado global do método. Uma função objetiva é

definida, baseada no erro ou na variância/desvio padrão do modelo, e testes são

aplicados para otimizá-la.

Assim como os modelos genéricos, os modelos baseados em árvore são

de classificação ou de previsão de acordo com a natureza da variável dependente.

Considerando o universo das Árvores de Previsão, ou seja, o universo dos modelos de

previsão baseados em estruturas de árvores, é importante considerar que existem dois

tipos de modelos diferentes. Esta diferença fica muito evidente na estrutura da árvore,

principalmente quando se observa o que está armazenado nas folhas da árvore que já foi

induzida. As folhas de uma Árvore de Regressão apresentam valores para a variável

dependente, e/ou possivelmente, valores para algumas estatísticas do conjunto de

valores da variável dependente que caíram naquele nó durante a fase de indução

(treinamento) do modelo. As Árvores de Regressão foram originalmente propostas por

Breiman (1984). As folhas de uma Árvore de Modelos apresentam modelos para que

os valores da variável dependente sejam obtidos. Estes modelos podem ser modelos de

regressão estimados através do conjunto de casos que alcança a folha, como foi

originalmente proposto por Quinlan (1992).

A grosso modo, esta diferenciação é bem aceita. Na verdade, a estrutura

da Árvore de Modelos proposta por Quinlan é bem mais complexa do que a estrutura de

uma Árvore de Regressão, pois apresentam algumas características que ainda não foram

relatadas. Além disso, as diferenças entre as estruturas obrigam que as metodologias

sejam mais específicas, conforme pode ser visto nos capítulos subseqüentes.

Os trabalhos de Breiman (1984) são um importante ponto de referência

para o uso de estruturas de árvores para indução de modelos. É, certamente, o primeiro

39

trabalho relevante nesta linha. Posteriormente, uma ferramenta computacional foi

desenvolvida com base nas idéias presentes no livro, e comercialmente leva o nome de

CART (Classification And Regression Trees). Esta ferramenta é atualmente muito bem

aceita comercialmente, inclusive ganhou a KDD Cup (importante evento anual

realizado por um grupo de pesquisadores de Data Mining) em 2000 (Cf. CART, 2003).

Atualmente, o termo CART designa o livro original, as metodologias de árvores de

classificação e de regressão, e o software.

Na seqüência desta seção, serão descritas as metodologias das

ferramentas de previsão baseadas em árvores. Pela própria natureza histórica a

ferramenta CART constitui a base fundamental para as demais. Portanto estão descritas

toda a metodologia desta ferramenta e as metodologias subseqüentes em função das

suas diferenças em relação à CART. Convém observar que dentre todas as ferramentas

pesquisadas na análise realizada no Capítulo 4, CART é a única Árvore de Regressão

estudada, sendo todas as demais Árvores de Modelos.

2.3.1 CART

Sobre o livro de Breiman (1984) pode-se dizer que em linhas gerais é

bem formalizado, autocontido (com conceitos e definições que são construídos desde os

níveis mais elementares até os resultados que são enunciados). Oferece uma roupagem

matemática apurada, propiciando uma leitura completa sobre o assunto de classificação

e previsão usando árvores. Está ilustrado com diversas aplicações.

O autor define Tree Structured Classifiers, (Cf. Breiman, 1984 pg. 20-

23) e Tree Structured Predictors (Cf. Breiman, 1984 pg. 228-232). Estas estruturas de

árvore são sempre binárias, com os nós internos indicando regras de seleção de registros

baseadas nos valores dos seus atributos. A diferença estabelecida entre elas é o que está

40

codificado nas suas folhas. No caso do classificador, a classe e no caso do previsor o

valor da previsão.

A título de exemplo, considere a Árvore de Regressão que está

representada na Figura 9, que foi induzida por Breiman a partir de 506 casos referentes

a bairros da cidade de Boston. A variável dependente de cada caso refere-se ao valor

médio das casas no bairro, e são 13 variáveis independentes referindo-se às

características do bairro, como qualidade do ar, acessibilidade a vias principais, etc. Por

exemplo, a variável RM refere-se ao número médio de quartos; a variável LSTAT

refere-se ao percentual da população de baixo status (financeiro); a variável DIS refere-

se a uma distância ponderada ao centro e a variável CRIM refere-se à taxa de crimes do

bairro. A descrição completa das variáveis está na página 218 de Breiman (1984).

O número dentro de cada nó é a média para a variável dependente

considerando todos os casos que alcançam o nó. Por exemplo, considerando os 506

bairros, a média da variável dependente é 22,5. Imediatamente abaixo de cada nó, pode-

se ver o teste de divisão dos casos. Os casos que atendem ao teste (resultado verdadeiro)

seguem para o filho da esquerda, e os que não atendem (resultado falso) seguem para o

filho da direita. Os números nas arestas que ligam cada um dos nós internos aos seus

filhos representam a quantidade de casos que são passados a este filho. Por exemplo,

430 bairros apresentam valor para a variável RM ≤ 6,9 e 76 não. Para usar esta árvore

para previsão, os dados para um bairro são aplicados na árvore, desde a raiz até alguma

folha. Então, o valor previsto para a variável dependente será a média que está

armazenada no nó terminal.

41

22,5

19,9 37,2

23,3 15,0

22,945,68,8

21,62,9

27,43,4

12,03,8

17,13,4

32,1

14,43,1

33,34,5

45,1

21,90,0

15,94,3

RM≤6,9

LSTAT≤14

DIS≤1,4 CRIM≤7,0

RM≤7,4

CRIM≤7,4 CRIM≤2,7

RM≤6,5

430 76

255 175

5 250

195 55

101 74 43 3 29 1

3046

Valor médio da variável de resposta

Figura 9: Árvore de Regressão. Adaptado de Breiman (1984)

Existem alguns detalhes importantes a serem observados na árvore. A

divisão RM ≤ 6,9 separa os 430 casos que atendem ao teste, de maneira que apresentam

um valor baixo para a média da variável dependente – 19,9, dos 76 que apresentam um

valor mais alto para a média da variável dependente – 37,2. O objetivo do teste que está

em cada nó não é dividir o conjunto de registros em partes iguais – este teste que foi

analisado passa longe de fazê-lo. O objetivo é separar o conjunto de casos de maneira a

criar conjuntos que tenham valor da variável dependente suficientemente diferente.

Além disso, apenas 4 das 13 variáveis independentes foram utilizadas para a definição

do modelo (estas quatro variáveis foram descritas anteriormente).

Os trabalhos de Breiman foram desenvolvidos tratando as estruturas para

classificação e previsão de maneira muito semelhante. De maneira geral, pode-se dizer

que as árvores de classificação estavam bem desenvolvidas, posto que as técnicas de

classificação baseadas em árvore avançaram muito pouco na seqüência histórico-

científica, ao contrário das árvores de regressão, que são profundamente desenvolvidas

42

no processo de amadurecimento científico. Isto principalmente por que o CART

apresenta os valores das previsões nas folhas ao invés de algum modelo mais elaborado,

como é feito pelas metodologias que o sucedem. Ao que parece, o fato de tratar as duas

técnicas de maneira tão semelhante reduziu a eficiência dos modelos de previsão.

2.3.1.1 Crescimento da árvore

Considere que se possui um conjunto L de casos para o treinamento.

Cada caso é um vetor na forma ( )yxxxX k ,,...,, 21= , com os valores para as k variáveis

independentes xi e o valor para a variável dependente y. Para descrever como será o

algoritmo de crescimento da árvore – que equivale ao treinamento do modelo – três

elementos são necessários:

• Um modo para selecionar uma divisão em cada nó interno;

• Uma regra para determinar quando um nó é terminal (folha);

• Uma regra para associar um valor y(f) para cada folha f.

A última questão é resolvida considerando o método dos mínimos

quadrados, como na metodologia dos modelos de regressão. Mais especificamente,

considerando que o valor previsto em uma determinada folha f é d, tem-se que a média

residual quadrática ( )fR desta folha dada por

( ) ( )∑∈

−=fX

ii

dyN

fR 21 (20)

que é um valor que se deseja minimizar. A constante N1 é considerada apenas para

facilitar o calculo do resíduo médio total. N é o tamanho do conjunto de treinamento.

É fácil provar (Cf. Breiman, 1984) que o valor d que minimiza a

função ( )fR acima descrita é o valor médio da variável dependente nos casos que caem

na folha f, ou seja:

43

( ) ( ) ∑∈

==fX

ii

yfN

fyd 1 , (21)

onde ( )fN é o número total de casos que caem na folha f.

Seja T~ o conjunto de folhas da árvore T. O erro médio de treinamento da

árvore T, R(T), pode ser estimado fazendo:

( ) ( )( )∑ ∑∈ ∈

−=Tf fX

ii

fyyN

TR~

21 (22)

que equivale a

( ) ( )∑∈

=Tf

fRTR~

(23)

A Equação 23 tem interpretação simples. Para cada folha f,

( )( )∑∈

−fX

ii

fyy 2 é a soma dos quadrados interna ao nó, isto é, é o desvio quadrado total

dos valores da variável dependente para a sua média, considerando apenas os casos que

caem na folha f. Somando sobre todas as folhas Tf ~∈ dá o desvio total considerando

todos os valores para a variável dependente, e dividindo por N dá o desvio quadrático

médio.

Um importante resultado apontado por Breiman mostra que o melhor

teste que divide os casos t que caem em um dado nó em dois conjuntos tL e tR é aquele

que mais reduz o valor R(T) definido anteriormente. Mais precisamente, para qualquer

teste de divisão s, seja

( ) ( ) ( ) ( )RL tRtRTRtsR −−=∆ , (24)

a função redução do desvio quadrático médio considerando o teste s de divisão no nó t.

Então, considerando que S é o conjunto de todos os testes de divisão possíveis ao nó t,

tem-se que a melhor divisão para este nó será s* tal que:

44

( ) ( )tsRtsRSs

,*, max ∆=∆∈

. (25)

Assim, a árvore de regressão é formada iterativamente dividindo os nós

para que maximizem a redução em R(T). Usando este critério, o melhor teste de divisão

em um nó é aquele que separa os valores mais altos da variável dependente dos mais

baixos.

É importante considerar também que o trabalho apresenta importantes

resultados sobre alternativas para estimar a precisão (como descrito inicialmente),

procedimentos para simplificação e generalização das estruturas (poda) e para o

processo de escolha das regras para divisão considerando atributos numéricos (ordered

ou numerical) e categóricos (categorical).

2.3.1.2 Poda

Breiman estabeleceu que as árvores modeladas eram desnecessariamente

grandes. E como o tamanho da árvore está diretamente relacionado com a complexidade

do modelo, árvores grandes implicam em modelos difíceis de interpretar e compreender.

Além disso, o modelo pode apresentar um problema conhecido como overfitting ou

sobreparametrização, ou seja, ajuste demasiado aos dados de treinamento. O modelo

precisa apresentar uma margem de generalidade para dados que não fazem parte do

conjunto de treinamento.

Para resolver estes dois problemas, Breiman define e usa a técnica de

poda da árvore. Depois que a árvore é completamente desenvolvida, alguns nós

intermediários são transformados em nós terminais (folhas). Isto aumenta a taxa de erro

do modelo em relação aos dados de treinamento, mas generaliza a árvore, ou seja, reduz

a taxa de erro para outros dados, como os dados de teste. Além disso, esta operação

reduz o tamanho da árvore, que significa um modelo final mais interpretável.

45

O processo é chamado de minimização do erro-complexidade. A idéia

básica é minimizar uma função que considera além da taxa de erro da árvore a sua

complexidade, que é medida em termos da quantidade de folhas que a árvore possui.

Esta função é chamada de função de erro-complexidade, e tem a forma a seguir:

( ) ( ) TTRTR αα += (26)

onde T é a quantidade de nós terminais (folhas) que a árvore T possui, e α é uma

constante positiva chamada de parâmetro de complexidade.

O valor ( )TRα representa uma combinação linear do erro da árvore e sua

complexidade. Se α for visto como um custo de complexidade a ser pago por cada

folha, então ( )TRα é formado acrescentando ao erro uma penalidade, que são os custos

por sua complexidade.

Considere que Tmax é a árvore que foi completamente desenvolvida, ou

seja, que não foi podada. Para cada valor de α, é encontrada aquela sub-árvore de Tmax

( ) maxTT pα que minimiza ( )TRα , isto é,

( )( ) ( )TRTRTT

αα α minmaxp

= . (27)

Se α é pequeno, a penalidade por ter um árvore muito complexa, ou seja,

com muitas folhas, é pequena, e então ( )αT tende a ser grande. Por exemplo, se maxT

for tão grande que cada folha contém apenas um caso, então cada caso é classificado

corretamente, ou seja, ( ) 0max =TR , e portanto maxT minimiza ( )TR0 . À medida que a

penalidade por folha α aumenta, as sub-árvores que minimizantes vão tendo cada vez

menos nós terminais. Finalmente, para valores de α suficientemente grandes, a sub-

árvore minimizante possuirá apenas um nó terminal, que é a própria raiz da árvore.

Neste caso, maxT foi completamente podada.

46

Apesar de α assumir valores contínuos, existem apenas uma quantidade

finita de sub-árvores de maxT . Assim, o processo de poda produz uma seqüência finita de

sub-árvores T1, T2, T3, ... com progressivamente menos nós terminais. Por conta desta

natureza finita, acontece que se ( )αT é a árvore que minimiza a função erro-

complexidade para algum valor de α, então ela continua minimizando à medida que α

aumenta, até que um determinado valor, por exemplo α', que é chamado de ponto de

salto (jump point). Neste momento uma nova árvore ( )'αT é a que minimiza a função de

erro-complexidade e continua sendo até que um novo valor de salto α'' é alcançado.

Breiman prova duas importantes propriedades sobre este esquema de

poda: (i) existe uma única sub-árvore maxTT p que minimiza ( )TRα , e (ii) existe uma

seqüência de árvores { }121 ... tTT ≥ff , ({ }1t representa a árvore que possui apenas a

raiz t1) ou seja, para valores crescentes do parâmetro de complexidade, cada nova sub-

árvore pode ser obtida da anterior. Com isto, o universo de escolha da árvore final está

restrito a esta seqüência. Esta escolha é feita usando uma estimativa mais honesta da

precisão da árvore do que a função de erro original (Equação 23). Breiman sugere o uso

do conjunto de teste, ou então o uso de validação cruzada sobre o conjunto de

treinamento.

2.3.1.3 Regras de divisão

Dado um conjunto de registros, existem inúmeras regras baseadas nos

valores dos atributos que podem ser utilizadas para dividi-lo. O critério para a escolha

de qual regra será usada para realizar a divisão dos registros é, no caso de modelos de

previsão, baseado na minimização da variância da variável de resposta. Esta heurística

baseia-se na lógica de que conjuntos de dados com a variável de resposta menos

dispersa são mais fáceis de serem modelados.

47

Breiman faz um estudo detalhado sobre a escolha das regras baseando-se

em um custo de fazer uma previsão errada. Este custo não está diretamente relacionado

com a taxa de erro do modelo como um todo, porque este ainda é desconhecido, pois a

árvore ainda será submetida ao processo de poda. São estabelecidos critérios minuciosos

para escolha da regra de divisão para vários tipos de modelo, entre os quais previsão

(Breiman considera também modelos de classificação, que ainda são divididos em

modelos com dois rótulos de classe e modelos com mais de dois rótulos de classe). As

regras de divisão estão definidas de acordo com o tipo do atributo, se categórico ou

numérico.

No caso de atributos contínuos (numéricos) a divisão fica bem definida

usando um valor que será utilizado como limite ou como nível para este atributo. A

divisão é feita então selecionando de um lado os registros que possuem o valor do

atributo em questão menor (ou igual) do que o limite obtido, e do outro lado aqueles

registros que possuem o valor do atributo em questão maior (ou igual) do que o limite

obitido.

No caso de teste em atributos categóricos, não é possível utilizar um

valor limite como feito anteriormente, pois não é possível estabelecer a regra em função

do valor do atributo ser maior do que o limite – considerando atributos não ordenados.

Torna-se então necessária a descrição explícita dos valores que irão compor os

subconjuntos resultantes do teste.

A busca pelo nível de divisão que será feita em atributos contínuos não

está otimizada. É necessário varrer todo o conjunto de casos procurando o melhor valor

para ser usado como limite na regra de divisão. Já a busca de como será feita a divisão

quando o atributo é categórico foi otimizada por Breiman (1984). Ele mostrou que a

melhor divisão usando um atributo categórico com k diferentes valores é obtida

48

tomando uma das k - 1 porções obtidas pela ordenação dos valores do atributo segundo

o valor médio da variável de resposta. Em outras palavras, considere que

( )kxxxX ,...,, 21= é o conjunto dos valores do atributo (com k categorias).

Naturalmente, existe uma ordenação )()2()1( ,...,, kOOO xxx tal que a média dos valores da

variável de resposta dos casos que possuem )(iOxX = é menor do que a média dos

valores da variável de resposta dos casos que possuem )( jOxX = para todos i e j entre 1

e k, sendo i < j. Breiman mostrou que a divisão ótima do atributo X gera os dois grupos

( ))()1(1 ,..., pOO xxX = e ( ))()1(

2 ,..., kOpO xxX += , ou seja, ordenados.

Este resultado, por si só, já representa um grande ganho em termos de

velocidade de processamento na busca da regra de divisão. Uma metodologia de

tratamento do atributo categórico otimizará ainda mais este procedimento, como pode

ser visto no algoritmo M5’, descrito no Capítulo 3.

2.3.2 M5

Historicamente Quinlan (1986) foi o primeiro texto em que se usa o

termo Árvore de Decisão para designar um modelo de aprendizado de máquina (neste

caso modelos de classificação), chamado de ID3. Este trabalho é posteriormente

desenvolvido gerando o clássico C4.5 no texto Quinlan (1993). Este livro é um texto

bem avançado sobre o problema de classificação utilizando árvores. O texto inclui o

problema de geração de regras, agrupamento de valores de atributos e interação com

outros modelos de classificação. Uma cópia dos arquivos fontes para compilação em

ambiente UNIX do software foram disponibilizados juntamente com o livro e

atualmente estão na Home Page do autor, bem como uma breve documentação e um

guia para o uso do sistema (Cf. Quinlan, 2001).

49

Quinlan (1992) define importantes alterações na estrutura original de

Breiman (1984) para realizar previsão utilizando árvores. O sistema é chamado de M5,

e está fundamentado nos trabalhos iniciais de Breiman. A estrutura criada foi

denominada Model Trees, ou árvores de modelos. Este nome foi utilizado porque as

árvores representam modelos lineares por partes. Todos os nós da árvore apresentam

equações lineares. Esta é uma grande diferença para o CART (Cf. Breiman, 1984), que

apresenta valores fixos, e apenas nas folhas.

O sistema completo apresenta as etapas de simplificação do modelo,

poda da árvore, baseados no CART. A contribuição é a técnica de suavização das

descontinuidades dos modelos. Esta característica tornou-se necessária para evitar que

dois exemplos muito semelhantes (tipicamente com todos os atributos iguais exceto

um), apresentem saída muito diferente.

Sobre a função de redução de erro, a Equação 23 torna-se

( ) ( )∑−=i

ii tsd

nn

tsdSDR (28)

onde sd(t) é o desvio padrão dos valores da variável de resposta no conjunto de casos t.

Pode ser mostrado que esta expressão deriva da Equação 22 ou 23, (Cf. Torgo, 1999), o

que, em última análise, prova que o sistema M5 também usa uma função objetiva para

aplicar o método dos mínimos quadrados.

Depois que a árvore foi completamente desenvolvida, uma equação de

regressão é estimada para cada nó interior. A equação é estimada utilizando os

procedimentos padrão para regressão (mínimos quadrados), usando apenas os atributos

que foram utilizados como teste na sub-árvore abaixo deste nó (por isso não existem

modelos nas folhas). Segundo Quinlan (1992), esta medida é para assegurar que, a

equação no nó que é a raiz da sub-árvore e a própria sub-árvore, possuam a mesma

50

informação, pois a precisão da equação de regressão será comparada com a precisão da

sub-árvore.

Depois que a equação de regressão é estimada, ela pode ser simplificada,

eliminando parâmetros para minimizar o seu erro estimado. A estimativa de erro é feita

a partir da média dos resíduos da regressão (nada é comentado especificamente sobre a

natureza desta média, mas deve ser a média absoluta ou a média quadrática). Esta média

é uma estimativa inferior para os casos não utilizados no treinamento, então um fator é

multiplicado por este erro:

vnvn

−+ (29)

onde n é o número de casos que alcançam o nó (e foram utilizados para estimar a

equação de regressão) e v é o número de parâmetros do modelo. A redução de

parâmetros em uma equação de regressão sempre aumenta a média dos resíduos

(absolutos ou quadráticos), mas reduz o fator expresso na Equação 29, portanto a

estimativa do erro pode diminuir. Uma busca insistente é feita para remover os atributos

que contribuem pouco para a equação de regressão. O caso extremo é não sobrar

atributos na equação de regressão, que é substituída por uma constante.

Depois disso, o uso de modelos lineares torna necessário tratar problemas

de descontinuidade, que surgem quando dois casos muito semelhantes (tipicamente

casos possuindo valores iguais para todos atributos exceto um) caem em diferentes

folhas. É importante garantir que os resultados não sejam tão diferentes.

A técnica de suavização prevê o valor de um caso realizando uma soma

ponderada dos valores previstos por todos os modelos que estão armazenados em cada

um dos nós que estão no caminho desde a raiz até a folha que o caso alcança. Esta soma

ponderada é obtida enviando valores de um nó para seu pai, seqüencialmente desde a

51

folha até a raiz. O primeiro valor é calculado na folha, através do modelo lá

armazenado. O valor previsto pelo nó S (e que será enviado para seu pai) é calculado

usando o valor Si, previsto pelo filho de S onde o caso caiu, usando a equação:

( ) ( )

knSkMSPVn

SPVi

ii

++

=)( (30)

aonde PV é o valor previsto pelo nó, M é o valor de resposta estabelecido pelo modelo

linear no nó em questão, ni é o número de casos que caem no nó Si durante a fase de

treinamento, e k é uma constante de suavização, declarada com valor padrão 15. Não se

conhece estudo sobre o comportamento do modelo de acordo com variações no valor da

constante k.

AA

F1F1 F2F2

PP F3F3

Figura 10: exemplo de árvore de regressão

Suponha, por exemplo, uma árvore que tenha apenas 3 níveis, ou seja,

dois níveis de nós internos mais o nível das folhas. Uma árvore como esta está

representada na Figura 10. Suponha também que se deseja prever o valor de um caso

que caiu na Folha F1. O valor previsto será uma ponderação dos valores obtidos quando

as três equações de regressão localizadas nos nós A, P e F1 são aplicadas ao registro.

Cria-se um fluxo de valores, desde a folha (F1) até a raiz da árvore (A). A equação de

regressão da folha é aplicada ao caso e fornece o valor que será passado para o nó P. A

Equação 30 é utilizada para calcular o valor que será passado para o próximo nó, no

nível mais alto, o nó A. Neste cálculo, PV(Si) será o valor fornecido pela equação de

52

regressão do nó F1, M(S) será o valor fornecido pela equação de regressão do nó P, e ni

será o número de casos que foram utilizados para estimar a equação de regressão na

folha F1. O valor resultado desta aplicação da Equação 30 será passado para o nó A, que

novamente utilizará a Equação 30 para fazer o cálculo do valor de previsão final. Neste

novo cálculo, PV(Si) será o valor que foi passado para o nó A (encontrado pelo uso da

Equação 30 no nó P), M(S) será o valor fornecido pela equação de regressão do nó A, e

ni será o número de casos que foram utilizados para estimar a equação de regressão no

nó P. Como o nó A é a raiz da árvore, este valor final será o valor de previsão para o

caso.

O uso deste procedimento de suavização aumenta substancialmente a

precisão da previsão (Cf. Quinlan, 1992 e Wang & Witten, 1997).

2.3.3 Retis

Este sistema de indução de Árvores de Modelos foi inicialmente descrito

em Karalic & Cestnik (1991). A idéia básica do sistema que foi definida neste artigo é o

uso de uma técnica que é chamada de m-distribution estimate, que é baseado na

abordagem Bayesiana. Esta abordagem Bayesiana não está relacionada com o famoso

Teorema de Bayes. A abordagem está fundamentada na idéia de que para estimar o

valor de um determinado parâmetro parte-se de um valor inicial (priori) que é alterado

em função de alguns experimentos, chegando ao valor final (posteriori).

A abordagem fundamental para este sistema é o uso de novas estimativas

para as estatísticas de média e de variância da variável dependente no conjunto de

exemplos (casos). Considere que o conjunto de exemplos para treinamento E é formado

por elementos da forma ( ){ }iniiiiii wxxxyee ,,...,,,| ,21= , onde yi é o valor da variável

dependente, xij é o valor do atributo j (sendo ao todo n atributos) e wi é um peso

associado ao elemento ei. A partir do conjunto E um novo conjunto Em é formado

53

associando a cada um dos elementos de E o peso Nm , sendo N a quantidade total de

exemplos no conjunto de treinamento E. A estimativa da distribuição da população de

exemplos é realizada usando o conjunto mEE ∪ , inclusive suas estatísticas. Têm-se

então as fórmulas

( ) ∑∑ ∪∈∪∈

=mi

mi

EEeii

EEei

yww

E 1µ e (31)

( ) ( )( )∑∑ ∪∈∪∈

−=mi

mi

EEeii

EEei

Eyww

E 22 1 µσ , (32)

para estimar a média e variância da população de exemplos.

Na seqüência, o sistema evolui para incluir o uso de modelos lineares nas

folhas (Karalic, 1992). Esta idéia fora citada como possibilidade de melhoras no artigo

inicial (Karalic & Cestinik, 1991), antes da apresentação pública do M5 (Quinlan,

1992). Os ajustes para usar modelos de regressão nas folhas da árvore são basicamente a

revisão da noção de impureza do conjunto de exemplos que está sendo examinado em

um determinado nó. A impureza estava relacionada com a variância da variável

dependente, (Eq. 19), e torna-se agora:

( ) ( )( )∑∑ ∪∈∪∈

−=mi

mi

EEeiii

EEei

xgyww

EI 21 r , (33)

sendo g o modelo linear estimado com o conjunto de exemplos E. A impureza esperada

devida a uma divisão é dada por

rrlldiv IpIpI += , (34)

54

onde pl e pr denotam probabilidades de transições no nó esquerdo e direito

respectivamente e Il e Ir são as impurezas correspondentes, estratégia usada para decidir

sobre a poda da subárvore que este nó é raiz.

2.3.4 CORE

O sistema CORE, que está descrito em Robnik-Sikonja (1997), é um

sistema que induz uma Árvore de Modelos que pode possuir vários tipos de modelos

nas suas folhas. O sistema foi criado durante os trabalhos de pesquisa para o título de

mestrado de Robnik-Sikonja e pode simular as técnicas desenvolvidas por outros

sistemas, como M5 e Retis.

O procedimento de crescimento da árvore prossegue até que uma das três

condições de parada seja verificada: quantidade mínima de exemplos, proporção

mínima de exemplos (em comparação ao total fornecido inicialmente) e proporção

mínima do desvio padrão em comparação ao desvio padrão de todos os exemplos

(fornecidos inicialmente).

A metodologia de indução do modelo está dividida em três tarefas:

escolha do teste de divisão em nós internos, construção dos modelos nas folhas e poda.

Na descrição destas tarefas as contribuições que foram estabelecidas são basicamente

três: como os testes são escolhidos e como são feitos os procedimentos de escolha dos

modelos nas folhas e poda.

2.3.4.1 Escolha do teste de divisão

CORE têm implementadas duas técnicas diferentes para escolha do teste

de divisão. A primeira técnica seleciona o atributo que será utilizado estimando a

qualidade dos atributos em cada nó interior. Esta qualidade servirá como índice para a

seleção. A segunda técnica é chamada de Indução Construtiva (constructive induction).

55

• Estimação da qualidade dos atributos

O procedimento de estimação da qualidade do atributo utilizado pelo

CORE é o mesmo utilizado pelo sistema RReliefF (Cf. Robnik-Sikonja & Kononenko,

1997), que induz modelos de previsão. A qualidade de um atributo está diretamente

relacionada com a correlação deste atributo com a variável dependente. Um atributo

considerado com qualidade é capaz de distinguir casos que possuam diferentes valores

para a variável dependente. Ou seja, se dois exemplos possuem valores diferentes para o

atributo em questão, então eles devem possuir valores diferentes para a variável

dependente. Por outro lado, se dois exemplos possuem o mesmo valor para o atributo,

então eles devem possuir o mesmo valor (ou valores não muito diferentes) para a

variável dependente.

A qualidade de um determinado atributo A é definida em termos de uma

taxa chamada W(A), que é definida como sendo:

W(A) = P(dif. valor de A | vizinho com dif. valor de Y) –

P(dif. valor de A | vizinho com mesmo valor de Y) (35)

onde Y é a variável dependente e P() é uma aproximação da probabilidade. É feita uma

contagem dos casos que atendem à definição, em todo o conjunto de casos ou em uma

amostra deste. A primeira expressão considera os exemplos que possuem diferentes

valores do atributo A e diferentes valores da variável dependente. Aparece na expressão

com sinal positivo, sendo portanto um prêmio. A segunda expressão considera os

exemplos que possuem diferentes valores do atributo A mas o mesmo valor da variável

dependente. Estes casos aparecem na expressão com sinal negativo, sendo portanto uma

punição.

56

Este procedimento de seleção do atributo para realizar o teste de divisão

é relatado em Robnik-Sikonja (1997) como muito robusto a ruídos e bem apropriado

para domínios com forte dependência entre os atributos.

• Indução construtiva

Alternativamente à buscar o melhor atributo dentre os que foram

fornecidos, foi implementado um algoritmo que constrói um novo atributo a partir dos

atributos existentes. Alguns operadores que estão relatados são conjunção, adição e

multiplicação. Fica a encargo do usuário definir quais dos operadores disponíveis serão

usados para a construção.

O procedimento de construção é exaustivo e o melhor resultado é

utilizado para o teste de divisão, mas não foi dito como é feita a comparação. O

procedimento possui um espaço de busca muito grande (exponencial no número de

atributos) e algumas heurísticas são utilizadas para limitá-lo.

2.3.4.2 Construção dos modelos nas folhas e poda

A descrição realizada em Robnik-Sikonja (1997) relata que o sistema

CORE permite o uso de modelos lineares nas folhas da árvore, o que o classifica como

indutor de Árvore de Modelos. O algoritmo usa um subconjunto otimizado de

parâmetros nos modelos lineares, assim como o M5 e M5’ (descritos na Seção 2.3.1 e

no Capítulo 3) fazem. Entretanto, esta otimização é realizada usando uma heurística

diferente. Enquanto os sistemas M5 e M5’ baseiam-se na relação entre complexidade do

modelo, número de exemplos (casos) e precisão, CORE baseia-se no princípio MDL –

Minimum Description Lenght (tamanho mínimo de descrição).

O princípio MDL está baseado na famosa lógica de Occam, que diz que

“it is vain to do with more what can be done with less” (Robnik-Sikonja, 1997). Esta

lógica de Occam também é conhecida como Princípio da Parcimônia. O procedimento

57

de poda está baseado no tamanho da codificação dos modelos nas folhas das árvores. O

modelo que apresentar menor codificação é escolhido (Cf. Robnik-Sikonja &

Kononenko, 1998).

CORE também pode utilizar outros tipos de modelos nas folhas das

árvores. Baseado nos trabalhos de Torgo (1999), foram testados modelos usando

vizinhos mais próximos ou modelos de regressão nuclear (Kernel Regression Models).

Segundo o relato, os resultados são bons, mas não foram definitivamente

implementados ainda. Pode também utilizar as técnicas de poda do Retis e do M5.

2.3.5 Árvore de regressões locais

Árvores de Regressões Locais (Local Regression Trees) são o resultado

da integração de árvores de regressão com modelagem local. Os conceitos sobre árvores

de regressão foram bastante discutidos na seção 2.1 deste mesmo capítulo. Uma breve

descrição daquela metodologia que é considerada modelagem local será feita. Na

seqüência será abordado o conceito de Torgo (1999) relativo à Árvore de Regressões

Locais.

2.3.5.1 Modelagem local

De acordo com Cleveland & Loader apud Torgo (1999), a modelagem

local é realizada desde o século XIX. O princípio básico deste método é estimar uma

função polinomial de grau p em partes dos dados, sendo estas expressões chamadas de

modelos (de regressão) locais. Quando p = 0, estas regressões são chamadas de

regressões nucleares (kernel regressions), e o critério de escolha do valor tem uma

grande semelhança com o critério usado pelas árvores de regressão de Breiman. Quando

p = 1, as regressões locais são lineares, e a semelhança é com as árvores de modelos de

Quinlan. As Regressões Locais estão dentro da comunidade de aprendizado de máquina

58

– Inteligência Artificial, e fortemente relacionadas com aprendizagem baseada em

memória (lazy learning).

A questão central nos modelos locais é a noção de similaridade, que é o

que permite isolar os dados em subgrupos – chamados vizinhanças – para estimação das

regressões. Esta similaridade é determinada considerando o conjunto de treinamento

como um espaço vetorial e usando uma métrica particular. Esta métrica é usada para

calcular a distância entre dois casos quaisquer. Diferentes métricas de distância existem,

e podem ser usadas (estas métricas foram anteriormente descritas na seção 2.2.3).

O tamanho da vizinhança usada para obter a previsão para um caso que

está sendo consultado é outra questão importante para as regressões locais. Muitas

alternativas existem para esta questão, como por exemplo, estimar uma distância

máxima, ou definir a quantidade de vizinhos que serão considerados (uma abordagem

bastante parecida com o método KNN discutido na seção 2.2.3).

Todos os casos na vizinhança considerada serão usados para a estimação

dos modelos locais. Entretanto, eles podem ser considerados com pesos diferentes, de

maneira que os vizinhos mais próximos do caso que está sendo previsto tenham mais

importância. Este esquema de ponderação é realizado usando uma função de

ponderação, ou função nuclear (kernel function), como funções tricúbicas (Cf.

Cleveland apud Torgo, 1999) e funções quadráticas.

2.3.5.2 Árvore de regressões locais

As críticas fundamentais realizadas por Torgo (1999) às árvores de

regressão concentram-se na questão do uso de valores constantes nas folhas. A primeira

crítica é no problema da descontinuidade, quando o modelo é considerado como um

todo. Uma outra crítica, que é também uma importante motivação para a integração

entre as árvores de regressão e a modelagem local, está no fato de que a poda da árvore

59

de regressão (que é realizada para alcançar modelos mais compreensivos e menos

complexos) aumenta a variabilidade dos valores da variável de resposta nas folhas das

árvores, o que torna muito inadequado o uso de valores constantes para a previsão. Uma

possível solução para este aumento da variabilidade é o uso de modelos mais complexos

nas folhas ao invés de “ingênuas” médias, que é a estratégia principal das Árvores de

Regressões Locais.

O algoritmo obtém uma árvore de regressão “comum” com o objetivo

principal de dar compreensibilidade para o usuário. Quando a árvore é usada para tarefa

de previsão, podem ser usados modelos mais complexos em cada folha. O resultado é

uma técnica de modelagem que está apta a alcançar excelentes taxas de precisão, e

oferecer um modelo simples para uma compreensão superficial da superfície

aproximada pelo modelo completo.

É importante considerar que, sendo uma fusão entre as técnicas árvore de

regressão e modelagem local, este algoritmo apresenta melhorias sobre os dois métodos.

A melhoria sobre as árvores de regressão é percebida na suavização da superfície

aproximada pelo modelo completo e a possibilidade de evitar a perda de precisão com a

poda. Sobre a modelagem local, as vantagens estão na possibilidade de visualização das

dependências entre a variável de resposta e as variáveis explicativas, e no fato de que a

busca dos vizinhos para estimação dos parâmetros é feita de maneira otimizada. Quando

um caso está para ser previsto, os vizinhos que devem ser considerados para estimação

do valor de previsão são determinados rapidamente seguindo o caminho na árvore que

leva até a folha onde o caso cai, e esta folha reúne os vizinhos que devem ser

considerados.

60

2.4 Aplicações

Ciências aplicadas, como a Computação ou Informática, têm o

desenvolvimento de seu tronco teórico diretamente relacionado com a possibilidade do

uso de suas técnicas e teorias em problemas reais. Realizamos, a título de ilustração,

uma rápida revisão da aplicação de algumas das técnicas de previsão consideradas mais

importantes. Esta revisão não tem o intuito de ser completa, nem profunda, mas apenas

de mostrar que, como se havia de esperar, esta ciência está diretamente envolvida com

problemas reais.

Uma aplicação comum de previsão está associada ao problema de visão

computacional, que pode ser estabelecido como extração de conhecimento a partir de

uma imagem em meio digital. O uso de uma técnica específica de previsão aplicado a

um problema assim pode ser visto em Coelho (1999a) e em Coelho (2000), onde Redes

Bayesianas são aplicadas juntamente com procedimentos de processamento de imagens

para detectar faces humanas em imagens digitais.

Um outro exemplo de redes bayesianas pode ser visto em Rezende,

Rocha & Lobo (2000), onde a ferramenta utilizada (BKD – Bayesian Knowledge

Discoverer) é capaz de extrair tanto a estrutura quanto as probabilidades condicionais

dos dados.

Uma aplicação direta das árvores de regressão, fazendo uso do algoritmo

M5 (na verdade o M5’, já que o Weka é utilizado) pode ser vista em Atanasova &

Kompare (2002). A técnica é aplicada em duas bases de dados relativas a processos

biológicos chamados de WWTP – Wastewater Treatment Plants. Em Chen et al (1998)

pode ser visto o uso das árvores de regressão para modelar dados financeiros. Em

comparação com um modelo de segmentação (clustering) baseado em funções

gaussianas, o autor também aponta para o uso de regressões diferentes em cada cluster.

61

As aplicações de redes neurais são diversas, e de maneira genérica, pode-

se citar toda a parte 3 de Ebecken (1998). A aplicação de redes neurais que parece mais

recorrente está relacionada a problemas financeiros, particularmente acompanhamento

de ativos e demais papéis e índices de bolsas de valores. Uma vasta lista de referências

de ferramentas desenvolvidas especificamente para estas aplicações pode ser vista em

Kdnuggets (2005), quase todas baseadas em redes neurais. Obviamente, existem outras

importantes aplicações desta técnica. Por exemplo, Lachtermacher, Cunha & Coelho

(2002) mostram a aplicação de uma técnica de treinamento de redes neurais chamada

weight-elimination para previsão de hipertensão arterial em adultos.

Uma importante área para aplicação das técnicas de Data Mining é o

gerenciamento do relacionamento com os clientes (CRM – Customer Relationship

Management), problema muito comum nas grandes corporações. Em Berson, Smith &

Thearling (1999) podem ser vistas algumas aplicações de algumas ferramentas de

classificação e previsão, como redes neurais, árvores de decisão, KNN e Regressões

Lineares. As estratégias relativas à implantação de sistemas de CRM em Call Centers

como elas podem ser aplicadas podem ser vistas em Serra & Martucci Júnior (2004).

Em Melo, Junior & Milioni (2004) pode ser visto um exemplo do uso de

Redes Neurais (Multi Layer Perceptron) e Modelos de Regressão Múltipla para gerar

um modelo híbrido do tipo MLEM (Mixture of Local Expert Models), aplicado à

previsão de séries temporais.

As aplicações da ferramenta computacional CART são extensas. O fato

de já ter vencido a KDD Cup (veja na Seção 2.3) tornou a ferramenta relativamente

popular. Entre os clientes famosos está a indústria farmacêutica Pfizer (Cf. CART,

2005), onde a ferramenta foi utilizada para criar escores de testes de diagnósticos de

62

disfunções eréteis em homens, como parte de um programa de marketing para

desmistificar o problema e promover o Viagra.

A facilidade de acesso ao Weka, inclusive os códigos que geram o

software, tem tornado a ferramenta extremamente popular. Uma mostra disso é a

quantidade de cursos de graduação, pós-graduação, técnicos e de extensão em geral que

estão utilizando a ferramenta, como a New York Universit, e a Imperial College London,

dentre diversas.

Uma aplicação de árvores de modelo do Weka pode ser vista em

Solomatine & Dulal (2003), onde o sistema Weka é utilizado em alternativa às redes

neurais para modelagem de dados hidrológicos.

63

3 Árvores de modelos – algoritmo M5’

O algoritmo de Árvores de Modelos M5’ foi apresentado à comunidade

acadêmica em 1997 (Cf. Wang & Witten, 1997). O seu desenvolvimento e publicação

se deram como conseqüência da implementação do algoritmo M5 de Quinlan (descrito

na Seção 2.3.2) dentro da suíte Weka.

O Weka (Cf. Weka Project, 2001) é um projeto de desenvolvimento de

ferramentas de Machine Learning e Data Mining, da Universidade de Waikato, na Nova

Zelândia. O projeto gerou um software (Cf. Weka Software, 2001), baseado em

linguagem Java, que leva o mesmo nome. Este software é uma suíte de KDD, que inclui

diversas técnicas e algoritmos para preparação, visualização e mineração de dados, além

de ferramentas para manipulação dos modelos obtidos. O software é desenvolvido de

acordo com o projeto GNU (Cf. GNU, 2005), e seu código está disponível, podendo ser

compilado em qualquer plataforma. Mais importante do que isto, o Projeto Weka não

está fechado e é possível realizar alterações no código e submeter estas alterações para

uma possível nova versão oficial do software.

O algoritmo M5’ está presente nas versões mais recentes da suíte e se

apresenta em uma classe com o nome de M5P. Dentro do software está disponível

também uma versão do algoritmo baseada em regras, a classe M5Rules. Estes indutores

de modelos têm o mesmo núcleo que é chamado de m5. Diferem em detalhes de saída e

apresentação do modelo final (Cf. Holmes, Hall & Frank, 1999).

Por ocasião da implementação do algoritmo M5 proposto por Quinlan

(1992) pela equipe de desenvolvimento do WEKA, percebeu-se que a descrição do

algoritmo era insuficiente, sem descrições de detalhes fundamentais para a transcrição

64

do algoritmo completo para uma linguagem computacional. Em Wang & Witten (1997)

percebem-se diretrizes mais substanciais para a implementação do M5. Neste texto,

algumas partes do algoritmo que estavam ocultas nos trabalhos originais de Quinlan

foram desenvolvidas (e estão descritas), e algumas outras foram obtidas a partir da

metodologia do CART. O sistema final, chamado de M5’, foi considerado pelos

próprios autores como uma fusão entre o CART e o M5.

O estudo realizado sobre o algoritmo M5’ vai além da tradicional e

comum leitura das publicações realizadas pelos seus autores e desenvolvedores. Para

alcançar o objetivo deste texto foi fundamental realizar também uma leitura do código-

fonte que implementa o algoritmo dentro da suíte Weka. Esta releitura do algoritmo

trouxe novas informações sobre o algoritmo que são fundamentais para a compreensão

das modificações propostas no Capítulo 5.

Assim, neste capítulo podem ser vistas duas explanações sobre o

algoritmo M5’. Na primeira parte, a descrição da parte de domínio público, disponível

na literatura. A segunda descrição, técnica, foi obtida a partir do código fonte. É

fundamental a comparação entre estas duas descrições do algoritmo, pois em alguns

casos a primeira é apenas omissa de alguns detalhes – algo parecido com o que a equipe

experimentou ao tentar implementar o algoritmo M5 original – salvaguardando o fato de

que o algoritmo implementado está disponível, o que jamais aconteceu com o M5,

provavelmente por motivos comerciais. Mas acontece que em alguns casos a descrição

oficial inclui alguns detalhes que não são observados na descrição técnica. Resumindo,

existem alguns procedimentos implementados que não estão descritos na literatura e

existem procedimentos que estão descritos na literatura e não estão implementados no

software. Estes detalhes estão realçados em meio à descrição técnica.

65

3.1 Descrição pública

As contribuições mais importantes de Wang & Witten (1997) sobre o

texto fundamental de Quinlan (1992) referem-se às regras de divisão para os atributos

categóricos e sobre valores faltantes. De forma holística, o modelo continua o mesmo:

crescimento total da árvore e depois a poda. Outras heurísticas presentes no algoritmo

também são as mesmas propostas originalmente por Quinlan.

Os atributos categóricos são substituídos por variáveis auxiliares, o que é

imperativo para que sejam estabelecidos os modelos de regressão nos nós da árvore.

Entretanto, estas variáveis auxiliares são também a chave para uma heurística que

resulta em melhor desempenho computacional. O impacto do uso de valores faltantes na

base de dados que está sendo utilizada para treinamento é minimizado fazendo uso de

uma nova função de redução do desvio da variável de resposta, em substituição à

proposta de Quinlan.

3.1.1 Atributos categóricos

Um atributo categórico com k diferentes valores é substituído por um

conjunto de k – 1 variáveis binárias auxiliares (variáveis dummy). A i-ésima variável

auxiliar terá valor 0 se o valor é um dos i-ésimos primeiros em uma ordenação pré-

estabelecida, e 1 caso contrário. Com isto, todas as divisões dos registros são binárias, e

as regras que as estabelecem e que ficam armazenadas em cada nó interno são dadas por

limites nos valores de algum dos atributos. Isto representa uma simplificação muito

grande no processo de busca da melhor regra de divisão.

Por exemplo, considere um atributo que possua três valores categóricos,

por exemplo X = (amarelo, azul, verde). Como possui k = 3, serão necessárias k – 1 = 2

variáveis auxiliares, binárias para codificar o atributo em questão. Assim, na base de

66

dados que será utilizada para induzir a árvore não haverá o atributo X, mas sim dois

atributos X1 e X2, definidos de acordo com as regras:

===

= verde); Xou azul (X contrário caso 1

amarelo; X se 0X1 (36)

===

= verde); (X contrário caso 1

azul; Xou amarelo X se 0X2 (37)

Observe que o valor de X é perfeitamente determinado em função dos

valores de X1 e X2 (veja a Tabela 1). Observe também que a regra de formação não

permite que um conjunto de valores para as variáveis auxiliares seja criado, no caso o

conjunto X1 = 0, X2 = 1, o que geraria uma contradição com as regras que as descrevem.

Tabela 1: Variáveis auxiliares para codificação de atributos categóricos

X1 X2 X 0 0 amarelo 1 0 azul 1 1 verde

Esta não é a única técnica de transformação de uma variável categórica

em um conjunto de variáveis auxiliares Dummy. Uma técnica muito conhecida para

modelagem de dados de negócios (econômicos, financeiros, administrativos, etc.), que

também faz uso de k – 1 variáveis auxiliares para representar uma variável com k

categorias está descrita em Mendenhall & Sincich (1996). As regras de definição das

variáveis determinam que a i-ésima variável terá valor 1 para o caso do atributo ter

valor igual à i-ésima categoria, e valor 0 caso contrário. Para o exemplo descrito acima,

as seguintes regras seriam obtidas:

===

= verde); Xou azul (X contrário caso 0

amarelo; X se 1X1 (38)

===

= verde); Xou amarelo (X contrário caso 0

azul; X se 1X2 (39)

67

Esta segunda maneira de codificar o atributo categórico X é, certamente,

mais interpretável. De fato, a variável auxiliar X1 está diretamente relacionada com a

categoria amarelo e a variável auxiliar X2 está diretamente relacionada com a categoria

azul. O valor zero para as duas variáveis é interpretado como a última categoria,

chamada de categoria base, no caso em questão o valor verde para a variável X.

Entretanto, a estratégia definida em Wang & Witten (1997) apresenta

vantagens do ponto de vista da eficiência computacional para a heurística definida por

Breiman (veja a Seção 2.3.1.3) para a escolha do teste de divisão dos registros baseados

em valor dos atributos. De fato, observe que uma regra sobre o valor de apenas uma das

variáveis auxiliares definidas pelas Definições 36 e 37 é bastante para definir dois

subconjuntos para os valores de X (e isto vale para qualquer quantidade de categorias).

Isto não acontece se forem utilizadas variáveis auxiliares definidas de acordo com as

Definições 38 e 39. Neste caso, para realizar a definição dos subconjuntos torna-se

necessário definir os valores de cada uma das variáveis auxiliares.

O M5’ realiza a transformação de todos os atributos categóricos apenas

uma vez no tratamento inicial dos dados. Isto representa uma redução ainda maior do

custo computacional e ganho de eficiência.

É proposto ainda um parâmetro β, utilizado para diminuir o

favorecimento que atributos categóricos com muitos valores diferentes têm em relação a

outros com poucos valores diferentes. De fato, observe que se um atributo categórico

possuir um valor diferente para cada observação, num total de n, que é a situação mais

extrema possível, ele não possui poder de previsão (o que não seria verdade se ele fosse

numérico). Entretanto, uma das n – 1 variáveis binárias que substituíram o atributo

categórico anteriormente seria automaticamente escolhida como atributo que melhor

divide a variável dependente, pois o ponto ótimo de divisão é um dos n – 1 pontos entre

68

as n observações e está, portanto, relacionado com alguma destas n – 1 variáveis. O

parâmetro β é proposto como 1 se o atributo categórico possuir apenas 2 valores

distintos, e seu valor reduz exponencialmente com o aumento do número de valores

distintos do atributo.

3.1.2 Valores faltantes

Valores faltantes para os atributos2 são tratados com uma nova função

objetiva para a busca do melhor atributo e da melhor regra de divisão do conjunto de

registros. Ao invés da Equação 28, a função é dada por:

( ) ( )

−= ∑

ii

i tsdnntsd

nmSDR β (40)

onde t é o conjunto de treinamento que alcança o nó, e ti representa o subconjunto de t

que segue para o nó filho i. Ainda, m é o número de exemplos sem valores faltantes para

o atributo i que está sendo avaliado, n é a quantidade total de observações do conjunto

de treinamento que alcançam este nó e sd(C) representa o desvio padrão dos valores da

classe do conjunto de observações C. Como as divisões são binárias, i assume apenas

dois valores, digamos D e E, e ni é o número de observações que estão no lado i (D ou

E) da divisão. O parâmetro β é aquele descrito anteriormente para compensar o

favorecimento natural de atributos com muitas categorias diferentes.

Em essência, a modificação da nova função é a presença do fator

multiplicativo βnm . Como este fator é sempre menor ou igual à unidade, tem-se que os

valores da nova função são sempre menores do que os da função original,

2 Apesar de não estar comentado na literatura, os registros que apresentam valores faltantes para a variável de resposta não são tratados. De fato, como está explicito na seção seguinte, o algoritmo elimina registros assim.

69

desfavorecendo os atributos que apresentam muitos valores faltantes e/ou os atributos

categóricos com muitas categorias diferentes.

3.1.3 Pseudo-código

Um pseudo-código para o algoritmo M5’ pode ser visto na Figura 11. As

linhas que estão grifadas em negrito foram acrescentadas para detalhar melhor algumas

partes do algoritmo. Estas alterações não incluem informações extraídas do código

fonte, que só estão descritas na Seção 3.2.

MakeModelTree (instances) {SD = sd(instances)For each k-valued nominal attribute

convert into k-1 synthetic binary attributesroot = newNoderoot.instances = instancessplit(root)prune(root)printTree(root)

}

split(node) {if sizeof(node.instances) < 4 or

sd(node.instances) < 0.05*SDnode.type = LEAF

elsenode.type = INTERIOR

for each attributefor all possible split positions

calculate the attribute´s SDRif there is a good attribute to split then

node.attribute = attribute with max SDRsplit(node.left)split(node.right)

else node.type = LEAFatt = usedAttributesBelow(node)

}

prune (node) {if node = INTERIOR then

prune(node.leftChild)prune(node.rightChild)node.model = linearRegression(node)if subtreeError(node) > error(node) then

node.type = LEAF}

subtreeError(node) {l = node.leftr = node.rightif node.type = = INTERIOR then

return (sizeof(l.instances)*subtreeError(l) +sizeof(r.instances)*subtreeError(r))/sizeof(node.instances)

else return error(node)}

linearRegression(node) {doRegression(node.instances, att)while reduce error(node) do

eliminateAttribute(att)}

Figura 11: Pseudo-código detalhado para o algoritmo M5’. Adaptado de Witten & Frank (2000)

O pseudo-código foi originalmente publicado em Wang & Witten (1997)

e posteriormente, com algumas modificações mínimas de ordem exclusivamente

lingüística em Witten & Frank (2000). Uma das funcionalidades do algoritmo que não

está explicitada no pseudo-código é a suavização dos parâmetros (coeficientes) dos

70

modelos de regressão, que é feita de maneira absolutamente análoga àquela descrita na

Seção 2.3.2, devida à Quinlan.

As duas principais partes deste pseudo-código estão criando a árvore

aplicando sucessivamente a divisão das instancias criando nós internos, galhos e folhas

– método split, e podando a árvore a partir das folhas para cima, realizado pelo método

prune (realizando busca em profundidade). No método split, a função

usedAttributesBelow varre todos os nós descendentes ao nó corrente coletando todos

os atributos que foram utilizados em testes de divisão de registros abaixo do nó

corrente. Apenas estes atributos são utilizados no modelo de regressão que será

estimando neste nó, o que, conforme comentado na Seção 2.3.2, já havia sido

estabelecido por Quinlan (1992).

A estrutura de dados data contém um flag chamado type dizendo quando

o nó é interno e quando é uma folha (INTERIOR e LEAF), ponteiros para os filhos

esquerdo e direito, o atributo que é usado na regra de divisão do nó e a regra (não

explicitada no pseudo-código), o conjunto de observações (registros) que foram usados

no treinamento em cada nó e o modelo de regressão que foi estimado com base neste

conjunto.

Algumas funções são utilizadas no pseudo-código mas não estão

definidas, pois possuem sentido bem explícito. A função sd chamada no início do

programa e novamente no início do método split calcula o desvio padrão dos valores da

classe para o conjunto de observações em questão. A função sizeof retorna o número de

elementos em um conjunto. Valores faltantes em atributos são tratados como descrito

anteriormente, e a função SDR está (ou deveria estar – veja a seção seguinte) de acordo

com a Equação 40.

71

A rotina linearRegression, que é chamada a partir da rotina prune, das

folhas para a raiz, é responsável por estimar o modelo de regressão linear usando o

conjunto de treinamento que alcança o nó e os atributos coletados por usedAttrBelow.

Por último, são realizados testes para determinar quais atributos podem ser eliminados,

de maneira a melhorar a estimativa de erro do modelo. Esta estimativa é feita através da

função error que está descrita e avaliada na seção seguinte.

3.1.3.1 Estimativa de erro

A estimativa de erro do modelo linear é calculada como sendo:

n

yyvnvn ii∑ −

×−+ ˆ

(41)

sendo o somatório feito considerando os n exemplos (registros) que de acordo com as

regras de divisão em nós ancestrais chegam até o nó em questão, e v é o número de

atributos usados na expressão do modelo de regressão (número de parâmetros do

modelo).

De acordo com Wang & Witten (1997), o parâmetro multiplicativo para

o somatório do erro funciona como uma compensação para a subestimação do erro para

casos desconhecidos. De fato, o somatório está usando os casos usados no treinamento

para estimar o erro do modelo. Esta estimativa é mais otimista do que o erro que

acontecerá quando o modelo for utilizado para casos desconhecidos. O fator

multiplicativo é sempre maior do que a unidade e, portanto, amplia estimativa de erro,

mesmo que de forma descontrolada – não existe indicativo de que a nova estimativa

esteja mais próxima do erro real do que a estimativa otimista, pode ser que a nova

estimativa superestime o erro.

72

3.1.3.2 Poda

O procedimento de poda é fundamental para modelos baseados em

árvore para evitar o fenômeno de overfitting. A poda para as árvores de modelos é feita

em duas etapas diferentes. Primeiro, cada modelo de regressão é testado para verificar

se a redução da quantidade de atributos usados pode ser reduzido de maneira a melhorar

a função de erro descrita na seção anterior. Esta operação é uma simplificação da

representação da árvore, e pode ser considerada como sendo uma parte da poda. A

segunda etapa é especificamente o que se conhece como poda, ou seja, a eliminação de

partes da árvore, transformando nós que eram interiores em folhas.

Esta segunda operação está descrita no pseudo-código na função poda,

onde o erro do modelo armazenado em cada nó interno é comparado com o erro total

dos modelos que estão armazenados em nós descendentes dos nós em questão. Observe

que são utilizadas sempre as medidas de erro de acordo com a Equação 41.

3.2 Descrição técnica

A leitura do código fonte do algoritmo M5’ trouxe diversas informações

que não estão disponíveis na literatura. Diversos detalhes do algoritmo, como

heurísticas para velocidade e escalabilidade, ou até procedimentos estatísticos, não são

comentados em nenhum dos textos que foram lidos. Mais importante do que isto,

algumas funcionalidades descritas na literatura não estão implementadas.

Será feito um novo exame do pseudo-código que está detalhado na

Figura 11, e seguindo por ele, serão declarados os pontos que na descrição técnica estão

diferentes da descrição Pública. Considere então a Figura 12, com um pseudo-código

revisto, contendo em negrito detalhes omitidos do pseudo-código publicado.

73

MakeModelTree (instances) {SD = sd(instances)Remove all instance without class valueReplace missing valuesFor each k-valued nominal attribute

convert into k-1 synthetic binary attributesroot = newNodebuildClassifier(root, instances)prune(root)smoothRegressionCoefficients(root)printTree(root)

}

buildClassifier(node, instances) {node.instances = instancesif sizeof(node.instances) < 4 orsd(node.instances) < 0.05*SDnode.type = LEAF

else { node.type = INTERIORsplit(node)

} }

prune (node) {if node = INTERIOR then

prune(node.leftChild)prune(node.rightChild)node.model = linearRegression(node)if subtreeError(node) > error(node) then

node.type = LEAF}

split(node) {for each attribute

for all possible split positionscalculate the attribute´s SDR

if there is a good attribute to split then node.attribute = attribute with max SDRbuildClassifier(node.left, splittedLeft)buildClassifier(node.right, splittedRight)

else node.type = LEAFatt = usedAttributesBelow(node)

}

subtreeError(node) {l = node.leftr = node.rightif node.type = = INTERIOR then

return (sizeof(l.instances)*subtreeError(l) +sizeof(r.instances)*subtreeError(r))/sizeof(node.instances)

else return error(node)}

linearRegression(node) {doRegression(node.instances, att)deselectColinearAttributeswhile reduce error(node) do

eliminateAttribute(att)}

Figura 12: Pseudo-código da descrição técnica (implementação) do M5’

Está ilustrado neste novo pseudocódigo a real estrutura recursiva de

criação da árvore, que é feita com duas rotinas buildClassifier e split, o que não está

esclarecido no pseudo-código publicado. A primeira rotina está encarregada de preparar

a estrutura de dados com as informações necessárias ao modelo, inclusive fazendo a

avaliação quanto à necessidade de continuar o crescimento da árvore. A segunda rotina

está encarregada de definir qual vai ser o teste de divisão dos registros, o que é definido

através de uma busca seqüencial em todos os atributos e em todos os valores destes, de

modo a testar todos os possíveis níveis para serem usados como limite para o teste. Caso

a busca pelo teste de divisão seja infrutífera, a função split pode abortar a divisão e

tornar este nó uma folha.

74

3.2.1 Valores faltantes

As duas primeiras linhas que aparecem em negrito na Figura 12 referem-

se ao real tratamento que o sistema dá para valores faltantes na base de dados. A

primeira linha refere-se ao tratamento a valores faltantes na variável de resposta e a

segunda linha aos outros atributos.

Veja que a segunda linha é contraditória com relação ao que está

disponível na literatura (veja a Seção 3.1.2). O algoritmo M5’ implementado no Weka

não realiza tratamento de valores faltantes. No início da execução do programa é

aplicado um filtro chamado ReplaceMissingValues que altera o conteúdo da base de

dados original, substituindo todos os valores faltantes em atributos (desconsiderando a

variável de resposta) pelo valor médio, se o atributo for numérico, ou pela moda (valor

mais freqüente), se o atributo for categórico.

A primeira linha em negrito do pseudo-código estabelece que registros

que não possuem valor para a variável de resposta são sumariamente eliminados. Não

existia relatos sobre este procedimento na literatura, de maneira que isto não pode ser

ressaltado como uma contradição. Deve-se considerar que esta é apenas uma

característica omissa.

3.2.2 Busca do melhor teste de divisão de registros

O procedimento verificado no código fonte do M5’ não usa a função

SDR definida em Wang & Witten (1997), Equação 40, e nem mesmo a definida por

Quinlan (1992), Equação 28, visto que é usada a raiz quinta da variância ao invés da

raiz quadrada. De acordo com os textos oficiais, a divisão cessa quando os valores da

classe apresentam uma variação muito pequena.

Outra característica importante que é observada no código é um

procedimento para lidar com o problema da escalabilidade. O procedimento de busca é

75

realizado seqüencialmente, de maneira que todos os possíveis pontos de divisão de cada

um dos atributos é testado. Este teste segue em busca do ponto que, se usado como

limite, maximizará a redução da dispersão da variável dependente.

Para reduzir o esforço computacional a busca seqüencial não é feita em

todos os valores do atributo. São consideradas apenas as 60% das observações que estão

mais próximas da mediana. Como existe uma ordenação feita anteriormente, é simples

desprezar as 20% primeiras e as 20% últimas observações da amostra no procedimento

de busca.

3.2.3 Eliminação de atributos

Na descrição pública já estava dito que depois que o modelo de regressão

era estimado alguns atributos eram eliminados em função da redução da função de erro

(veja Seção 3.1.3), e já está detalhado esta funcionalidade no pseudo-código público, na

Figura 11. Entretanto, não estava suficiente esclarecido como era realizada esta seleção.

A afirmação era de apenas de que o objetivo era minimizar a função de erro.

Também não estava dito na descrição oficial que, antes da eliminação

dos atributos que melhorariam o erro do modelo, eram eliminados atributos chamados

de colineares, conforme foi descoberto no código fonte.

3.2.3.1 Eliminação de atributos colineares

A rotina deselectColinearAttributes usa uma estatística chamada

Coeficiente Padronizado (standardized coefficients):

=

y

xii s

siββ * (42)

76

sendo xi o atributo que está sendo testado, y a variável de resposta, s o desvio padrão da

variável explicativa (xi) ou dependente (y), e iβ o coeficiente estimado para o atributo xi

na regressão.

Os coeficientes padronizados estão sempre relacionados com uma

medida de importância da variável independente, como declarado em Mendenhall &

Sincich (1996). Com a padronização, os coeficientes podem ser comparados uns com os

outros, e o aumento do tamanho é equivalente ao aumento de importância.

O procedimento que foi observado em deselectColinearAttributes é a

busca do maior coeficiente padronizado. Se este coeficiente for maior do que 1,5, o

atributo relacionado é eliminado. Uma nova regressão é estimada, com um conjunto de

atributos menor, e novos testes são realizados em busca de um novo atributo a ser

eliminado. O procedimento só para quando não nenhum atributo apresenta Coeficiente

Padronizado maior do que 1,5.

Existem alguns detalhes relativos a este procedimento que não estão de

acordo com a literatura. Antes de mais nada, não está definido o termo Atributos

Colineares, nem nas referências do relativas ao algoritmo nem em outras referências

consultadas. A princípio pensou-se que podia se referir ao fenômeno da

multicolinearidade, mas não foi encontrada nenhuma referência que apontasse na

direção do tratamento da multicolinearidade com os coeficientes padronizados.

A multicolinearidade é um fenômeno que ocorre quando dois ou mais

atributos estão correlacionados, e está diretamente relacionado à possibilidade de erros

de aproximação nos cálculos relacionados ao modelo de regressão. Isto ocorre porque a

inversão da matriz XX ' (veja Seção 2.2.1) torna-se cada vez mais difícil na medida

que a correlação entre dois atributos aumenta – as colunas da matriz referentes aos

atributos aproximam-se de se tornar linearmente dependentes. A multicolinearidade é

77

identificada através da correlação entre as variáveis independentes (atributos), ou

usando estatísticas específicas, como VIF e TOL (Cf. Mendenhall & Sincich, 1996).

3.2.3.2 Eliminação de atributos para melhoria do erro

A eliminação dos atributos – rotina eliminateAttribute na Figura 12,

também é feita usando os coeficientes padronizados. Só que, neste caso, são eliminados

os atributos que apresentam menor coeficiente padronizado. Lembrando que os

coeficientes padronizados estão diretamente associados à importância do atributo no

modelo de regressão (veja Seção anterior), pode-se perceber até intuitivamente o sentido

do procedimento.

Para definir se o atributo será ou não eliminado, é definida uma

estatística chamada de Akaike3, usada para comparar o modelo completo, com todos os

atributos, com o modelo onde foi retirado um atributo – aquele com menos coeficiente

padronizado.

( ) gknSSESSEAkaike

R

C 2+−= (43)

onde n é a quantidade de casos (registros) usados para estimar ambas regressões, SSEC

refere-se ao somatório dos quadrados dos resíduos da regressão completa, com k

atributos, e SSER é o mesmo somatório, só que da regressão reduzida, com g atributos,

sendo portanto g < k.

O procedimento busca o atributo i que apresenta menor coeficiente

padronizado. É estimada uma regressão com todos os atributos exceto este, um conjunto

com g atributos (neste primeiro passo, g = k – 1). Calcula-se a estatística Akaike, como

3 A estatística Akaike é baseada na Teoria da Informação, e é comumente chamada de AIC (Akaike Information Criterion). Existem várias expressões diferentes para estabelecer o valor da estatística, mas de maneira geral a magnitude da estatística está inversamente relacionado com a qualidade do modelo, ou seja, escolhe-se o modelo que apresenta menor AIC (Cf. Hair et. al, 2003 e Motulsky & Christopoulos, 2003). Não foi encontrada referência que utilizasse a expressão que foi encontrada no código-fonte e que está descrita na Equação 43.

78

definida na Equação 43, e esta estatística é comparada com a estatística Akaike anterior,

que no primeiro passo é calculada supondo SSEC = SSER. Se A estatística Akaike for

menor do que a estatística Akaike anterior, o atributo é eliminado, a estatística Akaike

calculada passa a ser considerada a estatística Akaike anterior, e o procedimento repete a

busca do atributo com menor coeficiente padronizado e cálculo da nova estatística

Akaike. Para efeito de cálculo, SSEC e k permanecem os mesmos. O procedimento só

pára quando o atributo que apresenta menor coeficiente padronizado não é eliminado.

Fica evidente então que o procedimento de eliminação de atributos não

está de acordo com o que foi divulgado na literatura.

3.2.4 Suavização dos coeficientes

A quarta linha que se apresenta em negrito já era esperada pelo que se lia

na descrição oficial, apesar de não estar presente nos pseudo-códigos divulgados na

literatura. Esta linha não foi inserida no pseudo-código da Figura 11 por que não é

possível estabelecer quando e como esta suavização é feita usando apenas a descrição

oficial.

Um fato importante a esclarecer é que a suavização é feita alterando os

valores dos coeficientes das regressões armazenadas nos nós. A uma leitura inicial, pode

parecer que a suavização é feita apenas no momento da previsão, quando um caso

desconhecido é aplicado no modelo, o que seria uma interpretação equivocada. Com o

procedimento de suavização, mesmo os nós que tiveram variáveis independentes

eliminadas podem voltar a apresentar um valor no coeficiente desta variável.

De maneira geral, as principais contradições entre as versões publicas e

técnicas do algoritmo M5’ parecem residir no fato de que a estimação dos modelos de

regressão que estão nos nós da árvore é feita usando uma classe pré-existente no Weka,

chamada de LinearRegression. Esta classe existe independente do M5’, pois é fornecida

79

pelo Weka como um classificador autônomo. Foi possível perceber no código desta

classe diversos ajustes para que a classe pudesse realizar as regressões necessárias para

o M5’.

80

4 Análise de ferramentas de previsão baseadas

em árvores

Existem disponíveis uma grande quantidade de ferramentas

computacionais capazes de induzir modelos de previsão. Estas ferramentas possuem

cunho comercial ou acadêmico. As ferramentas computacionais de cunho comercial

geralmente implementam algoritmos o algoritmo CART clássico. As ferramentas

acadêmicas geralmente são desenvolvidas para comparação de algoritmos específicos,

que estão sendo propostos e precisam ser experimentados para critérios de comparação.

Este capítulo descreve um estudo de comparação de algumas ferramentas

computacionais que implementam algum algoritmo de indução de modelos de previsão

baseados em árvore. O desenvolvimento do capítulo compreende uma descrição da base

de dados utilizada na comparação e das ferramentas computacionais que

implementaram os algoritmos envolvidos. Na seqüência, o processo de comparação é

descrito. A seção 4.3 detalha as peculiaridades de cada ferramenta. A seção 4.4 traz um

resumo dos resultados.

O estudo aqui realizado não deve ser considerado definitivo para a

seleção de uma ferramenta de previsão, pois as características intrínsecas ao problema

que está sendo modelado e o cenário administrativo em que a ferramenta será utilizada

serão determinantes no processo de escolha. Assim, não é feita uma escolha por

determinada ferramenta, apenas são ressaltados as características importantes de cada

uma.

81

4.1 Base de dados

Foi usada uma base de dados criada e manipulada pelo Zeus Software ©,

da Cyrnel International (Cf. Cyrnel, 2003). Esta companhia desenvolve e oferece

ferramentas amigáveis para ajudar a compreender e gerenciar retornos e riscos de

portifólios. O sistema inclui ferramentas de automação para permitir trabalhos

repetitivos na tarefa de análise, baseado em modelos de precificação e risco.

Os dados foram gerados usando um modelo pioneiramente desenvolvido

para mercados americanos por Haugen (1996). A aplicação deste modelo no mercado

brasileiro (e mexicano) tem sido realizada primeiramente pela Cyrnel Int. Alguns ativos

são selecionados de acordo com sua relevância, e são agrupados de acordo com sua

similaridade, o que é determinado por uma equipe de especialistas. Alguns fatores são

selecionados dentro do cenário econômico nacional e são agrupados também. Estes

fatores são chamados de estilos do mercado. A série de dados possui 25 variáveis, que

são grupos de ativos ou de estilos, em 438 observações (representando dois anos de

dados mensais). Os dados não requerem maiores preparações, pois por serem a saída do

Zeus Software já se encontram limpos, ou seja, sem valores faltantes, discrepantes

(outliers) e sem ruídos de outra natureza. O único pré-processamento que se fez

necessário foi a adaptação de formatos de arquivo para entrada nos softwares.

A variável Estilo de Mercado chamada Volatilidade foi escolhida como

variável de saída. Volatilidade é uma importante medida de síntese dos efeitos da

mudança de taxas de interesse nos prazos de negociação. Quão maior for a duração dos

prazos de negociação, maior é a volatilidade. O fator de estilo de volatilidade (presente

na base de dados) é uma medida de volatilidade considerando contratos de curto e longo

prazo (Cf. Cyrnel, 2003).

82

Os dados estão em duas planilhas do Excel. A primeira planilha possui

dados observados, referindo-se ao retorno das ações (210 ações ao todo). A segunda

planilha tem os dados sintéticos, resultado do modelo, referentes aos retornos dos

fatores. Estes últimos não precisam de pré-processamento, mas o mesmo não pode ser

dito sobre os retornos das ações. Existem muitos valores nulos, resultado de

observações que não estavam disponíveis.

Algumas estatísticas da variável de resposta escolhida foram calculadas e

podem ser vistas na Tabela 2 a seguir. Existem duas amostras por que o conjunto

original de casos foi divido em amostra de treinamento e amostra de teste.

Tabela 2: estatísticas da variável de reposta

Amostra Estatística Treinamento Teste Média 1,54E-04 -2,11E-04Desvio Padrão 0,006 0,007 Contagem 300 128 Somatório 0,046 -0,027

4.2 Comparação de modelos de previsão

A comparação de modelos de previsão induzidos deve ser feita segundo

algum(ns) critério(s). Foram selecionados os critérios mais importantes (Cf. Han &

Kamber, 2001):

• Velocidade: custo computacional envolvido na construção e no uso do modelo. Este

custo computacional está diretamente relacionado ao tempo de processamento;

• Escalabilidade: refere-se à habilidade de construir modelos de maneira eficiente

para grande volume de dados. Algumas técnicas podem se mostrar muito rápidas

para pequenos volumes de dados, e perder performance comparativamente a outras

técnicas com o aumento do volume de dados.

83

• Robustez: habilidade do modelo para fazer previsões corretas diante de dados com

ruídos ou com valores faltando. Geralmente os modelos são construídos a partir de

dados pré-processados (que passaram por tratamento de ruídos e/ou valores

faltando). A Robustez refere-se ao uso posterior do modelo;

• Interpretabilidade: nível de compreensão que é fornecido pelo modelo. Alguns

modelos são chamados de caixa preta, pois não permitem nenhum nível de

compreensão do conhecimento que foi assimilado, notadamente, Redes Neurais (Cf.

Haykin, 2000). Modelos baseados em árvores são considerados altamente

interpretáveis;

• Precisão: geralmente medida através de taxas de erros (ou de acertos). A precisão

refere-se à relação entre previsões corretas e incorretas. Existem diversas maneiras

diferentes de estimar a precisão. Basicamente, as técnicas testam o modelo em casos

subseqüentes (desconhecidos) cujo valor correto da variável de resposta seja

conhecido, e ponderam os erros obtidos.

Conceitualmente, depois que o previsor foi construído usando um

conjunto de casos, toma-se um outro conjunto de casos suficientemente grande

(virtualmente infinito), retirado da mesma amostra que o primeiro conjunto. Observa-se

o valor correto da variável de resposta de cada um destes casos e então compara-se com

o resultado oferecido pelo previsor. Pode-se tomar uma média aritmética simples dos

erros (na teoria de Regressão é comum chamar estes erros de resíduos).

Um modelo probabilístico estabelecido em Breiman (1984), definiu que a

taxa de erro é a probabilidade que a previsão seja feita de maneira errada em um novo

caso que tenha sido retirado da mesma distribuição que os casos que serviram para

estabelecer o previsor. Em problemas reais, geralmente a distribuição é desconhecida, e

então um conjunto de casos já classificados será utilizado tanto para construir o modelo

84

de previsão (previsor) quanto para estimar sua precisão. Estas técnicas são chamadas de

estimativa interna do erro, em oposição ao caso teórico de conhecer as distribuições

inicialmente, quando pode ser realizada a chamada estimativa externa. Quatro tipos de

estimativa internos podem ser considerados:

• Estimativa por resubstituição: considerada a menos precisa e a mais comumente

utilizada. O mesmo conjunto de casos que foi utilizado para construir o previsor é

utilizado para estimar a taxa de erro. Os casos são submetidos ao previsor, e o

resultado é comparado com o valor correto da variável de resposta. O problema com

esta técnica de estimativa é que não usa uma amostra independente da que foi

utilizada no treinamento (construção do previsor) para estimar a precisão. Isto torna

a estimativa absolutamente tendenciosa.

• Estimativa por amostra de teste: o conjunto de casos dos quais se conhece o valor

correto da variável de resposta é dividido em dois conjuntos. Um dos conjuntos é

chamado de conjunto de treinamento e é utilizado para construir o modelo. O outro

conjunto é chamado de conjunto de teste, e é utilizado para estimar a precisão do

previsor (modelo) que foi construído com o primeiro conjunto. Sugestões na

literatura (especificamente em Breiman, 1984) apontam para que a divisão seja feita

na proporção de 2 para o conjunto de treinamento e 1 para o conjunto de teste (ou de

67% e 33%, respectivamente). Uma desvantagem deste procedimento é reduzir o

tamanho do conjunto de treinamento. Na medida em que o tamanho do conjunto

inicial de casos já classificados cresce, este problema vai sendo minimizado.

Entretanto, se o conjunto inicial de casos for pequeno, esta técnica de estimativa de

erro pode se tornar indesejada.

• Validação cruzada (cross-validation): este método divide o conjunto de casos

conhecidos em uma determinada quantidade n de subconjuntos. O procedimento

85

estimará a taxa de erro através da média de n taxas de erro estimadas considerando n

diferentes modelos de previsão. Cada previsor é criado considerando um dos n

subconjuntos como conjunto de teste e considerando os outros n – 1 subconjuntos

reunidos como conjunto de treinamento. A taxa de erro de cada um dos n previsores

é estimada através da técnica de amostra de teste descrita anteriormente. A técnica

de validação cruzada é altamente recomendada quando o conjunto de casos

conhecidos é pequeno, pois cada um dos casos é utilizado para construir os

previsores, e é usado exatamente uma vez como caso de teste. Além disso, esta

técnica de estimativa da taxa de erro é muito estável, e a estimativa é bem mais

próxima do valor probabilístico esperado (Cf. Breiman, 1984). É bem comum o uso

de 10 subconjuntos para esta técnica.

• Bootstrap: Esta técnica usa o método de Simulação conhecido como Monte Carlo

(Cf. Banks, 2000) para estimar a diferença entre o erro estimado por alguma técnica

anteriormente descrita e o erro real (Cf. Efron, 1995, Breiman, 1984 e Kennedy,

1998). Entretanto, Breiman aponta que os resultados quando aplicados para

problemas de classificação podem não ser muito adequados.

Pugliesi & Rezende (2004) aponta que precisão e interpretabilidade são

interesses concorrentes, e como tal é necessário abrir mão de um em função de outro.

Usando os algoritmos Cubist, M5 e RT, é demonstrado que vale a pena remover as

regras mais fracas em nome do ganho em termos do nível de interpretabilidade.

As ferramentas de previsão (e mesmo de classificação) baseadas em

árvores são notadamente conhecidas em função de seus desempenhos em todos os

quesitos acima, tanto as Árvores de Regressão quanto as Árvores de Modelos. Isto

explica a escolha destes modelos para o estudo. Convém observar que as técnicas

apresentam pequenas diferenças segundo o critério de interpretabilidade, pois o

86

conhecimento embutido nas árvores de modelos depende dos modelos que estão

presentes nas folhas.

4.3 Ferramentas

Procurou-se utilizar ferramentas que utilizassem a metodologia de

Árvores de Regressão (CART, Mineset e Clementine) e de Árvores de Modelos

(WEKA e RT). Na lista de ferramentas que se segue, são discutidas a questão da

interface ao usuário. Infelizmente o preço não é divulgado por todos os fabricantes, de

maneira que preferiu-se não abordar este assunto. Algumas das ferramentas ofereciam

uma grande quantidade de parâmetros de configuração e ajustes que não foram

discutidos profundamente. Como o foco principal da comparação é a precisão,

procurou-se utilizar os parâmetros com os valores propostos pelo próprio software,

exceto quando indicado em contrário.

4.3.1 CART

Este foi o primeiro sistema computacional de ferramenta de previsão

baseadas em árvores. O sistema agora está na versão 5, e foi o vencedor da KDD Cup

2000 (competição pública realizada anualmente pela ACM – Association for Computing

Machinery Cf. ACM, 2003, para premiar ferramentas que apresentem melhor precisão

em problemas selecionados – Cf. KDD, 2000). Este sistema é especificamente

desenvolvido para tarefas de classificação e previsão (não é, portanto, uma suíte de

mineração de dados). É desenvolvido pela Salford Systems (2003), que dá o suporte ao

software e que também inclui outros softwares de mineração de dados.

87

Figura 13: tela inicial do CART Fonte: CART (2003b).

O sistema é muito simples, mas bastante poderoso. A interface é bastante

intuitiva, como pode ser visto na Figura 13. Depois que o modelo é treinado, é possível

realizar uma análise bem profunda dos resultados, indo muito além da simples

visualização da árvore de regressão. É possível analisar, por exemplo, o ponto de poda

que foi escolhido através de um gráfico que mostra o tamanho da árvore e a função de

redução de erro-complexidade (veja Equação 20), como pode ser visto na Figura 14.

0.464

Rel

ative

Err

or

Number of Nodes

0.400.450.500.550.600.650.70

0 10 20 30 40 50 60

Figura 14: Ponto de corte para escolha da árvore podada.

A interface permite que diversos gráficos, diagramas e tabelas sejam

exportadas para um arquivo de relatório, em formato rtf. O sistema permite ainda, entre

outras coisas, uma análise de importância das variáveis, como pode ser visto na Figura

15 a seguir.

88

Figura 15: navegador de resultados do CART. Fonte: CART (2003b).

4.3.2 Clementine

Este software é desenvolvido pelo grupo de pacotes estatísticos SPSS

(Cf. Clementine, 2003), e é considerado atualmente uma importante suíte de KDD. Nele

está implementado o algoritmo de Árvore de Regressão, sob o nome de C&R Tree.

Existem outras soluções para previsão, como Redes Neurais.

A interface do sistema é bem simples, baseada em nós. Os nós são

ligados formando uma estrutura de fluxograma. Cada nó realiza uma tarefa, como

importação ou exportação, filtro, estimação do modelo ou estimação do erro – que

usaria um modelo já estimado. Uma visão da interface do sistema pode ser vista na

Figura 16.

O software permite importação de dados a partir de uma grande

quantidade de tipos de arquivos inclusive arquivos de texto (flat files). O software pode

ser usado para a fase de preparação dos dados, e existem alguns filtros disponíveis para

exportar os dados em diversos formatos, incluído pastas do excel.

A árvore modelada é exibida em um formato html, sendo possível

expandir ou agrupar galhos da árvore, permitindo uma visualização mais ou menos

89

carregada de detalhes. O algoritmo implementado fornece ainda algumas estatísticas

básicas para a analisar a precisão do modelo obtido.

Figura 16: interface do Clementine.

4.3.3 Mineset

Este é um grande software para atividades de visualização (de dados, de

modelos, etc.). Ele foi desenvolvido pela Silicon Graphics (Cf. Silicon Graphics, 2003)

em ambiente nativo das estações Silicon (IRIX) e posteriormente migrado para a

plataforma Windows NT. Entretanto, infelizmente o software não é mais desenvolvido e

a Silicon Graphics não mais vende ou dá suporte ao sistema. O sistema é uma suíte de

KDD, que realiza desde preparação dos dados até visualização dos modelos obtidos. É

possível importar dados de diferentes formatos, utilizando um pequeno programa a

parte, que funciona muito bem. Para realizar a visualização do modelo final, a suíte cria

90

um mundo virtual e permite um elevado grau de interação no modelo para analisar os

resultados. Um exemplo deste mundo virtual pode ser visto na Figura 17.

Figura 17: visualização de uma árvore no Mineset.

4.3.4 WEKA

O software foi desenvolvido por uma equipe de pesquisadores da

Universidade de Waikato (Cf. Weka Machine Learning Project, 2001), e foi feito em

Java, e o código fonte está disponível (Cf. Weka Software, 2001), o que permite que o

software seja utilizado em (possivelmente) qualquer plataforma computacional. O

sistema é gratuito para qualquer propósito, inclusive para possível

modificações/melhoramentos e revenda.

O software WEKA também é uma suíte para atividades de KDD,

incluindo filtros para a fase de pré-processamento e uma grande quantidade de técnicas

e algoritmos para modelagem de dados. Também existe uma ferramenta de visualização

de dados e de modelos baseada em gráficos de dispersão, mas é bastante simples.

91

Figura 18: Interface do Weka – algoritmo de classificação baseado no C4.5

A interface é bastante diferente, com muitas peculiaridades, comuns a

sistemas desenvolvidos nesta linguagem. O software apenas lê dados armazenados em

um formato específico chamado arff, desenvolvido pela própria equipe. Não existe

software de conversão, o usuário precisa realizar esta conversão manualmente. A única

vantagem é que o formato é muito simples e existe uma descrição completa de como

realizar a transcrição no site do sistema.

No sistema estão disponíveis três técnicas para atividades de previsão: o

algoritmo original do CART, o M5’ (revisão do algoritmo M5), e a técnica de regressão

linear múltipla. Foi utilizada apenas a técnica M5’.

4.3.5 RT

Este software foi desenvolvido por Luis Torgo – e sua documentação

pode ser encontrada em RT (2005). Este software está disponível especificamente para

92

as plataformas SunOs e Linux Red Hat 7.x. Ele é gratuito para propósitos acadêmicos, e

é vendido para usos comerciais.

A interface é por linha de comando, e a saída inclui um arquivo gráfico

para a visualização da árvore, mas este arquivo tem um formato bem específico para um

programa que não se conhece similar na plataforma Microsoft.

Existe um manual do usuário disponível on-line, explicando como é o

formato do arquivo de dados para entrada, as opções da linha de comando e o formato

de saída dos dados.

O software pode executar as técnicas de modelagem da árvore de

modelos baseada na tecnologia desenvolvida por Torgo (2002) (Árvore de Regressões

Locais), e também pode emular outros métodos, incluindo CART. O sistema foi

executado sempre com a opção padrão, que era modelar a Árvore de Regressões Locais

usando o método de mínimos quadrados.

4.4 Características dos sistemas

Algumas etapas do processo de descoberta de conhecimento não foram

realizadas devido às características da própria base de dados. A etapa de seleção dos

dados foi realizada em um nível altamente sofisticado, pela Cyrnel Internacional e pelo

Zeus Software (veja a seção anterior). Como relatado anteriormente, a natureza dos

dados desobrigou a realização da fase de preparação dos dados, pois estes não

apresentavam valores faltantes ou discrepantes, afinal são o resultado da operação de

modelagem realizada pelo Zeus Software.

4.4.1 Entrada dos dados

A transformação dos dados para o formato apropriado foi necessária, pois

cada uma das ferramentas possui um formato de entrada próprio. Este processo de

93

transformação foi realizado basicamente usando os filtros de exportação de dados do

Excel e um editor de textos. Não foi necessário o desenvolvimento de uma pequena

aplicação específica, como se pensou a princípio. Na seqüência estão disponíveis as

descrições de como foram realizadas as importações dos dados para cada uma das cinco

ferramentas:

• CART: o sistema está apto a ler dados a partir de uma grande quantidade de

formatos de arquivos diferentes. Foi utilizado o arquivo de pastas do excel

diretamente para a entrada, sem precisar realizar grandes modificações. A planilha

deve ter os dados em forma de lista, ou seja, cada coluna da planilha representando

uma variável. A primeira linha pode ser utilizada para nomear as variáveis, sendo

chamada linha de rótulos. Caso não seja utilizada a linha de rótulos, o sistema dá

nomes automáticos às variáveis. O formato do arquivo como foi recebido já possuía

esta estrutura de representação, incluindo a linha de rótulos;

• Clementine: utilizou-se o filtro de arquivos ASCCI (flat files) presente na suíte

Clementine para a entrada de dados. O arquivo ASCII foi criado a partir da planilha

do Excel com as listas das variáveis, já rotuladas. Para tanto, criou-se uma cópia da

planilha no formato CSV (Comma Separated Values).

O arquivo que é gerado com este formato é um arquivo de texto, e pode ser

visualizado em qualquer editor de textos, desde o robusto e poderoso Word até o

simples e portátil Notepad. Existe uma diferença entre o formato deste arquivo e o

formato do documento que é gerado normalmente no Word. Um arquivo de texto só

possui os caracteres da tabela ASCII, que é uma tabela com um padrão de

caracteres. Todos os caracteres do arquivo de texto podem ser vistos e alterados. Já

um documento do Word possui uma grande quantidade de informações além dos

94

caracteres que podem ser vistos e alterados, que são caracteres de controle, de

formatação e de verificação.

O arquivo de texto que foi gerado possui uma linha de dados em cada parágrafo, ou

seja, é utilizada uma marca de parágrafo para marcar uma quebra de linha. Os

valores desta linha estão separados através de um caractere especial de separação,

ou seja, um caractere especial é utilizado para separar os valores. Este caractere de

separação pode ser a vírgula (que é o padrão do software em versão americana,

justificando o nome do formato – comma) ou o ponto e vírgula. Como foi utilizada a

notação brasileira para separação de casas decimais, que é especificado com uma

vírgula ao invés de ponto, o Excel utiliza o ponto e vírgula como caractere especial

de separação (observe que se o Excel utilizasse vírgula para separação dos campos

seria impossível distinguir um número do outro).

A suíte Clementine está apta para ler o arquivo já desta forma, separando cada um

dos valores. Entretanto não conseguiria compreender os valores armazenados, pois

esta suíte, ao contrário do Excel, não permite configurar outro caractere de

separação decimal que não seja o ponto. O arquivo estava no formato utilizado pelo

Excel, e foi então necessário corrigir o caractere de separação decimal.

Seria possível utilizar qualquer editor de textos para efetuar a troca dos caracteres

vírgula por ponto. Foi utilizado o Word para esta troca, tomando o cuidado de salvar

o arquivo final no formato somente texto, o que evitou que fosse criado um

documento do Word com os seus caracteres especiais, de formatação, que o

Clementine não poderia ler.

A partir deste arquivo final, o Clementine pode realizar a importação sem

problemas.

95

• Mineset: este programa possui um utilitário de linha de comando chamado

dataschema para realizar a importação de dados. Enquanto o filtro do Clementine

está integrado ao software, de maneira que o resultado da filtragem pode ser usado

diretamente para outras atividades, o dataschema não está, e o processo gera

arquivos de saída. São dois arquivos, que devem ser mantidos juntos para que o

Mineset possa ler. Um arquivo possui a tabela de dados, e recebe a extensão .data. O

outro arquivo possui informações sobre as dimensões da tabela (número de variáveis

e de casos) e nome e natureza das variáveis, e recebe a extensão .schema. Estes

arquivos comportam-se como se o arquivo data fosse o arquivo de dados, e o

arquivo schema fosse o metadado, ou dicionário para os dados.

O arquivo de texto que foi passado para o utilitário de transformação foi exatamente

o mesmo que havia sido gerado para a importação de dados do Clementine, ou seja,

o arquivo CSV com as vírgulas trocadas por pontos.

• WEKA: não existe nenhum utilitário para criar os arquivos arff que são requeridos

pelo WEKA. É necessário realizar esta transformação manualmente. Felizmente,

isto não é muito difícil, e pode-se fazer a partir do arquivo de texto que foi usado

anteriormente para o Clementine e para o Mineset.

Os dados devem ser separados por vírgula. Este arquivo possuía ponto e vírgula, e

então foi utilizado novamente o Word para realizar esta troca. Novos cuidados para

evitar que o formato de somente texto não se perdesse foram tomados.

A linha de rótulos usada anteriormente foi transformada em um cabeçalho mais

detalhado, onde cada uma das variáveis é declarada em uma linha específica, que

deve conter uma palavra de controle (@ATTRIBUTE), o nome da variável e o tipo

desta variável, que poderia ser numérico (numeric), categóricos – neste caso

96

requerendo uma lista de especificação de valores, texto (string), ou data (date),

sendo possível até utilizar uma lista de formatos. As variáveis eram todas numéricas.

Figura 19: formato arff

Separando as linhas de declaração de variáveis e a tabela de dados, uma nova

palavra de controle deveria ser utilizada: @DATA. Além disso, é necessário definir

um nome para a base de dados, o que é feito usando uma linha especial, antes de

todas as declarações de variáveis, com a palavra de controle @RELATION e o

nome escolhido para a base de dados. O formato final do arquivo foi algo como o

que pode ser visto na Figura 19.

O controle de parâmetros do Weka é feito em uma tela a parte, que surge quando o

usuário aciona a linha em branco que fica ao lado do botão de seleção do método de

aprendizagem, e que exibe a linha de comando que será passada para o sistema. No

caso do M5’, a tela é como a que pode ser vista na Figura 20, com seis parâmetros

ao todo. O primeiro parâmetro (de cima para baixo) permite o controle se a saída do

97

sistema será uma árvore ou um conjunto de regras, como disposto em Homes, Hall

& Frank (1999). O segundo parâmetro é comum a todos os classificadores do Weka,

e serve para que relatórios mais completos sejam exibidos durante a execução do

sistema. O terceiro, quinto e sexto parâmetro referem-se à funcionalidades do

sistema, como descrito no Capítulo 3. Finalmente, o quarto parâmetro serve para

que sejam armazenadas cópias da base de dados juntamente com a estrutura do

modelo que está sendo gerada.

Figura 20: Entrada de parâmetros do M5’ – Weka

• RT: assim como o WEKA, este programa utiliza um formato específico para

entrada dos dados. Os dados devem ser armazenados em dois arquivos, de maneira

bem parecida com o arquivo de schema do Mineset. O arquivo com os dados recebe

a extensão .data – este arquivo só possui os dados, com ponto separando casas

decimais e qualquer caractere separando valores (foi utilizado o ponto e virgula). O

arquivo com o dicionário recebe a extensão .domain – este arquivo possui apenas as

declarações das variáveis, uma por linha. Cada linha contém o nome da variável e o

tipo de domínio desta variável. Neste caso, todas eram continuous, ou seja,

numéricas e contínuas. A variável que será modelada, ou seja, a variável

dependente, deve ser declarada duas vezes, sendo que na segunda vez não é

necessário declarar o tipo. Esta segunda declaração deve acabar com um ponto.

98

A etapa de modelagem foi realizada satisfatoriamente seis vezes, uma

vez para cada um dos softwares listados na seção a seguir, exceto o Clementine, que foi

utilizado para gerar dois modelos diferentes. Na seqüência, estão brevemente descritas a

forma como os sistemas realizam a saída dos resultados, e como pode ser feita a

estimativa do erro, que foi o critério de comparação mais importante na análise de

resultados abaixo.

4.4.2 Output dos sistemas

• CART: depois que o modelo é treinado o sistema oferece um navegador de

resultados (como pôde ser visto na Figura 13, página 88). Este navegador permite

que seja realizada uma análise bem mais profunda dos resultados do que uma

simples visualização da árvore de regressão. Além do ponto ótimo para poda que foi

escolhido, é possível ver estatísticas iniciais da base de dados, estrutura da árvore,

estatísticas sobre o modelo que foi gerado, etc.

A estimativa de erro pode ser feita de diversas maneiras diferentes. O sistema

permite que seja especificado um arquivo de teste, que foi a opção utilizada.

Alternativamente, seria possível pedir que o sistema realizasse a extração de uma

amostra de teste, fornecendo-se inclusive o tamanho percentual desta amostra de

teste. Ou ainda, a estimativa poderia ser feita por validação cruzada (cross

validation).

• Clementine: a árvore que foi criada pelo Clementine pode ser visualizada em um

navegador que é disponibilizado juntamente com o software. Na verdade é gerado

um arquivo em formato html, que permite expandir ou agrupar galhos da árvore.

Isto permite uma visualização com mais ou menos detalhes, facilitando a análise.

99

Acessando o ícone do resultado do modelo é possível obter algumas estatísticas

básicas sobre a precisão do modelo obtido.

A interface do Clementine também permite várias maneiras de estimar o erro, que

inclui amostra de teste e validação cruzada. Foi utilizada a amostra de teste que foi

separada inicialmente para a estimativa. Para tanto, foi bastante criar uma nova

seqüência de ícones de ação para importação dos dados de teste, preparação e

aplicação ao modelo treinado.

• Mineset: este software apresenta uma ferramenta de visuallização muito requintada,

permitindo uma navegação entre os nós da árvore gerada. Durante esta navegação é

possível acessar estatísticas de cada nó, e saber como foi a distribuição de valores

das variáveis que alcançaram aquele nó na fase de treinamento.

O teste deste sistema pode ser realizado por amostra de teste e por validação

cruzada. Entretanto, não é possível especificar um arquivo com os dados de teste. O

Mineset permite apenas que a amostra de teste seja extraída do conjunto total pelo

próprio sistema, imediatamente antes da modelagem. Isto fez com que esta

ferramenta fosse a única que teve a estimativa realizada de maneira diferente (veja a

seção 4.4.2 a seguir, que trata da comparação da precisão).

• WEKA: a interface não é um ponto forte desta ferramenta, de maneira que a

visualização do modelo treinado não apresenta grandes requintes. A árvore que foi

gerada é exibida em formato de texto, e este arquivo pode ser salvo. As estatísticas

do resultado também estão disponíveis neste arquivo de saída. Existe um pacote de

visualização de gráficos de dispersão, mas para o caso de árvores de regressão não é

muito útil.

100

Existem ao todo cinco estatísticas que são fornecidas como output do sistema. Estas

estatísticas estão descritas na Tabela 3. Considere que existem n observações sendo

testadas, que o valor real de cada classe é ai e o valor previsto de cada classe é pi.

Para as expressões abaixo, deve-se considerar que ∑=i

ipn

p 1 e ∑=i

ian

a 1 são os

valores médios e ( )∑ −−

=i

ip ppn

s 2

11 e ( )∑ −

−=

iia aa

ns 2

11 são os desvios

padrões (amostrais) das variáveis p e a, respectivamente, e

( )( )∑ −−−

=i

iipa aappn

s1

1 é a covariância (amostral) entre elas.

Tabela 3: medidas de performance para previsão fornecidas na suíte Weka

Estatística Expressão

Correlation coefficient AP

PA

sss

Mean absolute error ∑ −i

ii apn1

Root mean squared error ( )∑ −i

ii apn

21

Relative absolute error ∑∑

−

−

ii

iii

aa

ap

Root relative squared error( )

( )∑∑

−

−

ii

iii

aa

ap2

2

O erro do modelo também pode ser estimado usando a técnica de amostra de teste e

validação cruzada. A ferramenta permite que seja especificado um arquivo de testes,

de maneira que foi possível usar a amostra que foi extraída anteriormente para o

teste, permitindo uma melhor comparação entre este sistema e os demais.

• RT: a saída possui as estatísticas do resultado e um arquivo gráfico para a

visualização da árvore. Este arquivo é um formato gráfico vetorial, ou seja, não é

101

uma figura, e sim um conjunto de instruções para que a árvore seja desenhada. O

único aplicativo conhecido que pode realizar esta visualização é o dotty (Cf.

Graphviz, 2003), pertencente ao pacote de softwares graphviz, desenvolvido em

código aberto para ambientes UNIX.

O erro do modelo também pode ser estimado usando a técnica de amostra de teste e

validação cruzada, sendo possível especificar o arquivo com a amostra de teste.

Como a opção de validação cruzada não estava disponível em um dos softwares

analisados (RT), a opção escolhida foi o uso de amostra de teste. Esta

homogeneização da metodologia é importante para que as comparações pudessem

ser feitas sem restrições.

4.5 Resultados

A precisão foi utilizada para a comparação dos sistemas, principalmente

por ser considerada o critério mais importante. Alguns critérios nem puderam ser

acessados, como escalabilidade, robustez e velocidade, pois a base de dados era

pequena e estava limpa. Sobre a interpretabilidade, é possível afirmar holisticamente

que as árvores de regressão têm um nível maior do que as árvores de modelos.

4.5.1 Modelos

Serão mostrados os modelos que foram obtidos nos softwares, para fins

de comparação da estrutura que lhes foi imposta. Os algoritmos de indução das árvores

escolhem os atributos mais correlacionados com a variável modelada para realizar os

testes de divisão dos atributos.

A Tabela 4 foi obtida do CART, que estabelece um ranking das variáveis

dependentes segundo a importância. Não foram encontradas referências para os cálculos

102

que determinam o valor do score presente na tabela, entretanto é certo que este valor

está diretamente relacionado com a correlação da variável dependente com a variável

modelada.

Esperamos, portanto, que as variáveis mais importantes sejam utilizadas

para os testes de divisão pelo menos nos níveis mais altos das árvores modeladas. Nos

níveis mais inferiores os testes podem variar muito de uma ferramenta para outra, pois

as especificidades dos algoritmos podem considerar diversos outros fatores.

Tabela 4: variáveis segundo sua importância. Resultado obtido do CART.

Variable Score FINANCAS 100.00 |||||||||||||||||||||||||||||||||||||||||| HOLDING 93.18 ||||||||||||||||||||||||||||||||||||||| TELECOMF 73.69 ||||||||||||||||||||||||||||||| PETROQUI 64.76 ||||||||||||||||||||||||||| ENERGIA 56.48 ||||||||||||||||||||||| METALURG 45.49 ||||||||||||||||||| SIDERURG 24.49 |||||||||| AUTOMEC 18.97 ||||||| METALEMI 17.62 ||||||| CONSTRUC 13.91 ||||| ALIMFUMO 13.35 ||||| BLUECHIP 12.54 |||| TEXTIL 10.74 |||| DOLLAR 10.68 |||| COMERCIO 10.07 ||| PAPELCEL 9.94 ||| TELECOMC 8.45 ||| SIZE 8.38 ||| MOMENTUM 7.31 || AGRICPEC 6.58 || VALUE 5.70 | ELETRONI 1.45 OUTROS 0.32 TRANSPOR 0.19

Abaixo pode ser vista uma seqüência de representações dos modelos que

foram gerados pelo CART, pelo Clementine e pelo Weka (Figura 21, Figura 22 e

Apêndice I, respectivamente). Os dois primeiros modelos são árvores de regressão, mas

o último é uma árvore de modelos e, por isso estão descritos no final da listagem da

103

árvore todos os modelos de regressão que estão armazenados nas suas folhas. O modelo

obtido é muito grande, motivo pelo qual optou-se colocá-lo em um Apêndice.

DOLLAR METALEMI

CONSTRUC TELECOMF

FINANCAS

METALEMI

SIDERURG METALEMI

DOLLAR

SIZE

METALEMI

HOLDING

METALEMI

PETROQUI

COMERCIO

DOLLAR

PAPELCEL

MOMENTUM

MOMENTUM

TELECOMC

ALIMFUMO

HOLDING

TELECOMF

PAPELCEL

AUTOMEC

BLUECHIP

FINANCAS

FINANCAS

Figura 21: modelo gerado pelo CART

De uma maneira geral, é possível perceber que as árvores apresentam

uma estrutura muito semelhante, que sempre privilegia a variável FINANÇAS, que é a

mais importante, segundo a Tabela 4. Além disso, a variável HOLDING também

aparece com bastante freqüência nos níveis mais altos. No caso do Weka (Apêndice I),

pode-se ver que a variável FINANÇAS foi tão decisiva que ela aparece em todos os três

testes nos dois primeiros níveis da árvore.

Figura 22: modelo gerado pelo Clementine, com opção de Impurity = 10-6

Na árvore de modelos que foi gerada pelo WEKA cada nó terminal é

representado pela presença do nome do modelo de regressão que está presente no nó e

104

da estatística deste modelo. O nome do modelo segue a regra de formação LMi, onde i é

um número automático, crescente, na ordem em que aparece na árvore. A estatística do

modelo apresenta dois valores. O primeiro é a quantidade de casos que alcançou aquela

folha. O segundo valor é uma percentagem, que não está descrita em nenhuma

referência que foi consultada. Havia uma indicação na lista de discussão do software

(Cf. Wekalist, 2003) afirmando que esta é uma taxa de erro. Entretanto, parece que esta

pode ser uma taxa de acerto, que seria o coeficiente de determinação da equação de

regressão, R2 (Cf. Neter, 1996 e Draper, 1998). Estudos mais profundos se fazem

necessários para que se possa compreender melhor a natureza desta medida. Os modelos

estimados pelo Weka apresentam ao todo 17 variáveis e por isso não foi possível

estimá-los usando o Excel para comparar o resultado (o Excel só estima regressões com

até 16 variáveis). O modelo gerado pelo Weka assumiu proporções que tornaram

proibitivo sua exibição nesta seqüência do texto, mas pode ser visto no Apêndice I.

Os modelos gerados pelo RT e pelo Mineset não estão demonstrados. O

RT, como foi dito antes, apresenta o modelo em um formato não muito amigável, de

maneira que não foi possível importá-lo para o ambiente onde este texto foi elaborado

(plataforma Microsoft). O Mineset está, infelizmente, descontinuado pela empresa

fabricante, a Silicon Graphics Inc., e a única versão que se possuía funcionando foi

desinstalada. Como o estudo da estrutura das árvores foi feito posteriormente, não foi

possível importar os resultados gráficos desta ferramenta. Apenas as estatísticas que

foram armazenadas anteriormente ficaram disponíveis. Estas estão demonstradas na

seção seguinte.

4.5.2 Precisão

Os resultados segundo a precisão estão descritos na Tabela 5. A medida

de Erro padrão é relativa à amostra de teste, com 128 casos. Todas as ferramentas foram

105

treinadas e testadas considerando sempre a mesma amostra de treinamento e teste,

respectivamente, exceto o Mineset, pelos motivos anteriormente comentados. Utilizou-

se esta estratégia para evitar a dúvida de que a precisão obtida pelos softwares estivesse

viesada pela amostra que foi realizada. Esta amostragem foi realizada anteriormente à

fase de modelagem.

Tabela 5: precisão dos softwares

Ferramenta/opção Erro padrão CART 0,004890634 Clementine imp=10-6 0,0042894 Clementine imp=0 0,0042002 Mineset 0,003819775 WEKA 0,0035 RT 0,000055

Todos os softwares foram executados utilizando as opções padrão para

todos os parâmetros, exceto o caso do Clementine. Quando o Clementine foi executado,

a árvore não foi desenvolvida, em função de um parâmetro que é chamado de impurity,

que está relacionado à tolerância na comparação de valores de ponto flutuante. Valores

mais altos deste parâmetro tornam o software mais tolerante a diferenças, ou seja,

valores que não são exatamente iguais são considerados iguais. Valores menores tornam

o software menos tolerante, ou mais exigente, de maneira que os valores só são

considerados iguais quando estiverem muito próximos um do outro. A árvore de

regressão do clementine só foi desenvolvida (assumindo altura maior do que a unidade)

quando o valor deste parâmetro foi alterado para níveis menores do que o padrão. Os

valores que foram praticados estão enunciados na Tabela 5.

Os erros obtidos por todos os softwares estão na casa de 3 ou 4 (x10-2),

exceto o RT, que alcança um erro bem menor, de 5x10-5, o que realmente é

surpreendente. Deve-se evidenciar entretanto, que as árvores de modelos tiveram

desempenho melhor do que as árvores de regressão. Mesmo o WEKA, que teve um erro

106

padrão bem maior do que o RT, apresenta uma pequena vantagem em relação aos

demais.

107

5 Uma revisão para o M5’

Os algoritmos de indução de árvores de modelos, mesmo o M5’ que já se

apresenta como o M5 melhorado, apresentam alguns processos que parecem não

otimizados ou não terem sido devidamente testados. Os argumentos para revisar estes

processos estão fundamentados nas Teorias de Estimação de Regressão, principalmente

o Método dos Mínimos Quadrados (Neter, 1996 e Draper, 1998). Existem grandes

lacunas entre tais teorias e o que está praticado.

Serão evidenciados os processos que parecem não otimizados e os que

percebe-se que podem ser resolvidos através de outras heurísticas. Em seguida, serão

mostradas como foram implementadas estas otimizações e alternativas a partir do

código do M5’ (weka).

5.1 Processos a revisar

5.1.1 Critério de parada

Existem dois critérios de parada no procedimento de crescimento da

árvore (veja pseudo-código na Figura 12). O primeiro critério é em função do tamanho

do conjunto de casos que alcança o nó. Existe um limite pré-estabelecido de 4 unidades,

mas este limite é um parâmetro para a classe, e pode ser controlado pelo usuário através

da interface.

O segundo critério de parada é em função da redução da dispersão da

variável de resposta. O processo recursivo de divisão é interrompido quando o desvio

padrão da variável de resposta no conjunto de casos que alcança o nó for menor do que

5% do desvio padrão no conjunto completo de casos. Este parâmetro não é controlável a

108

partir da interface (a implementação realizada permitiu que esta fração fosse

controlada).

O controle pela quantidade de casos é razoável. De fato, existe um limite

a partir do qual a divisão não faz mais sentido, e não é viável chegar até a unidade. Qual

deve ser este limite, se 4 é um valor pequeno ou grande, é uma questão a ser

investigada. O sistema original permite o controle deste limite, de maneira que não foi

necessário alterar esta característica da implementação. A investigação pôde ser feita

através de experimentos.

Entretanto, o controle pela dispersão da variável de resposta não parece

uma idéia suficientemente boa. Existem dois problemas potenciais em definir um limite

para a dispersão como critério de parada. Por um lado, é possível que um subconjunto

de dados que apresente uma dispersão da variável de resposta maior do que 5% da

dispersão inicial possa ser linearmente modelado com os atributos disponíveis. Neste

caso, esta heurística faria divisões desnecessárias. Por outro lado, fatalmente haverá

subconjuntos de dados com dispersão menor ou igual a 5% da dispersão inicial que não

poderão ser linearmente modelados com qualidade.

Deve-se é estabelecer como critério de parada no crescimento da árvore

uma possível medida de qualidade do modelo de regressão que será estabelecido. Este

critério pode ser um teste de validação do modelo baseado na Análise de Variância que

a regressão estabelece (veja Seção 2.2.1).

Este teste pode ser usado como critério de parada na etapa de

crescimento da árvore. O nível de confiança a ser utilizado precisa ser testado. Também

pode-se estudar o uso concomitante deste critério com os outros, já estabelecidos pelo

algoritmo.

109

5.1.2 Escolha do teste de divisão

O critério de divisão dos atributos utiliza a função de redução de desvio

padrão, que precisa ser maximizada. De acordo com a Seção 3.2.2 (busca do melhor

teste de divisão), a expressão que representa a função objetivo é:

( ) ( )∑−=i

ii tsd

nn

tsdSDR , (44)

onde )(sd representa a raiz quinta da variância da variável de resposta do conjunto

avaliado, ni é a cardinalidade do subconjunto i e n é a cardinalidade do superconjunto,

que é igual a soma das cardinalidades dos subconjuntos, que são sempre dois.

Estão descritos alguns estudos em Wang & Witten (1997) que concluem

que o uso do desvio padrão e da variância como função objetiva no critério de divisão

não apresentam diferenças significativas. Entretanto estes resultados estão apenas

mencionados, e não descritos.

A variância e o desvio padrão apresentam forte correlação positiva, o que

indica que as funções baseadas nestas estatísticas terão comportamento semelhante.

Entretanto, dada a natureza quadrática da variância, é esperado que a diferença entre o

uso destas duas estatísticas é muito sutil, sendo percebida para determinados valores

extremos, ou muito grandes, ou muito próximos de 1 e de 0. Os experimentos para

provar a indiferença no uso das estatísticas precisam ser controlados, estudando

conjunto diferentes de casos que apresentem variâncias e desvios padrões da variável de

resposta em diferentes faixas de valores.

Deseja-se investigar também porque foi feito o uso de uma medida de

dispersão tão inusitada quanto a raiz quinta da variância. É necessário comparar os

resultados obtidos quando forem usadas medidas de dispersão conhecidas – desvio

padrão e variância, já que podem apresentar resultados diferentes. Além disso, uma

110

importante medida de qualidade dos modelos de regressão é uma relação entre o desvio

padrão e a média da variável de resposta, pois dá uma estimativa do erro padrão.

Finalmente, um detalhe técnico do algoritmo chamou-nos a atenção. O

uso de uma medida de off-set para o procedimento de busca do ponto de divisão (veja

Seção 3.2.2). Esta é uma heurística em prol da escalabilidade e velocidade do algoritmo,

e dentro do cenário de Data Mining preocupações como esta são fundamentais. É óbvio

que há um preço a ser pago em função deste ganho computacional. Este preço está

relacionado com a possibilidade de que o ponto ótimo de divisão tenha sido descartado

– caso estivesse no início ou no fim do conjunto. Considerando-se a possibilidade de

conjuntos viesados, esta possibilidade fica cada vez mais provável.

Assim, a medida de off-set deveria ser acompanhada de algum outro

critério em função do tamanho do conjunto que se está examinando. Conjuntos

pequenos podem ser vasculhados em sua totalidade, sem perda de performance, e assim

não se correria o risco de estar lidando com conjuntos viesados. O que justifica a

existência deste risco é a presença de conjuntos maiores, que sejam problema à

escalabilidade e velocidade do algoritmo.

5.1.3 Fator multiplicativo na função de erro

O fator multiplicativo que está descrito na Equação 41 é utilizado com o

princípio de compensar o erro em função da quantidade de atributos, de maneira que

modelos de regressão com menos atributos possam, dependendo do nível de

contribuição dos atributos removidos, apresentar estimativa de erro menor. Na teoria de

regressão, o desvio da variável dependente é comparado com a soma dos resíduos

quadráticos do modelo através da estatística R2. Existe uma estatística chamada de R2

ajustado que faz esta compensação através dos graus de liberdade do desvio da variável

dependente (n – 1) com o desvio do modelo (n – v –1), e o fator multiplicativo ficaria:

111

1

1−−

−vn

n (45)

que também serve como compensador diante da redução da quantidade de atributos no

modelo de regressão (valor v).

O uso deste fator, se não reduzir a eficácia do algoritmo de indução e/ou

a qualidade do modelo final, poderia ser justificado pela padronização de resultados,

que facilitaria a comparação entre Árvores de Modelos e Modelos de Regressão, pois

foi justamente com este intuito que o fator foi criado (Cf. Mendenhall & Sincich, 1996).

5.1.4 Pré-seleção dos atributos

De acordo com ambas as descrições feitas do M5’ (veja Capítulo 3), os

modelos de regressão que são construídos nos nós são estimados usando como variáveis

independentes apenas os atributos que foram utilizados para realizar testes de divisão de

registros em algum nó das sub-árvores descendentes.

Esta heurística parece estar fundamentada no fato que os atributos que

são utilizados como teste já foram selecionados pelo algoritmo como os mais

significativos, ou seja, aqueles que, segundo a função objetiva, dividem melhor o

conjunto de treinamento. Convém observar entretanto que a equação da função objetivo

está relacionada com a redução da variação (no caso a raiz quinta da variância) da

variável de resposta. Quando um modelo de regressão está sendo estimado, o objetivo é

explicar o comportamento da variável dependente. Não é óbvio que apenas os atributos

que maximizaram a função de redução de desvio padrão em algum nível

necessariamente são os únicos que apresentam poder explicativo da variável

dependente, que é, em última análise, a lógica da heurística.

112

Se a heurística estiver correta, ainda que apenas para uma parte

significativa dos casos, então usá-la pode agilizar sensivelmente o algoritmo.

Entretanto, se a heurística não se aplicar tão freqüentemente, o seu uso pode significar

uma grande perda de performance, pois os modelos de regressão estimados poderiam ter

uma precisão significativamente maior, melhorando a precisão do modelo global

(árvore).

Outros dois conjuntos de atributos podem ser utilizados: 1) as variáveis

que foram utilizadas em testes abaixo e acima do nó onde está sendo estimado o modelo

de regressão – usando a mesma lógica, mas ampliando a heurística; e 2) todas as

variáveis (atributos) disponíveis no conjunto de casos de treinamento. O primeiro

conjunto de variáveis foi sugerido por que os testes feitos em níveis superiores da árvore

também podem ser importantes para a descrição dos casos que estão sendo usados na

estimação do modelo. O segundo conjunto pode ser utilizado caso nenhuma destas duas

heurísticas apresentasse um resultado satisfatório.

Convém lembrar que os modelos serão simplificados, ou seja, atributos

podem ser removidos depois que os modelos de regressão são estimados. Com isso, a

complexidade não é um problema, visto que só será mantida uma carga muito grande de

atributos se estes se fizerem interessante. O que pode vir a ser uma perda de qualidade é

o custo computacional, que será ampliado. Entretanto, não se pode avaliar de antemão a

magnitude deste aumento de custo, sendo necessária uma bateria de exames para medir

a relação entre estes três fatores.

5.1.5 Simplificação dos modelos

O uso de algum método de simplificação dos modelos está diretamente

relacionado com o ganho no critério de interpretabilidade do modelo. Estes métodos

podem ser particularmente importantes quando as heurísticas que pré-selecionam os

113

atributos a serem considerados como variáveis independentes nos modelos de regressão

forem comprovadamente falhas.

A Teoria de Regressão desenvolvida baseada no Método dos Mínimos

Quadrados apresenta algumas maneiras de reduzir a quantidade de variáveis

independentes, de maneira controlada, mantendo a significância do modelo e

melhorando os níveis de complexidade e interpretabilidade.

Um possível método é baseado nos coeficientes de determinação parcial.

Quando o modelo de regressão é estimado, é possível saber a carga de contribuição que

cada variável independente possui na previsão da variável dependente. O custo

computacional de calcular estes coeficientes é relativamente alto – exigiria a matriz de

correlação das variáveis, mas também é muito alto o custo computacional do processo

de simplificação proposto originalmente (tanto na descrição pública quanto na descrição

técnica), que inclui a comparação do modelo completo com os modelos gerados a partir

da remoção de cada variável, numa busca exaustiva.

Uma outra alternativa para o processo de seleção de variáveis é o uso

método de seleção de variáveis, como os métodos forward, backward e stepwise (Cf.

Neter, 1996, Draper, 1998 e SPSS, 1999). Estes métodos estão baseados em testes de

comparação de modelos encaixados, ao invés de comparação do erro do modelo.

Apresentam a grande vantagem de permitir o uso de níveis de significância, que podem

permitir uma maior ou menor tolerância no momento da escolha dos modelos. Além

disso, o método backward é bem rápido, tendo seu custo computacional no pior caso

igual ao custo do melhor caso dos processos de busca exaustiva executados pelo M5 e

M5’, que seria O(k), onde k é a quantidade de variáveis independentes.

Como foi observado na descrição técnica do algoritmo (Seção 3.2.3), o

uso de algum método de seleção de variáveis torna desnecessário o uso da estimativa de

114

erro ponderado pelo fator descrito anteriormente, o que anulou a discussão sobre o fator

de ponderação (veja a Seção 5.1.3).

5.1.6 Suavização dos coeficientes

O último processo a ser considerado é a suavização, descrita na Seção

2.3.2, que pode ser interpretado como uma média ponderada de várias previsões para o

mesmo caso.

Cada nó da árvore apresenta um teste sobre os valores dos atributos do

caso, e estes testes determinam o caminho que o caso fará até uma folha da árvore. Ao

longo deste caminho, cada nó, inclusive a folha, possui um modelo de regressão. As

previsões de cada um destes modelos são ponderadas, de maneira que casos

semelhantes (registros próximos) possuam valores de previsão não muito diferentes.

De acordo com a Equação 30 os pesos de ponderação são o tamanho do

conjunto de treinamento que alcança o nó filho para a previsão feita por ele e o valor de

k para a previsão feita pelo modelo de regressão no nó pai. Se o conjunto de treinamento

do nó filho for menor que k, então a equação de regressão terá peso maior que a

previsão do filho. E se o conjunto de treinamento do nó filho for maior do que k, então a

previsão do filho será mais importante. O valor de k funciona como um limite que

determina a quantidade máxima de casos que torna o modelo de regressão de um nó

mais relevante do que a previsão do seu filho.

Fixado um valor para k, quanto mais distante da folha, maior a relevância

da previsão vinda do filho, visto que a quantidade de casos que alcança o filho cresce.

Dado que o valor de k é proposto ser fixo em 15, tem-se que os únicos modelos de

regressão mais relevantes do que a previsão do filho são os que estão em nós cujo filho

foi treinado com menos de 15 elementos – provavelmente os dois ou três níveis mais

próximos da folha.

115

A relevância do modelo de regressão deve ser função do grau de

liberdade da regressão, que inclui a quantidade de casos e também a quantidade de

parâmetros estimados. Além disso, o fato de que o valor de k vai determinar o peso dos

modelos de regressão no somatório total reforça a idéia que este valor deve girar em

função da quantidade de observações do conjunto de treinamento total. Definitivamente,

fixar o valor k em um número como 15 é equivocado.

Convém observar também que Árvores de Modelos perdem bastante de

sua característica de alta interpretabilidade. Modelos (de previsão ou de classificação)

baseados em árvore são considerados altamente interpretáveis por que permitem a

percepção visual imediata de quais atributos são relevantes para a previsão do caso, que

são aqueles que servem como testes em nós intermediários. No caso das Árvores de

Modelos, atributos que nem sequer foram utilizados como teste podem ser fundamentais

para a previsão de casos, se estiverem relacionados com a variável de previsão através

de alguma equação de regressão (considerando a terceira heurística de pré-seleção de

atributos descritos na Seção 5.1.4).

Observe que o procedimento de suavização reduz ainda mais a

interpretabilidade do modelo de previsão, pois o valor final da previsão depende de

todos os modelos que estão no caminho desde a raiz da árvore até a folha onde o caso

foi previsto. E não é sempre verdade que os modelos mais inferiores terão maior

importância que os modelos superiores, pois até mesmo a equação de regressão na raiz

da árvore pode ter o peso maior na média ponderada, caso o conjunto de treinamento

seja muito pequeno ou então desbalanceado. Nestes casos perde-se a certeza de

relevância dos atributos na previsão do caso, pois os modelos localizados em nós

internos da árvore podem apresentar outros atributos, que não os utilizados em testes.

116

5.2 Implementação das revisões

A implementação de todas as revisões sugeridas na Seção anterior foi

feita dentro do próprio ambiente Weka. Como é um sofware de código aberto, estão

disponíveis todos os códigos fontes do sistema. Foi utilizado o IDE NetBeans da Java,

versão 3.6 para desenvolvimento e compilação da implementação feita, bem como para

gerar a documentação final em Javadoc, como pode ser vista no Apêndice IV. Sobre a

documentação, os campos de autoria e copyright não foram modificados, pois grande

parte do código final da implementação feita é original. Isto pode ser visto nos anexos.

A árvore de diretórios que é obtida quando o código fonte do Weka é

copiado inclui um arquivo chamado build.xml que contém diversos targets para

compilação do sistema. Estes targets são interpretados por um software específico que

funciona como uma camada sobre o compilador javac, chamado ant. Como utilizou-se

a IDE Netbeans, a instalação do ant foi desnecessária, e foi possível executar os targets

fornecidos com o código do Weka, que inclui a geração do arquivo binário do Weka e a

documentação das classes baseada em Javadoc.

Foi criado a partir do pacote m5 o pacote chamado m5_5. Procurou-se

usar um nome que deixasse claro o fato de ser o pacote m5_5 derivado direto do pacote

m5. O pacote original contém 8 classes mais a classe principal, e esta estrutura foi

mantida, mais uma classe que foi criada e chamada de Statistic.Java, que contém os

cálculos necessários para o teste de validação do modelo, usado como critério de parada

do crescimento da árvore segundo o algoritmo proposto. Uma descrição rápida de cada

uma destas classes pode ser vista na Tabela 6. O texto foi extraído diretamente do

Javadoc, e a língua inglesa foi mantida para fins de facilitação da divulgação dos

resultados.

117

Tabela 6: classes que compõem o pacote m5_5

Classe Descrição CorrelationSplitInfo Finds split points using correlation.

Impurity Class for handling the impurity values when spliting the instances

M5_5Base M5_5Base. PreConstructedLinearModel This class encapsulates a linear regression function. Rule Generates a single m5 tree or rule RuleNode Constructs a node for use in an m5 tree or rule Statistic Compute statistical distributions F and T. Values Stores some statistics. YongSplitInfo Stores split information.

Algumas destas classes não foram nem mesmo alteradas. São elas:

CorrelationSplitInfo e Values. A classe Statistic foi totalmente criada. As demais classes

foram, de alguma maneira, alteradas, de forma a realizar as revisões propostas. Um

resumo rápido do motivo de modificação de cada classe:

• Impurity: nesta classe estão os métodos que fazem a busca do melhor teste de

divisão dos registros durante a construção da árvore. É nesta classe que está

definida a função de redução da dispersão da variável de resposta, que era a raiz

quinta da variância;

• M5_5Base: esta classe é a primeira classe chamada dentro do pacote, e é onde os

parâmetros são passados para a interface gráfica que pode ser vista na Figura 23 e

interpretados pelo sistema. Também é responsável por distribuir estes parâmetros

para as respectivas classes;

• PreConstructedLinearModel: Esta classe armazena informações sobre a

regressão que foi estimada. Esta classe foi alterada para que as informações extras

sobre a regressão SSE e SSR ficassem salvas, para que o teste de hipóteses para o

critério de crescimento da árvore pudesse ser realizado;

118

• Rule, RuleNode: passagem de parâmetros;

• RuleNode: realiza a avaliação dos critérios de parada do crescimento da árvore e

faz a pré-seleção dos atributos que serão utilizados na indução do modelo de

regressão. Além disso, realiza também a suavização dos modelos de regressão;

• YongSplitInfo: Controla o andamento da busca do teste de divisão dos registros, e

é onde usa-se a heurística de escalabilidade chamada de off-set na Seção 5.1.2.

Figura 23: Parâmetros implementados

Além das classes internas ao pacote m5_5, duas outras classes foram

alteradas. A classe weka.classifiers.trees.M5_5 é a classe principal que dá nome ao

pacote. Além disso, a classe weka.classifiers.functions.LinearRegression também

precisou ser alterada. Infelizmente, esta classe é a mesma que é utilizada para o

classificador disponível na suíte que leva o mesmo nome, mas era preciso inserir uma

119

maneira de calcular a estatística F para o novo critério de parada de crescimento da

árvore.

Na Figura 23 pode-se ver a tela que permite o controle dos parâmetros

para a modelagem. Comparando esta tela com a tela da Figura 20, ressalta-se que

existem ao todo 8 parâmetros a mais. Há abaixo uma descrição de cada um destes

parâmetros, comentando sobre as rotinas envolvidas com o parâmetro e a revisão de

processo relacionada.

• attributePreSelectionMethod: este parâmetro controla como será feita a pré-

seleção dos atributos que serão utilizados como variável dependente no modelo de

regressão. O parâmetro é do tipo lista, com quatro opções: 1) pré-seleção original,

ou seja, apenas os atributos usados em testes abaixo do nó corrente; 2) apenas os

atributos usados em testes acima do nó corrente; 3) os atributos usados em testes

acima ou abaixo do nó corrente; 4) todos os atributos (não faz pré-seleção);

• confLevel: refere-se ao nível de confiança utilizado no teste F de utilidade global do

modelo de regressão. O teste pode ser usado como um dos critérios de parada do

procedimento de crescimento da árvore, o que depende do valor do parâmetro

stopCriteria. O parâmetro é um número real, indicando a probabilidade associada à

rejeição da Hipótese Nula do teste F;

• eliminateColinearAttributes: controla se será realizada ou não a etapa de remoção

dos atributos que apresentam coeficiente padronizado maior do que 1,5, durante a

seleção do melhor modelo de regressão;

• impurityCalculation: o sistema M5’ chama de impurity a dispersão da variável de

resposta, quando está sendo procurado o teste de divisão dos registros em um nó. O

sistema calcula esta dispersão através da raiz quinta da variância. O parâmetro é

uma lista, que permite quatro opções de cálculo desta dispersão: 1) usando a

120

heurística original, que trabalha a raiz quinta da variância, 2) cálculo através do

desvio padrão; 3) cálculo através da variância; 4) uso da razão entre a variância e a

média;

• impurityOffSet: é chamado de off-set ao volume de dados que é desprezado

durante a busca do melhor ponto para ser usado como limite no teste de divisão dos

registros. Esta é uma medida para garantir a escalabilidade e velocidade do sistema.

O sistema trabalhava exclusivamente com um off-set de 20%. O parâmetro é uma

lista com quatro opções, onde a primeira é o padrão trabalhado do sistema, a

segunda é um off-set de 10%, a terceira de 5% e a última é não usar o off-set;

• newPruningFactor: este parâmetro foi definido para que se pudesse controlar qual

seria o fator multiplicativo da função de erro do modelo de regressão, que

originalmente seria como demonstrado na Seção 3.1.3.1, e que é proposto ser como

na Seção 5.1.3. O valor falso para este parâmetro estaria relacionado ao uso do fator

original, e o valor verdadeiro estaria relacionado ao uso do fator proposto;

• smoothingConstant: na Seção 5.1.6 foi discutida a natureza da constante que

aparece na expressão de suavização dos modelos de regressão, que é apresentada

com valor constante igual a quinze. A fim de estudar uma relação entre esta

constante e o tamanho da base de dados, colocou-se este valor como uma variável,

controlada através este parâmetro que é um número real qualquer;

• stopCriteria: este parâmetro refere-se ao critério de parada do algoritmo de

crescimento da árvore. Existem ao todo três critérios em uso: o controle da redução

percentual da dispersão da variável dependente, chamado de %SD, o controle pelo

número mínimo de registros, chamado de MinInst, e o controle pelo teste F,

chamado de F test. Como o controle pelo número mínimo de registros é

121

fundamental para garantir a existência do modelo de regressão, o parâmetro possui

três opções que incluem sempre este critério: 1) o uso do critério original, composto

pela redução percentual da dispersão da variável dependente e o número mínimo de

registros; 2) o teste F e o número mínimo de registros; 3) a redução percentual da

dispersão, o teste F e o número mínimo, simultaneamente e 4) a redução percentual

do SSE – Somatório dos Quadrados dos Erros do modelo de regressão, o teste F e o

número mínimo, simultaneamente.

• threshold: um dos critérios sugeridos originalmente para a parada do crescimento

da árvore é a redução da dispersão da variável dependente. Originalmente esta

redução estava fixada em 5%, ou seja, se o conjunto de casos (registros) que alcança

o nó apresenta desvio padrão da variável de resposta (dependente) menor do que 5%

do desvio padrão do conjunto de treinamento todo, este nó pode ser considerado

uma folha. O parâmetro é um número real, indicando a fração do desvio que será

usada para este critério. Novamente, nem sempre este critério é utilizado,

dependendo do valor do parâmetro stopCriteria;

122

6 Testes e resultados

Os testes descritos neste capítulo foram realizados para experimentar o

algoritmo desenvolvido, o M5.5’. Muitos destes testes servem para ajudar a definir

parâmetros definitivos para o algoritmo final e outros têm o intuito de mostrar a

qualidade dos modelos obtidos.

Apesar de terem sido utilizadas heurísticas que pareciam melhores do

que as anteriores, é necessário mostrar em termos de resultados concretos, numéricos

sempre que possível, os níveis de qualidade. Foram criados cenários comparativos com

modelos obtidos de algoritmos clássicos.

Estes cenários comparativos foram definidos com o uso de bases de

dados conhecidas academicamente e que foram utilizadas por outros sistemas de

indução de modelos de previsão baseados em árvores. Os resultados obtidos por estes

sistemas foram publicados para a divulgação do próprio sistema e pode ser assumido

que são os melhores resultados que estes sistemas podem alcançar.

Este capítulo começa com a descrição das bases de dados utilizadas nos

testes, que são descritos em seguida. Os principais resultados de cada teste estão

descritos em cada subseção. Cada subseção está relacionada a uma bateria de testes que

dizem respeito a problemas semelhantes.

6.1 Bases de dados usadas

Para experimentar o algoritmo de indução de modelos M5.5’, foram

usadas ao todo 6 bases de dados bem conhecidas academicamente. As bases em questão

já foram utilizadas por sistemas de indução de modelos de previsão, e estão disponíveis

123

no Repositório de bases de dados de aprendizado de máquina da UCI (University of

California, Irvine) (UCI, 2005). Referências importantes que usam estas bases são

Quinlan (1993) e Wang & Witten (1997). Ambas fizeram experimentos dos sistemas

propostos, mas a segunda referência já usa as bases num cenário comparativo entre o

M5’ e o M5. Uma destas bases, chamada pw-linear, única dentre estas que é sintética,

também já tinha sido usada por Breiman (1984) para experimentos do CART.

Tabela 7: características das bases de dados

Nome da Base Atributos Numéricos

Atributos Categóricos Casos

auto-mpg 5 2 398 auto-price 15 0 159 auto-price-w_cat 15 10 159 auto-price-w_catmiss 15 10 205 cpu 6 1 209 housing 12 1 506 pw-linear 10 0 200 servo 2 2 167

É possível ver na Tabela 7 um resumo com as características físicas

destas bases de dados. Estão enumerados quantos são os atributos numéricos e

categóricos. Atributos são apenas as variáveis explicativas. Portanto, para saber a

quantidade de variáveis (colunas) que tem uma destas bases é necessário considerar uma

variável a mais do que a quantidade de atributos, que é referente à variável dependente

(variável contínua). Por exemplo, a base sintética pw-linear possui 11 variáveis, todas

contínuas (10 atributos numéricos + 0 atributos categóricos + a variável de resposta).

• auto-mpg: estes dados referem-se ao consumo de combustível (dado em miles per

galon, mpg – milhas por galão) de veículos rodando em ambientes urbanos. Não

existem maiores descrições das variáveis desta base além dos nomes: mpg (variável

de resposta), cylinders, displacement, horsepower, weight, acceleration, model year

e origin. As variáveis categóricas são cylinders e origin.

124

• auto-price: A classe para esta base de dados é uma lista de preços de 1985 de

automóveis comuns. Os 15 atributos numéricos são (os atributos cujo significado

não está claro possuem uma breve descrição de seu conteúdo): symboling (inteiros

de -3 a 3), normalized-losses (inteiros de 65 até 256), wheel-base (numéricos com 1

casa decimal de 86,6 até 120,9), length, width, height, curb-weight (freio), engine-

size, bore (numéricos com 2 casas decimais de 2,54 até 3,94), stroke (torque),

compression-ratio, horsepower, peak-rpm, city-mpg, highway-mpg e price.

No repositório original, a base está armazenada sob o nome de autos. A base

original difere da que é utilizada em Quinlan (1993) e em Wang & Witten (1997)

não só no nome. Foram removidos a partir da base original os 10 atributos

categóricos e os registros que apresentavam valor faltante. Os atributos categóricos

incluíam o make (fabricante), fuel-type, aspiration, num-of-doors, body-style, drive-

wheels (tração), engine-location, engine-type, num-of-cylinders e fuel-system. Além

disso 46 registros apresentam valores faltando, em 7 atributos diferentes, e também

foram eliminados para as comparações (portanto a base original tinha 205 registros).

Para efeito de trabalho, são consideradas também duas outras bases a partir do

arquivo original, que ficaram com o nome auto-price-w_cat e auto-price-w_catmiss.

A primeira contém os atributos categóricos que foram eliminados, mas não contém

os registros que apresentam valores faltantes. A segunda base equivale ao arquivo

original, ou seja, contém os atributos categóricos e os registros que apresentam

valores faltando.

• cpu: a base de dados relaciona uma medida de desempenho da Unidade Central de

Processamento (CPU – Central Processing Unit) com seis atributos numéricos

MYCT (ciclo da máquina em nanosegundos), MMIN: (memória principal mínima

em kilobytes), MMAX: (memória principal máxima em kilobytes), CACH:

125

(memória cache em kilobytes), CHMIN: (mínimo de canais em unidades) e

CHMAX (máximo de canais, em unidades). Além disso, existe um atributo

categórico, que é o fabricante. No arquivo ainda aparece uma nona coluna que são

os valores previstos para a classe pelo primeiro modelo de indução que publicou a

base, e que foi ignorada.

• housing: esta base de dados refere-se a valores médios de moradias ocupadas pelos

proprietários em unidades de US $1000 nos subúrbios (cidades satélites) de Boston.

O atributo categórico é na verdade uma variável binária indicando se a moradia em

questão é próxima a um rio e chama-se CHAS (Charles River Dummy Variable). Os

outros atributos são: CRIM: taxa de crime per capita da cidade, ZN: proporção de

terrenos com mais de 25 mil pés quadrados, INDUS: proporção de terreno não

comercializado por cidade, NOX: concentração de óxido nítrico em partes por 10

milhões, RM: número médio de cômodos por moradia, AGE: proporção de unidades

ocupadas pelo dono anteriores a 1940, DIS: distância ponderada para cinco centros

de trabalho de Boston, RAD: índice de acessibilidade a vias principais (radial

highways), TAX: valor total dos impostos, em unidades de US$10,000, PTRATIO:

taxa de aluno-professor da cidade, B ( )263,01000 −Bk , onde Bk é a proporção de

negros da cidade, LSTAT: percentual da população de classe inferior (lower status).

• pw-linear: esta base de dados foi originalmente proposta por Breiman (1984), e foi

utilizada para testes no CART. É uma função linear por partes (piecewise linear

funcion). Os 10 atributos numéricos são definidos da seguinte maneira:

( ) ( )2111 11 ===−= xPxP e ( ) ( ) ( ) 10,...,3,2,

31101 ======−= ixPxPxP iii .

126

A variável de resposta é definida em termos dos atributos criados, mais uma variável

aleatória independente z, com distribuição normal, de média zero e variância dois. A

regra de formação da variável de resposta é:

−=++++−=++++

=1 se ,233

1 se ,233

1765

1432

xzxxxxzxxx

y

Veja que as variáveis x8, x9 e x10 não são utilizadas na definição da variável

dependente. Estas variáveis funcionam, assim como z, como ruído. São criados 200

casos de acordo com este modelo.

Não existem versões desta base de dados disponíveis para copiar. Isto é ruim, pois

apesar do modelo que gera a base estar bem definido, detalhes como a correlação

entre os atributos sintéticos pode fazer diferença na hora de avaliar os modelos. Está

disponível no Apêndice III a base de dados que foi gerada e utilizada nos testes,

como uma tentativa de padronização do conteúdo desta base.

• servo: a descrição do conteúdo desta base de dados não está completamente definida

na literatura. Sabe-se apenas que a classe refere-se ao tempo de resposta de um

mecanismo. Considere o fragmento extraído de Quinlan (1993), descrevendo a base

de dados em questão:

This interesting collection of data, provided by Karl Ulrich, refers to an extremely non-

linear phenomenon – prediction the rise time of a servomechanism in terms of two

(continuous) gain settings and two (discrete) choices of mechanical linkages.

A descrição física das 5 variáveis (considerando a classe) do arquivo é: motor –

categórico com 5 valores, screw – categórico com 5 valores, pgain – inteiros de 3 a

6, vgain – inteiros de 1 a 5 e class – valores contínuos de 0.13 a 7.10.

127

6.2 Critérios

Os critérios de comparação que foram utilizados para todos os testes aqui

descritos possuem três naturezas distintas, a saber, precisão, velocidade e complexidade.

A medida de complexidade é o tamanho da árvore, medido pela quantidade de folhas ou

regras. A velocidade pode ser medida pelo tempo, que é dado em segundos, pelo

próprio sistema. As medidas de precisão são dadas pelas estatísticas definidas na seção

4.4.2, pág. 100. São usadas siglas para representar estas estatísticas de precisão nos

gráficos e tabelas que se seguem. Estas siglas estão definidas na Tabela 8.

Tabela 8: Siglas para as estatísticas de precisão

Estatística Sigla Correlation coefficient Corr Mean absolute error MAE Root mean squared error RMSE Relative absolute error Era Root relative squared error RRSE

Convém observar que os critérios de complexidade (regras), tempo e

todas as medidas de precisão, exceto a correlação, tem utilidade decrescente, ou seja,

quanto menor a medida, melhor o modelo. O contrário ocorre com a correlação, pois o

melhor modelo apresenta maior nível de correlação entre a variável de resposta e os

valores previstos para ela.

A estação de trabalho que foi utilizada para as comparações é um

Pentium III, com clock de 800MHz, com sistema operacional Windows XP. Muitas

vezes o teste foi realizado concomitantemente com outras tarefas, como edição de texto

e de gráficos, serviços de impressão e até acesso a internet. Conseqüentemente, a

medida de tempo apresenta uma variabilidade em função não só do esforço

computacional dos sistemas sendo testados para realizar a modelagem. Assim, o uso do

critério de tempo como parâmetro para a comparação deve ser feito com cuidado,

128

principalmente quando pequenas bases de dados são utilizadas. O problema é

minimizado quando a modelagem envolve grandes bases de dados, pois como o tempo

gasto para modelar é maior, tanto um sistema quanto o outro serão prejudicados pela

não dedicação da estação.

6.3 Testes das revisões

Os testes que estão demonstrados a seguir foram feitos considerando

revisões individuais. Para realizar estes testes foram consideradas todas as possíveis

heurísticas – métodos – de cada uma das revisões propostas, assumindo todos os outros

métodos como propostos originalmente no M5’. O objetivo dos testes é fazer uma

sondagem da resposta de cada um dos métodos individualmente.

6.3.1 Pré-seleção dos atributos

Dentre os quatro possíveis métodos para Pré-seleção dos atributos, o que

mais se destacou foi o uso de todos os atributos, ou seja, sem pré-seleção

.

Percentual Ganho por Método

25%

10%

26%

39% BelowAboveBelow e AboveAll

Figura 24: Percentual de escolha para os métodos de pré-seleção dos atributos.

Na Figura 24 pode ser vista uma contagem de quantas vezes cada um dos

métodos foi preferido segundo os sete critérios (5 relativos a precisão mais o tempo e a

complexidade) que estão sendo utilizados. Veja que, em caso de empate, um critério

pode preferir mais de um método. Por exemplo, no critério Tempo houve um empate

129

para os três primeiros métodos quando a base pw-linear foi utilizada e os três métodos

foram contados como escolhidos (veja as tabelas no Apêndice III).

Examinando os critérios que elegeram este método, vê-se que o tempo

não foi um deles, veja a Figura 25. Isso é relativamente esperado, posto que haverá

muita perda de tempo na etapa subseqüente de simplificação dos modelos de regressão e

poda da árvore. Convém lembrar que o critério tempo não é muito confiável, conforme

comentado anteriormente. Além disso, este critério escolhe o método Above 87,5% das

vezes, que não é um método preferido por nenhum dos outros critérios.

Preferência por Critérios

62.50%

37.50%

62.50%50.00%

62.50%

0.00%

75.00%

0.00%10.00%20.00%30.00%40.00%50.00%60.00%70.00%80.00%

Corr MAERMSE

RAE

RRSE

Tempo

Regras

Figura 25: Percentual de preferência da não pré-seleção.

Diante do exposto, é preferido o uso do método de pré-seleção All,

exceto o caso explícito em que a base de dados se torne muito grande, ou na quantidade

de casos ou na quantidade de atributos – principalmente os categóricos em muitos

níveis.

6.3.2 Sobre a eliminação atributos colineares

A eliminação dos atributos colineares não traz vantagens do ponto de

vista da complexidade, visto que em todos os casos analisados a quantidade de regras da

árvore final (podada e simplificada) foi a mesma. O critério de tempo aponta para a não

130

eliminação, pois é uma etapa do processamento que é evitada, sem conseqüências

posteriores.

Percentual Ganho por Método

do Eliminate38%

don´t Eliminate

62%

Figura 26: Percentual de escolha para Eliminar ou não os Atributos Colineares.

O gráfico da Figura 26, que mostra que a eliminação dos atributos

colineares não deve ser realizada, foi estimado considerando oito votos, um de cada

base de dados utilizada. Cada base de dados votou no método que mais ganhou dentre

os critérios abordados. Os detalhes de cada um dos votos pode ser considerado também

na Figura 27.

012345678

Corr MAE RMSE RAE RRSE Tempo Regras

Contagem por Critério

do Eliminate don´t Eliminate

Figura 27: Contagem de preferência de cada método considerando cada critério

6.3.3 Função de dispersão no cálculo do SDR

Dentre as funções de Dispersão estudadas, a que mais se destacou nos

critérios de comparação foi a proposta originalmente – raiz quinta da variância, quase

131

empatada com a razão entre a variância e a média da variável de resposta. Os dois

métodos apresentam-se bem equilibrados nos critérios de precisão – empate total. A

função proposta originalmente destaca-se na complexidade (poucas regras) e a razão

entre a variância e a média destaca-se no tempo, logo depois da variância.

Preferência por Critério

0

1

2

3

4

5

6

7

Corr MAE RMSE RAE RRSE Tempo Regras

5th rootStd DeviationVarianceVariance/Mean

Figura 28: escolha da função para o cálculo do SDR

Mesmo não tendo uma prova definitiva da superioridade da razão entre a

variância e a média como medida da dispersão da variável dependente – ocorreu um

empate técnico – a opção é pelo uso da segunda função para os testes definitivos feitos

no final deste capítulo. Apesar do critério tempo não ser confiável, o ganho de tempo é

real, pois o calculo de qualquer uma das outras funções requer o cálculo da média e da

variância da variável de resposta. É bem provável que este ganho de tempo seja

fundamental quando bases de escala considerável forem usadas.

6.3.4 Uso de medidas de off-set no cálculo do SDR

O ganho de tempo em realizar a busca do ponto ótimo de divisão do

conjunto de registros considerando um off-set é inegável, e pode ser visto em todos os

exemplos executados, exceto alguns casos esporádicos que foram gerados,

provavelmente, pelos problemas de processamento da estação que foi utilizada.

132

Tabela 9: off-sets selecionados por bases de dados

off-set 20% off-set 10% off-set 5% Sem off-set auto-mpg X auto-prices X auto-prices-witCat X auto-prices-witCatMiss X cpu X X X housing X pw-linear X X X X servo X X X

Era esperado, de uma maneira geral, um ganho de precisão quando não

fossem utilizadas medidas de off-set. A Tabela 9 mostra, para cada base, qual foi a

medida de off-set que apresentou melhores taxas de precisão. Entretanto, isto só

aconteceu em apenas uma base de dados, que foi a base housing. Em outras três bases,

não usar off-set empatou com outras medidas, inclusive na base pw-linear, onde houve

um empate geral. Curiosamente, a base auto-mpg mostrou melhores taxas de precisão

considerando um off-set de 10%, e as três bases originadas a partir de auto-prices,

apresentaram melhores taxas de precisão quando o off-set de 20% foi utilizado. Não

parece haver razão lógica para isto. O fato deve ter sido ocasional, em função de alguma

característica intrínseca a estas bases. Nestes casos foi escolhido um ponto de divisão

que não é ótimo para a redução da função de SDR, pois o ótimo foi obtido quando a

busca foi feita sem off-set. Ocorreu então que este ponto não ótimo levou o modelo final

(árvore) a obter resultados melhores. Mas esta é uma situação que não pode ser prevista

nem considerada, sendo apenas um acaso.

6.3.5 Fator de ponderação na função de erro para poda da árvore

De maneira geral, foi observado que o uso da nova função de Erro poda

menos a árvore e gera, portanto, modelos mais complexos. As árvores geradas usando

esta nova função de erro apresentaram em média 4 vezes mais regras do que as

originais. Naturalmente, houve um ganho de precisão significante. Esta comparação

133

pode ser vista na Figura 29, sendo a precisão representada pela Correlação entre os

valores observados da variável de resposta e os valores previstos pelo modelo.

auto-mpg

auto-prices

auto-prices- witCat

auto-prices-witCatMiss

cpu

housing

pw-linear

servo

0

10

20

30

40

50

60

Regras

original factor new factor

auto-mpg

auto-prices

auto-prices-witCat

auto-prices-witCatMiss cpu

housingpw-linear servo

0.86

0.88

0.9

0.92

0.94

0.96

0.98

1

Correlação

original factor new factor

Figura 29: comparação entre o ganho de precisão e de complexidade

Se a complexidade não é um critério importante para a análise que está

sendo feita, o que ocorre sempre que a interpretabilidade se impõe à precisão, este novo

fator multiplicativo pode ser utilizado. Associado com um critério de divisão da árvore

que seja menos propenso ao crescimento – tipicamente um threshold maior, esta nova

função de poda pode apresentar bons resultados.

134

6.3.6 Constante de suavização dos modelos de regressão

As constantes de suavização foram analisadas considerando apenas o

critério de precisão do modelo final, pois o tempo e a complexidade não são afetados

pelos valores que são armazenados como coeficientes de regressão.

De maneira geral, as constantes de suavização apresentaram um

comportamento uniforme em relação as bases de dados. Existe um ponto de mínimo nas

medidas de erro (ou de máximo para a medida de correlação). Veja na Figura 30 um

estudo do comportamento deste ponto de mínimo para algumas das bases trabalhadas.

base auto-mpg

2.94

2.95

2.96

2.97

2.98

2.99

3

0 20 40 60 80

Constante de Suavização

RM

SE

base auto-prices

2050

2100

2150

2200

2250

2300

2350

0 5 10 15 20 25

Constante de Suavização

RM

SE

base auto-prices-witCatMiss

22002220224022602280230023202340

0 10 20 30 40

Constante de Suavização

RM

SE

base housing

3.743.7423.7443.7463.7483.75

3.752

0 10 20 30

Constante de Suavização

RM

SE

Figura 30: Avaliação da Melhor Constante de Suavização para algumas bases de dados

O objetivo é definir uma expressão que pudesse determinar o valor da

constante de suavização para uma base de dados qualquer. Foi construída, a partir das

bases de dados, uma tabela onde o melhor valor para a constante de suavização está

135

emparelhada com as seguintes características das bases de dados: tamanho, quantidade

de atributos numéricos, quantidade de atributos categóricos e quantidade de valores

faltantes nos atributos (variáveis explicativas). Estes valores emparelhados podem ser

vistos na Tabela 10.

Tabela 10: características das bases de dados e constante de suavização (k)

Base n Num Cat Missing k auto-mpg 398 5 2 0 60 auto-prices 159 15 0 0 4 auto-prices-wcat 159 15 10 0 5 auto-prices-wcatmiss 201 15 10 46 16 cpu 209 6 1 0 10 housing 506 12 1 0 23,5pw-linear 200 10 0 0 5 servo 167 2 2 0 3

Estes valores foram utilizados para buscar a expressão desejada, e

verificou-se que apenas o tamanho da base mostrou uma correlação significativa com o

valor da constante de suavização. Como era sabido que a constante de suavização

apresentava um ponto de ótimo dado como mínimo (ou máximo) nos critérios de

precisão, considerou-se também na análise o quadrado do tamanho da base, que

apresentou correlação forte com o valor da constante. Estas correlações podem ser

vistas na Tabela 11.

Tabela 11: Correlações das características das bases com a constante de suavização

Característica Correlação com k n2 0,6459 n 0,7118 Num -0,2785 Cat -0,0731 Missing 0,0039

Esta pequena amostra de relações entre o tamanho da base e o seu

quadrado explicando o valor da constante de suavização gerou a Tabela 12, que pode

136

ser vista abaixo. É uma regressão estimada através do Excel, que apresenta boas

estatísticas de avaliação dos parâmetros, individual e coletivamente, e onde 82,56% da

variação do valor da constante de suavização pode ser explicado. Foi adotada então a

expressão para o valor da constante como sendo:

604,110001,0868,0 2 −×−×= nnk , (46)

considerando os limites onde a função ainda possui valores positivos e siginificativos,

170 e 550, respectivamente.

Tabela 12: regressão estimada para definir uma expressão para a constante de suavização

RESUMO DOS RESULTADOS Estatística de regressão R múltiplo 0,9086 R-Quadrado 0,8256 R-quadrado ajustado 0,7558 Erro padrão 9,4923 Observações 8 ANOVA Gl SQ MQ F F de significação Regressão 2 2132,45 1066,23 11,83 0,013 Resíduo 5 450,52 90,10 Total 7 2582,97 Coeficientes Erro padrão Stat t valor-P 95% inferiores Interseção -110,604 33,97162 -3,25577 0,0226 -197,9304 n2 -0,001 0,00039 -3,02334 0,0293 -0,0022 N 0,868 0,25361 3,42147 0,0188 0,2158

6.3.7 Critério de parada no crescimento da árvore

O critério de parada mais elaborado dentre os propostos, que é o uso do

teste F de validação do modelo, juntamente com o teste da redução do Somatório dos

Quadrados dos Erros, medindo a qualidade dos modelos obtidos nas folhas, e a

quantidade mínima de casos, controlando o fim da recursão, se mostrou bem estável nas

bases de dados estudada.

137

Usando nível de confiança para o teste estatístico baixo – tipicamente

0,01, e uma proporção do erro também baixa – usou-se também o valor de 0,01, em

somente uma base de dados foi obtido um resultado pior do que o resultado obtido

quando o método original era utilizado. Esta base de dados foi a servo, e os resultados

podem ser vistos na Tabela 13. É importante notar que, a nível nominal, a diferença não

é tão proeminente.

Tabela 13: testes do critério de parada usando a base servo

Método Corr MAE RMSE RAE RRSE Tempo Regras

%SD OR MinInst 0,9348 0,3119 0,5763 26,9798 36,9476 0,36 9

(F test AND %SSE) OR MinInst 0,9347 0,3128 0,5764 27,058 36,9531 0,53 9

6.4 Testes comparativos – modelo final

Considerando o modelo final definido pelos métodos escolhidos na seção

anterior, tem-se o algoritmo que está sendo chamado de M5.5’. Os gráficos a seguir

mostram uma comparação entre os resultados obtidos pelo M5.5’ e o M5’ usando as

bases de dados utilizadas anteriormente.

Tabela 14: testes comparativos – modelo final

Base Auto-mpg Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' 0,9319 2,0028 2,8324 30,5824 36,1723 2 40 M5' 0,9238 2,0872 2,9912 31,8716 38,2 1,71 9 Base auto-prices Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' 0,7513 2228,1346 4520,2254 48,2053 76,4522 1,15 14 M5' 0,9243 1480,4075 2240,8748 32,0283 37,9007 0,45 7 Base auto-prices with Categorical Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' 0,9523 1303,6836 1800,8849 28,2049 30,459 5,85 1 M5' 0,9328 1432,164 2116,4588 30,9846 35,7964 0,75 1

138

Base auto-prices with Categorical & Missing Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' 0,9483 1740,7834 2571,1781 29,5776 32,1587 9,41 1 M5' 0,9599 1524,3286 2224,9209 25,8998 27,8279 1,04 4 Base cpu Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' 0,9828 10,4089 29,2121 11,8744 18,8753 3,9 6 M5' 0,9766 13,6917 35,3003 15,6194 22,8092 0,39 2 Base housing Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' 0,9083 2,4063 3,8479 36,09 41,7384 4,73 28 M5' 0,9131 2,5053 3,7506 37,5758 40,683 2,58 19

Base pw-linear Sistema Corr MAE RMSE Era RRSE Tempo Regras M5.5' 0,7681 2,2106 2,7779 62,2067 64,2131 1,12 1 M5' 0,933 1,2521 1,5585 35,2361 36,0267 1,09 2 Base servo Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' 0,9689 0,2034 0,3867 17,5912 24,7879 0,59 14 M5' 0,9353 0,3059 0,5745 26,4577 36,8312 0,34 11

A Tabela 14 mostra um resumo comparativo dos dois sistemas. Os

valores sombreados são os que apresentam melhor avaliação. Observe que o sistema

M5.5’ está sendo utilizado considerando apenas a variação da constante de suavização

dos modelos de regressão linear. Nenhum parâmetro que pudesse ajustar o sistema para

a base de dados está sendo utilizado. Ainda assim, o sistema mostra-se competitivo na

maioria das bases de dados utilizadas.

6.5 Testes de escalabilidade

Foram realizados testes do sistema desenvolvido usando bases de dados

de escala relativamente grande. Os testes estão descritos a seguir, segundo a base de

dados utilizada.

139

6.5.1 Base idh

Foi realizado um teste do sistema desenvolvido usando uma base de

dados de escala relativamente grande. Esta base de dados, que é chamada de idh foi

obtida a partir do cruzamento de dados do IPEA (IPEA, 2005) e dados do IBGE (IBGE,

2005). Esta base de dados refere-se a variáveis geográficas e econômicas nacionais,

onde tenta-se explicar o IDH – Índice de Desenvolvimento Humano de alguns

municípios brasileiros. A base possui 5.507 registros e 21atributos (20 variáveis

explicativas mais a variável dependente). Na Tabela 15 estão descritos os atributos da

base.

Tabela 15: descrição dos atributos da base idh

Atributo Significado ESTADO Nome Estado HR Homens residentes PRAU Pessoas residentes - área urbana PR10 Pessoas residentes - 10 anos ou mais de idade PR10A Pessoas residentes - 10 anos ou mais de idade-alfabetizada PR10TA Pessoas residentes - 10 anos ou mais de idade - taxa de alfabetização PR04 Pessoas residentes - 0 a 4 anos de idade PR59 Pessoas residentes- 5 a 9 anos de idade PR1019 Pessoas residentes- 10 a 19 anos de idade PR2029 Pessoas residentes- 20 a 29 anos de idade PR3039 Pessoas residentes- 30 a 39 anos de idade PR4049 Pessoas residentes- 40 a 49 anos de idade PR5059 Pessoas residentes- 50 a 59 anos de idade PR60 Pessoas residentes- 60 anos ou mais de idade DPPRG Domicílios particulares permanentes - forma de abastecimento de água-

rede geral DPPPN Domicílios particulares permanentes - forma de abastecimento de água-

poço ou nascente DPPOF Domicílios particulares permanentes - forma de abastecimento de água-

outras formas DPPBS Domicílios particulares permanentes - com banheiro ou sanitário DPPBSRG Domicílios particulares permanentes - com banheiro ou sanitário-

esgotamento sanitário-rede geral DPPLC Domicílios particulares permanentes - destino de lixo-coletado IDH IDH-M 2000

140

Os resultados podem ser vistos na Tabela 16. Usando os parâmetros

adotados como padrão para o M5.5’, e uma constante de suavização igual a 60, os

resultados são favoráveis, exceto pelo problema do tempo – o sistema não foi otimizado

ainda, e da complexidade, que é um custo a ser pago.

Tabela 16: teste com a base escalada idh

Base Idh Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' 0,9755 0,0146 0,0183 20,2704 21,9747 323,08 8 M5' 0,975 0,0147 0,0186 20,4562 22,2207 92,34 2

6.5.2 Base comp-activ

Esta base foi obtida em Delve (2005), e é uma coleção de medidas de

atividades de sistemas computacionais. Os dados foram coletados a partir de uma

estação Sparc Sun 20/712 com 128 Mbytes de memória rodando em modo multi-

usuário. Os usuários realizam uma grande variedade de tarefas, como acessar a internet,

editar arquivos ou executar programas que exploram bastante a CPU. Os dados foram

coletados continuamente em duas ocasiões distintas. Em ambas, a atividade do sistema

foi verificada a cada 5 segundos. A base inclui quantidades iguais de observações de

cada ocasião, em uma ordem aleatória. A base originalmente possui 8.192 registros e 27

atributos, dos quais um é a variável dependente, sendo todos numéricos. Um dos

registros foi removido, pois era a indicação de momento em que foi feita a medida e

apresentava-se praticamente como um identificador do registro (6% dos registros

apresentavam valores repetidos para este atributo, pois este não era composto pelo dia

em que a observação foi feita). A descrição dos 26 atributos utilizados está disponível

na Tabela 17, e foi obtida a partir dos arquivos disponibilizados no site.Todos os

primeiros 25 atributos descritos foram utilizados para modelar o último.

141

Tabela 17: atributos da base comp-activ

Nome do atributo Descrição

lread Reads (transfers per second ) between system memory and user memory lwrite writes (transfers per second) between system memory and user memory scall Number of system calls of all types per second sread Number of system read calls per second swrite Number of system write calls per second fork Number of system fork calls per second exec Number of system exec calls per second rchar Number of characters transferred per second by system read calls wchar Number of characters transfreed per second by system write calls pgout Number of page out requests per second ppgout Number of pages, paged out per second pgfree Number of pages per second placed on the free list. pgscan Number of pages checked if they can be freed per second

atch Number of page attaches (satisfying a page fault by reclaiming a page in memory) per second

pgin Number of page-in requests per second ppgin Number of pages paged in per second pflt Number of page faults caused by protection errors (copy-on-writes). vflt Number of page faults caused by address translation runqsz Process run queue size runocc % time that that run queue is occupied freemem Number of memory pages available to user processes freeswap Number of disk blocks available for page swapping. Usr Portion of time (%) that cpus run in user mode Sys Portion of time (%) that cpus run in system mode Wio Portion of time (%) that cpus are idle waiting for block IO Idle Portion of time (%) that cpus are otherwise idle

Os resultados dos experimentos realizados com esta base de dados

podem ser vistos na Tabela 18. Quando o sistema M5.5’ foi executado usando os

parâmetros fixados, ele já mostrou uma grande superioridade, valendo um destaque para

o tempo, critério que o sistema não costuma se destacar, e complexidade: apenas uma

regra (não houve árvore, propriamente, apenas uma regressão). Em função desta

complexidade tão reduzida, o sistema voltou a ser executado com uma modificação no

conjunto de parâmetros. Usou-se a função de Impureza baseada na variância ao invés da

razão entre a variância e a média.

142

Tabela 18: testes com a base escalada comp-activ

Base Comp-activ Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' op.1 0.6762 0.0491 0.1627 63.3388 73.7428 21.39 1 M5.5' op.2 0.7081 0.0414 0.1559 53.4986 70.6832 54.7 76 M5' 0.4902 0.0562 0.1977 72.5469 89.6057 34.02 128

6.5.3 Base abalone

Esta base está originalmente disponível em UCI (2005), mas foi obtida

em Delve (2005). Possui 4.177 registros e 9 atributos, sendo apenas um categórico (3

níveis), descritos na Tabela 19. Abalones são moluscos, membros de uma grande classe

biológica, e possuem conchas feitas com apenas uma peça. A base em questão relaciona

a idade de indivíduos desta espécie usando medidas físicas. A idade é normalmente

determinada cortando a concha e contando o número de anéis percebidos usando um

microscópio.

Tabela 19: atributos da base abalone

Nome do Atributo Descrição Sex Gender or Infant(I) Length Longest shell measurement(mm) Diameter perpendicular to length (mm) Height with meat in shell (mm) whole_weight whole abalone (gr) shucked_weight weight of meat (gr) viscera_weight gut weight (after bleeding) (gr) shell_weight after being dried (gr) rings +1.5 gives the age in years

Os resultados obtidos com esta base de dados podem ser vistos na Tabela

20. Foram utilizadas ao todo quatro opções diferentes nos parâmetros do sistema M5.5’

por que a complexidade inicialmente obtida foi muito alta. A opção 1 é utilizando os

melhores valores para os parâmetros, conforme descrito na seção anterior. A opção 2

fez uso da variância como função de cálculo da Impureza. A opção 3 fez uso do critério

de parada do crescimento da árvore baseada no Desvio Padrão da variável de resposta.

A opção 4 utilizou o fator de Poda usado originalmente no sistema M5’.

143

De maneira geral, para esta base, o sistema M5.5’ conseguiu ser mais

preciso, mas o custo, em termos de quantidade das regras, foi muito alto.

Tabela 20: testes com a base escalada abalone

Base abalone Sistema Corr MAE RMSE RAE RRSE Tempo Regras M5.5' op.1 0.7503 1.4995 2.1322 63.4663 66.1287 40.88 415 M5.5' op.2 0.7521 1.5024 2.1253 63.5888 65.9125 26.77 372 M5.5' op.3 0.7522 1.5022 2.125 63.5821 65.9052 17.27 307 M5.5' op.4 0.7433 1.5356 2.1573 64.9955 66.9071 15.38 20 M5' 0.7511 1.5062 2.1296 63.7521 66.0486 16.68 12

144

7 Conclusão

A leitura de um algoritmo algumas vezes aponta que algumas

modificações nas heurísticas empregadas podem ser empregadas. Algumas vezes estas

modificações não são profundas e não são traduzidas em termos de ganhos de qualidade

no produto final – o algoritmo modificado. Entretanto, quando as modificações se fazem

notar, o resultado pode ser chamado de um novo algoritmo. Este é o processo de

melhoria contínua da tecnologia – no caso de software. Este processo está diretamente

ligado ao avanço da ciência rumo ao ainda não alcançado, que é, em última análise, a

razão de sua existência.

No caso da Ciência da Computação, existe um fator agravante para o seu

desenvolvimento, que são as inovações tecnológicas. O crescimento da capacidade

computacional e da velocidade de processamento faz com que diversas limitações sejam

vencidas, o que gera um processo de obsolescência das diversas heurísticas e

metodologias. Diante disto, é inevitável que os algoritmos sejam revistos.

A proposta que foi feita aqui para o novo algoritmo de indução de

modelos se encaixa neste perfil. Analisando historicamente, desde o CART até o M5.5’,

uma série de desenvolvimentos contínuos foram feitos, adequando o antigo sistema às

tecnologias emergentes. De maneira geral, estes sistemas apresentam maior poder de

tratamento de casos extremos, como atributos categóricos, base escaladas, valores

faltantes, entre outros. E trazendo sempre vantagens qualitativas, segundo mais

importantes critérios de comparação de modelos.

A aproximação da técnica de indução de modelos de previsão com as

teorias estatísticas traz diversas vantagens. Além da padronização obtida ao usar

145

heurísticas bem conhecidas na comunidade científica, uma outra importante vantagem

foi o ganho de precisão observado nas bases de dados estudadas.

Por outro lado, a existência do M5.5’ como um outro sistema de indução

de modelos de previsão, além do CART, M5 e M5’ dentre outros, têm também a

importante função de popularizar técnicas de previsão. Importante ressaltar também que

a popularização da suíte Weka também traz benefícios para o desenvolvimento das

técnicas de Data Mining, pois a suíte é bastante estável e robusta, o que, juntamente

com a sua acessibilidade torna-a uma excelente ferramenta.

Analisando individualmente, as alterações que foram propostas

apresentaram ganhos comparativos nos casos analisados:

• Pré-seleção de atributos: os dois critérios de pré-seleção de atributos propostos

apresentaram bons níveis de qualidade. O uso de todos os atributos da base é

abusivo, mas os modelos de regressão são simplificados depois de serem estimados,

de maneira que atributos não significativos serão removidos. Assim, se a quantidade

de atributos não tornar esta possibilidade proibitiva, esta heurística não se traduzirá

em termos de complexidade inaceitável. Alternativamente, o critério que considera

apenas os atributos utilizados em testes acima ou abaixo do nó que se está avaliando

ampliou o critério antigo, fornecendo mais recursos para aumentar a precisão do

modelo final, e pode ser utilizado quando a quantidade de atributos for muito

grande;

• Critério de Parada: o crescimento da árvore em função da dispersão da variável

dependente é bastante grosseiro. Como o intuito do crescimento da árvore é obter

subconjuntos que possam ser bem modelados por regressões lineares, não é bastante

verificar se a variável dependente tem dispersão menor. É importante avaliar a

quantidade dos modelos que estão sendo obtidos para verificar se a divisão

146

(crescimento da árvore) pode parar. Ainda que os critérios desenhados não estejam

absolutamente prontos, foi dado um passo neste sentido. Talvez uma nova

investigação deva ser feita para melhorar estes critérios;

• Eliminação de Atributos Colineares: como pode ser visto nos resultados, esta

funcionalidade além de aumentar o tempo gasto pelo sistema, não apresentava

vantagem para a precisão. A sua remoção do algoritmo só trouxe ganhos para o

sistema final;

• Cálculo da Função de SDR: as técnicas relativas ao uso da nova função de SDR,

incluindo a crítica ao uso da medida de off-set, trouxeram também vantagens para o

sistema final. A função de SDR é o núcleo principal para o desenvolvimento da

árvore;

• Fator de Poda: o uso do novo fator multiplicativo para a função de erro dos

modelos de regressão que é utilizada na poda trouxe duas vantagens. Primeiro o

aumento da precisão, mesmo que em detrimento ao aumento da complexidade. E em

segundo lugar, a padronização deste fator com o fator utilizado para as estatísticas

de comparação de modelos de regressão facilita comparações do algoritmo

desenhado com os algoritmos de seleção de modelos de regressão baseados no

Método dos Mínimos Quadrados;

• Constante de Suavização: tornar a constante de suavização dos modelos de

regressão instalados na árvore auto-ajustáveis à base de dados que está sendo

utilizada para o treinamento trouxe ao M5.5’ a vantagem da adaptação, fundamental

para os sistemas inteligentes.

147

7.1 Trabalhos futuros

O desenvolvimento de um trabalho como este é apenas o início de uma

jornada. Se não fosse a escassez de tempo, e as limitações de escopo, este trabalho não

se encerraria por aqui. Existem ainda diversas atividades que devem ser realizadas,

sempre na direção da melhoria contínua da pesquisa realizada.

A implementação que foi feita tinha apenas o intuito de experimentar as

heurísticas que foram desenhadas durante o estudo dos algoritmos CART, M5 e M5’.

Não foi intenção desenvolver um software que pudesse ser disponibilizado para a

comunidade, mesmo que acadêmica. Uma revisão de todo o código seria necessária para

que o sistema pudesse ser disponibilizado. Esta revisão teria que considerar:

• Preceitos da Engenharia de Software e da Orientação a Objetos, de maneira que o

reuso das classes e pacotes internos da suíte Weka fosse realizado corretamente;

• Reescrever a classe LinearRegression, não só dentro dos moldes da Engenharia de

Software, mas revendo a estrutura de dados – objeto, que está atualmente desenhada

para atender a dois sistemas diferentes: o M5’ e a própria LinearRegression, que é

um modelo de previsão independente.

Ainda sobre a implementação, uma tarefa que pode vir a ser

desenvolvida é a implementação do sistema de regras, que é alternativo à árvore. Como

já está desenvolvida para o M5’ a classe M5Rules, a proposta é desenhar a classe

M5_5Rules, que implementaria esta funcionalidade extra para o sistema M5.5’.

Finalmente, um problema importante a ser considerado é a existência de

dados viesados, ou seja, dados que apresentem uma distribuição da variável de resposta

desigual. O problema de dados viesados tem preocupado a comunidade de Machine

Learning, como pode ser visto em Espíndola (2004) e Chawla, Japkowicz & Kolcz

148

(2004). Diversas técnicas são propostas para tratar os dados viesados quando a variável

de resposta é discreta – problemas de classificação. Mas para problemas de previsão

este problema também merece atenção. Não será possível fazer uso da mesma técnica,

que são as matrizes de confusão e as medidas de desempenho que são calculadas a partir

dela, pois estas servem apenas ao ambiente discreto. Talvez medidas com o mesmo

significado possam ser obtidas considerando o problema da modelagem contínua.

149

Referências Bibliográficas

Aha, David W. Editorial. In Artificial Intelligence Review, 11(1-5), pp. 1-6. Special Issue on Lazy Learning, 1997.

Atanasova, N. & Kompare, B. Modeling of waste water treatment plant with regression trees. In Zanasi, A., Brebbia, C. A., Ebecken, N. F. F. & Melli, P. Data Mining III. WIT Press: Southamptom,2002.

Banks, Jerry et al. Discrete-Event System Simulation. 3 ed. Nova Jersey, EUA: Prentice Hall, 2000. 594 p.

Bárdossy, András & Duckstein, Lucien. Fuzzy Rule-Based Modeling with Applications to Geophysical, Biological and Engineering Systems. CRC Press, 1995. 232 p.

Berry, Michael J. A.; Linoff, Gordon. Data Mining Techniques. Nova York, EUA: John Wiley & Sons, 1997. 454p.

Berson, Alex, Smith, Stephen & Thearling, Kurt. Building data mining applications for CRM. McGraw-Hill, 1999.

Berson, Alex; Smith, Stephen; Thearling, Kurt. Building Data Mining Applications for CRM. Nova York, EUA: McGraw-Hill, 1999.510 p.

Breiman, L. et al. Classification and Regression Trees. Boca Raton, Florida, EUA: Chapman & Hall/CRC, 1984. 358 p.

CART. Cart Decision Tree Software for Data Mining Web Mining and Business. Disponível em: < http://www.salford-systems.com/products-cart.html>. Acesso em: 7 mai. 2003.

CART. CART Walkabout. Disponível em: <http://www.salfordsystems.com/walkabout/cart1.html>. Acesso em: 20 nov. 2003(b).

CART. Customer Success Stories. Disponível em <http://www.salford-systems.com/1116.php>. Acessado em 17 de março de 2005.

Chawla, Nitesh, Japkowicz, Nathalie & Kolcz, Aleksander. Editorial: Special issue on Learning from Imbalanced Datasets. SIGKDD Explorations, Volume 6, Issue 1, 2004.

Chen, Fei, Figlewski, Stephen, Weigend, Andreas S. & Waterhouse, Steven R. Modeling financial data using clustering and tree-based approaches. Data Mining. WIT Press: Southampton, UK, 1998.

Clementine. Clementine—Data mining, Predictive models. Disponível em: <http://www.spss.com/spssbi/clementine/index.htm>. Acesso em 15 nov. 2003.

150

Coelho, Paulo Sérgio de Souza, Esperança, Cláudio & Oliveira, Antonio Alberto Fernandes. Enhancing the Bayesian Network Approach to Face Detection. Proceedings of XIX International Conference of the Chilean Computer Science Society, IEE Computer Society, Talca- Chile, 1999.

Coelho, Paulo Sérgio de Souza. Um Sistema de Reconhecimento de Faces Humanas Usando Processamento de Imagens e Redes Bayesianas. Tese de Mestrado, COPPE – UFRJ, Rio de Janeiro, 2000.

Coelho, Paulo Sérgio de Souza; Ebecken, Nelson. A comparison of some classification techniques. In Zanasi, A., Brebbia, C. A., Ebecken, N. F. F. & Melli, P. Data Mining III. Southamptom, Inglaterra: WIT Press, 2002.

Coelho, Paulo Sérgio de Souza; Ebecken, Nelson. A comparison of some classification techniques. In Zanasi, Alessandro et al Data Mining III. Southamptom, Inglaterra: WIT Press, 2002.

Cyrnel Research Group. Zeus System Methodology Guide. Relatório Técnico. Rio de Janeiro, 2003.

Date, C. J. An Introduction to Database Systems. 7. ed. Addison Wesley, 1999. 960 p.

Delve. Data for Evaluating Learning in Valid Experiments. Disponível em: <http://www.cs.toronto.edu/~delve/>. Acesso em: 30 mar. 2005.

Draper, N. R. & Smith Jr., H. Apllied Regression Analysis. 3a Edição. Nova Iorque, EUA: John Wiley & Sons, 1998. 706 p.

Ebecken, Nelson F. F. Data Mining. WIT Press: Southampton, UK, 1998.

Efron, Bradley; Tibshirani, Robert. Cross-Validation and the Bootstrap: Estimating the Error Rate of a Prediction Rule. Technical Report (TR-477), Dept. of Statistics, Stanford University, 1995.

Espíndola, Rogério Pinto. Sistema Inteligente para Classificação de Dados. Tese de D.Sc., COPPE/UFRJ, Rio de Janeiro, 2004.

Evsukoff, Alexandre, Branco, Antonio C. S. & Galichet, Sylvie. Structure identification ans parameter optimization for non-linear fuzzy modeling. Fuzzy Sets and Systems v. 132-2. 2002. pp. 173-188.

GNU. GNU General Public License - GNU Project - Free Software Foundation (FSF) <http://www.gnu.org/copyleft/gpl.html>. Acessado em: 21 de março de 2005.

Graphviz. Graphviz. Disponível em: <http://www.research.att.com/sw/tools/graphviz/>. Acesso em: 20 dez. 2003.

Habermas, Jurgen. Racionalidade e Comunicação. Editora Edições 70, 2002.

Hair, Joseph F., Tatham, Ronald L., Anderson, Rolph E. & Black, William. Multivariate Data Analysis. 6a edição. Prentice Hall, 2003.

151

Han, Jiawei; Kamber, Micheline. Data Mining concepts and Techniques. San Francisco: Morgan Kaufmann, 2001. 550 p.

Haugen, Robert A.; Baker, Nardin L. Commonality in the Determinants of Expected Returns. Disponível em <http://www.newfinance.com/research/common/commonal.html>. Acesso em: 29 abr. 2003.

Haykin, Simon S. Redes Neurais: princípios e prática. 2 ed. São Paulo: Bookman, 2000. 900 p.

Holmes, Geoffrey, Hall, Mark & Frank, Eibe. Generating Rule Sets from Model Trees. Proceedings of the Twelfth Australian Joint Conference on Artificial Intelligence, Sydney, Australia. Springer-Verlag, pp. 1-12. 1999.

IBGE. Instituto Brasileiro de Geografia e Estatística. Disponível em: <http://www.ibge.gov.br/>. Acessado em: 30 de março de 2005.

IPEA. Instituto de Pesquisa Economica Aplicada. Disponível em: <http://www.ipeadata.gov.br/>. Acessado em: 30 de março de 2005.

Karalic, Aram & Cestnik, Bojan. The Bayesian Approach to Tree-Structured Regression. Proceedings of ITI’91 (Information Technology Interfaces). 155-160, 1991.

Karalic, Aram. Employing linear regression in regression tree leaves. Technical Report IJS DP-6450, Jozef Stefan Institute, Ljubljana, Slovenia, 1992.

Kdnuggets. Stock Analysis and Prediction Solutions. Disponível em <http://www.kdnuggets.com/solutions/stock.html>. Acessado em: 16 de março de 2005.

Kennedy, Ryby L. et al. Solving Data Mining Problems through Pattern Recognition. Nova Jersey, EUA: Prentice Hall, 1998.

Lachtermacher, G., Cunha, A. G. G., Coelho, P. S. S. The use of neural networks in prediction of arterial hypertension in adults. In Zanasi, A., Brebbia, C. A., Ebecken, N. F. F. & Melli, P. Data Mining III. WIT Press: Southamptom,2002.

Lachtermacher, Gerson. Backpropagation in Time Series Analysis. Tese (PhD in Management Sciences) University of Waterloo, Waterloo, Ontario, Canada, 1993.

Lachtermacher, Gerson. Sistema de Previsão de Séries Temporais Utilizando Redes Neurais. Pesquisa Operacional, 2 vol. 12 15-44, 1992.

McCulloch, W. S. e Pitts, W. A logical calculus of the ideias immanent in nervous activity. Bulletin of Mathematical Biophysics, vol. 5, pp. 115-133, 1943.

Melo, B. de, Nascimento Júnior, C. L. & Milioni, A. Z. Daily sugar price forecasting using the Mixture of Local Expert Models. Data Mining V, data mining, text mining and their business applications. WIT Press: Southampton, UK, 2004.

Mendenhall, William & Sincich, Terry. A Second Course in Statistics: regression analysis. 5a edição. Prentice Hall: New Jersey, 1996.

152

Motulsky, Harvey & Christopoulos, Arthur. Fitting Models to Biological Data using Linear and Nonlinear Regression: a practical guide to curve fitting. GraphPad Software Inc., San Diego, CA, www.graphpad.com. 2003.

Neter, J. et al. Applied Linear Statistical Models. 4 ed. Chicago: Irwin, 1996.

Pearl, Judea. Probabilistic Reasoning in Inteligent Systems: networks of plausible inference. São Francisco, Califórnia, EUA: Morgan Kaufmann Publishers, Inc., 1998.

Pugliesi, J. B. & Rezende, S. O. Precision and comprehensibility in the integration of regression rules. In Ebecken, Nelson F. F., Brebbia, C. A. & Zanasi, A. Data Mining IV. WIT Press: Southamptom, UK, 2004.

Pyle, Dorian. Data Preparation for Data Mining. Science & Technology Books, 1999. 504pp.

Quinlan, John Ross. C4.5: programs for machine learning. San Mateo, California, EUA: Morgan Kaufmann Publishers, 1993.

Quinlan, John Ross. Home Page Pessoal. Disponível em: <http://www.cse.unsw.edu.au/~quinlan/>. Acesso em: 10 abr. 2001.

Quinlan, John Ross. Induction of Decision Trees. Machine Learning, 1:81-106, 1986.

Quinlan, John Ross. Learning With Continuous Classes. In Proceedings AI'92 (Adams Sterling, Eds), 343-348, Singapore: World Scientific, 1992.

Rezende, S. O. , Rocha, C. A. J. & Lôbo, R. B. Bayesian networks for knowledge discovery in a database from a program for genetic improvement of the Nelore breed. In Ebecken, Nelson F. F. & Brebbia, C. A. Data Mining II. WIT Press: Southamptom, UK, 2000.

Robnik-Sikonja, Marko & Kononenko, Igor. An adaptation of Relief for attribute estimation in regression. In Fisher, D., editor, Machine Learning: Proceedings of the Fourteenth International Conference (ICML’97), 296-304. Morgan Kaufmann Publishers, 1997.

Robnik-Sikonja, Marko & Kononenko, Igor. Pruning regression trees with MDL. European Conference on Artificial Intelligence, 455-459, 1998.

Robnik-Sikonja, Marko. CORE – a system that predicts continuous variables. Proceedings of Electrotechnical and Computer Science Conferenc3e. 145-148. Partoroz, Slovenia, 1997.

RT - a regression tree induction system, (c) Luís Torgo. A brief summary. Disponível em <http://www.liacc.up.pt/~ltorgo/RT/>. Acesso em: 15 mar. 2005.

Serra, A. P. G. & Martucci Júnior, M. The application of CRM in call centers. In Ebecken, Nelson F. F., Brebbia, C. A. & Zanasi, A. Data Mining IV. WIT Press: Southamptom, UK, 2004.

Silicon Graphics. Welcome to SGI. Disponível em: < http://www.sgi.com/>. Acesso em: 15 nov 2003.

SPSS Inc. SPPS Base 9.0 Application Guide. Prentice Hall, 1999. 412p.

153

Szwarcfiter, Jayme Luiz & Markenzon, Lilian. Estrutura de Dados e seus Algoritmos. 2a Edição. Rio de Janeiro: LTC Editora, 1994.

Torgo, Luís Fernando Raínho Alves. Inductive Learning of Tree-based Regression Models. Tese (doutorado em Ciência dos Computadores), Faculdade de Ciências – Universidade do Porto. Porto, Portugal, 1999.

Torgo, Luís Fernando Raínho Alves. Computationally Efficient Linear Regression Trees. Proceed. of IFCS 2002, 2002.

UCI. UCI Machine Learning Repository. Disponível em: <http://www.ics.uci.edu/~mlearn/MLRepository.html>. Acesso em 24 de março de 2005.

Wang, Yong and Witten, Ian H. Inducing Model Trees for Continuous Classes. Proc of Poster Papers, 9 th European Conference on Machine Learning, Prague, Czech, 1997.

Weiss, Sholom M.; Indurkhya, Nitin. Predictive Data Mining: a pratical guide. São Francisco, CA: Morgan Kaufmann Publishers, 1998.228 p.

Wekalist. [Wekalist] Interpret M5 model tree output. Dispnível em: <https://list.scms.waikato.ac.nz/mailman/htdig/wekalist/2003-July/001609.html>. Acesso em: 21 dez. 2003.

Weka Machine Learning Project. Disponível em: <http://www.cs.waikato.ac.nz/~ml>. Acesso em: 10 abr. 2001.

Weka Software. Weka 3 - Data Mining with Open Source Machine Learning Software in Java. Disponível em: < http://www.cs.waikato.ac.nz/~ml/weka/index.html >. Acesso em: 10 abr. 2001.

Witten, Ian H. & Frank, Eibe. Data Mining: Practical machine learning tools with Java implementations. Morgan Kaufmann: San Francisco, 2000.

154

Apêndice I

Listagem da saída do sistema Weka para o problema discutido no

Capítulo 4 (veja Seção 4.4.1).

Financas <= -0.00116 : | Financas <= -0.016 : | | MetalMin <= -0.00277 : | | | BlueChip <= 0.00401 : | | | | Value <= 7.26e-4 : LM1 (15/44.6%) | | | | Value > 7.26e-4 : | | | | | PapelCelul <= -0.0202 : LM2 (3/19.4%) | | | | | PapelCelul > -0.0202 : LM3 (5/30.9%) | | | BlueChip > 0.00401 : LM4 (6/60.1%) | | MetalMin > -0.00277 : | | | Siderurgia <= -0.0196 : | | | | AlimFumo <= -0.01 : LM5 (5/22.3%) | | | | AlimFumo > -0.01 : LM6 (2/7.85%) | | | Siderurgia > -0.0196 : LM7 (9/52.5%) | Financas > -0.016 : LM8 (113/55.2%) Financas > -0.00116 : | Financas <= 0.0187 : | | TelecomFixa <= -0.00175 : | | | PetroQuimica <= -0.00143 : LM9 (13/48%) | | | PetroQuimica > -0.00143 : | | | | Momentum <= 0.00291 : | | | | | AgricPecuaria <= 0.00845 : LM10 (3/20.1%) | | | | | AgricPecuaria > 0.00845 : LM11 (2/12%) | | | | Momentum > 0.00291 : | | | | | AlimFumo <= -0.00914 : LM12 (4/21.1%) | | | | | AlimFumo > -0.00914 : | | | | | | TelecomFixa <= -0.00604 : | | | | | | | Value <= -6.98e-4 : LM13 (3/9.93%) | | | | | | | Value > -6.98e-4 : LM14 (3/11.7%) | | | | | | TelecomFixa > -0.00604 : LM15 (4/10.7%) | | TelecomFixa > -0.00175 : | | | MetalMin <= -0.00563 : | | | | Energia <= 0.00882 : LM16 (13/38%) | | | | Energia > 0.00882 : LM17 (6/44.5%) | | | MetalMin > -0.00563 : | | | | BlueChip <= -4.28e-4 : | | | | | Textil <= 0.00946 : | | | | | | TelecomFixa <= 0.0029 : | | | | | | | TelecomFixa <= 4.26e-4 : LM18 (3/6.81%) | | | | | | | TelecomFixa > 4.26e-4 : LM19 (2/4.92%) | | | | | | TelecomFixa > 0.0029 : | | | | | | | PetroQuimica <= 0.0149 : | | | | | | | | Holding <= 0.00276 : LM20 (4/14.1%) | | | | | | | | Holding > 0.00276 : | | | | | | | | | Comercio <= -0.00775 : LM21 (3/2.88%) | | | | | | | | | Comercio > -0.00775 : LM22 (2/4.37%) | | | | | | | PetroQuimica > 0.0149 : LM23 (3/9.68%) | | | | | Textil > 0.00946 : | | | | | | Transportes <= 0.016 : LM24 (4/14.9%) | | | | | | Transportes > 0.016 : | | | | | | | Siderurgia <= 0.0136 : LM25 (2/1.38%) | | | | | | | Siderurgia > 0.0136 : | | | | | | | | AutoMec <= 0.0116 : LM26 (2/2.15%) | | | | | | | | AutoMec > 0.0116 : LM27 (3/5.64%)

155

| | | | BlueChip > -4.28e-4 : | | | | | BlueChip <= 0.00699 : | | | | | | Energia <= 0.0169 : | | | | | | | PetroQuimica <= -0.00314 : LM28 (4/18.4%) | | | | | | | PetroQuimica > -0.00314 : | | | | | | | | Construcao <= 0.0256 : LM29 (11/32.3%) | | | | | | | | Construcao > 0.0256 : LM30 (4/24.6%) | | | | | | Energia > 0.0169 : LM31 (6/15.4%) | | | | | BlueChip > 0.00699 : LM32 (7/10.2%) | Financas > 0.0187 : | | BlueChip <= -0.0101 : LM33 (7/89.5%) | | BlueChip > -0.0101 : | | | AutoMec <= 0.0064 : LM34 (6/66.1%) | | | AutoMec > 0.0064 : LM35 (18/59.9%) Models at the leaves: Smoothed (complex): LM1: Volatility = -0.00465 + 0.0472TelecomFixa + 0.0179AgricPecuaria + 0.0196AlimFumo + 0.058AutoMec + 0.00389Financas - 0.00268Comercio + 0.0184Construcao + 0.0206Holding + 0.0548MetalMin + 0.00193Metalurgia - 0.0102Outros - 0.0316PapelCelul + 0.0152PetroQuimica - 0.0495Siderurgia - 0.175Size + 0.164Dollar - 0.108Value LM2: Volatility = -0.00492 + 0.0472TelecomFixa + 0.0179AgricPecuaria + 0.0196AlimFumo + 0.058AutoMec - 0.00159Financas - 0.00268Comercio + 0.0184Construcao + 0.0206Holding + 0.0548MetalMin + 0.00193Metalurgia - 0.0102Outros - 0.0316PapelCelul + 0.0152PetroQuimica - 0.0495Siderurgia - 0.175Size + 0.164Dollar - 0.108Value LM3: Volatility = -0.00526 + 0.0361TelecomFixa + 0.0179AgricPecuaria + 0.0196AlimFumo + 0.058AutoMec - 0.00159Financas - 0.00268Comercio + 0.0184Construcao + 0.0206Holding + 0.0548MetalMin + 0.00193Metalurgia - 0.0102Outros - 0.0316PapelCelul + 0.0152PetroQuimica - 0.0495Siderurgia - 0.175Size + 0.164Dollar - 0.108Value LM4: Volatility = -0.0053 + 0.0472TelecomFixa + 0.0179AgricPecuaria + 0.0196AlimFumo + 0.058AutoMec + 0.0219Financas - 0.00268Comercio + 0.0184Construcao + 0.0206Holding + 0.0548MetalMin + 0.00193Metalurgia - 0.0102Outros - 0.0316PapelCelul + 0.0152PetroQuimica - 0.0495Siderurgia - 0.175Size + 0.164Dollar - 0.195Value LM5: Volatility = -0.00201 + 0.0595TelecomFixa + 0.0242AgricPecuaria + 0.0278AlimFumo + 0.0693AutoMec + 0.0219Financas - 0.00268Comercio + 0.0184Construcao - 0.00415Eletronicos + 0.0206Holding + 0.0687MetalMin + 0.00193Metalurgia - 0.0149Outros - 0.0458PapelCelul + 0.0152PetroQuimica + 0.0272Siderurgia - 0.175Size + 0.169Momentum + 0.164Dollar LM6: Volatility = -0.00183 + 0.0595TelecomFixa + 0.0242AgricPecuaria + 0.0278AlimFumo + 0.0693AutoMec + 0.0219Financas - 0.00268Comercio + 0.0184Construcao + 0.0206Holding + 0.0687MetalMin + 0.00193Metalurgia - 0.0149Outros - 0.0458PapelCelul + 0.0152PetroQuimica + 0.0272Siderurgia - 0.175Size + 0.169Momentum + 0.164Dollar LM7: Volatility = -0.00104 + 0.0595TelecomFixa + 0.0242AgricPecuaria + 0.0278AlimFumo + 0.0693AutoMec + 0.0219Financas - 0.0271Comercio + 0.0184Construcao + 0.0206Holding + 0.0687MetalMin + 0.00193Metalurgia - 0.0235Outros - 0.0458PapelCelul + 0.0152PetroQuimica + 0.0201Siderurgia - 0.175Size + 0.154Momentum + 0.164Dollar

156

LM8: Volatility = -5.94e-4 + 0.0109TelecomFixa + 0.00277AgricPecuaria + 0.0186AutoMec + 0.0142Financas - 0.00268Comercio + 0.0496Construcao + 0.058Holding + 0.0431MetalMin + 0.00193Metalurgia + 0.0225Outros + 0.00208PapelCelul + 0.0657PetroQuimica - 0.0169Siderurgia - 0.508Size + 0.498Dollar + 0.0526BlueChip LM9: Volatility = 0.00128 + 0.0471TelecomFixa + 0.00907AgricPecuaria + 0.042AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0233MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0617PetroQuimica - 0.089Siderurgia + 0.0391Textil - 0.0027Transportes - 0.137Size - 0.174Momentum + 0.23Dollar + 0.0152Value LM10: Volatility = 0.00323 + 0.0471TelecomFixa + 0.0178AgricPecuaria + 0.042AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0233MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0557PetroQuimica - 0.0807Siderurgia + 0.0168Textil - 0.0027Transportes - 0.137Size - 0.299Momentum + 0.23Dollar + 0.0152Value LM11: Volatility = 0.00328 + 0.0471TelecomFixa + 0.0183AgricPecuaria + 0.042AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0233MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0557PetroQuimica - 0.0807Siderurgia + 0.0168Textil - 0.0027Transportes - 0.137Size - 0.299Momentum + 0.23Dollar + 0.0152Value LM12: Volatility = 0.00247 + 0.0603TelecomFixa + 0.0266AgricPecuaria - 0.0214AlimFumo + 0.042AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0233MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0557PetroQuimica - 0.0807Siderurgia + 0.0168Textil - 0.0027Transportes - 0.137Size - 0.253Momentum + 0.23Dollar + 0.0152Value LM13: Volatility = 0.00208 + 0.0471TelecomFixa + 0.0224AgricPecuaria - 0.0163AlimFumo + 0.042AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0233MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0557PetroQuimica - 0.0807Siderurgia + 0.0168Textil - 0.0027Transportes - 0.137Size - 0.253Momentum + 0.23Dollar + 0.0152Value LM14: Volatility = 0.00208 + 0.0471TelecomFixa + 0.0224AgricPecuaria - 0.0163AlimFumo + 0.042AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0233MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0557PetroQuimica - 0.0807Siderurgia + 0.0168Textil - 0.0027Transportes - 0.137Size - 0.253Momentum + 0.23Dollar + 0.0152Value LM15: Volatility = 0.00203 + 0.0471TelecomFixa + 0.0294AgricPecuaria - 0.0163AlimFumo + 0.042AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0233MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0557PetroQuimica - 0.0807Siderurgia + 0.0168Textil - 0.0027Transportes - 0.137Size - 0.253Momentum + 0.23Dollar + 0.0152Value LM16: Volatility = 0.00159 - 0.0136TelecomCel + 0.0562TelecomFixa + 0.00907AgricPecuaria + 0.0597AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.0159Energia + 0.00304Holding + 0.0314MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0496Siderurgia - 0.00419Textil - 0.0027Transportes - 0.137Size - 0.0206Momentum + 0.26Dollar + 0.0152Value

157

LM17: Volatility = 0.00195 - 0.0136TelecomCel + 0.0562TelecomFixa + 0.00907AgricPecuaria + 0.0597AutoMec + 0.00819Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.0212Energia + 0.00304Holding + 0.0314MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0496Siderurgia - 0.00419Textil - 0.0027Transportes - 0.137Size - 0.0206Momentum + 0.26Dollar + 0.0152Value LM18: Volatility = 0.00232 - 0.0256TelecomCel - 0.00515TelecomFixa + 0.0173AgricPecuaria + 0.0737AutoMec + 0.0411Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.0216Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0527Siderurgia - 0.0153Textil - 0.0108Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM19: Volatility = 0.00229 - 0.0256TelecomCel - 0.00942TelecomFixa + 0.0173AgricPecuaria + 0.0737AutoMec + 0.0411Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.0216Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0527Siderurgia - 0.0153Textil - 0.0108Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM20: Volatility = 0.00263 - 0.0256TelecomCel + 0.0606TelecomFixa + 0.0173AgricPecuaria + 0.0737AutoMec + 0.0411Financas + 4.3e-4Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.0228Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0527Siderurgia - 0.0153Textil - 0.0108Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM21: Volatility = 0.00266 - 0.0256TelecomCel + 0.0606TelecomFixa + 0.0173AgricPecuaria + 0.0737AutoMec + 0.0411Financas + 9.37e-4Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.0238Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0527Siderurgia - 0.0153Textil - 0.0108Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM22: Volatility = 0.00266 - 0.0256TelecomCel + 0.0606TelecomFixa + 0.0173AgricPecuaria + 0.0737AutoMec + 0.0411Financas + 9.66e-4Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.0238Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0527Siderurgia - 0.0153Textil - 0.0108Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM23: Volatility = 0.00272 - 0.0256TelecomCel + 0.0606TelecomFixa + 0.0173AgricPecuaria + 0.0737AutoMec + 0.0411Financas + 0.00156Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.0241Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0527Siderurgia - 0.0153Textil - 0.0108Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM24: Volatility = 0.00249 - 0.03TelecomCel + 0.0412TelecomFixa + 0.0173AgricPecuaria + 0.0778AutoMec + 0.0411Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0527Siderurgia - 0.0178Textil - 0.014Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip

158

LM25: Volatility = 0.00248 - 0.03TelecomCel + 0.0412TelecomFixa + 0.0173AgricPecuaria + 0.0778AutoMec + 0.0411Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0563Siderurgia - 0.0178Textil - 0.0136Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM26: Volatility = 0.00248 - 0.03TelecomCel + 0.0412TelecomFixa + 0.0173AgricPecuaria + 0.0763AutoMec + 0.0411Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0558Siderurgia - 0.0178Textil - 0.0136Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM27: Volatility = 0.00248 - 0.03TelecomCel + 0.0412TelecomFixa + 0.0173AgricPecuaria + 0.0763AutoMec + 0.0411Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0558Siderurgia - 0.0178Textil - 0.0136Transportes - 0.137Size - 0.0206Momentum + 0.28Dollar + 0.0152Value + 0.0256BlueChip LM28: Volatility = 0.00295 - 0.00616TelecomCel + 0.0412TelecomFixa + 0.0288AgricPecuaria + 0.055AutoMec + 0.0383Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0513Siderurgia - 0.00419Textil - 0.0101Transportes - 0.137Size - 0.0206Momentum + 0.274Dollar + 0.0152Value + 0.0234BlueChip LM29: Volatility = 0.00295 - 0.00616TelecomCel + 0.0412TelecomFixa + 0.0288AgricPecuaria + 0.055AutoMec + 0.0383Financas - 0.00295Comercio + 0.014Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0513Siderurgia - 0.00419Textil - 0.0101Transportes - 0.137Size - 0.0206Momentum + 0.306Dollar + 0.0152Value + 0.0234BlueChip LM30: Volatility = 0.00308 - 0.00616TelecomCel + 0.0412TelecomFixa + 0.0288AgricPecuaria + 0.055AutoMec + 0.0383Financas - 0.00295Comercio + 0.0154Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0513Siderurgia - 0.00419Textil - 0.0101Transportes - 0.137Size - 0.0206Momentum + 0.274Dollar + 0.0152Value + 0.0234BlueChip LM31: Volatility = 0.00282 - 0.00616TelecomCel + 0.0412TelecomFixa + 0.0325AgricPecuaria + 0.055AutoMec + 0.0383Financas - 0.00295Comercio + 0.00756Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0513Siderurgia - 0.00419Textil - 0.0101Transportes - 0.137Size - 0.0206Momentum + 0.274Dollar + 0.0152Value + 0.0234BlueChip LM32: Volatility = 0.00291 - 0.00616TelecomCel + 0.0412TelecomFixa + 0.0281AgricPecuaria + 0.055AutoMec + 0.0546Financas - 0.00295Comercio + 0.0101Construcao + 0.00698Eletronicos + 0.00304Holding + 0.0241MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0207PetroQuimica - 0.0513Siderurgia - 0.00419Textil - 0.0101Transportes - 0.137Size - 0.0206Momentum + 0.274Dollar + 0.0152Value + 0.0234BlueChip

159

LM33: Volatility = 0.00287 + 0.0198TelecomFixa + 0.129AgricPecuaria + 0.0407AutoMec + 0.0953Financas - 0.00295Comercio + 0.02Construcao + 0.0191Eletronicos + 0.00304Holding + 0.0556MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0298PetroQuimica - 0.00691Siderurgia - 0.0115Textil - 0.00739Transportes - 0.658Size + 0.214Dollar + 0.0416Value - 0.0688BlueChip LM34: Volatility = 0.00343 + 0.0416TelecomCel + 0.0198TelecomFixa + 0.137AgricPecuaria + 0.0407AutoMec + 0.00819Financas - 0.00295Comercio + 0.02Construcao + 0.0191Eletronicos + 0.00304Holding + 0.0632MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0298PetroQuimica - 0.00691Siderurgia - 0.0115Textil - 0.00739Transportes - 0.675Size + 0.214Dollar + 0.0416Value - 0.0388BlueChip LM35: Volatility = 0.00313 - 0.00835TelecomFixa + 0.117AgricPecuaria + 0.0407AutoMec + 0.00819Financas - 0.00295Comercio + 0.02Construcao + 0.0191Eletronicos + 0.00304Holding + 0.0791MetalMin + 0.00213Metalurgia + 0.00109Outros + 0.00229PapelCelul + 0.0298PetroQuimica + 0.0217Siderurgia - 0.0115Textil - 0.00739Transportes - 0.609Size + 0.214Dollar + 0.0416Value - 0.0388BlueChip

160

Apêndice II

Listagem da base pw-linear criada e utilizada:

Obs X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 Y 1 -1 0 -1 0 0 0 1 1 -1 -1 0.489523329 2 -1 -1 0 0 0 1 0 0 -1 1 0.202290688 3 -1 -1 1 0 -1 0 -1 1 -1 -1 -6.167190402 4 1 0 0 -1 1 0 0 0 0 1 -0.697357146 5 -1 1 0 -1 1 -1 -1 0 -1 -1 -2.47019001 6 1 1 -1 1 0 -1 0 -1 0 0 4.495041384 7 -1 -1 -1 1 0 -1 1 1 0 1 -6.304314117 8 1 0 1 1 1 -1 0 1 0 0 4.877869741 9 -1 0 0 0 -1 0 -1 -1 0 0 -5.303611213 10 -1 0 1 1 -1 -1 1 0 -1 1 -6.52961497 11 1 -1 0 0 0 -1 1 -1 -1 1 1.260877998 12 -1 1 0 -1 0 -1 -1 -1 -1 -1 -5.917926318 13 -1 1 -1 1 1 -1 0 0 -1 0 -4.362284041 14 1 -1 1 1 -1 -1 1 0 1 0 4.319224141 15 1 -1 -1 1 1 0 -1 0 1 1 0.107370887 16 -1 1 1 0 1 -1 -1 -1 1 -1 -4.382171735 17 1 0 1 0 -1 -1 0 -1 0 0 5.825064947 18 -1 0 1 1 1 0 0 0 1 0 -0.095374802 19 1 1 0 0 1 1 0 -1 1 1 4.114266805 20 1 1 -1 -1 0 1 -1 -1 1 1 3.161221214 21 -1 0 -1 1 -1 1 -1 -1 -1 0 -3.608477448 22 1 -1 1 -1 -1 -1 0 0 0 0 -1.834918347 23 1 -1 -1 -1 1 1 1 1 1 -1 -2.478338213 24 -1 1 -1 -1 0 0 1 1 1 0 -2.560947762 25 1 1 -1 -1 -1 0 1 1 1 0 2.700444245 26 1 -1 0 -1 0 -1 0 -1 -1 -1 -1.133200916 27 1 0 1 0 -1 0 1 0 -1 1 3.668055146 28 1 1 -1 0 1 -1 1 -1 -1 -1 3.30569376 29 -1 1 0 1 1 1 0 -1 -1 -1 1.238189732 30 1 0 -1 0 0 0 1 1 1 0 -0.022563988 31 1 0 0 1 1 1 -1 1 1 0 2.512666939 32 1 -1 1 -1 1 -1 0 1 1 1 -0.27063719 33 -1 -1 0 -1 1 0 -1 1 0 0 0.857288445 34 1 -1 1 1 -1 0 -1 0 1 0 2.766608997 35 -1 1 0 0 1 -1 1 0 1 0 0.337109026 36 1 0 1 -1 -1 1 -1 0 0 -1 2.832553004 37 -1 0 1 1 -1 -1 -1 0 1 -1 -10.78159441 38 1 0 0 -1 0 -1 0 -1 0 1 3.536444146 39 -1 1 -1 0 0 -1 -1 -1 0 -1 -4.918218455 40 1 0 -1 0 0 -1 1 0 -1 0 -1.14576824

161

41 -1 1 1 0 -1 0 1 0 1 1 -5.67828155 42 1 -1 1 1 -1 -1 0 1 1 -1 2.895076625 43 1 1 -1 0 1 0 1 1 1 -1 4.693500745 44 1 0 -1 0 -1 1 1 -1 0 -1 -0.354363664 45 1 1 1 -1 -1 -1 -1 0 0 -1 7.693272441 46 1 -1 1 0 -1 0 1 1 -1 1 0.89981265 47 1 0 0 1 0 -1 0 -1 1 -1 3.764920833 48 1 0 0 0 1 0 1 -1 0 -1 5.423160821 49 -1 0 0 1 0 -1 -1 -1 0 1 -4.621937737 50 -1 1 0 1 -1 0 0 -1 1 1 -5.055274815 51 -1 1 -1 0 -1 1 -1 1 0 -1 -4.344105105 52 1 -1 -1 1 1 1 1 -1 1 -1 -1.911035874 53 1 1 0 1 1 0 1 1 -1 -1 7.133753991 54 1 0 -1 1 -1 -1 0 1 -1 1 1.554903658 55 -1 1 0 0 0 0 -1 0 -1 0 -3.284746064 56 -1 -1 1 -1 -1 1 0 1 -1 0 -6.609746288 57 -1 0 1 -1 -1 -1 1 1 -1 1 -5.381845529 58 1 1 1 -1 -1 1 -1 -1 -1 1 6.778766989 59 -1 0 0 1 1 1 0 0 0 0 0.805336595 60 1 0 1 -1 -1 -1 1 1 0 -1 3.50201591 61 -1 -1 1 1 -1 0 -1 -1 -1 1 -7.183392426 62 1 1 0 1 1 -1 1 0 -1 -1 6.880394426 63 -1 1 0 0 -1 0 1 0 0 1 -6.200798674 64 1 0 0 -1 -1 -1 0 1 0 0 3.092299607 65 1 -1 0 0 1 0 1 1 1 0 1.996129436 66 1 -1 0 -1 1 -1 -1 -1 0 -1 -1.407876358 67 1 0 1 0 -1 -1 0 1 0 -1 2.574948436 68 -1 0 0 0 0 1 0 -1 -1 1 1.260589077 69 -1 1 1 1 1 0 0 1 0 1 0.713147752 70 -1 1 1 1 1 1 -1 1 0 -1 2.344884225 71 1 0 0 0 -1 1 1 0 1 -1 2.008073766 72 -1 1 1 0 0 -1 0 0 0 0 -5.046668876 73 -1 1 0 -1 0 -1 0 -1 1 1 -1.48368102 74 -1 0 -1 -1 0 1 1 0 1 0 1.139304508 75 1 1 0 -1 -1 0 1 0 0 0 5.008444033 76 1 1 -1 0 0 1 1 0 -1 1 3.933177669 77 -1 1 1 0 1 0 1 0 1 1 2.105843501 78 -1 -1 0 -1 0 1 1 -1 0 -1 -1.356067905 79 -1 -1 -1 -1 1 1 -1 -1 -1 1 -0.064022066 80 -1 0 -1 1 1 -1 1 1 -1 0 -0.008630056 81 -1 0 1 1 -1 -1 -1 -1 -1 -1 -9.710935454 82 -1 0 0 1 1 0 -1 0 -1 0 -0.69821587 83 1 -1 -1 -1 -1 -1 1 -1 1 -1 -3.851358494 84 -1 -1 -1 0 0 -1 1 0 1 1 -5.285525183 85 -1 0 1 1 -1 1 1 0 1 1 -3.889974026 86 1 -1 0 1 -1 1 1 1 1 0 0.928650175 87 1 -1 0 1 1 -1 1 -1 1 1 3.490050679 88 1 -1 -1 0 0 -1 1 1 0 0 -1.108460001 89 -1 -1 0 -1 0 1 1 0 0 1 0.424238681 90 1 1 -1 1 0 -1 -1 -1 0 -1 7.110712321

162

91 -1 1 0 1 -1 1 1 1 1 -1 -0.244441411 92 1 0 0 1 1 -1 -1 0 -1 -1 1.71006582 93 -1 0 1 0 1 0 0 -1 0 0 -0.910794708 94 -1 -1 0 -1 -1 1 1 -1 0 0 -3.797912848 95 1 0 1 1 0 0 1 0 1 -1 7.782655545 96 -1 0 -1 1 0 0 1 -1 -1 1 -2.818900739 97 -1 0 1 -1 1 1 0 1 0 0 1.663196929 98 -1 -1 1 -1 -1 0 0 0 0 -1 -5.840987869 99 1 0 0 -1 0 1 1 -1 0 0 1.363692624 100 -1 -1 -1 0 -1 -1 1 -1 0 1 -8.441315334 101 1 1 0 1 -1 1 -1 0 -1 -1 9.945288863 102 1 0 1 -1 0 0 0 0 0 -1 6.331035332 103 -1 0 -1 0 0 0 1 0 0 0 -2.947583808 104 -1 1 0 0 1 1 1 -1 1 1 5.664687164 105 -1 0 -1 0 1 -1 -1 1 0 -1 -2.429505272 106 1 -1 1 1 1 -1 -1 0 1 0 1.21989117 107 -1 1 1 -1 -1 -1 1 1 1 -1 -6.643027396 108 -1 1 1 -1 -1 -1 1 -1 -1 0 -4.894509731 109 1 -1 -1 -1 -1 0 1 1 -1 -1 -3.121579921 110 -1 -1 0 0 1 -1 -1 -1 1 -1 -2.310526731 111 -1 0 -1 0 0 1 -1 -1 0 -1 -1.465676987 112 -1 1 0 0 -1 -1 -1 0 1 1 -10.26840238 113 -1 0 0 1 0 -1 -1 -1 -1 -1 -6.916569835 114 -1 0 -1 1 1 1 -1 1 -1 0 1.660705357 115 1 -1 1 1 -1 -1 -1 0 0 1 1.916797182 116 1 1 0 0 -1 1 1 0 1 0 5.888446162 117 -1 -1 1 -1 0 1 -1 -1 0 -1 -0.673277198 118 -1 0 -1 1 -1 0 -1 1 0 1 -5.341647946 119 1 0 -1 0 1 1 0 1 0 0 3.045115114 120 1 0 0 0 -1 0 -1 0 0 0 0.626204293 121 1 1 1 0 0 -1 1 -1 -1 0 8.797559138 122 -1 -1 1 0 1 -1 0 0 1 0 -4.083766018 123 1 0 0 1 0 1 1 -1 0 1 4.730701436 124 -1 -1 -1 -1 1 0 0 1 -1 1 0.027295191 125 1 1 1 -1 1 1 1 1 -1 0 6.602564531 126 1 1 -1 0 -1 1 1 1 0 0 2.060470664 127 1 -1 -1 -1 1 -1 0 -1 0 -1 -2.77306582 128 -1 1 -1 -1 -1 1 0 1 1 1 -5.633090698 129 -1 1 0 -1 -1 0 0 1 -1 -1 -4.807310942 130 1 -1 1 1 -1 -1 0 -1 0 -1 2.77292112 131 1 1 0 0 0 0 1 0 0 -1 6.329236883 132 1 0 -1 -1 1 0 -1 1 -1 -1 -1.19767316 133 1 -1 0 -1 0 0 -1 -1 -1 0 -2.140616452 134 1 1 -1 0 -1 -1 0 -1 -1 0 3.051287534 135 1 1 1 1 1 0 1 0 0 1 7.510785843 136 1 0 -1 0 -1 1 -1 -1 0 0 3.623926861 137 -1 -1 -1 -1 1 -1 0 1 1 -1 -3.031754028 138 -1 1 -1 0 1 -1 0 0 0 0 -3.151311369 139 -1 -1 1 0 1 -1 1 0 -1 1 -1.121081511 140 1 0 1 1 1 1 0 -1 -1 -1 5.114907178

163

141 -1 1 1 1 1 -1 1 1 -1 0 -2.39736199 142 -1 1 1 -1 1 -1 1 1 -1 0 -0.538160293 143 1 0 -1 1 0 -1 1 -1 1 -1 1.621828887 144 -1 0 -1 0 0 1 -1 -1 0 0 1.405138145 145 1 1 1 -1 -1 -1 0 1 1 1 6.166233777 146 -1 0 -1 1 1 0 -1 1 1 0 -1.114672921 147 1 1 1 0 -1 -1 0 0 1 0 8.032221412 148 1 1 1 1 1 -1 1 -1 1 0 7.437802519 149 -1 -1 0 -1 -1 0 1 0 -1 -1 -3.875239422 150 -1 1 -1 0 -1 0 1 -1 1 0 -5.206623163 151 -1 0 0 -1 0 1 1 -1 1 0 -2.987168178 152 1 1 -1 1 0 -1 -1 0 -1 0 1.761787453 153 1 -1 -1 1 1 1 0 0 0 1 -1.280365356 154 1 -1 0 1 1 0 0 0 1 0 -0.020014058 155 1 0 0 0 -1 0 0 0 1 0 3.561804706 156 -1 0 -1 0 -1 1 1 0 0 -1 -4.436019324 157 1 0 1 1 0 1 -1 -1 -1 -1 3.187461876 158 1 1 0 -1 -1 1 0 0 0 0 2.982802285 159 -1 1 1 -1 1 0 -1 1 1 0 -4.179740998 160 1 1 0 0 1 0 1 -1 1 -1 5.970754579 161 -1 -1 -1 1 -1 1 -1 -1 1 0 -4.078839968 162 -1 0 1 1 0 -1 1 0 -1 1 -3.421596629 163 1 1 0 0 1 -1 -1 -1 1 0 5.869556417 164 1 -1 -1 1 -1 0 1 0 1 0 -1.425159936 165 -1 1 1 -1 1 -1 1 0 1 0 -0.798984755 166 -1 1 -1 0 0 -1 1 -1 1 1 -2.9916198 167 -1 0 1 -1 -1 1 0 0 0 1 -3.982203542 168 -1 0 1 -1 0 1 0 1 0 0 -0.719179644 169 1 0 0 1 -1 -1 1 -1 -1 0 6.469194626 170 1 0 -1 1 0 1 0 0 0 1 4.402658478 171 1 1 1 -1 0 0 1 1 0 0 6.630916029 172 1 0 0 0 -1 -1 0 -1 1 0 5.066228411 173 -1 1 0 1 -1 -1 -1 0 0 -1 -8.706423559 174 -1 1 -1 -1 1 0 0 1 -1 -1 -0.164206851 175 1 0 1 0 0 1 -1 1 -1 1 1.823448827 176 1 0 -1 1 0 0 0 -1 0 0 1.78872233 177 -1 -1 0 -1 1 -1 -1 1 1 -1 -2.890518583 178 -1 -1 0 0 1 0 0 0 -1 -1 0.01675462 179 1 -1 0 1 0 -1 0 0 -1 0 -0.21365444 180 1 1 -1 -1 -1 0 0 -1 -1 -1 3.850057804 181 1 -1 -1 1 0 1 0 1 0 0 1.902740714 182 1 1 -1 0 1 0 -1 -1 0 -1 4.800215181 183 -1 1 -1 -1 0 1 0 0 1 0 0.954552382 184 -1 0 1 1 0 0 -1 1 0 -1 -2.105424044 185 -1 0 -1 1 -1 0 1 0 1 1 -1.849250395 186 -1 0 0 0 -1 1 1 1 0 -1 -3.482837245 187 1 -1 -1 -1 0 0 -1 0 -1 -1 -3.403967858 188 1 0 1 1 1 -1 -1 -1 1 0 7.636071512 189 -1 -1 1 1 1 1 0 0 0 -1 4.357184179 190 1 1 0 1 -1 1 -1 0 1 1 5.201916249

164

191 1 0 1 -1 1 0 -1 0 1 0 3.637935574 192 1 0 1 1 -1 -1 0 0 0 0 8.326417803 193 -1 1 -1 -1 1 0 1 1 -1 0 0.969757758 194 -1 -1 1 0 0 1 0 1 0 1 -3.198631872 195 -1 0 0 1 -1 0 0 0 -1 0 -6.477962472 196 -1 -1 0 -1 -1 -1 0 -1 1 1 -10.22011817 197 1 -1 1 1 1 1 0 -1 1 0 1.84124785 198 1 -1 -1 0 1 1 1 1 1 0 -1.048946614 199 -1 1 1 1 0 0 1 1 -1 0 -2.472746851 200 -1 0 1 1 -1 -1 1 1 1 -1 -7.520636027

165

Apêndice III

As tabelas abaixo são o sumário de todos os testes realizados. Os testes

são comparativos entre os valores possíveis de todos os parâmetros. O significado

destas tabelas e o uso destes resultados podem ser vistos no Capítulo 6.

• Pré-seleção dos Atributos

Base auto-mpg Metodo Corr MAE RMSE RAE RRSE Tempo Regras Below 0,9238 2,08722,9912 2,9912 31,8716 38,2 1,26 9 Above 0,9211 2,1262 3,0451 32,4675 38,888 1,35 15 Below e Above 0,9249 2,071 2,9711 31,6241 37,9425 1,6 13 All 0,9231 2,0936 3,007 31,9699 38,4017 1,39 12 Melhor 0,9249 2,071 2,9711 31,6241 37,9425 1,26 9 Base auto-prices Metodo Corr MAE RMSE RAE RRSE Tempo Regras Below 0,9243 1480,4075 2240,8748 32,0283 37,9007 0,48 7 Above 0,9153 1526,8987 2363,2939 33,0342 39,9713 0,46 5 Below e Above 0,9286 1463,7045 2179,7915 31,667 36,8676 0,53 6 All 0,882 1843,5579 2767,0782 39,885 46,8006 0,69 1 Melhor 0,9286 1463,7045 2179,7915 31,667 36,8676 0,46 1 Base auto-prices with Categorical Metodo Corr MAE RMSE RAE RRSE Tempo Regras Below 0,9328 1432,164 2116,4588 30,9846 35,7964 1,52 1 Above 0,9132 1577,1377 2389,7463 34,1211 40,4187 0,78 5 Below e Above 0,9229 1528,9218 2257,2249 33,0779 38,1773 1,17 1 All 0,9509 1306,4255 1833,0869 28,2643 31,0037 3,69 1 Melhor 0,9509 1306,4255 1833,0869 28,2643 31,0037 0,78 1 Base auto-prices with Categorical & Missing Metodo Corr MAE RMSE RAE RRSE Tempo Regras Below 0,9599 1524,3286 2224,9209 25,8998 27,8279 1,37 4 Above 0,9364 1873,2416 2795,1008 31,8282 34,9594 1,19 5 Below e Above 0,9556 1573,7695 2336,2439 26,7399 29,2203 1,21 4 All 0,9243 1861,2646 3157,6148 31,6247 39,4934 5,75 2 Melhor 0,9599 1524,3286 2224,9209 25,8998 27,8279 1,19 2

166

Base cpu Metodo Corr MAE RMSE RAE RRSE Tempo Regras Below 0,9766 13,6917 35,3003 15,6194 22,8092 0,42 2 Above 0,9518 18,764 47,7874 21,4058 30,8776 0,39 10 Below e Above 0,9779 12,3966 33,6523 14,142 21,7443 0,41 6 All 0,9791 11,7569 31,9658 13,4122 20,6545 1,06 3 Melhor 0,9791 11,7569 31,9658 13,4122 20,6545 0,39 2 Base housing Metodo Corr MAE RMSE RAE RRSE Tempo Regras Below 0,9131 2,5053 3,7506 37,5758 40,683 2,81 19 Above 0,8874 2,8125 4,2454 42,1828 46,05 2,28 30 Below e Above 0,9114 2,5028 3,7887 37,5375 41,0966 2,89 17 All 38,9171 36,8669 3,5878 2,4581 0,9209 3,78 6 Melhor 38,9171 2,5028 3,5878 2,4581 0,9209 2,28 6 Base pw-linear Metodo Corr MAE RMSE RAE RRSE Tempo Regras Below 0,933 1,2521 1,5585 35,2361 36,0267 0,63 2 Above 0,9062 1,4382 1,8505 40,4731 42,7765 0,63 6 Below e Above 0,933 1,2521 1,5585 35,2361 36,0267 0,63 2 All 0,933 1,2521 1,5585 35,2361 36,0267 0,71 2 Melhor 0,933 1,2521 1,5585 35,2361 36,0267 0,63 2 Base servo Metodo Corr MAE RMSE RAE RRSE Tempo Regras Below 0,9353 0,3059 0,5745 26,4577 36,8312 0,29 11 Above 0,8599 0,4213 0,819 36,4354 52,5038 0,25 12 Below e Above 0,9351 0,3086 0,575 26,6896 36,8646 0,27 11 All 0,9361 0,3108 0,5679 26,8813 36,4041 0,29 6 Melhor 0,9361 0,3059 0,5679 26,4577 36,4041 0,25 6

• Critério de Parada no Crescimento da Árvore – T = 0,01

Base auto-mpg Metodo Corr MAE RMSE RAE RRSE Tempo Regras %SD OR MinInst 0,9238 2,0872 2,9912 31,8716 38,2 1,49 9 F test OR MinInst -0,1634 6,5488 7,8304 100 100 0,23 1 (F test AND %SD) OR MinInst 0,9238 2,0872 2,9912 31,8716 38,2 2,4 9 (F test AND %SSE) OR MinInst 0,9238 2,0872 2,9912 31,8716 38,2 2,02 9 Melhor 0,9238 2,0872 2,9912 31,8716 38,2 0,23 1

167

Base auto-prices Metodo Corr MAE RMSE RAE RRSE Tempo Regras %SD OR MinInst 0,9243 1480,4075 2240,8748 32,0283 37,9007 0,58 7 F test OR MinInst -0,2777 4622,1816 5912,4833 100 100 0,08 1 (F test AND %SD) OR MinInst 0,9269 1446,4737 2206,2715 31,2942 37,3155 1 9 (F test AND %SSE) OR MinInst 0,9269 1445,413 2205,9947 31,2712 37,3108 1,04 9 Melhor 0,9269 1445,413 2205,9947 31,2712 37,3108 0,08 1 Base auto-prices with Categorical Metodo Corr MAE RMSE RAE RRSE Tempo Regras %SD OR MinInst 0,9328 1432,164 2116,4588 30,9846 35,7964 1,38 1 F test OR MinInst -0,2777 4622,1816 5912,4833 100 100 0,5 1 (F test AND %SD) OR MinInst 0,9316 1468,1509 2132,5708 31,7632 36,069 3,96 1 (F test AND %SSE) OR MinInst 0,9316 1468,1509 2132,5708 31,7632 36,069 3,92 1 Melhor 0,9328 1432,164 2116,4588 30,9846 35,7964 0,5 1 Base auto-prices with Categorical & Missing Metodo Corr MAE RMSE RAE RRSE Tempo Regras %SD OR MinInst 0,9599 1524,3286 2224,9209 25,8998 27,8279 1,09 4 F test OR MinInst -0,2717 5885,4761 7995,2877 100 100 0,92 1 (F test AND %SD) OR MinInst 0,9605 1517,0366 2207,6303 25,7759 27,6116 6,27 4 (F test AND %SSE) OR MinInst 0,9613 1500,6404 2187,0573 25,4973 27,3543 7 4 Melhor 0,9613 1500,6404 2187,0573 25,4973 27,3543 0,92 1 Base cpu Metodo Corr MAE RMSE RAE RRSE Tempo Regras %SD OR MinInst 0,9766 13,6917 35,3003 15,6194 22,8092 0,42 2 F test OR MinInst -0,1442 87,6583 154,7639 100 100 0,29 1 (F test AND %SD) OR MinInst 0,9724 14,3974 36,5284 16,4245 23,6026 2,19 3 (F test AND %SSE) OR MinInst 0,9659 16,951 41,0005 19,3375 26,4923 2,79 4 Melhor 0,9766 13,6917 35,3003 15,6194 22,8092 0,29 1 Base housing Metodo Corr MAE RMSE RAE RRSE Tempo Regras %SD OR MinInst 0,9131 2,5053 3,7506 37,5758 40,683 3,13 19 F test OR MinInst -0,1691 6,6674 9,2191 100 100 0,35 1 (F test AND %SD) OR MinInst 0,9112 2,5139 3,7894 37,7039 41,1035 3,74 19 (F test AND %SSE) OR MinInst 0,9109 2,5225 3,796 37,8336 41,1756 3,58 19 Melhor 0,9131 2,5053 3,7506 37,5758 40,683 0,35 1 Base pw-linear Metodo Corr MAE RMSE RAE RRSE Tempo Regras %SD OR MinInst 0,933 1,2521 1,5585 35,2361 36,0267 0,72 2 F test OR MinInst -0,1369 3,5536 4,326 100 100 0,13 1 (F test AND %SD) OR MinInst 0,933 1,2521 1,5585 35,2361 36,0267 1,06 2 (F test AND %SSE) OR MinInst 0,933 1,2521 1,5585 35,2361 36,0267 0,94 2 Melhor 0,933 1,2521 1,5585 35,2361 36,0267 0,13 1

168

Base servo Metodo Corr MAE RMSE RAE RRSE Tempo Regras %SD OR MinInst 0,9353 0,3059 0,5745 26,4577 36,8312 0,32 11 F test OR MinInst -0,1646 1,1562 1,5599 100 100 0,03 1 (F test AND %SD) OR MinInst 0,9352 0,3076 0,5748 26,6049 36,8508 0,42 11 (F test AND %SSE) OR MinInst 0,9347 0,3128 0,5764 27,058 36,9531 Melhor 0,9353 0,3059 0,5745 26,4577 36,8312 0,03 1

• Critério de Parada no Crescimento da Árvore – T = 0,05

Base auto-mpg Metodo Corr MAE RMSE RAE RRSE Tempo Regras%SD OR MinInst 0,9238 2,0872 2,9912 31,8716 38,2 1,44 9 F test OR MinInst -0,1634 6,5488 7,8304 100 100 0,2 1 (F test AND %SD) OR MinInst 0,9238 2,0872 2,9912 31,8716 38,2 2,09 9 (F test AND %SSE) OR MinInst 0,9238 2,0872 2,9912 31,8716 38,2 2,04 9 Melhor 0,9238 2,0872 2,9912 31,8716 38,2 0,2 1 Base auto-prices Metodo Corr MAE RMSE RAE RRSE Tempo Regras%SD OR MinInst 0,9269 1445,413 2205,9947 31,2712 37,3108 0,56 9 F test OR MinInst -0,2777 4622,1816 5912,4833 100 100 0,08 1 (F test AND %SD) OR MinInst 0,9269 1445,413 2205,9947 31,2712 37,3108 1,49 9 (F test AND %SSE) OR MinInst 0,9269 1445,413 2205,9947 31,2712 37,3108 1,03 9 Melhor 0,9269 1445,413 2205,9947 31,2712 37,3108 0,08 1 Base auto-prices with Categorical Metodo Corr MAE RMSE RAE RRSE Tempo Regras%SD OR MinInst 0,9316 1468,1509 2132,5708 31,7632 36,069 1,44 1 F test OR MinInst -0,2777 4622,1816 5912,4833 100 100 0,54 1 (F test AND %SD) OR MinInst 0,9316 1468,1509 2132,5708 31,7632 36,069 3,41 1 (F test AND %SSE) OR MinInst 0,9316 1468,1509 2132,5708 31,7632 36,069 4,1 1 Melhor 0,9316 1468,1509 2132,5708 31,7632 36,069 0,54 1 Base auto-prices with Categorical & Missing Metodo Corr MAE RMSE RAE RRSE Tempo Regras%SD OR MinInst 0,9613 1502,9667 2187,3044 25,5369 27,3574 1,1 7 F test OR MinInst -0,2717 5885,4761 7995,2877 100 100 1,33 1 (F test AND %SD) OR MinInst 0,9613 1500,5523 2187,0554 25,4959 27,3543 6,85 4 (F test AND %SSE) OR MinInst 0,9613 1500,6404 2187,0573 25,4973 27,3543 7,02 4 Melhor 0,9613 1500,5523 2187,0554 25,4959 27,3543 1,1 1 Base cpu Metodo Corr MAE RMSE RAE RRSE Tempo Regras%SD OR MinInst 0,9657 17,0156 41,1125 19,4113 26,5646 0,57 4 F test OR MinInst -0,1442 87,6583 154,7639 100 100 0,27 1 (F test AND %SD) OR MinInst 0,9658 16,9196 41,071 19,3017 26,5378 2,69 4 (F test AND %SSE) OR MinInst 0,9659 16,951 41,0005 19,3375 26,4923 2,16 4 Melhor 0,9659 16,9196 41,0005 19,3017 26,4923 0,27 1

169

Base housing Metodo Corr MAE RMSE RAE RRSE Tempo Regras%SD OR MinInst 0,9109 2,5225 3,796 37,8336 41,1756 3,31 19 F test OR MinInst -0,1691 6,6674 9,2191 100 100 1,06 1 (F test AND %SD) OR MinInst 0,9109 2,5225 3,796 37,8336 41,1756 4,23 19 (F test AND %SSE) OR MinInst 0,9109 2,5225 3,796 37,8336 41,1756 4,39 19 Melhor 0,9109 2,5225 3,796 37,8336 41,1756 1,06 1 Base pw-linear Metodo Corr MAE RMSE RAE RRSE Tempo Regras%SD OR MinInst 0,933 1,2521 1,5585 35,2361 36,0267 0,65 2 F test OR MinInst -0,1369 3,5536 4,326 100 100 0,13 1 (F test AND %SD) OR MinInst 0,933 1,2521 1,5585 35,2361 36,0267 0,97 2 (F test AND %SSE) OR MinInst 0,933 1,2521 1,5585 35,2361 36,0267 0,94 2 Melhor 0,933 1,2521 1,5585 35,2361 36,0267 0,13 1 Base servo Metodo Corr MAE RMSE RAE RRSE Tempo Regras%SD OR MinInst 0,9348 0,3119 0,5763 26,9798 36,9476 0,36 9 F test OR MinInst -0,1646 1,1562 1,5599 100 100 0,03 1 (F test AND %SD) OR MinInst 0,9347 0,3128 0,5764 27,058 36,9531 0,52 9 (F test AND %SSE) OR MinInst 0,9347 0,3128 0,5764 27,058 36,9531 0,53 9 Melhor 0,9348 0,3119 0,5763 26,9798 36,9476 0,03 1

• Eliminação de Atributos Colineares

Base auto-mpg Metodo Corr MAE RMSE RAE RRSE Tempo Regras do Eliminate 0,9238 2,0872 2,9912 31,8716 38,2 1,62 9 don´t Eliminate 0,9238 2,0872 2,9912 31,8716 38,2 1,27 9 Melhor 0,9238 2,0872 2,9912 31,8716 38,2 1,27 9 Base auto-prices Metodo Corr MAE RMSE RAE RRSE Tempo Regras do Eliminate 0,9237 1483,192 2249,667 32,0886 38,0494 0,54 7 don´t Eliminate 0,9264 1445,8229 2213,1235 31,2801 37,4314 0,51 7 Melhor 0,9264 1445,8229 2213,1235 31,2801 37,4314 0,51 7 Base auto-prices with Categorical Metodo Corr MAE RMSE RAE RRSE Tempo Regras do Eliminate 0,9344 1422,1858 2092,4413 30,7687 35,3902 0,75 1 don´t Eliminate 0,9327 1468,4324 2114,8401 31,7692 35,7691 0,75 1 Melhor 0,9344 1422,1858 2092,4413 30,7687 35,3902 0,75 1 Base auto-prices with Categorical & Missing Metodo Corr MAE RMSE RAE RRSE Tempo Regras do Eliminate 0,958 1558,7246 2276,7798 26,4843 28,4765 1,13 4 don´t Eliminate 0,958 1549,1947 2276,6821 26,3223 28,4753 1,48 4 Melhor 0,958 1549,1947 2276,6821 26,3223 28,4753 1,13 4

170

Base cpu Metodo Corr MAE RMSE RAE RRSE Tempo Regras do Eliminate 0,9766 13,6917 35,3003 15,6194 22,8092 0,41 2 don´t Eliminate 0,9766 13,6917 35,3003 15,6194 22,8092 0,44 2 Melhor 0,9766 13,6917 35,3003 15,6194 22,8092 0,41 2 Base housing Metodo Corr MAE RMSE RAE RRSE Tempo Regras do Eliminate 0,9131 2,5027 3,7507 37,5364 40,6838 2,68 19 don´t Eliminate 0,913 2,5059 3,7536 37,5842 40,7158 2,3 19 Melhor 0,9131 2,5027 3,7507 37,5364 40,6838 2,3 19 Base pw-linear Metodo Corr MAE RMSE RAE RRSE Tempo Regras do Eliminate 0,933 1,2521 1,5585 35,2361 36,0267 0,71 2 don´t Eliminate 0,933 1,2521 1,5585 35,2361 36,0267 0,67 2 Melhor 0,933 1,2521 1,5585 35,2361 36,0267 0,67 2 Base servo Metodo Corr MAE RMSE RAE RRSE Tempo Regras do Eliminate 0,9353 0,3059 0,5745 26,4577 36,8312 0,3 11 don´t Eliminate 0,9353 0,3059 0,5745 26,4577 36,8312 0,29 11 Melhor 0,9353 0,3059 0,5745 26,4577 36,8312 0,29 11

• Cálculo do SDR (Impurity Calculation)

Base auto-mpg Metodo Corr MAE RMSE RAE RRSE Tempo Regras 5th root 0,9238 0,9238 2,9912 31,8716 38,2 1,16 9 Std Deviation 0,9233 2,1021 3,0001 32,0994 38,3129 1,19 9 Variance 0,9255 2,0779 2,9561 31,7292 37,7512 1,02 4 Variance/Mean 0,9269 2,054 2,9316 31,3638 37,4387 1,07 9 Melhor 0,9269 0,9238 2,9316 31,3638 37,4387 1,02 4 Base auto-prices Metodo Corr MAE RMSE RAE RRSE Tempo Regras 5th root 0,9243 1480,4075 2240,8748 32,0283 37,9007 0,54 7 Std Deviation 0,9233 1442,734 2252,9736 31,2133 31,2133 0,48 11 Variance 0,9266 1443,2967 2204,9364 31,2254 37,2929 0,41 8 Variance/Mean 0,9273 1440,1112 2196,122 31,1565 37,1438 0,42 8 Melhor 0,9273 1440,1112 2196,122 31,1565 31,2133 0,41 7 Base auto-prices with Categorical Metodo Corr MAE RMSE RAE RRSE Tempo Regras 5th root 0,9328 1432,164 2116,4588 30,9846 35,7964 0,76 1 Std Deviation 0,923 1489,9914 2256,9521 32,2357 38,1727 1,95 1 Variance 0,924 1502,6939 2242,9588 32,5105 37,936 0,53 1 Variance/Mean 0,9254 1502,0985 2222,9868 32,4976 37,5982 0,53 1 Melhor 0,9328 1432,164 2116,4588 30,9846 35,7964 0,53 1

171

Base auto-prices with Categorical & Missing Metodo Corr MAE RMSE RAE RRSE Tempo Regras 5th root 0,9599 1524,3286 2224,9209 25,8998 27,8279 1,04 4 Std Deviation 0,959 1555,9606 2248,8695 26,4373 28,1274 1,3 27,8279 Variance 0,964 1469,4343 2112,9523 24,9671 26,4275 2,17 9 Variance/Mean 0,9576 1586,5044 1586,5044 26,9563 28,6294 2,05 7 Melhor 0,964 1469,4343 1586,5044 24,9671 26,4275 1,04 4 Base cpu Metodo Corr MAE RMSE RAE RRSE Tempo Regras 5th root 0,9766 13,6917 35,3003 15,6194 22,8092 1,56 2 Std Deviation 0,9725 14,4478 36,1554 16,482 23,3616 1,64 3 Variance 0,9717 14,8445 38,3016 16,9346 24,7484 0,34 3 Variance/Mean 0,969 15,3459 38,5022 17,5065 24,878 0,34 3 Melhor 0,9766 13,6917 35,3003 15,6194 22,8092 0,34 2 Base housing Metodo Corr MAE RMSE RAE RRSE Tempo Regras 5th root 0,9131 2,5053 3,7506 37,5758 40,683 3,3 19 Std Deviation 0,9105 2,4489 3,8023 36,7301 41,2436 2,33 14 Variance 0,9035 2,5251 3,9535 37,8718 42,8844 3,38 8 Variance/Mean 0,9067 2,5239 3,8776 37,8551 42,061 2,04 18 Melhor 0,9131 2,4489 3,7506 36,7301 40,683 2,04 8 Base pw-linear Metodo Corr MAE RMSE RAE RRSE Tempo Regras 5th root 0,933 1,2521 1,5585 35,2361 36,0267 1,84 2 Std Deviation 0,9331 1,2489 1,5574 35,144 35,9998 1,92 2 Variance 0,933 1,2521 1,5585 35,2361 36,0267 0,59 2 Variance/Mean 0,7721 2,2616 2,7459 63,6435 63,4749 0,68 1 Melhor 0,9331 1,2489 1,5574 35,144 35,9998 0,59 1 Base servo Metodo Corr MAE RMSE RAE RRSE Tempo Regras 5th root 0,9355 0,3122 0,5735 27,0015 36,7665 0,33 7 Std Deviation 0,9358 0,3134 0,5707 27,1088 36,5845 0,33 7 Variance 0,9286 0,3328 0,5902 0,5902 37,839 0,25 7 Variance/Mean 0,9405 0,3037 0,5484 0,5484 35,1587 0,26 8 Melhor 0,9405 0,3037 0,5484 0,5484 35,1587 0,25 7

• Uso de off-set para calculo do SDR

Base auto-mpg Metodo Corr MAE RMSE RAE RRSE Tempo Regras Off Set 20% 0,9238 2,0872 2,9912 31,8716 38,2 2,58 9 Off Set 10% 0,9242 2,077 2,985 31,7151 38,1201 1,21 8 Off Set 5% 0,9233 2,1029 2,9998 32,1119 38,3092 1,43 5 No Off Set 0,9234 2,0995 2,998 32,0599 38,2862 1,42 5 Melhor 0,9242 2,077 2,985 31,7151 38,1201 1,21 5

172

Base auto-prices Metodo Corr MAE RMSE RAE RRSE Tempo Regras Off Set 20% 0,9243 1480,4075 2240,8748 32,0283 37,9007 0,5 7 Off Set 10% 0,8876 1701,5561 2709,9563 36,8128 45,8345 0,5 9 Off Set 5% 0,8969 1705,0541 2607,6387 36,8885 44,1039 2,24 9 No Off Set 0,8969 1705,0541 2607,6387 36,8885 44,1039 0,52 9 Melhor 0,9243 1480,4075 2240,8748 32,0283 37,9007 0,5 7 Base auto-prices with Categorical Metodo Corr MAE RMSE RAE RRSE Tempo Regras Off Set 20% 0,9328 1432,164 2116,4588 30,9846 35,7964 0,69 1 Off Set 10% 0,9302 1509,2743 2157,0389 32,6529 36,4828 2,2 1 Off Set 5% 0,914 1569,3072 2381,2537 33,9517 40,275 0,82 1 No Off Set 0,914 1569,3072 2381,2537 33,9517 40,275 2,18 1 Melhor 0,9328 1432,164 2116,4588 30,9846 35,7964 0,69 1 Base auto-prices with Categorical & Missing Metodo Corr MAE RMSE RAE RRSE Tempo Regras Off Set 20% 0,9599 1524,3286 1524,3286 25,8998 27,8279 1,05 4 Off Set 10% 0,9595 1512,1631 2242,0379 25,6931 28,042 2,49 3 Off Set 5% 0,9574 1547,5618 2297,0285 26,2946 28,7298 1,93 3 No Off Set 0,9574 1547,5618 2297,0285 26,2946 28,7298 2,55 3 Melhor 0,9599 1512,1631 1524,3286 25,6931 27,8279 1,05 3 Base cpu Metodo Corr MAE RMSE RAE RRSE Tempo Regras Off Set 20% 0,9766 13,6917 35,3003 15,6194 22,8092 0,37 2 Off Set 10% 0,9777 10,7721 33,0833 12,2887 21,3766 0,41 2 Off Set 5% 0,9777 10,7721 33,0833 12,2887 21,3766 0,43 2 No Off Set 0,9777 10,7721 33,0833 12,2887 21,3766 0,43 2 Melhor 0,9777 10,7721 33,0833 12,2887 21,3766 0,37 2 Base housing Metodo Corr MAE RMSE RAE RRSE Tempo Regras Off Set 20% 0,9131 2,5053 3,7506 37,5758 40,683 3,58 19 Off Set 10% 0,9051 2,5253 3,9096 37,8751 42,4084 3,82 12 Off Set 5% 0,9042 2,5415 3,9302 38,1191 42,6317 2,46 13 No Off Set 0,9146 0,9146 3,717 37,4779 40,3184 2,5 16 Melhor 0,9146 0,9146 3,717 37,4779 40,3184 2,46 12 Base pw-linear Metodo Corr MAE RMSE RAE RRSE Tempo Regras Off Set 20% 0,933 1,2521 1,5585 35,2361 36,0267 0,58 2 Off Set 10% 0,933 1,2521 1,5585 35,2361 36,0267 0,6 2 Off Set 5% 0,933 1,2521 1,5585 35,2361 36,0267 0,61 2 No Off Set 0,933 1,2521 1,5585 35,2361 36,0267 0,61 2 Melhor 0,933 1,2521 1,5585 35,2361 36,0267 0,58 2

173

Base servo Metodo Corr MAE RMSE RAE RRSE Tempo Regras Off Set 20% 0,9353 0,3059 0,5745 26,4577 36,8312 0,28 11 Off Set 10% 0,9355 0,3122 0,5735 27,0015 36,7665 0,29 7 Off Set 5% 0,9355 0,3122 0,5735 27,0015 36,7665 0,27 7 No Off Set 0,9355 0,3122 0,5735 27,0015 36,7665 0,29 7 Melhor 0,9355 0,3059 0,5735 26,4577 36,7665 0,27 7

• Fator para Função de Erro para Poda

Base auto-mpg Metodo Corr MAE RMSE RAE RRSE Tempo Regras old factor 0,9238 2,0872 2,9912 31,8716 38,2 1,6 9 new factor 0,9327 1,9671 2,8176 30,0368 35,9826 1,22 29 Melhor 0,9327 1,9671 2,8176 30,0368 35,9826 1,22 9 Base auto-prices Metodo Corr MAE RMSE RAE RRSE Tempo Regras old factor 0,9237 1483,192 2249,667 32,0886 38,0494 0,49 7 new factor 0,9329 1399,9762 2115,8766 30,2882 35,7866 0,48 18 Melhor 0,9329 1399,9762 2115,8766 30,2882 35,7866 0,48 7 Base auto-prices with Categorical Metodo Corr MAE RMSE RAE RRSE Tempo Regras old factor 0,9344 1422,1858 2092,4413 30,7687 35,3902 0,75 1 new factor 0,9282 1439,6681 2190,6167 31,1469 37,0507 0,79 19 Melhor 0,9344 1422,1858 2092,4413 30,7687 35,3902 0,75 1 Base auto-prices with Categorical & Missing Metodo Corr MAE RMSE RAE RRSE Tempo Regras old factor 0,958 1558,7246 2276,7798 26,4843 28,4765 1,63 4 new factor 0,9607 1493,1702 2203,8623 25,3704 27,5645 1,6 21 Melhor 0,9607 1493,1702 2203,8623 25,3704 27,5645 1,6 4 Base cpu Metodo Corr MAE RMSE RAE RRSE Tempo Regras old factor 0,9766 13,6917 35,3003 15,6194 22,8092 0,44 2 new factor 0,9806 12,139 32,2904 13,8481 20,8643 0,4 4 Melhor 0,9806 12,139 32,2904 13,8481 20,8643 0,4 2 Base housing Metodo Corr MAE RMSE RAE RRSE Tempo Regras old factor 0,9131 2,5027 3,7507 37,5364 40,6838 2,65 19 new factor 0,9149 2,4283 3,7125 36,4209 40,2699 2,58 58 Melhor 0,9149 2,4283 3,7125 36,4209 40,2699 2,58 19

174

Base pw-linear Metodo Corr MAE RMSE RAE RRSE Tempo Regras old factor 0,933 1,2521 1,5585 35,2361 36,0267 0,69 2 new factor 0,9329 1,251 1,5598 35,2052 36,0563 0,68 2 Melhor 0,933 1,251 1,5585 35,2052 36,0267 0,68 2 Base servo Metodo Corr MAE RMSE RAE RRSE Tempo Regras old factor 0,9353 0,3059 0,5745 26,4577 36,8312 0,28 11 new factor 0,9358 0,3083 0,5712 26,6667 36,6155 0,88 11 Melhor 0,9358 0,3059 0,5712 26,4577 36,6155 0,28 11

• Escolha da Constante para Suavização dos Modelos de Regressão

Base auto-mpg k Corr MAE RMSE RAE RRSE 15 0,9238 2,0872 2,9912 31,8716 38,2 30 0,9253 2,0802 2,9618 31,765 37,824 35 0,9255 2,0829 2,9568 31,8052 37,7607 45 0,9259 2,0917 2,9508 31,9402 37,6842 50 0,9259 2,0962 2,9493 32,0094 37,6642 55 0,926 2,1006 2,9484 32,0757 37,6533 60 0,926 2,1048 2,9481 32,1402 37,6499 70 0,9259 2,1138 2,949 32,278 37,6604 Melhor 0,926 2,0802 2,9481 31,765 37,6499 Base auto-prices k Corr MAE RMSE RAE RRSE 3 0,92 1537,941 2300,815 33,2731 38,9145 4 0,9331 1390,324 2110,14 30,0794 35,6896 5 0,9327 1388,229 2115,792 30,0341 35,7852 6 0,9321 1388,51 2124,544 30,0401 35,9332 10 0,9289 1411,259 2173,84 30,5323 36,767 15 0,9243 1480,408 2240,875 32,0283 37,9007 20 0,92 1537,941 2300,815 33,2731 38,9145 Melhor 0,9331 1388,229 2110,14 30,0341 35,6896 Base auto-prices with categorical k Corr MAE RMSE RAE RRSE 5 0,933 1436,434 2115,373 31,0776 35,7781 10 0,9328 1433,277 2117,124 31,0087 35,8077 15 0,9328 1432,164 2116,459 30,9846 35,7964 20 0,9328 1434,679 2115,523 31,039 35,7806 Melhor 0,933 1432,164 2115,373 30,9846 35,7781

175

Base auto-prices with categorical and Missing k Corr MAE RMSE RAE RRSE 5 0,9561 1591,598 2322,535 27,0428 29,0488 10 0,9592 1541,627 2244,975 26,1937 28,0787 14 0,9599 1525,844 2226,452 25,9256 27,8471 15 0,9599 1524,329 2224,921 25,8998 27,8279 16 0,96 1523,643 2224,248 25,8882 27,8195 17 0,96 1524,828 2224,299 25,9083 27,8201 18 0,9599 1525,97 2224,961 25,9277 27,8284 19 0,9599 1527,24 2226,138 25,9493 27,8431 20 0,9598 1528,621 2227,752 25,9728 27,8633 30 0,9587 1552,577 2257,042 26,3798 28,2297 Melhor 0,96 1523,643 2224,248 25,8882 27,8195 Base cpu k Corr MAE RMSE RAE RRSE 10 0,9762 13,3625 13,6531 15,2439 23,0371 15 0,9766 13,6917 35,3003 15,6194 22,8092 20 0,9759 14,1824 35,5623 16,1791 22,9784 30 0,9739 15,3302 36,6202 17,4886 23,662 Melhor 0,9766 13,3625 13,6531 15,2439 22,8092 Base housing k Corr MAE RMSE RAE RRSE 15 0,9131 2,5053 3,7506 37,5758 40,683 20 0,9134 2,4984 3,7424 37,4716 40,5941 21 0,9134 2,4974 3,7418 37,4568 40,5879 22 0,9134 2,4966 3,7415 37,4452 40,5848 23 0,9134 2,4962 3,7415 37,4387 40,5846 24 0,9134 2,4959 3,7417 37,4342 40,5869 25 0,9133 2,4959 3,7422 37,4346 40,5917 Melhor 0,9134 2,4959 3,7415 37,4342 40,5846 Base pw-linear k Corr MAE RMSE RAE RRSE 4 0,9358 1,2198 1,5219 34,3248 35,1798 5 0,953 1,3392 1,6476 33,3163 30,3687 6 0,9354 1,225 1,5266 34,4726 35,2882 7 0,9352 1,228 1,5293 34,5569 35,3516 10 0,951 1,3717 1,7041 34,1248 31,4118 15 0,9481 1,4249 1,7771 35,4493 32,7567 20 0,9446 1,4753 1,8566 36,7027 34,2213 30 0,9363 1,581 2,0157 39,3322 37,1539 Melhor 0,953 1,2198 1,5219 33,3163 30,3687

176

Base servo k Corr MAE RMSE RAE RRSE 3 0,94 0,2457 0,5389 21,2515 34,5458 5 0,9402 0,2521 0,5406 21,8072 34,6557 6 0,94 0,257 0,5429 22,2296 34,801 10 0,9382 0,2782 0,5557 24,0608 35,6253 15 0,9353 0,3059 0,5745 26,4577 36,8312 20 0,932 0,3305 0,5935 28,5892 38,0471 25 0,9285 0,3547 0,6118 30,6758 39,2204 Melhor 0,9402 0,2457 0,5389 21,2515 34,5458

177

Apêndice IV

Listagem da documentação da classe e do pacote M5_5.

178

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees Class M5_5P java.lang.Object weka.classifiers.Classifier weka.classifiers.trees.m5_5.M5_5Base weka.classifiers.trees.M5_5P All Implemented Interfaces:

AdditionalMeasureProducer, java.lang.Cloneable, Drawable, OptionHandler, java.io.Serializable

public class M5_5P extends M5_5Base implements Drawable

M5P. Implements routines for generating M5 model trees. Valid options are:

-U Use unsmoothed predictions.

Version: $Revision: 1.1 $

Author: Mark Hall

See Also: Serialized Form

Field Summary

Fields inherited from class weka.classifiers.trees.m5_5.M5_5Base ATTRIBUTE_PRE_SELECTION_ABOVE, ATTRIBUTE_PRE_SELECTION_ALL, ATTRIBUTE_PRE_SELECTION_BELOW, ATTRIBUTE_PRE_SELECTION_BELOWABOVE, IMPURITY_CALCULATION_ORIGINAL, IMPURITY_CALCULATION_STDEVIATION, IMPURITY_CALCULATION_VAR_MEAN, IMPURITY_CALCULATION_VARIANCE, IMPURITY_OFF_SET_00, IMPURITY_OFF_SET_05, IMPURITY_OFF_SET_10, IMPURITY_OFF_SET_20, STOP_CRITERIA_1, STOP_CRITERIA_2, STOP_CRITERIA_3, STOP_CRITERIA_ORIGINAL, TAGS_ATTRIBUTE_PRE_SELECTION, TAGS_IMPURITY_CALCULATION, TAGS_IMPURITY_OFF_SET, TAGS_STOP_CRITERIA

179

Fields inherited from interface weka.core.Drawable BayesNet, NOT_DRAWABLE, TREE

Constructor Summary M5_5P() Creates a new M5_5P instance.

Method Summary java.lang.String[] getOptions()

Gets the current settings of the classifier. boolean getSaveInstances()

Get whether instance data is being save. java.lang.String graph()

Return a dot style String describing the tree. int graphType()

Returns the type of graph this classifier represents. java.util.Enumeration listOptions()

Returns an enumeration describing the available options

static void main(java.lang.String[] args) Main method by which this class can be tested

void setOptions(java.lang.String[] options) Parses a given list of options.

void setSaveInstances(boolean save) Set whether to save instance data at each node in the tree for visualization purposes

Methods inherited from class weka.classifiers.trees.m5_5.M5_5Base buildClassifier, classifyInstance, enumerateMeasures, getAttributePreSelectionMethod, getBuildRegressionTree, getConfLevel, getEliminateColinearAttributes, getImpurityCalculation, getImpurityOffSet, getM5RootNode, getMeasure, getMinNumInstances, getNewPruningFactor, getSmoothingConstant, getStopCriteria, getThreshold, getUnpruned, getUseUnsmoothed, impurityOffSetTipText, measureNumRules, newPruningFactorTipText, setAttributePreSelectionMethod, setBuildRegressionTree, setConfLevel, setEliminateColinearAttributes, setImpurityCalculation, setImpurityOffSet, setMinNumInstances, setNewPruningFactor, setSmoothingConstant, setStopCriteria, setThreshold, setUnpruned, setUseUnsmoothed, smoothingConstantTipText, thresholdTipText, toString

180

Methods inherited from class weka.classifiers.Classifier debugTipText, distributionForInstance, forName, getDebug, makeCopies, setDebug

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

M5_5P

public M5_5P()

Creates a new M5_5P instance.

Method Detail

graphType

public int graphType()

Returns the type of graph this classifier represents. Specified by: graphType in interface Drawable Returns: Drawable.TREE

graph

public java.lang.String graph() throws java.lang.Exception

Return a dot style String describing the tree. Specified by: graph in interface Drawable Returns: a String value Throws: java.lang.Exception - if an error occurs

181

setSaveInstances

public void setSaveInstances(boolean save)

Set whether to save instance data at each node in the tree for visualization purposes Parameters: save - a boolean value

getSaveInstances

public boolean getSaveInstances()

Get whether instance data is being save. Returns: a boolean value

listOptions

public java.util.Enumeration listOptions()

Returns an enumeration describing the available options Specified by: listOptions in interface OptionHandler Overrides: listOptions in class M5_5Base Returns: an enumeration of all the available options

setOptions

public void setOptions(java.lang.String[] options) throws java.lang.Exception

Parses a given list of options.

Valid options are:

-U Use unsmoothed predictions.

-R Build a regression tree rather than a model tree.

-L Save instance data at each node (for visualization purposes).

Specified by:

182

setOptions in interface OptionHandler Overrides: setOptions in class M5_5Base Parameters: options - the list of options as an array of strings Throws: java.lang.Exception - if an option is not supported

getOptions

public java.lang.String[] getOptions()

Gets the current settings of the classifier. Specified by: getOptions in interface OptionHandler Overrides: getOptions in class M5_5Base Returns: an array of strings suitable for passing to setOptions

main

public static void main(java.lang.String[] args)

Main method by which this class can be tested Parameters: args - an array of options

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

183

Overview Package Class Tree Deprecated Index Help Weka's home

PREV NEXT FRAMES NO FRAMES All Classes

Hierarchy For Package weka.classifiers.trees.m5_5 Package Hierarchies:

All Packages

Class Hierarchy o class java.lang.Object

o class weka.classifiers.Classifier (implements java.lang.Cloneable, weka.core.OptionHandler, java.io.Serializable)

o class weka.classifiers.trees.m5_5.M5_5Base (implements weka.core.AdditionalMeasureProducer, weka.core.OptionHandler)

o class weka.classifiers.trees.m5_5.PreConstructedLinearModel (implements java.io.Serializable)

o class weka.classifiers.trees.m5_5.RuleNode o class weka.classifiers.trees.m5_5.CorrelationSplitInfo (implements

java.lang.Cloneable, java.io.Serializable, weka.classifiers.trees.m5_5.SplitEvaluate)

o class weka.classifiers.trees.m5_5.Impurity o class weka.classifiers.trees.m5_5.Rule (implements java.io.Serializable) o class weka.classifiers.trees.m5_5.Statistic o class weka.classifiers.trees.m5_5.Values o class weka.classifiers.trees.m5_5.YongSplitInfo (implements

java.lang.Cloneable, java.io.Serializable, weka.classifiers.trees.m5_5.SplitEvaluate)

Interface Hierarchy o interface weka.classifiers.trees.m5_5.SplitEvaluate

Overview Package Class Tree Deprecated Index Help Weka's home

PREV NEXT FRAMES NO FRAMES All Classes

184

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class CorrelationSplitInfo java.lang.Object weka.classifiers.trees.m5_5.CorrelationSplitInfo All Implemented Interfaces:

java.lang.Cloneable, java.io.Serializable, SplitEvaluate

public final class CorrelationSplitInfo extends java.lang.Object implements java.lang.Cloneable, java.io.Serializable, SplitEvaluate

Finds split points using correlation.

Version: $Revision: 1.1 $

Author: Mark Hall (mhall@cs.waikato.ac.nz)

See Also: Serialized Form

Constructor Summary CorrelationSplitInfo(int low, int high, int attr) Constructs an object which contains the split information

Method Summary void attrSplit(int attr, Instances inst)

Finds the best splitting point for an attribute in the instances SplitEvaluate copy()

Makes a copy of this CorrelationSplitInfo object void initialize(int low, int high, int attr)

Resets the object of split information double maxImpurity()

Returns the impurity of this split int position()

Returns the position of the split in the sorted values. -1 indicates that a split could not be found.

185

int splitAttr() Returns the attribute used in this split

double splitValue() Returns the split value

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

CorrelationSplitInfo

public CorrelationSplitInfo(int low, int high, int attr)

Constructs an object which contains the split information Parameters:

low - the index of the first instance high - the index of the last instance attr - an attribute

Method Detail

copy

public final SplitEvaluate copy() throws java.lang.Exception

Makes a copy of this CorrelationSplitInfo object Specified by: copy in interface SplitEvaluate Returns: a copy of the object Throws: java.lang.Exception

initialize

public final void initialize(int low, int high, int attr)

186

Resets the object of split information Parameters: low - the index of the first instance high - the index of the last instance attr - the attribute

attrSplit

public final void attrSplit(int attr, Instances inst) throws java.lang.Exception

Finds the best splitting point for an attribute in the instances Specified by: attrSplit in interface SplitEvaluate Parameters: attr - the splitting attribute inst - the instances Throws: java.lang.Exception - if something goes wrong

maxImpurity

public double maxImpurity()

Returns the impurity of this split Specified by: maxImpurity in interface SplitEvaluate Returns: the impurity of this split

splitAttr

public int splitAttr()

Returns the attribute used in this split Specified by: splitAttr in interface SplitEvaluate Returns: the attribute used in this split

position

public int position()

Returns the position of the split in the sorted values. -1 indicates that a split could not be found.

187

Specified by: position in interface SplitEvaluate Returns: an int value

splitValue

public double splitValue()

Returns the split value Specified by: splitValue in interface SplitEvaluate Returns: the split value

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

188

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class Impurity java.lang.Object weka.classifiers.trees.m5_5.Impurity

public final class Impurity extends java.lang.Object

Class for handling the impurity values when spliting the instances

Version: $Revision: 1.6 $

Author: Yong Wang (yongwang@cs.waikato.ac.nz)

Constructor Summary Impurity(int partition, int attribute, Instances inst, int impuritycalculation) Constructs an Impurity object containing the impurity values of partitioning the instances using an attribute

Method Summary void incremental(double value, int type)

Incrementally computes the impurirty values java.lang.String toString()

Converts an Impurity object to a string

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

189

Impurity

public Impurity(int partition, int attribute, Instances inst, int impuritycalculation)

Constructs an Impurity object containing the impurity values of partitioning the instances using an attribute

Parameters: partition - the index of the last instance in the left subset attribute - the attribute used in partitioning inst - set of instances impuritycalculation - the order of the impurity; =1, the variance; =2, the stardard deviation; =k, the k-th order root of the variance

Method Detail

toString

public final java.lang.String toString()

Converts an Impurity object to a string Returns: the converted string

incremental

public final void incremental(double value, int type)

Incrementally computes the impurirty values Parameters: value - the incremental value type - if type=1, value will be added to the left subset; type=-1, to the right subset; type=0, initializes

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

190

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class M5_5Base java.lang.Object weka.classifiers.Classifier weka.classifiers.trees.m5_5.M5_5Base All Implemented Interfaces:

AdditionalMeasureProducer, java.lang.Cloneable, OptionHandler, java.io.Serializable

Direct Known Subclasses: M5_5P

public abstract class M5_5Base extends Classifier implements OptionHandler, AdditionalMeasureProducer

M5_5Base. Implements base routines for generating M5_5 Model trees and rules.

Valid options are:

-U Use unsmoothed predictions.

-R Build regression tree/rule rather than model tree/rule

Version: $Revision: 1.10 $

See Also: Serialized Form

Field Summary static int ATTRIBUTE_PRE_SELECTION_ABOVE

static int ATTRIBUTE_PRE_SELECTION_ALL

static int ATTRIBUTE_PRE_SELECTION_BELOW

static int ATTRIBUTE_PRE_SELECTION_BELOWABOVE

191

static int IMPURITY_CALCULATION_ORIGINAL

static int IMPURITY_CALCULATION_STDEVIATION

static int IMPURITY_CALCULATION_VAR_MEAN

static int IMPURITY_CALCULATION_VARIANCE

static int IMPURITY_OFF_SET_00

static int IMPURITY_OFF_SET_05

static int IMPURITY_OFF_SET_10

static int IMPURITY_OFF_SET_20

static int STOP_CRITERIA_1

static int STOP_CRITERIA_2

static int STOP_CRITERIA_3

static int STOP_CRITERIA_ORIGINAL

static Tag[] TAGS_ATTRIBUTE_PRE_SELECTION

static Tag[] TAGS_IMPURITY_CALCULATION

static Tag[] TAGS_IMPURITY_OFF_SET

static Tag[] TAGS_STOP_CRITERIA

Constructor Summary M5_5Base() Constructor

Method Summary void buildClassifier(Instances data)

192

Generates the classifier. double classifyInstance(Instance inst)

Calculates a prediction for an instance using a set of rules or an M5 model tree

java.util.Enumeration enumerateMeasures() Returns an enumeration of the additional measure names

SelectedTag getAttributePreSelectionMethod() Gets the method used to pre select attributes to each node linear model

boolean getBuildRegressionTree() Get the value of regressionTree.

double getConfLevel() Gets the Confidence Level to the F test in Stop Criteria

boolean getEliminateColinearAttributes() Get wheter EliminateColinearAttributes are

SelectedTag getImpurityCalculation() Gets the method used to calculate the impurity to select attribute (split)

SelectedTag getImpurityOffSet() Gets the off set to be used during the search for split points

RuleNode getM5RootNode()

double getMeasure(java.lang.String additionalMeasureName) Returns the value of the named measure

double getMinNumInstances() Get the minimum number of instances to allow at a leaf node

boolean getNewPruningFactor()

java.lang.String[] getOptions() Gets the current settings of the classifier.

double getSmoothingConstant() Get whether Smoothing Constant are

SelectedTag getStopCriteria() Gets the Stop Criteria to tree Greeding

double getThreshold() Get whether threshold are

boolean getUnpruned() Get whether unpruned tree/rules are being generated

boolean getUseUnsmoothed() Get whether or not smoothing is being used

193

java.lang.String impurityOffSetTipText() Returns the tip text for this property

java.util.Enumeration listOptions() Returns an enumeration describing the available options

double measureNumRules() return the number of rules

java.lang.String newPruningFactorTipText() Returns the tip text for this property

void setAttributePreSelectionMethod(SelectedTag method) Sets the method to pre select attributes for use in each linear regression

void setBuildRegressionTree(boolean newregressionTree) Set the value of regressionTree.

void setConfLevel(double conflevel) Sets the Confidence Level to the F test in Stop Criteria

void setEliminateColinearAttributes(boolean newEliminateColinearAttributes) Set the value of EliminateColinearAttributes.

void setImpurityCalculation(SelectedTag method) Sets the method to calculate impurity, during attribute selection (split)

void setImpurityOffSet(SelectedTag method) Sets the amount of instances that will not be used to search split point

void setMinNumInstances(double minNum) Set the minumum number of instances to allow at a leaf node

void setNewPruningFactor(boolean newpruningfactor) Use new Pruning Factor based in stat adj.

void setOptions(java.lang.String[] options) Parses a given list of options.

void setSmoothingConstant(double smoothingconstant) Constant used to smoothing calculation (sum of nodes predictions)

void setStopCriteria(SelectedTag method) Sets the Stop Criteria to tree Greeding

void setThreshold(double threshold) Threshold acceptable to turns a node into a leaf

void setUnpruned(boolean unpruned) Use unpruned tree/rules

void setUseUnsmoothed(boolean s) Use unsmoothed predictions

194

java.lang.String smoothingConstantTipText() Returns the tip text for this property

java.lang.String thresholdTipText() Returns the tip text for this property

java.lang.String toString() Returns a description of the classifier

Methods inherited from class weka.classifiers.Classifier debugTipText, distributionForInstance, forName, getDebug, makeCopies, setDebug

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

ATTRIBUTE_PRE_SELECTION_BELOW

public static final int ATTRIBUTE_PRE_SELECTION_BELOW See Also:

Constant Field Values

ATTRIBUTE_PRE_SELECTION_ABOVE

public static final int ATTRIBUTE_PRE_SELECTION_ABOVE See Also:

Constant Field Values

ATTRIBUTE_PRE_SELECTION_BELOWABOVE

public static final int ATTRIBUTE_PRE_SELECTION_BELOWABOVE See Also:

Constant Field Values

ATTRIBUTE_PRE_SELECTION_ALL

195

public static final int ATTRIBUTE_PRE_SELECTION_ALL See Also:

Constant Field Values

TAGS_ATTRIBUTE_PRE_SELECTION

public static final Tag[] TAGS_ATTRIBUTE_PRE_SELECTION

IMPURITY_CALCULATION_ORIGINAL

public static final int IMPURITY_CALCULATION_ORIGINAL See Also:

Constant Field Values

IMPURITY_CALCULATION_STDEVIATION

public static final int IMPURITY_CALCULATION_STDEVIATION See Also:

Constant Field Values

IMPURITY_CALCULATION_VARIANCE

public static final int IMPURITY_CALCULATION_VARIANCE See Also:

Constant Field Values

IMPURITY_CALCULATION_VAR_MEAN

public static final int IMPURITY_CALCULATION_VAR_MEAN See Also:

Constant Field Values

TAGS_IMPURITY_CALCULATION

public static final Tag[] TAGS_IMPURITY_CALCULATION

STOP_CRITERIA_ORIGINAL

196

public static final int STOP_CRITERIA_ORIGINAL See Also:

Constant Field Values

STOP_CRITERIA_1

public static final int STOP_CRITERIA_1 See Also:

Constant Field Values

STOP_CRITERIA_2

public static final int STOP_CRITERIA_2 See Also:

Constant Field Values

STOP_CRITERIA_3

public static final int STOP_CRITERIA_3 See Also:

Constant Field Values

TAGS_STOP_CRITERIA

public static final Tag[] TAGS_STOP_CRITERIA

IMPURITY_OFF_SET_20

public static final int IMPURITY_OFF_SET_20 See Also:

Constant Field Values

IMPURITY_OFF_SET_10

public static final int IMPURITY_OFF_SET_10 See Also:

Constant Field Values

197

IMPURITY_OFF_SET_05

public static final int IMPURITY_OFF_SET_05 See Also:

Constant Field Values

IMPURITY_OFF_SET_00

public static final int IMPURITY_OFF_SET_00 See Also:

Constant Field Values

TAGS_IMPURITY_OFF_SET

public static final Tag[] TAGS_IMPURITY_OFF_SET

Constructor Detail

M5_5Base

public M5_5Base()

Constructor

Method Detail

listOptions

public java.util.Enumeration listOptions()

Returns an enumeration describing the available options Specified by: listOptions in interface OptionHandler Overrides: listOptions in class Classifier Returns: an enumeration of all the available options

setOptions

public void setOptions(java.lang.String[] options) throws java.lang.Exception

Parses a given list of options.

Valid options are:

198

-U Use unsmoothed predictions.

-R Build a regression tree rather than a model tree.

Specified by: setOptions in interface OptionHandler Overrides: setOptions in class Classifier Parameters: options - the list of options as an array of strings Throws: java.lang.Exception - if an option is not supported

getOptions

public java.lang.String[] getOptions()

Gets the current settings of the classifier. Specified by: getOptions in interface OptionHandler Overrides: getOptions in class Classifier Returns: an array of strings suitable for passing to setOptions

setThreshold

public void setThreshold(double threshold)

Threshold acceptable to turns a node into a leaf Parameters: threshold - acceptable for a leaf

getThreshold

public double getThreshold()

Get whether threshold are Returns: Fraction of deviation acceptable for a leaf

setSmoothingConstant

public void setSmoothingConstant(double smoothingconstant)

199

Constant used to smoothing calculation (sum of nodes predictions) Parameters: smoothingconstant - (sum of nodes predictions)

getSmoothingConstant

public double getSmoothingConstant()

Get whether Smoothing Constant are Returns: Fraction of deviation acceptable for a leaf

setNewPruningFactor

public void setNewPruningFactor(boolean newpruningfactor)

Use new Pruning Factor based in stat adj. R2 Parameters: newpruningfactor - to use new factor (based on stat adj. R2)

getNewPruningFactor

public boolean getNewPruningFactor()

setEliminateColinearAttributes

public void setEliminateColinearAttributes(boolean newEliminateColinearAttributes)

Set the value of EliminateColinearAttributes. Parameters: newEliminateColinearAttributes - Value to assign to EliminateColinearAttributes.

getEliminateColinearAttributes

public boolean getEliminateColinearAttributes()

Get wheter EliminateColinearAttributes are Returns: new pruning factor status

setUnpruned

200

public void setUnpruned(boolean unpruned)

Use unpruned tree/rules Parameters: unpruned - true if unpruned tree/rules are to be generated

getUnpruned

public boolean getUnpruned()

Get whether unpruned tree/rules are being generated Returns: true if unpruned tree/rules are to be generated

setUseUnsmoothed

public void setUseUnsmoothed(boolean s)

Use unsmoothed predictions Parameters: s - true if unsmoothed predictions are to be used

getUseUnsmoothed

public boolean getUseUnsmoothed()

Get whether or not smoothing is being used Returns: true if unsmoothed predictions are to be used

getBuildRegressionTree

public boolean getBuildRegressionTree()

Get the value of regressionTree. Returns: Value of regressionTree.

setBuildRegressionTree

public void setBuildRegressionTree(boolean newregressionTree)

Set the value of regressionTree. Parameters: newregressionTree - Value to assign to regressionTree.

201

setMinNumInstances

public void setMinNumInstances(double minNum)

Set the minumum number of instances to allow at a leaf node Parameters: minNum - the minimum number of instances

getMinNumInstances

public double getMinNumInstances()

Get the minimum number of instances to allow at a leaf node Returns: a double value

buildClassifier

public void buildClassifier(Instances data) throws java.lang.Exception

Generates the classifier. Specified by: buildClassifier in class Classifier Parameters: data - set of instances serving as training data Throws: java.lang.Exception - if the classifier has not been generated successfully

classifyInstance

public double classifyInstance(Instance inst) throws java.lang.Exception

Calculates a prediction for an instance using a set of rules or an M5 model tree Overrides: classifyInstance in class Classifier Parameters: inst - the instance whos class value is to be predicted Returns: the prediction Throws: if - a prediction can't be made. java.lang.Exception - if an error occurred during the prediction

toString

202

public java.lang.String toString()

Returns a description of the classifier Returns: a description of the classifier as a String

enumerateMeasures

public java.util.Enumeration enumerateMeasures()

Returns an enumeration of the additional measure names Specified by: enumerateMeasures in interface AdditionalMeasureProducer Returns: an enumeration of the measure names

getMeasure

public double getMeasure(java.lang.String additionalMeasureName)

Returns the value of the named measure Specified by: getMeasure in interface AdditionalMeasureProducer Parameters: additionalMeasureName - the name of the measure to query for its value Returns: the value of the named measure Throws: java.lang.Exception - if the named measure is not supported

measureNumRules

public double measureNumRules()

return the number of rules Returns: the number of rules (same as # linear models & # leaves in the tree)

getM5RootNode

public RuleNode getM5RootNode()

thresholdTipText

public java.lang.String thresholdTipText()

203

Returns the tip text for this property Returns: tip text for this property suitable for displaying in the explorer/experimenter gui

smoothingConstantTipText

public java.lang.String smoothingConstantTipText()

Returns the tip text for this property Returns: tip text for this property suitable for displaying in the explorer/experimenter gui

newPruningFactorTipText

public java.lang.String newPruningFactorTipText()

Returns the tip text for this property Returns: tip text for this property suitable for displaying in the explorer/experimenter gui

impurityOffSetTipText

public java.lang.String impurityOffSetTipText()

Returns the tip text for this property Returns: tip text for this property suitable for displaying in the explorer/experimenter gui

setAttributePreSelectionMethod

public void setAttributePreSelectionMethod(SelectedTag method)

Sets the method to pre select attributes for use in each linear regression Parameters: method - to pre select attributes for use in linear regressions at each node

getAttributePreSelectionMethod

public SelectedTag getAttributePreSelectionMethod()

Gets the method used to pre select attributes to each node linear model Returns: the method to pre select attributes to linear models

setImpurityCalculation

204

public void setImpurityCalculation(SelectedTag method)

Sets the method to calculate impurity, during attribute selection (split) Parameters: method - to impurity calculation

getImpurityCalculation

public SelectedTag getImpurityCalculation()

Gets the method used to calculate the impurity to select attribute (split) Returns: the method to impurity calculation

setImpurityOffSet

public void setImpurityOffSet(SelectedTag method)

Sets the amount of instances that will not be used to search split point Parameters: method - the value of this off set

getImpurityOffSet

public SelectedTag getImpurityOffSet()

Gets the off set to be used during the search for split points Returns: the off set to search split points

setStopCriteria

public void setStopCriteria(SelectedTag method)

Sets the Stop Criteria to tree Greeding Parameters: method - the value of this Criteria

getStopCriteria

public SelectedTag getStopCriteria()

Gets the Stop Criteria to tree Greeding Returns: the Stop Criteria

205

setConfLevel

public void setConfLevel(double conflevel)

Sets the Confidence Level to the F test in Stop Criteria Parameters: conflevel - the Confidence Level

getConfLevel

public double getConfLevel()

Gets the Confidence Level to the F test in Stop Criteria Returns: the Confidence Level to the F test in Stop Criteria

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

206

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class PreConstructedLinearModel java.lang.Object weka.classifiers.Classifier weka.classifiers.trees.m5_5.PreConstructedLinearModel All Implemented Interfaces:

java.lang.Cloneable, OptionHandler, java.io.Serializable

public class PreConstructedLinearModel extends Classifier implements java.io.Serializable

This class encapsulates a linear regression function. It is a classifier but does not learn the function itself, instead it is constructed with coefficients and intercept obtained elsewhere. The buildClassifier method must still be called however as this stores a copy of the training data's header for use in printing the model to the console.

Version: $Revision: 1.2 $

Author: Mark Hall (mhall@cs.waikato.ac.nz)

See Also: Serialized Form

Constructor Summary PreConstructedLinearModel(double[] coeffs, double intercept, int numinstances, double sse, double sst) Constructor

Method Summary void buildClassifier(Instances instances)

Builds the classifier. double classifyInstance(Instance inst)

Predicts the class of the supplied instance using the linear model.

double[] coefficients() Return the array of coefficients

207

double intercept() Return the intercept

int numInstances() Return the number of instances used to obtain the linear model

int numParameters() Return the number of parameters (coefficients) in the linear model

double SSE() Return the Sum Squared Error (SSE) of model

double SST() Return the Sum Squared Regression (SSR) of model

java.lang.String toString() Returns a textual description of this linear model

Methods inherited from class weka.classifiers.Classifier debugTipText, distributionForInstance, forName, getDebug, getOptions, listOptions, makeCopies, setDebug, setOptions

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

PreConstructedLinearModel

public PreConstructedLinearModel(double[] coeffs, double intercept, int numinstances, double sse, double sst)

Constructor Parameters:

coeffs - an array of coefficients intercept - the intercept numinstances - the total instances used to regression estimate sse - the Sum Squared Error of regression sst - the total deviation of dependent variable (variance = sst/n)

Method Detail

208

buildClassifier

public void buildClassifier(Instances instances) throws java.lang.Exception

Builds the classifier. In this case all that is done is that a copy of the training instances header is saved. Specified by: buildClassifier in class Classifier Parameters: instances - an Instances value Throws: java.lang.Exception - if an error occurs

classifyInstance

public double classifyInstance(Instance inst) throws java.lang.Exception

Predicts the class of the supplied instance using the linear model. Overrides: classifyInstance in class Classifier Parameters: inst - the instance to make a prediction for Returns: the prediction Throws: java.lang.Exception - if an error occurs

numParameters

public int numParameters()

Return the number of parameters (coefficients) in the linear model Returns: the number of parameters

numInstances

public int numInstances()

Return the number of instances used to obtain the linear model Returns: the number of instances

coefficients

209

public double[] coefficients()

Return the array of coefficients Returns: the coefficients

intercept

public double intercept()

Return the intercept Returns: the intercept

SSE

public double SSE()

Return the Sum Squared Error (SSE) of model Returns: SSE - Sum Squared Error

SST

public double SST()

Return the Sum Squared Regression (SSR) of model Returns: SSR - Sum Squared Regression

toString

public java.lang.String toString()

Returns a textual description of this linear model Returns: String containing a description of this linear model

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

210

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class Rule java.lang.Object weka.classifiers.trees.m5_5.Rule All Implemented Interfaces:

java.io.Serializable

public class Rule extends java.lang.Object implements java.io.Serializable

Generates a single m5 tree or rule

Version: $Revision: 1.10 $

Author: Mark Hall

See Also: Serialized Form

Constructor Summary Rule() Constructor declaration

Method Summary void buildClassifier(Instances data)

Generates a single rule or m5 model tree. double classifyInstance(Instance instance)

Calculates a prediction for an instance using this rule or M5 model tree

int getAttributePreSelectionMethod() Gets the method used to pre select attributes to each node linear model

double getConfLevel() Gets the Confidence Level to the F test in Stop Criteria

boolean getEliminateColinearAttributes()

211

Get wheter EliminateColinearAttributes are int getImpurityCalculation()

Gets the method used to impurity calculation int getImpurityOffSet()

Gets the off set to be used during the search for split points RuleNode getM5RootNode()

double getMinNumInstances()

Get the minimum number of instances to allow at a leaf node

boolean getNewPruningFactor() Get wheter new pruning factor are

boolean getRegressionTree() Get the value of regressionTree.

boolean getSmoothing() Get whether or not smoothing has been turned on

double getSmoothingConstant() Get whether Smoothing Constant are

int getStopCriteria() Gets the Stop Criteria to Tree Greeding

double getThreshold() Get the deviation fraction to allow at a leaf node

boolean getUnpruned() Get whether unpruned tree/rules are being generated

boolean getUseTree() get whether an m5 tree is being used rather than rules

Instances notCoveredInstances() Get the instances not covered by this rule

void setAttributePreSelectionMethod(int attributepreselection) Sets the method to pre select attributes for use in each linear regression

void setConfLevel(double conflevel) Sets the Confidence Level to the F test in Stop Criteria

void setEliminateColinearAttributes(boolean newEliminateColinearAttributes) Set the value of EliminateColinearAttributes.

void setImpurityCalculation(int impuritycalculation) Sets the method to calculate the impurity of a split (attribute selection)

void setImpurityOffSet(int impurityoffset) Sets the amount of instances that will not be used to search split point

void setMinNumInstances(double minNum) Set the minumum number of instances to allow at a leaf

212

node void setNewPruningFactor(boolean newpruningfactor)

Flag to use a different Pruning Factor, based on adj. void setRegressionTree(boolean newregressionTree)

Set the value of regressionTree. void setSmoothing(boolean s)

Smooth predictions void setSmoothingConstant(double smoothingconstant)

Constant used to smoothing calculation (sum of nodes predictions)

void setStopCriteria(int stopcriteria) Sets the Stop Criteria to Tree Greeding

void setThreshold(double threshold) Set threshold to allow at a leaf node

void setUnpruned(boolean unpruned) Use unpruned tree/rules

void setUseTree(boolean u) Use an m5 tree rather than generate rules

RuleNode topOfTree() Returns the top of the tree.

java.lang.String toString() Return a description of the m5 tree or rule

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

Rule

public Rule()

Constructor declaration

Method Detail

buildClassifier

public void buildClassifier(Instances data) throws java.lang.Exception

Generates a single rule or m5 model tree.

213

Parameters: data - set of instances serving as training data Throws: java.lang.Exception - if the rule has not been generated successfully

classifyInstance

public double classifyInstance(Instance instance) throws java.lang.Exception

Calculates a prediction for an instance using this rule or M5 model tree Parameters: instance - the instance whos class value is to be predicted Returns: the prediction Throws: if - a prediction can't be made. java.lang.Exception

topOfTree

public RuleNode topOfTree()

Returns the top of the tree.

toString

public java.lang.String toString()

Return a description of the m5 tree or rule Returns: a description of the m5 tree or rule as a String

setUnpruned

public void setUnpruned(boolean unpruned)

Use unpruned tree/rules Parameters: unpruned - true if unpruned tree/rules are to be generated

getUnpruned

public boolean getUnpruned()

Get whether unpruned tree/rules are being generated

214

Returns: true if unpruned tree/rules are to be generated

setUseTree

public void setUseTree(boolean u)

Use an m5 tree rather than generate rules Parameters: u - true if m5 tree is to be used

getUseTree

public boolean getUseTree()

get whether an m5 tree is being used rather than rules Returns: true if an m5 tree is being used.

setSmoothing

public void setSmoothing(boolean s)

Smooth predictions Parameters: s - true if smoothing is to be used

getSmoothing

public boolean getSmoothing()

Get whether or not smoothing has been turned on Returns: true if smoothing is being used

notCoveredInstances

public Instances notCoveredInstances()

Get the instances not covered by this rule Returns: the instances not covered

getRegressionTree

215

public boolean getRegressionTree()

Get the value of regressionTree. Returns: Value of regressionTree.

setRegressionTree

public void setRegressionTree(boolean newregressionTree)

Set the value of regressionTree. Parameters: newregressionTree - Value to assign to regressionTree.

setMinNumInstances

public void setMinNumInstances(double minNum)

Set the minumum number of instances to allow at a leaf node Parameters: minNum - the minimum number of instances

getMinNumInstances

public double getMinNumInstances()

Get the minimum number of instances to allow at a leaf node Returns: a double value

setThreshold

public void setThreshold(double threshold)

Set threshold to allow at a leaf node Parameters: threshold - the deviation fraction at a leaf

getThreshold

public double getThreshold()

Get the deviation fraction to allow at a leaf node Returns: a double value

216

setSmoothingConstant

public void setSmoothingConstant(double smoothingconstant)

Constant used to smoothing calculation (sum of nodes predictions) Parameters: smoothingconstant - (sum of nodes predictions)

getSmoothingConstant

public double getSmoothingConstant()

Get whether Smoothing Constant are Returns: Fraction of deviation acceptable for a leaf

setNewPruningFactor

public void setNewPruningFactor(boolean newpruningfactor)

Flag to use a different Pruning Factor, based on adj. R2 Parameters: newpruningfactor - to use new factor based on adj. R2

getNewPruningFactor

public boolean getNewPruningFactor()

Get wheter new pruning factor are Returns: new pruning factor status

setEliminateColinearAttributes

public void setEliminateColinearAttributes(boolean newEliminateColinearAttributes)

Set the value of EliminateColinearAttributes. Parameters: newEliminateColinearAttributes - Value to assign to EliminateColinearAttributes.

getEliminateColinearAttributes

public boolean getEliminateColinearAttributes()

Get wheter EliminateColinearAttributes are

217

Returns: new pruning factor status

setAttributePreSelectionMethod

public void setAttributePreSelectionMethod(int attributepreselection)

Sets the method to pre select attributes for use in each linear regression Parameters: attributepreselection - method to pre select attributes for use in linear regressions at each node

getAttributePreSelectionMethod

public int getAttributePreSelectionMethod()

Gets the method used to pre select attributes to each node linear model Returns: the method to pre select attributes to linear models

setImpurityCalculation

public void setImpurityCalculation(int impuritycalculation)

Sets the method to calculate the impurity of a split (attribute selection) Parameters: impuritycalculation - to impurity calculation

getImpurityCalculation

public int getImpurityCalculation()

Gets the method used to impurity calculation Returns: the method to calculate the impurity of a split

setImpurityOffSet

public void setImpurityOffSet(int impurityoffset)

Sets the amount of instances that will not be used to search split point Parameters: impurityoffset - the value of this off set

getImpurityOffSet

218

public int getImpurityOffSet()

Gets the off set to be used during the search for split points Returns: the off set to search split points

setStopCriteria

public void setStopCriteria(int stopcriteria)

Sets the Stop Criteria to Tree Greeding Parameters: stopcriteria - the criteria

getStopCriteria

public int getStopCriteria()

Gets the Stop Criteria to Tree Greeding Returns: the Criteria to stop the tree greeding

setConfLevel

public void setConfLevel(double conflevel)

Sets the Confidence Level to the F test in Stop Criteria Parameters: conflevel - the Confidence Level

getConfLevel

public double getConfLevel()

Gets the Confidence Level to the F test in Stop Criteria Returns: the Confidence Level to the F test in Stop Criteria

getM5RootNode

public RuleNode getM5RootNode()

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes

219

SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

220

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class RuleNode java.lang.Object weka.classifiers.Classifier weka.classifiers.trees.m5_5.RuleNode All Implemented Interfaces:

java.lang.Cloneable, OptionHandler, java.io.Serializable

public class RuleNode extends Classifier

Constructs a node for use in an m5 tree or rule

Version: $Revision: 1.8 $

Author: Mark Hall (mhall@cs.waikato.ac.nz)

See Also: Serialized Form

Field Summary int m_numParameters

the number of paramters in the chosen model for this node---either the subtree model or the linear model.

Constructor Summary RuleNode(double globalDev, double globalAbsDev, RuleNode parent) Creates a new RuleNode instance.

Method Summary void buildClassifier(Instances data)

Build this node (find an attribute and split point) double classifyInstance(Instance inst)

221

Classify an instance using this node. void findBestLeaf(double[] maxCoverage,

RuleNode[] bestLeaf) Find the leaf with greatest coverage

double getMinNumInstances() Get the minimum number of instances to allow at a leaf node

PreConstructedLinearModel

getModel() Get the linear model at this node

int getNumInstances() Return the number of instances that reach this node.

boolean getRegressionTree() Get the value of regressionTree.

void graph(java.lang.StringBuffer text) Assign a unique identifier to each node in the tree and then calls graphTree

void installLinearModels() Traverses the tree and installs linear models at each node.

void installSmoothedModels()

boolean isLeaf() Return true if this node is a leaf

RuleNode leftNode() Get the left child of this node

java.lang.String nodeToString() Returns a description of this node (debugging purposes)

int numberOfLinearModels() Get the number of linear models in the tree

int numLeaves(int leafCounter) Sets the leaves' numbers

RuleNode parentNode() Get the parent of this node

void printAllModels() Print all the linear models at the learf (debugging purposes)

java.lang.String printLeafModels() print all leaf models

java.lang.String printNodeLinearModel() print the linear model at this node

void prune() Recursively prune the tree

void returnLeaves(FastVector[] v) Return a list containing all the leaves in the tree

222

RuleNode rightNode() Get the right child of this node

void setAttributePreSelectionMethod(int attributepreselection) Sets the method to pre select attributes for use in each linear regression

void setConfLevel(double conflevel) Sets the Confidence Level to the F test in Stop Criteria

void setEliminateColinearAttributes(boolean newEliminateColinearAttributes) Set the value of EliminateColinearAttributes.

void setImpurityCalculation(int impuritycalculation) Sets the method to calculate the impurity of a split (attribute selection)

void setImpurityOffSet(int impurityoffset) Sets the amount of instances that will not be used to search split point

void setMinNumInstances(double minNum) Set the minumum number of instances to allow at a leaf node

void setNewPruningFactor(boolean newpruningfactor) Set the status of Pruning Factor

void setRegressionTree(boolean newregressionTree) Set the value of regressionTree.

void setSmoothingConstant(double smoothingconstant) Set the smoothing Constant

void setStopCriteria(int stopcriteria) Sets the Stop Criteria to Tree Greed

void setThreshold(double threshold) Set the threshold to allow at a leaf node

void split() Finds an attribute and split point for this node

int splitAtt() Get the index of the splitting attribute for this node

double splitVal() Get the split point for this node

java.lang.String toString() print the linear model at this node

java.lang.String treeToString(int level) Recursively builds a textual description of the tree

Methods inherited from class weka.classifiers.Classifier

223

debugTipText, distributionForInstance, forName, getDebug, getOptions, listOptions, makeCopies, setDebug, setOptions

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

m_numParameters

public int m_numParameters

the number of paramters in the chosen model for this node---either the subtree model or the linear model. The constant term is counted as a paramter---this is for pruning purposes

Constructor Detail

RuleNode

public RuleNode(double globalDev, double globalAbsDev, RuleNode parent)

Creates a new RuleNode instance. Parameters:

globalDev - the global standard deviation of the class globalAbsDev - the global absolute deviation of the class parent - the parent of this node

Method Detail

buildClassifier

public void buildClassifier(Instances data) throws java.lang.Exception

Build this node (find an attribute and split point) Specified by: buildClassifier in class Classifier Parameters: data - the instances on which to build this node Throws: java.lang.Exception - if an error occurs

224

classifyInstance

public double classifyInstance(Instance inst) throws java.lang.Exception

Classify an instance using this node. Recursively calls classifyInstance on child nodes. Overrides: classifyInstance in class Classifier Parameters: inst - the instance to classify Returns: the prediction for this instance Throws: java.lang.Exception - if an error occurs

split

public void split() throws java.lang.Exception

Finds an attribute and split point for this node Throws: java.lang.Exception - if an error occurs

numLeaves

public int numLeaves(int leafCounter)

Sets the leaves' numbers Parameters: leafCounter - the number of leaves counted Returns: the number of the total leaves under the node

toString

public java.lang.String toString()

print the linear model at this node

printNodeLinearModel

public java.lang.String printNodeLinearModel()

print the linear model at this node

225

printLeafModels

public java.lang.String printLeafModels()

print all leaf models

nodeToString

public java.lang.String nodeToString()

Returns a description of this node (debugging purposes) Returns: a string describing this node

treeToString

public java.lang.String treeToString(int level)

Recursively builds a textual description of the tree Parameters: level - the level of this node Returns: string describing the tree

installLinearModels

public void installLinearModels() throws java.lang.Exception

Traverses the tree and installs linear models at each node. This method must be called if pruning is not to be performed. Throws: java.lang.Exception - if an error occurs

installSmoothedModels

public void installSmoothedModels() throws java.lang.Exception

Throws: java.lang.Exception

prune

public void prune() throws java.lang.Exception

226

Recursively prune the tree Throws: java.lang.Exception - if an error occurs

findBestLeaf

public void findBestLeaf(double[] maxCoverage, RuleNode[] bestLeaf)

Find the leaf with greatest coverage Parameters: maxCoverage - the greatest coverage found so far bestLeaf - the leaf with the greatest coverage

returnLeaves

public void returnLeaves(FastVector[] v)

Return a list containing all the leaves in the tree Parameters: v - a single element array containing a vector of leaves

parentNode

public RuleNode parentNode()

Get the parent of this node Returns: the parent of this node

leftNode

public RuleNode leftNode()

Get the left child of this node Returns: the left child of this node

rightNode

public RuleNode rightNode()

Get the right child of this node Returns: the right child of this node

227

splitAtt

public int splitAtt()

Get the index of the splitting attribute for this node Returns: the index of the splitting attribute

splitVal

public double splitVal()

Get the split point for this node Returns: the split point for this node

numberOfLinearModels

public int numberOfLinearModels()

Get the number of linear models in the tree Returns: the number of linear models

isLeaf

public boolean isLeaf()

Return true if this node is a leaf Returns: true if this node is a leaf

getModel

public PreConstructedLinearModel getModel()

Get the linear model at this node Returns: the linear model at this node

getNumInstances

public int getNumInstances()

Return the number of instances that reach this node. Returns:

228

the number of instances at this node.

getRegressionTree

public boolean getRegressionTree()

Get the value of regressionTree. Returns: Value of regressionTree.

setMinNumInstances

public void setMinNumInstances(double minNum)

Set the minumum number of instances to allow at a leaf node Parameters: minNum - the minimum number of instances

setThreshold

public void setThreshold(double threshold)

Set the threshold to allow at a leaf node Parameters: threshold - the deviation fraction of instances

setSmoothingConstant

public void setSmoothingConstant(double smoothingconstant)

Set the smoothing Constant Parameters: smoothingconstant - the deviation fraction of instances

setEliminateColinearAttributes

public void setEliminateColinearAttributes(boolean newEliminateColinearAttributes)

Set the value of EliminateColinearAttributes. Parameters: newEliminateColinearAttributes - Value to assign to EliminateColinearAttributes.

setNewPruningFactor

229

public void setNewPruningFactor(boolean newpruningfactor)

Set the status of Pruning Factor Parameters: newpruningfactor - use to control what pruning factor are to be used

setAttributePreSelectionMethod

public void setAttributePreSelectionMethod(int attributepreselection)

Sets the method to pre select attributes for use in each linear regression Parameters: attributepreselection - method to pre select attributes for use in linear regressions at each node

setImpurityCalculation

public void setImpurityCalculation(int impuritycalculation)

Sets the method to calculate the impurity of a split (attribute selection) Parameters: impuritycalculation - method to impurity calculation

setImpurityOffSet

public void setImpurityOffSet(int impurityoffset)

Sets the amount of instances that will not be used to search split point Parameters: impurityoffset - the value of this off set

setStopCriteria

public void setStopCriteria(int stopcriteria)

Sets the Stop Criteria to Tree Greed Parameters: stopcriteria - the criteria

setConfLevel

public void setConfLevel(double conflevel)

Sets the Confidence Level to the F test in Stop Criteria Parameters: conflevel - the Confidence Level

230

getMinNumInstances

public double getMinNumInstances()

Get the minimum number of instances to allow at a leaf node Returns: a double value

setRegressionTree

public void setRegressionTree(boolean newregressionTree)

Set the value of regressionTree. Parameters: newregressionTree - Value to assign to regressionTree.

printAllModels

public void printAllModels()

Print all the linear models at the learf (debugging purposes)

graph

public void graph(java.lang.StringBuffer text)

Assign a unique identifier to each node in the tree and then calls graphTree Parameters: text - a StringBuffer value

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

231

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Interface SplitEvaluate All Known Implementing Classes:

CorrelationSplitInfo, YongSplitInfo

public interface SplitEvaluate

Interface for objects that determine a split point on an attribute

Version: $Revision: 1.1 $

Author: Mark Hall (mhall@cs.waikato.ac.nz)

Method Summary void attrSplit(int attr, Instances inst)

Finds the best splitting point for an attribute in the instances SplitEvaluate copy()

makes a copy of the SplitEvaluate object double maxImpurity()

Returns the impurity of this split int position()

Returns the position of the split in the sorted values. -1 indicates that a split could not be found.

int splitAttr() Returns the attribute used in this split

double splitValue() Returns the split value

Method Detail

copy

public SplitEvaluate copy() throws java.lang.Exception

makes a copy of the SplitEvaluate object

232

Returns: a copy of the object Throws: java.lang.Exception

attrSplit

public void attrSplit(int attr, Instances inst) throws java.lang.Exception

Finds the best splitting point for an attribute in the instances Parameters: attr - the splitting attribute inst - the instances Throws: java.lang.Exception - if something goes wrong

maxImpurity

public double maxImpurity()

Returns the impurity of this split Returns: the impurity of this split

position

public int position()

Returns the position of the split in the sorted values. -1 indicates that a split could not be found. Returns: an int value

splitAttr

public int splitAttr()

Returns the attribute used in this split Returns: the attribute used in this split

splitValue

public double splitValue()

233

Returns the split value Returns: the split value

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

234

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class Statistic java.lang.Object weka.classifiers.trees.m5_5.Statistic

public class Statistic extends java.lang.Object

Compute statistical distributions F and T. Adapted from Numerical Recipes in C.

Author: Paulo Sergio Coelho

Constructor Summary Statistic()

Method Summary static double betacf(double a, double b, double x)

Continued fraction rotine for betai function. static double betai(double a, double b, double x)

Returns the value of incomplete beta function Ix(a,b). static double Fdist(double F, int df1, int df2)

Computes the probability of an F value distributed with df1 and df2 degrees of freedon In accord of Numerical Recipes in C, page 619

static double gammln(double xx) Returns the value of ln Gamma(xx), for xx > 0.

static double tdist(double t, int df) Computes the probability of an t value distributed with df degree of freedom In accord of Numerical Recipes in C, page 619

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, toString, wait, wait,

235

wait

Constructor Detail

Statistic

public Statistic()

Method Detail

gammln

public static double gammln(double xx)

Returns the value of ln Gamma(xx), for xx > 0. In accord of Numerical Recipes in C, page 214 Returns: the value of ln of Gamma Function

betai

public static double betai(double a, double b, double x)

Returns the value of incomplete beta function Ix(a,b). In accord of Numerical Recipes in C, page 227 Parameters: a - the lower limit b - the upper limit x - the value to be calculated Returns: the value of Incomplete beta function

betacf

public static double betacf(double a, double b, double x)

Continued fraction rotine for betai function. In accord of Numerical Recipes in C, page 227 Parameters: a - the lower limit b - the upper limit

236

x - the value to be calculated

Fdist

public static double Fdist(double F, int df1, int df2)

Computes the probability of an F value distributed with df1 and df2 degrees of freedon In accord of Numerical Recipes in C, page 619 Parameters: F - the F Stat df1 - the numerator degree of freedom df2 - the denominator df Returns: the value of Fdist

tdist

public static double tdist(double t, int df)

Computes the probability of an t value distributed with df degree of freedom In accord of Numerical Recipes in C, page 619 Parameters: t - the t Stat df - the degree of freedom Returns: the value of tdist

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

237

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class Values java.lang.Object weka.classifiers.trees.m5_5.Values

public final class Values extends java.lang.Object

Stores some statistics.

Version: $Revision: 1.5 $

Author: Yong Wang (yongwang@cs.waikato.ac.nz)

Constructor Summary Values(int low, int high, int attribute, Instances inst) Constructs an object which stores some statistics of the instances such as sum, squared sum, variance, standard deviation

Method Summary java.lang.String toString()

Converts the stats to a string

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Detail

Values

238

public Values(int low, int high, int attribute, Instances inst)

Constructs an object which stores some statistics of the instances such as sum, squared sum, variance, standard deviation

Parameters: low - the index of the first instance high - the index of the last instance attribute - the attribute inst - the instances

Method Detail

toString

public final java.lang.String toString()

Converts the stats to a string Returns: the converted string

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

239

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.trees.m5_5 Class YongSplitInfo java.lang.Object weka.classifiers.trees.m5_5.YongSplitInfo All Implemented Interfaces:

java.lang.Cloneable, java.io.Serializable, SplitEvaluate

public final class YongSplitInfo extends java.lang.Object implements java.lang.Cloneable, java.io.Serializable, SplitEvaluate

Stores split information.

Version: $Revision: 1.1 $

Author: Yong Wang (yongwang@cs.waikato.ac.nz), Mark Hall (mhall@cs.waikato.ac.nz)

See Also: Serialized Form

Constructor Summary YongSplitInfo(int low, int high, int attr, int impuritycalculation, int impurityoffset) Constructs an object which contains the split information

Method Summary void attrSplit(int attr, Instances inst)

Finds the best splitting point for an attribute in the instances

SplitEvaluate copy() Makes a copy of this SplitInfo object

void initialize(int low, int high, int attr) Resets the object of split information

double maxImpurity() Returns the impurity of this split

240

int position() Returns the position of the split in the sorted values. -1 indicates that a split could not be found.

int splitAttr() Returns the attribute used in this split

double splitValue() Returns the split value

java.lang.String toString(Instances inst) Converts the spliting information to string

Methods inherited from class java.lang.Object equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

YongSplitInfo

public YongSplitInfo(int low, int high, int attr, int impuritycalculation, int impurityoffset)

Constructs an object which contains the split information Parameters:

low - the index of the first instance high - the index of the last instance attr - an attribute

Method Detail

copy

public final SplitEvaluate copy() throws java.lang.Exception

Makes a copy of this SplitInfo object Specified by: copy in interface SplitEvaluate Returns: a copy of the object Throws: java.lang.Exception

241

initialize

public final void initialize(int low, int high, int attr)

Resets the object of split information Parameters: low - the index of the first instance high - the index of the last instance attr - the attribute

toString

public final java.lang.String toString(Instances inst)

Converts the spliting information to string Parameters: inst - the instances

attrSplit

public final void attrSplit(int attr, Instances inst) throws java.lang.Exception

Finds the best splitting point for an attribute in the instances Specified by: attrSplit in interface SplitEvaluate Parameters: attr - the splitting attribute inst - the instances Throws: java.lang.Exception - if something goes wrong

maxImpurity

public double maxImpurity()

Returns the impurity of this split Specified by: maxImpurity in interface SplitEvaluate Returns: the impurity of this split

splitAttr

242

public int splitAttr() Returns the attribute used in this split Specified by: splitAttr in interface SplitEvaluate Returns: the attribute used in this split

position

public int position()

Returns the position of the split in the sorted values. -1 indicates that a split could not be found. Specified by: position in interface SplitEvaluate Returns: an int value

splitValue

public double splitValue()

Returns the split value Specified by: splitValue in interface SplitEvaluate Returns: the split value

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

243

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD

weka.classifiers.functions Class LinearRegression java.lang.Object weka.classifiers.Classifier weka.classifiers.functions.LinearRegression All Implemented Interfaces:

java.lang.Cloneable, OptionHandler, java.io.Serializable, WeightedInstancesHandler

public class LinearRegression extends Classifier implements OptionHandler, WeightedInstancesHandler

Class for using linear regression for prediction. Uses the Akaike criterion for model selection, and is able to deal with weighted instances.

Valid options are:

-D Produce debugging output.

-S num Set the attriute selection method to use. 1 = None, 2 = Greedy (default 0 = M5' method)

-C Do not try to eliminate colinear attributes

-R num The ridge parameter (default 1.0e-8)

Version: $Revision: 1.19 $

Author: Eibe Frank (eibe@cs.waikato.ac.nz), Len Trigg (trigg@cs.waikato.ac.nz)

See Also: Serialized Form

Field Summary static int SELECTION_GREEDY

244

static int SELECTION_M5

static int SELECTION_NONE

static Tag[] TAGS_SELECTION

Constructor Summary LinearRegression()

Method Summary java.lang.String attributeSelectionMethodTipText()

Returns the tip text for this property void buildClassifier(Instances data)

Builds a regression model for the given data. double calculateSE(boolean[] selectedAttributes,

double[] coefficients) Calculate the squared error of a regression model on the training data

double classifyInstance(Instance instance) Classifies the given instance using the linear regression function.

double[] coefficients() Returns the coefficients for this linear model.

java.lang.String debugTipText() Returns the tip text for this property

java.lang.String eliminateColinearAttributesTipText() Returns the tip text for this property

SelectedTag getAttributeSelectionMethod() Gets the method used to select attributes for use in the linear regression.

boolean getDebug() Controls whether debugging output will be printed

boolean getEliminateColinearAttributes() Get the value of EliminateColinearAttributes.

int getNumInstances() The num of instances used to estimate the model

java.lang.String[] getOptions() Gets the current settings of the classifier.

245

double getRidge() Get the value of Ridge.

double getSSE() The Sum Squared Error of final regression

double getSST() The Total Deviation of the class attribute

java.lang.String globalInfo() Returns a string describing this classifier

java.util.Enumeration listOptions() Returns an enumeration describing the available options.

static void main(java.lang.String[] argv) Generates a linear regression function predictor.

int numParameters() Get the number of coefficients used in the model

java.lang.String ridgeTipText() Returns the tip text for this property

void setAttributeSelectionMethod(SelectedTag method) Sets the method used to select attributes for use in the linear regression.

void setDebug(boolean debug) Controls whether debugging output will be printed

void setEliminateColinearAttributes(boolean newEliminateColinearAttributes) Set the value of EliminateColinearAttributes.

void setOptions(java.lang.String[] options) Parses a given list of options.

void setRidge(double newRidge) Set the value of Ridge.

java.lang.String toString() Outputs the linear regression model as a string.

void turnChecksOff() Turns off checks for missing values, etc.

void turnChecksOn() Turns on checks for missing values, etc.

Methods inherited from class weka.classifiers.Classifier distributionForInstance, forName, makeCopies

Methods inherited from class java.lang.Object

246

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

SELECTION_M5

public static final int SELECTION_M5 See Also:

Constant Field Values

SELECTION_NONE

public static final int SELECTION_NONE See Also:

Constant Field Values

SELECTION_GREEDY

public static final int SELECTION_GREEDY See Also:

Constant Field Values

TAGS_SELECTION

public static final Tag[] TAGS_SELECTION

Constructor Detail

LinearRegression

public LinearRegression()

Method Detail

getSST

public double getSST()

The Total Deviation of the class attribute

247

getSSE

public double getSSE()

The Sum Squared Error of final regression

getNumInstances

public int getNumInstances()

The num of instances used to estimate the model

turnChecksOff

public void turnChecksOff()

Turns off checks for missing values, etc. Use with caution. Also turns off scaling.

turnChecksOn

public void turnChecksOn()

Turns on checks for missing values, etc. Also turns on scaling.

globalInfo

public java.lang.String globalInfo()

Returns a string describing this classifier Returns: a description of the classifier suitable for displaying in the explorer/experimenter gui

buildClassifier

public void buildClassifier(Instances data) throws java.lang.Exception

Builds a regression model for the given data. Specified by: buildClassifier in class Classifier Parameters: data - the training data to be used for generating the linear regression function Throws: java.lang.Exception - if the classifier could not be built successfully

248

classifyInstance

public double classifyInstance(Instance instance) throws java.lang.Exception

Classifies the given instance using the linear regression function. Overrides: classifyInstance in class Classifier Parameters: instance - the test instance Returns: the classification Throws: java.lang.Exception - if classification can't be done successfully

toString

public java.lang.String toString()

Outputs the linear regression model as a string.

listOptions

public java.util.Enumeration listOptions()

Returns an enumeration describing the available options. Specified by: listOptions in interface OptionHandler Overrides: listOptions in class Classifier Returns: an enumeration of all the available options.

setOptions

public void setOptions(java.lang.String[] options) throws java.lang.Exception

Parses a given list of options. Valid options are:

-D Produce debugging output.

-S num Set the attriute selection method to use. 1 = None, 2 = Greedy (default 0 = M5' method)

249

-C Do not try to eliminate colinear attributes

-R num The ridge parameter (default 1.0e-8)

Specified by: setOptions in interface OptionHandler Overrides: setOptions in class Classifier Parameters: options - the list of options as an array of strings Throws: java.lang.Exception - if an option is not supported

coefficients

public double[] coefficients()

Returns the coefficients for this linear model.

getOptions

public java.lang.String[] getOptions()

Gets the current settings of the classifier. Specified by: getOptions in interface OptionHandler Overrides: getOptions in class Classifier Returns: an array of strings suitable for passing to setOptions

ridgeTipText

public java.lang.String ridgeTipText()

Returns the tip text for this property Returns: tip text for this property suitable for displaying in the explorer/experimenter gui

getRidge

public double getRidge()

Get the value of Ridge. Returns:

250

Value of Ridge.

setRidge

public void setRidge(double newRidge)

Set the value of Ridge. Parameters: newRidge - Value to assign to Ridge.

eliminateColinearAttributesTipText

public java.lang.String eliminateColinearAttributesTipText()

Returns the tip text for this property Returns: tip text for this property suitable for displaying in the explorer/experimenter gui

getEliminateColinearAttributes

public boolean getEliminateColinearAttributes()

Get the value of EliminateColinearAttributes. Returns: Value of EliminateColinearAttributes.

setEliminateColinearAttributes

public void setEliminateColinearAttributes(boolean newEliminateColinearAttributes)

Set the value of EliminateColinearAttributes. Parameters: newEliminateColinearAttributes - Value to assign to EliminateColinearAttributes.

numParameters

public int numParameters()

Get the number of coefficients used in the model Returns: the number of coefficients

attributeSelectionMethodTipText

251

public java.lang.String attributeSelectionMethodTipText()

Returns the tip text for this property Returns: tip text for this property suitable for displaying in the explorer/experimenter gui

setAttributeSelectionMethod

public void setAttributeSelectionMethod(SelectedTag method)

Sets the method used to select attributes for use in the linear regression. Parameters: method - the attribute selection method to use.

getAttributeSelectionMethod

public SelectedTag getAttributeSelectionMethod()

Gets the method used to select attributes for use in the linear regression. Returns: the method to use.

debugTipText

public java.lang.String debugTipText()

Returns the tip text for this property Overrides: debugTipText in class Classifier Returns: tip text for this property suitable for displaying in the explorer/experimenter gui

setDebug

public void setDebug(boolean debug)

Controls whether debugging output will be printed Overrides: setDebug in class Classifier Parameters: debug - true if debugging output should be printed

getDebug

public boolean getDebug()

Controls whether debugging output will be printed

252

Overrides: getDebug in class Classifier Returns: true if debugging output is on

calculateSE

public double calculateSE(boolean[] selectedAttributes, double[] coefficients) throws java.lang.Exception

Calculate the squared error of a regression model on the training data Parameters: selectedAttributes - an array of flags indicating which attributes are included in the regression model coefficients - an array of coefficients for the regression model Returns: the mean squared error on the training data Throws: java.lang.Exception - if there is a missing class value in the training data

main

public static void main(java.lang.String[] argv)

Generates a linear regression function predictor.

Overview Package Class Tree Deprecated Index Help Weka's home

PREV CLASS NEXT CLASS FRAMES NO FRAMES All Classes SUMMARY: NESTED | FIELD | CONSTR | METHOD DETAIL: FIELD | CONSTR | METHOD