C.pia de TeseCompleta pos Defesa - cin.ufpe.brjtalr/Mestrado/COELHO_PSS_05_t_D_int.pdf · Prof....
Transcript of C.pia de TeseCompleta pos Defesa - cin.ufpe.brjtalr/Mestrado/COELHO_PSS_05_t_D_int.pdf · Prof....
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 ([email protected])
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 ([email protected])
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 ([email protected])
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 ([email protected])
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 ([email protected])
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 ([email protected])
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 ([email protected]), Mark Hall ([email protected])
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 ([email protected]), Len Trigg ([email protected])
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