Bot Tesisdegradoingenieriainformatica

Facultad de Ingeniera de la Universidad de Buenos Aires
Ingeniera en Informtica

Tesis de Grado

Data Mining utilizando
Redes Neuronales

Tutor: Dr. Juan M. Ale

Tesista: Romina Laura Bot

Padrn: 75722
E-mail: rbot@fi.uba.ar

- Mayo de 2005 -
Universidad de Buenos Aires Data Mining utilizando Redes Neuronales

Facultad de Ingeniera

Romina Laura Bot 1
Padrn 75722

Resumen

Las Redes Neuronales son ampliamente utilizadas para tareas relacionadas con
reconocimiento de patrones y clasificacin. Aunque son clasificadores muy precisos,
no son comnmente utilizadas para Data Mining porque producen modelos de
aprendizaje inexplicables. El algoritmo TREPAN extrae hiptesis explicables de una
Red Neuronal entrenada. Las hiptesis producidas por el algoritmo se representan
con un rbol de decisin que aproxima a la red. Los rboles de decisin extrados
por TREPAN no pueden describir predicciones de Redes Neuronales entrenadas para
realizar tareas de regresin y, algunas veces, los rboles de decisin extrados no
son lo suficientemente concisos. En el presente trabajo se presentan dos nuevos
algoritmos de extraccin de reglas que construyen rboles difusos y rboles modelo
a partir de una Red Neuronal entrenada, para ser utilizados en aquellos casos en
los que el rbol de decisin no es lo suficientemente conciso, o no describe
correctamente el mtodo de clasificacin de la Red Neuronal que realiza tareas de
regresin. Con estos nuevos mtodos es posible comprender el mtodo de
clasificacin de una Red Neuronal entrenada para un rango de dominios no cubierto
por TREPAN.


Romina Laura Bot 2
Padrn 75722

Abstract

Neural Networks are widely used for pattern recognition and classification. Although
they often provide a high level of predictive accuracy, Neural Networks are not
commonly used for Data Mining because the learning models generated are difficult
to understand. TREPAN algorithm extracts understandable hypotheses from a
trained Neural Network. The hypothesis produced by the algorithm is a decision
tree that approximates the network. Decision trees extracted from TREPAN cannot
describe real-valued predictions of networks trained to perform regression tasks.
The above mentioned decision trees exhibit a high level of fidelity to their target
network, however, sometimes they tend to be complex. In this thesis we present
two new rule extraction algorithms capable to construct fuzzy decision trees and
model trees from a trained Neural Network, to be applied in those cases where
decision trees are not concise, and to describe real-valued predictions of networks
trained to perform regression tasks. These new algorithms make it possible to
understand the classification method used by a trained Neural Network in domains
not covered by TREPAN.


Romina Laura Bot 3
Padrn 75722

Contenido

1. Introduccin........................................................................................... 4
1.1 Contribucin.................................................................................... 4
1.2 Estructura de la Tesis ....................................................................... 5
2. Antecedentes ......................................................................................... 6
2.1 Data Mining y Clasificacin ................................................................ 6
2.2 Redes Neuronales............................................................................. 8
3. Extraccin de Reglas utilizando Redes Neuronales......................................12
3.1 Extraccin de Reglas de una Red Neuronal Simple...............................13
3.2 Mtodos de Extraccin de Reglas basados en la Bsqueda....................15
3.3 Mtodos de Aprendizaje de Hiptesis Simples .....................................16
3.4 Mtodos de Extraccin de Reglas basados en la Topologa ....................17
3.5 Mtodos de Extraccin de Reglas basados en el Aprendizaje.................19
3.6 Algoritmo TREPAN...........................................................................21
3.7 Una Implementacin del Algoritmo TREPAN........................................23
3.8 Limitaciones de TREPAN...................................................................28
4. Mejoras al mtodo TREPAN .....................................................................29
4.1 rboles Modelo ...............................................................................29
4.2 rboles Difusos ...............................................................................29
5. TREPAN M5 ...........................................................................................31
5.1 Algoritmo M5 .................................................................................31
5.2 Implementacin del algoritmo TREPAN M5..........................................32
6. TREPAN Fuzzy .......................................................................................36
6.1 Discretizacin Suave........................................................................36
6.2 Implementacin del Algoritmo TREPAN Fuzzy .....................................38
7. Criterios de Evaluacin de los Clasificadores..............................................47
7.1 Comprensibilidad.............................................................................47
7.2 Fidelidad ........................................................................................48
7.3 Precisin ........................................................................................48
7.4 Escalabilidad...................................................................................49
7.5 Generalidad....................................................................................49
8. Resultados Experimentales......................................................................50
8.1 TREPAN M5 ....................................................................................50
8.2 TREPAN Fuzzy.................................................................................72
9. Conclusiones y Trabajo Futuro.................................................................99
10. Referencias...................................................................................... 100
A. Diseo de la Solucin ........................................................................... 103
B. Manual de Usuario ............................................................................... 108
C. Cdigo Fuente ..................................................................................... 112
D. Software............................................................................................. 215


Romina Laura Bot 4
Padrn 75722

Data Mining utilizando Redes Neuronales

1. Introduccin

El objetivo de hacer Data Mining es la bsqueda de informacin nueva al explorar
un gran volumen de datos. A menudo, para alcanzar este objetivo se aplican
mtodos de aprendizaje supervisado y no supervisado, que construyen modelos
sobre los datos que se estn manejando.

Las Redes Neuronales se han utilizado en una gran variedad de aplicaciones de
aprendizaje supervisado y no supervisado, para tareas relacionadas con
clasificacin y reconocimientos de patrones. Sin embargo, aunque son clasificadores
muy precisos, no son comnmente utilizadas para Data Mining porque producen
modelos de aprendizaje inexplicables y requieren mucho tiempo de entrenamiento
(Craven et al., [5]). Las Redes Neuronales pueden predecir con gran precisin, pero
son como una "caja negra. En la mayora de las tareas de aprendizaje, es
importante construir clasificadores que no slo sean precisos, sino tambin fciles
de entender por los humanos (Craven et al., [8]).

Existen varios enfoques para realizar Data Mining utilizando Redes Neuronales que
son capaces de producir modelos explicables y no requieren tiempos de
entrenamiento excesivos. En uno de los enfoques, llamado `Extraccin de Reglas,
se extraen modelos simblicos de Redes Neuronales ya entrenadas.

En (Craven & Shavlik, [8]) los autores han desarrollado un algoritmo que extrae
reglas a partir de una Red Neuronal entrenada. El algoritmo TREPAN construye un
rbol de decisin con reglas m-de-n que modela el mtodo de clasificacin de la
Red Neuronal. Los rboles de decisin extrados por TREPAN no pueden describir
predicciones de Redes Neuronales entrenadas para realizar tareas de regresin y,
algunas veces, los rboles de decisin extrados no son lo suficientemente concisos.
En el presente trabajo se presentan dos nuevos algoritmos de extraccin de reglas
que construyen rboles difusos y rboles modelo a partir de una Red Neuronal
entrenada (Bot et al., [2]).

El objetivo de esta Tesis de Grado es ampliar la aplicabilidad de los algoritmos
existentes para obtener modelos explicables a partir de Redes Neuronales,
particularmente en aquellos casos para los que el rbol de decisin no es lo
suficientemente conciso o no describe correctamente el mtodo de clasificacin de
la Red Neuronal que realiza tareas de regresin.

Para validar los algoritmos propuestos se han realizado pruebas con el fin de
comprobar que efectivamente los rboles extrados representan el mtodo de
clasificacin de la red, y evaluar la escalabilidad de los algoritmos.

1.1 Contribucin

La contribucin de esta tesis es la siguiente:

a) Desarrollo del algoritmo TREPAN FUZZY para extraer rboles difusos a partir
de una Red Neuronal entrenada. Con este nuevo mtodo es posible obtener
rboles concisos y con un alto grado de fidelidad a la red, en aquellos

Romina Laura Bot 5
Padrn 75722

datasets con valores continuos para los que el rbol de decisin no es lo
suficientemente conciso.

b) Desarrollo del algoritmo TREPAN M5 para extraer rboles modelo a partir de
una Red Neuronal entrenada. Con este nuevo mtodo es posible comprender
el mtodo de clasificacin de una Red Neuronal entrenada para un rango de
dominios no cubierto por TREPAN. Especficamente, en aquellos dominios
donde en lugar de asignar una clase como resultado de la clasificacin se
asignan valores numricos

c) Experimentacin exhaustiva de los algoritmos desarrollados para comprobar
que efectivamente los rboles extrados modelan el mtodo de clasificacin
de la red, comparar los resultados con respecto a los algoritmos existentes y
evaluar la escalabilidad de los algoritmos.

1.2 Estructura de la Tesis

Esta tesis se ha organizado de la siguiente manera: En el Capitulo 2 se detallan los
antecedentes. La Extraccin de Reglas de clasificacin a partir de Redes Neuronales
se trata en el Capitulo 3, donde se presentan diferentes mtodos de extraccin. Se
profundiza en aquellos mtodos de Extraccin de Reglas que utilizan Redes
Neuronales ya entrenadas, presentando el algoritmo TREPAN, y se analizan las
ventajas y desventajas de este mtodo. En el Capitulo 4 se detallan las posibles
mejoras al mtodo TREPAN. En los Captulos 5 y 6 se presentan los nuevos
algoritmos de extraccin de reglas TREPAN M5 y TREPAN Fuzzy, implementados en
Java para integrarlos al sistema Weka (Witten et al., [38]). En el Capitulo 7 se
describen los criterios utilizados para evaluar a los nuevos clasificadores. Los
resultados de las pruebas realizadas y la comparacin de los distintos mtodos se
tratan en el Capitulo 8, donde se analizan los resultados obtenidos. Por ltimo, el
Capitulo 9 corresponde a la conclusin.


Romina Laura Bot 6
Padrn 75722

2. Antecedentes

En este captulo se detallan los antecedentes del presente trabajo. La primer
seccin describe los objetivos de Data Mining y en particular, de los clasificadores.
La segunda seccin provee una introduccin a las Redes Neuronales, indicando sus
ventajas y limitaciones.

2.1 Data Mining y Clasificacin

Uno de los objetivos fundamentales de Data Mining es poder predecir el valor de
una variable predictiva o dependiente en funcin de los valores de otras variables
llamadas independientes, existentes en una base de datos. Varios algoritmos
realizan este tipo de tareas y pueden clasificarse como: de asociacin, clasificacin,
clustering, etc.

Los clasificadores asignan `clases a las instancias de un dataset. Para un conjunto
de registros con sus correspondientes atributos y una clase asignada a cada uno de
ellos, un clasificador produce descripciones de las caractersticas de los registros de
cada clase. Como resultado se extraen reglas que pueden ser utilizadas para
clasificar nuevos datasets.

2.1.1 Clasificadores

Existen diversos modelos de clasificacin entre los que se encuentran los rboles de
decisin, los rboles de regresin, las redes neuronales y los modelos genticos. A
continuacin se definen algunos de estos modelos:

rboles de Decisin. Un rbol de decisin es un discriminador de clases que,
recursivamente, particiona un conjunto de instancias hasta que cada particin
consista ntegramente, o dominadamente, de ejemplos de una clase. Cada nodo
interno de un rbol contiene un punto de separacin o criterio de particin, el que
consiste de un test sobre uno o ms atributos y determina el particionamiento de
los datos. Los rboles de decisin representan reglas.

Regresiones Lineales. Una funcin de regresin lineal modela la salida de la
clasificacin como una combinacin lineal de los atributos de entrada. Las
regresiones lineales se utilizan para clasificar datasets con clases numricas.

rboles de Regresin. Un rbol de regresin tiene una estructura similar a la de
un rbol de decisin, pero sus hojas son valores reales en lugar de identificadores
de clases. Al igual que las regresiones lineales, se utilizan para clasificar datasets
con clases numricas.

Redes Neuronales. Son modelos simples de interconexiones neuronales. Una
neurona artificial simula el proceso de una neurona en el cerebro humano. Una red
neuronal arprende desde un conjunto de entrenamiento desde el que generaliza
patrones para clasificacin y prediccin. Las Redes Neuronales se presentan en
detalle en la prxima seccin.

Algoritmos Genticos. Son mtodos de optimizacin combinatoria que se basan
en las simulacin de los procesos evolutivos de la naturaleza. Se debe definir una
funcin objetivo llamada funcin de fitness y una representacin para los objetos

Romina Laura Bot 7
Padrn 75722

del modelo, normalmente como un cromosoma. Se aplican diversos operadores:
seleccin, mutacin y crossover (recombinacin) a una poblacin inicial,
generndose as nuevos objetos (hijos) que reemplazan a los padres. Los objetos
que "sobreviven son los que tienen mejores valores de fitness.

2.1.2 Tipos de Reglas

Las reglas extradas como resultado de la clasificacin pueden ser inferencias
conjuntivas (if-then), reglas m-de-n, reglas difusas, etc.

Reglas If-Then. Las reglas if-then son expresiones booleanas del tipo:

SI (condicin
1
Y condicin
2
Y .... Y condicin
n
son verdaderas)
ENTONCES conclusin es verdadera

Una regla if-then se satisface cuando todas sus condiciones son satisfechas. Una de
las caractersticas de las reglas if-then es que son reglas modulares: cada una
define un espacio de conocimiento relativamente pequeo e independiente.

Reglas M-de-N. Una expresin m-de-n es una expresin Booleana, especificada
por un umbral entero, m, y un conjunto de n condiciones booleanas. Una expresin
m-de-n se satisface cuando al menos m de sus n condiciones son satisfechas:

SI (n de los m antecedentes son verdaderos)
ENTONCES conclusin es verdadera

Por ejemplo, para tres atributos bolanos a, b y c, la expresin 2-de-{a, b, c} es
lgicamente equivalente a (a b) (a c) (b c). Una regla m-de-n consiste
en la conjuncin de una o ms expresiones m-de-n. Las reglas m-de-n son ms
concisas que las reglas if-then.

Reglas Difusas. Las reglas difusas proveen probabilidades de clasificacin en lugar
de respuestas del tipo "si/no. Una regla difusa if-then simple asume la forma:

SI x es A
ENTONCES y es B

Donde A y B son valores definidos por conjuntos difusos dentro del rango X e Y
respectivamente. Por ejemplo, para la regla:

SI el servicio es bueno
ENTONCES el precio es aceptable

El valor "bueno se representa con un nmero entre 0 y 1 (el antecedente es una
interpretacin que retorna un nico valor entre 0 y 1). Por otro lado, "aceptable se
representa como un conjunto difuso (el consecuente es una asignacin del conjunto
difuso B a la variable de salida y). Aplicando un proceso de difusin inverso al
conjunto difuso se obtiene un nico valor de salida.

2.1.3 Aplicaciones

Ejemplos de aplicacin incluyen la clasificacin de tendencias en mercados
financieros, diagnstico y tratamientos mdicos, prediccin de respuestas de
clientes y la identificacin automatizada de objetos de inters en grandes bases de
datos de imgenes. Por ejemplo, para evaluar el riesgo crediticio se clasifican los

Romina Laura Bot 8
Padrn 75722

aspirantes a un crdito como de riesgo bajo, medio o alto; en el diagnstico mdico
los pacientes se clasifican de acuerdo a los sntomas como padeciendo una
determinada enfermedad, etc.

2.1.4 Evaluacin de un Clasificador

La precisin de la clasificacin, definida como el porcentaje de muestras clasificadas
correctamente en las pruebas, constituye la mtrica primaria para evaluar un
clasificador. Otras mtricas, denominadas secundarias, son el tiempo de
clasificacin y la complejidad del modelo extrado, por ejemplo, el tamao para un
rbol de decisin o la cantidad de antecedentes para una regla.

2.1.5 Aprendizaje Supervisado

El aprendizaje supervisado es muy til en Data Mining ya que al construir modelos
descriptivos de un conjunto de datos se provee una forma de explorarlos.

En el aprendizaje supervisado, se da al clasificador un conjunto de instancias de la
forma (x, y), donde y representa la variable que el sistema debe predecir, y x es el
vector de valores de los atributos relevantes para determinar y. El objetivo del
aprendizaje supervisado es inducir un mapeo general de vectores x a valores y. O
sea, el clasificador debe construir un modelo y = f(x) de la funcin f desconocida
que permita predecir los valores y para ejemplos no conocidos previamente.

Los mtodos de construccin de rboles y las Redes Neuronales generalmente
utilizan aprendizaje supervisado.

2.2 Redes Neuronales

Las Redes Neuronales son colecciones de nodos conectados, con entradas, salidas y
procesamiento en cada nodo. Entre las entradas y las salidas de la red existe un
nmero de capas ocultas de procesamiento. La Red Neuronal debe ser entrenada
con un conjunto de patrones de entrenamiento (aprendizaje supervisado). Una vez
entrenada es utilizada para hacer predicciones.

Las Redes Neuronales se utilizan para clasificacin y para reconocimiento de
patrones. Dado un conjunto fijo de ejemplos de entrenamiento, existen muchos
modelos que podran representar esos datos, y cada algoritmo de aprendizaje
determina alguno de esos modelos. Para algunos problemas las Redes Neuronales
proveen una mejor induccin que el resto de los algoritmos. Son, en muchos casos,
el mtodo de aprendizaje preferido porque inducen hiptesis que generalizan mejor
que los otros algoritmos. Varios estudios indican que hay algunos dominios de
problemas donde las Redes Neuronales proveen mayor precisin predictiva que los
algoritmos de aprendizaje simblicos comnmente utilizados (por ejemplo: rboles
de decisin). An as, las Redes Neuronales no son muy utilizadas para Data
Mining. Hay dos razones principales: los mtodos de clasificacin de las redes
neuronales ya entrenadas no son explicables, y los tiempos de aprendizaje son
lentos, imprcticos para grandes volmenes de datos (Craven et al., [5]).

Existe una gran variedad de arquitecturas y mtodos de aprendizaje de Redes
Neuronales. Los mtodos de aprendizaje pueden ser supervisados o no
supervisados. En esta tesis se utilizarn Redes Neuronales Feed-Forward, que sern
detalladas a continuacin.

Romina Laura Bot 9
Padrn 75722

2.2.1 Redes Neuronales Biolgicas

En el cerebro humano, una neurona tpica recibe seales de otras neuronas a
travs de un conjunto de finas estructuras llamadas dendritas. La neurona enva
picos de actividad elctrica a travs de una fibra nerviosa larga y fina, el axn, que
se divide en ramas, conduciendo el pulso a varios cientos de neuronas. Los
contactos de un axn pueden estar localizados en las dendritas o directamente en
el cuerpo de la neurona destino y son conocidos como sinapsis. Las sinapsis
convierten la actividad del axn en efectos elctricos que inhiben o excitan la
actividad del axn, inhibiendo o excitando la actividad en las neuronas conectadas.

Figura 1.1 - Componentes de una Neurona

Cuando una neurona recibe una entrada excitada que es lo suficientemente grande
comparada con un cierto valor umbral, enva un pico de actividad elctrica a travs
de su axn. El aprendizaje ocurre por cambios en la efectividad de las sinapsis que
producen que la influencia de una neurona sobre otra cambie.

Figura 1.1 - Sinapsis

2.2.2 Estructura de las Redes Neuronales

Una Red Neuronal Feed-Forward se compone de varias capas de unidades de
procesamiento simple, llamadas neuronas. El estado de una neurona se representa
por su activacin, que es un valor numrico real, tpicamente en el rango [0, 1] o
en el rango [-1, 1]. La capa de entrada de una red contiene neuronas cuyas
activaciones representan los valores de los atributos del dominio donde la red es

Romina Laura Bot 10
Padrn 75722

aplicada. Generalmente, los atributos numricos se representan con una neurona
de entrada, y los atributos discretos con n valores posibles se representan con n
neuronas de entrada. Las neuronas de la capa de salida de la red representan las
decisiones tomadas por la red. Entre las neuronas de entrada y de salida puede
existir un nmero de capas ocultas de neuronas. Las neuronas se conectan entre s
mediante conexiones de distintos pesos.

Figura 1.3 - Red Neuronal. Las neuronas en la capa de entrada representan
atributos del dominio. Las neuronas de la capa de salida representan las
predicciones de la red. Las neuronas de las capas ocultas permiten que la red
aprenda y utilice atributos "derivados.

Una red utilizada para clasificacin que solo tiene neuronas de entrada y salida es
capaz de representar nicamente lmites de decisin lineales. Para representar
lmites ms complejos es necesario agregar neuronas ocultas a la red. El rol de las
neuronas ocultas es transformar el espacio de entrada en otro espacio ms propicio
para que las neuronas de salida puedan realizar discriminaciones lineales.

La clasificacin en una Red Neuronal Feed-Forward comienza asignando los valores
de activacin de las neuronas de entrada correspondientes para representar una
instancia del dominio. La activacin de las entradas avanza a travs de las
conexiones hacia las neuronas de las capas ocultas y luego a las neuronas de la
capa de salida. La respuesta dada por la red es determinada por las activaciones
resultantes en las neuronas de salida.

Las redes Feed-Forward permiten que las seales viajen en un nico sentido, desde
las neuronas de entrada hacia las neuronas de salida. No hay feedback entre las
neuronas.

La entrada de una neurona oculta o de salida est dada por:

EN
i
=
j
w
ij
a
j
+
i

y
Capa de Entrada
Capa de Salida
Capa Oculta
x
1
x
2
x
3
x
4
x
5
x
6


Romina Laura Bot 11
Padrn 75722

Donde w
ij
es el peso de la conexin de la neurona j con la neurona i, a
j
es la
activacin de la neurona j y
i
es el umbral para la neurona i. El umbral de una
neurona, que es un parmetro ajustable, puede definirse como la predisposicin de
la neurona a tener una activacin alta o baja. La activacin de una neurona oculta o
de salida se determina evaluando su entrada mediante una funcin de
transferencia. Una funcin comnmente utilizada es la siguiente:

i
EN
i
e
a
+
=
1
1

Esta funcin sigmoidal adapta la entrada de la neurona a un valor de activacin
dentro del rango [0, 1].

2.2.3 Aprendizaje

El mtodo de aprendizaje ms utilizado es el algoritmo Backpropagation. El
aprendizaje en una Red Neuronal se basa en modificar los pesos y umbrales de la
red para minimizar una funcin de costo. La funcin de costo siempre incluye un
trmino correspondiente al error, que da una medida de como se aproximan las
predicciones de la red a las clases de los ejemplos utilizados para entrenarla.
Adicionalmente, puede incluir un trmino que refleje una distribucin preestablecida
de los valores que pueden tomar los parmetros. Usualmente, el entrenamiento
finaliza antes de que la funcin de costo alcance un mnimo local. Otro mtodo
consiste en utilizar un conjunto de validacin para monitorear la precisin en la
prediccin de la red.

En el proceso de aprendizaje, la mayora de las Redes Neuronales utilizan mtodos
de optimizacin basados en el clculo del gradiente para ajustar los parmetros de
la red. Estos mtodos ejecutan dos pasos en forma iterativa: calculan el gradiente
de la funcin de error y ajustan los parmetros de la red en la direccin sugerida
por el gradiente. Con estos mtodos el aprendizaje resulta lento para grandes
volmenes de datos.

2.2.4 Comprensibilidad

Las hiptesis representadas por una Red Neuronal entrenada dependen de (a) la
topologa de la red, (b) las funciones de transferencia utilizadas para las neuronas
ocultas y de salida, y (c) los parmetros asociados con las conexiones en la red
(p.e. los pesos) y las neuronas (p.e. el valor umbral). Estas hiptesis son difciles
de explicar por varias razones:

- las Redes Neuronales tpicamente utilizadas tienen cientos o miles de
parmetros. Estos parmetros codifican la relacin entre los atributos de
entrada, x, y el valor a determinar y,

- en redes multi-capa, los parmetros pueden representar relaciones no
lineales o no montonas entre los atributos de entrada y el valor a
determinar. Esto hace que no sea posible determinar, en forma aislada, el
efecto de un atributo dado en el valor de salida obtenido.


Romina Laura Bot 12
Padrn 75722

3. Extraccin de Reglas utilizando Redes Neuronales

Una forma de entender las hiptesis representadas por una Red Neuronal
entrenada es traducir estas hiptesis en lenguajes ms comprensibles. Esta
estrategia es la Extraccin de Reglas (Craven et al., [5]).

Existen varios motivos por los que es deseable poder extraer reglas a partir de una
Red Neuronal (Boz, [3]):

- Las reglas extradas de la red entrenada pueden utilizarse en otros sistemas,
por ejemplo, en sistemas expertos.

- Las reglas pueden usarse para descubrir caractersticas previamente
desconocidas en los datos (data mining).

- Las reglas explican el razonamiento con el que se llega a la salida del
sistema.

- Las reglas pueden utilizarse para refinar dominios de conocimiento
incompletos.

Hay varios mtodos de extraccin de reglas. Estos mtodos difieren en tres
caractersticas:

- Formalismos de Representacin: es el formalismo utilizado por el
mtodo de extraccin para describir el modelo aprendido por la red. Los
formalismos utilizados incluyen reglas de inferencias conjuntivas (if-then),
reglas m-de-n, reglas difusas, rboles de decisin, etc.

- Estrategias de Extraccin: es la estrategia utilizada por el mtodo de
extraccin para mapear el modelo representado por la red entrenada en un
nuevo modelo que utiliza el formalismo de representacin.

- Requerimientos de la Red: son los requerimientos de arquitectura y de
entrenamiento que los mtodos de extraccin imponen a las Redes
Neuronales. En otras palabras, el rango de redes al que se puede aplicar el
mtodo.

Siempre que una Red Neuronal se utilice para resolver algn problema de
clasificacin, existir un procedimiento de decisin implcito para determinar la
clase a predecir para un caso dado. En general, una regla extrada describe
(aproximadamente) un conjunto de condiciones bajo las cuales la red predice una
clase.

Los mtodos de extraccin de reglas tambin pueden caracterizarse por su nivel de
descripcin. Por ejemplo, un enfoque es extraer un conjunto de reglas globales que
caracterizan la salida directamente en trminos de las entradas. Un enfoque
alternativo es la extraccin de reglas locales por descomposicin de una red multi-
capa en un conjunto de redes de una sola capa. Se extraen las reglas que describen
a cada una de ellas para luego combinarlas en un conjunto de reglas que describen
a toda la red.


Romina Laura Bot 13
Padrn 75722

Se han desarrollado varios algoritmos de extraccin de reglas a partir de Redes
Neuronales. Estos algoritmos difieren en el mtodo utilizado para la extraccin de
las reglas de decisin. A continuacin se describen varios de estos mtodos.

3.1 Extraccin de Reglas de una Red Neuronal Simple

En la figura 3.1 es posible observar la extraccin de reglas en una red muy simple.
Esta red de una nica capa (perceptrn) tiene cinco entradas booleanas y una
salida tambin booleana. Cualquier red de este tipo, con valores de entrada y salida
discretos, puede ser descripta por un conjunto finito de reglas simblica del tipo if-
then, ya que hay un nmero finito de vectores de entrada posibles.

Las reglas extradas especifican condiciones en los atributos de entrada que,
cuando son satisfechas, garantizan un valor de salida determinado. En una red
simple, el concepto asociado con la neurona de salida es el consecuente de la regla
mientras que las condiciones asociadas a un conjunto de neuronas de entrada
representan los antecedentes de la regla. El proceso de extraccin de reglas se
basa en encontrar las condiciones suficientes para cada consecuente.

Reglas Extradas: y x
1
^ x
2
^ x
3
y x
1
^ x
2
^ x
5
y x
1
^ x
3
^ x
5

Figura 3.1

En este ejemplo se asume que el valor falso para un atributo de entrada booleano
se representa con una activacin de 0, y el valor verdadero se representa con una
activacin de 1. Tambin se asume que la neurona de salida utiliza la funcin
umbral:

1 si
i
w
i
a
i
+ > 0
a
y
=
0 en otro caso

Donde a
y
es la activacin de la neurona de salida, a
i
es la activacin de la i-sima
neurona de entrada, w
i
es el peso de la i-sima entrada, y es el valor umbral de
la neurona de salida. Se utiliza x
i
para referirse al valor del i-simo atributo, y a
i

para referirse a la activacin de la neurona correspondiente. Por ejemplo, si x
i
es
verdadero entonces a
i
= 1.


Romina Laura Bot 14
Padrn 75722

Los valores correspondientes al peso de cada neurona de entrada, para esta red
simple, son: w
1
= 6, w
2
= 4, w
3
= 4, w
4
= 0 y w
5
= -4. El valor umbral de la neurona
de salida es -9.

Al clasificar la entrada:

X = {verdadero, falso, verdadero, verdadero, falso}

se obtiene:

a
1
= 1, a
2
= 0, a
3
= 1, a
4
= 1, a
5
= 0

i
w
i
a
i
+ = 6.1 + 4.0 + 4.1 + 0.1 + (-4).0 + (-9) = 1

i
w
i
a
i
+ > 0 a
y
= 1

La neurona de salida se activa con valor 1, por lo tanto y = verdadero. La figura 1
muestra tres reglas conjuntivas que describen las condiciones bajo las cuales la
neurona de salida se activa. La regla:

y x
1
^ x
2
^ x
5

establece que cuando x
1
= verdadero, x
2
= verdadero y x
5
= falso, entonces la
neurona de salida que representa a y tiene una activacin de 1:

i
w
i
a
i
+ = 6.1 + 4.1 + (-4).0 + (-9) = 1

La red predice que y = verdadero. Para verificar si la regla es vlida, se deben
considerar los casos cubiertos por esta:

a
1
w
1
+ a
2
w
2
+ a
5
w
5
+ = 1

La suma siempre excede 1, adems se puede observar que:

0 a
3
w
3
+ a
4
w
4
4

No importa que valores tengan los atributos x
3
y x
4
, la neurona de salida siempre
tendr el valor 1. Por lo tanto, la regla es vlida.

Una regla es vlida si describe exactamente el comportamiento de la red. Para
comprobar que la regla es general se debe verificar que al eliminar algunos de los
literales de su antecedente, entonces sta no describir en forma precisa el
comportamiento de la red. Por ejemplo, al quitar el antecedente x
5
de la regla:

-3
i
w
i
a
i
+ 5

entonces la red no predice que y = verdadero para todos los ejemplos cubiertos por
la regla.


Romina Laura Bot 15
Padrn 75722

3.2 Mtodos de Extraccin de Reglas basados en la
Bsqueda

Muchos algoritmos de extraccin de reglas realizan esta tarea como un problema de
bsqueda explorando un espacio de reglas candidatas y testeando cada una de
ellas contra la red para ver si son reglas vlidas. Estos mtodos pueden ser
globales o locales.

La mayora de estos algoritmos realizan su bsqueda a travs de un espacio de
reglas conjuntivas. La bsqueda contina hasta que todas o la mayora de las
reglas generales hayan sido encontradas.

Uno de los puntos problemticos que aparecen en los enfoques orientados a la
bsqueda para la extraccin de reglas es que el tamao del espacio de reglas
puede ser muy grande. Para un problema con n atributos binarios, existen 3n
reglas conjuntivas posibles (ya que cada atributo puede estar ausente en el
antecedente de la regla, o puede aparecer como un literal positivo o negativo). Se
utilizan varias heursticas para limitar esta cantidad. Una de ellas limita la bsqueda
a combinaciones de los literales que aparecen en el conjunto de entrenamiento
utilizado para la red. Entonces, si el conjunto de entrenamiento no contiene algn
ejemplo donde x
1
= verdadero y x
2
= verdadero, la bsqueda no considerar la
regla y x
1
^ x
2
ni sus especializaciones.

Explorar un espacio de reglas candidatas no es el nico paso de la tarea de
extraccin de reglas basada en la bsqueda. El otro paso es testear las reglas
candidatas contra la red.

3.2.1 VIA - Anlisis de intervalos vlidos

Existe un mtodo que opera propagando intervalos de activacin a travs de la red.
Se asume que las neuronas de entrada para las que no se especifica el valor de
activacin pueden tomar cualquier valor dentro de los permitidos, entonces se
propagarn intervalos de activaciones a las neuronas de la capa siguiente. Esto
determina un rango de activaciones posibles para las neuronas de salida, y en base
a estos valores el procedimiento decide si acepta la regla o no. Aunque este
algoritmo garantiza que acepta slo reglas vlidas, devuelve reglas demasiado
especficas y muchas veces no acepta reglas generales. Esto se debe a que al
propagar intervalos de activacin desde las neuronas ocultas hacia adelante, el
procedimiento asume que la activacin de cada neurona oculta es independiente del
estado de las otras neuronas.

El mtodo llamado anlisis de intervalos vlidos (VIA - validity interval analysis) es
una versin ms generalizada de esta tcnica (Thrun, [32]). VIA testea las reglas
propagando intervalos de activacin a travs de una red luego de poner
restricciones sobre algunas de las neuronas de entrada y de salida, determinando
intervalos de validez (p.e. rangos de activacin vlidos para cada neurona). La
habilidad de incorporar restricciones lineales arbitrarias en el proceso de extraccin
implica que el mtodo puede ser utilizado para testear reglas que especifican
condiciones generales en las neuronas de salida. Aunque este mtodo es mejor que
el anterior detectando reglas generales, tambin asume que las neuronas ocultas
actan en forma independiente, lo que impide encontrar reglas generales muy
tiles.


Romina Laura Bot 16
Padrn 75722

Una ventaja de los mtodos locales, en comparacin con los globales, es que la
bsqueda es menos compleja. Adems el proceso de testeo de las reglas
candidatas es mucho ms simple.

Los mtodos basados en la bsqueda extraen reglas que describen el
comportamiento de las neuronas de salida en trminos de las neuronas de entrada.
Otro enfoque al problema de extraccin de reglas descompone la red en una
coleccin de redes, y luego extrae un conjunto de reglas describiendo cada subred.
Las reglas de cada subred pueden combinarse en un nico conjunto de reglas que
describen a toda la red (Setiono, [30]).

3.3 Mtodos de Aprendizaje de Hiptesis Simples

Un enfoque alternativo para hacer Data Mining con Redes Neuronales es utilizar
mtodos de aprendizaje que directamente aprenden hiptesis explicables
produciendo Redes Neuronales simples. Estas son redes de una sola capa. Las
hiptesis representadas por una Red Neuronal de una nica capa son usualmente
mucho ms simples de entender porque cada parmetro describe una relacin
simple (p.e. lineal) entre un atributo de entrada y una categora de salida.

3.3.1 Algoritmo BBP

BBP (Craven et al., [5|) es un algoritmo muy utilizado para aplicaciones de Data
Mining porque construye Redes Neuronales en forma incremental. La idea bsica de
este mtodo es agregar nuevas neuronas de entrada a las hiptesis aprendidas,
utilizando diferentes distribuciones probabilsticas sobre el conjunto de
entrenamiento. Como el algoritmo agrega a las hiptesis neuronas con peso en
forma incremental, la complejidad de estas hiptesis puede ser controlada
fcilmente.

Las entradas incorporadas a una hiptesis por BBP representan funciones booleanas
que mapean a {-1, +1}. En otras palabras, las entradas son neuronas binarias que
tienen una activacin de -1 o +1. Estas entradas corresponden directamente a
atributos booleanos, o pueden representar estados de atributos nominales o
numricos (p.e. color = rojo, x
1
> 0.8), o combinaciones lgicas de atributos (p.e.
[color = rojo] [formato = rectangular]). Adicionalmente, el algoritmo puede
incorporar una entrada que represente la funcin verdadero. El peso asociado a
esta entrada corresponde al umbral del perceptrn.

En cada iteracin del algoritmo BBP, se selecciona una entrada de un conjunto de
candidatas, y se agrega a las hiptesis que se estn construyendo. BBP mide la
correlacin de cada entrada con la funcin objetivo que se quiere aprender, y
selecciona la entrada cuya correlacin tenga la mayor magnitud. La correlacin
entre una candidata dada y la funcin objetivo vara de iteracin a iteracin porque
es medida con respecto a la distribucin cambiante del conjunto de entrenamiento.

El algoritmo BBP tiene dos limitaciones. Primero, fue diseado para tareas de
clasificacin binaria. De todos modos, puede ser aplicado en problemas multi-clase,
utilizando un perceptrn para cada clase. La otra limitacin del mtodo es que
sume que las entradas son funciones booleanas pero, como se ha mencionado
anteriormente, los atributos pueden discretizarse.


Romina Laura Bot 17
Padrn 75722

3.3.2 Clasificacin utilizando Perceptrones

El mtodo presentado por Tom Bylander (Bylander, [4]) utiliza perceptrones para
realizar tareas de clasificacin. El algoritmo busca la funcin umbral lineal ms
apropiada para clasificar con mayor precisin.

Suponiendo que existe un vector w de n entradas (incluyendo el umbral), donde w
i

es el peso de la i-sima entrada, con "precisin 1-d, "error promedio q y "separacin
de balance : Si clasifica correctamente un ejemplo x con probabilidad 1-d; sobre los
ejemplos clasificados incorrectamente por w, el valor esperado de |w.x| es q; y
sobre una cierta porcin de los ejemplos clasificados correctamente, el valor
esperado de |w.x| es . Entonces, con probabilidad 1-, el perceptrn tiene una
precisin de al menos 1-(c+ d(1+ q/)) despus de O(n c
-2
-2
(ln 1f )) ejemplos.
Aunque una funcin umbral lineal no es la adecuada para la mayora de las
situaciones, puede hacerse un primer intento usando perceptrones, dadas sus
propiedades de convergencia y su simplicidad, antes de utilizar otros mtodos ms
complejos.

3.3.3 Redes Mnimas

Este mtodo, utilizado para extraccin de reglas de diagnstico, propone utilizar
redes neuronales que puedan ser representadas como un conjunto de frmulas
simblicas (lgicas), que son ms comprensibles y fciles de entender (Schetinin,
[28]).

La tcnica extrae reglas a partir de una red neuronal. Esta red neuronal es mnima:
mnima cantidad de neuronas posibles y mnima cantidad de capas. Adems se
eliminan las entradas menos significativas, utilizando un algoritmo.

La red neuronal entrenada se representa como un conjunto mnimo de frmulas
lgicas g
i
(u
1
,u
2
), donde cada frmula esta asociada a una neurona de la red. A
partir de estas frmulas se extraen reglas m-de-n.

3.4 Mtodos de Extraccin de Reglas basados en la
Topologa

Muchos mtodos de extraccin de reglas se basan en la topologa de la red
neuronal. Los mtodos basados en la topologa de la red son aquellos que requieren
Redes Neuronales con una topologa especfica (cantidad de neuronas, cantidad de
capas ocultas), realizan una poda (pruning) en la red despus de entrenarla,
utilizan funciones umbral determinadas, o construyen la red durante el proceso de
entrenamiento.

3.4.1 C-MLP2NL

C-MLP2NL (Duch et al., [14]) transforma una Red Neuronal del tipo perceptrn
multi-capa (MLP) en una red que realiza operaciones lgicas (Red Lgica, LN). Esta
transformacin puede realizarse de muchas formas. El mtodo utilizado en C-
MLP2LN es partir de una nica neurona y construir la Red Lgica utilizando
directamente las instancias de entrenamiento.

La transformacin de la Red Neuronal a una Red Lgica sigue los siguientes pasos:

Romina Laura Bot 18
Padrn 75722

1. incrementar gradualmente la pendiente de las funciones sigmoidales o(x)
para obtener regiones bien definidas (crisp regions);
2. simplificar la estructura de la red induciendo los pesos a travs de un
trmino de penalidad;
3. llevar los pesos a valores enteros 0, 1 y -1, interpretados como 0 = entrada
irrelevante, 1 = evidencia positiva y -1 = evidencia negativa.

Esto se logra agregando dos trminos adicionales a la funcin de error cuadrtico
medio estndar.

Se utiliza el conocimiento inicial sobre el problema para insertarlo directamente en
la estructura de la red, definiendo condiciones iniciales que pueden ser modificadas
durante el entrenamiento. La red puede expandirse agregando neuronas, o
contraerse eliminando conexiones con pesos pequeos. El proceso de
entrenamiento se realiza para cada clase por separado.
El resultado final se presenta como un conjunto de reglas o una red de nodos
asociados a funciones lgicas, con neuronas ocultas que representan las reglas, con
pesos iguales a 1 o -1.

3.4.2 KBANN

El algoritmo KBANN (Towell et al., [34]) utiliza una base de conocimiento con reglas
de inferencia del dominio a estudiar (teora del dominio), para determinar la
topologa y los pesos iniciales de una Red Neuronal basada en el conocimiento
(KNN).

KBANN traduce la teora del dominio en una KNN en la que cada neurona y cada
conexin corresponde a una parte de la teora del dominio. Luego de entrenar la
red, se extraen dos tipos de reglas: versiones modificadas de las reglas utilizadas
para inicializar la red, y reglas que describen nuevas relaciones entre los atributos.

Las reglas se extraen utilizando el mtodo NOFM, que extrae reglas m-de-n a partir
de Redes Neuronales basadas en el conocimiento (Towel et al., [33]). Este mtodo
requiere que el entrenamiento de la red no distorsione en gran medida el
significado de cada neurona, y que la activacin de las neuronas sea cercana a uno
o a cero.

En resumen, el mtodo consiste en tres pasos:
1. Insertar el conocimiento en la red neuronal.
2. Refinar la red neuronal.
3. Extraer el conocimiento refinado de la red.

3.4.3 FERNN

Antes de extraer reglas simblicas de una Red Neuronal entrenada, usualmente se
realiza una poda (pruning) de la red para obtener reglas ms concisas. Los
algoritmos de pruning requieren reentrenar la red, lo que incurre en un costo de
tiempo adicional.

FERNN - Fast Extraction of Rules from Neural Networks - (Setiono, [29]) es un
mtodo rpido de extraccin de reglas a partir de Redes Neuronales que no
necesita reentrenamiento de la red. Dada una Red Neuronal Feedforward
totalmente conectada con una capa oculta, FERNN identifica las neuronas
relevantes calculando su ganancia de informacin. Para cada neurona relevante,
sus valores de activacin se dividen en dos subintervalos tales que maximicen la

Romina Laura Bot 19
Padrn 75722

ganancia de informacin. FERNN busca el conjunto de conexiones relevantes de la
red desde las neuronas de entrada a las neuronas ocultas chequeando la magnitud
de sus pesos. Las conexiones con mayor peso son consideradas relevantes.
Finalmente, FERNN genera reglas para distinguir los dos subintervalos de activacin
ocultos en trminos de los valores de entrada a la red.

Las reglas extradas pueden ser conjuntivas (if-then) o reglas m-de-n. El mtodo
utiliza una funcin umbral particular y un rbol de decisin para detectar las
conexiones relevantes. El rbol de decisin clasifica las instancias en trminos de
los valores de activacin de la red. Para cada neurona oculta, cuya activacin se
utiliza en la particin del nodo del rbol, se remueven las conexiones irrelevantes
de la neurona si no afectan la performance de la clasificacin del rbol.

3.4.4 Algoritmo RX

Rudy Setiono propuso un algoritmo para extraer reglas de una Red Neuronal
Feedforward de tres capas (Setiono, [30]). La Red Neuronal es podada para
remover conexiones redundantes y para detectar las entradas relevantes.

El algoritmo RX - Rule-Extraction - genera reglas a partir de una Red Neuronal
considerando slo un nmero pequeo de valores de activacin en las neuronas
ocultas. Si el nmero de entradas conectadas a una neurona oculta es
suficientemente pequeo, se generan reglas que describen como se alcanza cada
valor de activacin. Sino, la neurona oculta se separa de la red, formando una
nueva subred, donde cada neurona de salida corresponde a un valor de activacin.
Se inserta una capa oculta de neuronas y luego se entrena y se poda repitiendo el
procedimiento para extraer nuevas reglas.

El proceso de extraccin de reglas es mucho ms simple si se reduce la complejidad
de la red. El proceso de podado trata de eliminar la mayor cantidad de conexiones
posibles, manteniendo la precisin de la red. No se requiere conocimiento inicial del
dominio del problema. Los atributos relevantes e irrelevantes de los datos se
distinguen durante el proceso de podado.

El proceso de extraccin de reglas consiste bsicamente en dos pasos. El primer
paso divide los valores de activacin de las neuronas ocultas en un nmero
pequeo de clusters. Si la cantidad de entradas conectadas a la neurona oculta es
relativamente grande, el segundo paso del algoritmo divide la neurona oculta en
varias neuronas. El nmero de clusters generados en el primer paso determina el
nmero de neuronas a generar. Estas neuronas forman una nueva red tratando a
cada neurona como una neurona de salida y agregando una nueva capa oculta.
Esta red es entrenada y podada, y el proceso se repite si es necesario.

Finalmente, se generan reglas que relacionan las entradas y las salidas, utilizando
las reglas obtenidas en cada subred.

3.5 Mtodos de Extraccin de Reglas basados en el
Aprendizaje

Uno de los mtodos para comprender la representacin aprendida por una red
neuronal entrenada consiste en extraer la descripcin de los conceptos aprendidos
utilizando la misma red: dada una red y los datos con los que fue entrenada,
producir una descripcin conceptual que sea comprensible y que clasifique a las
instancias de la misma forma en que lo hace la red neuronal.

Romina Laura Bot 20
Padrn 75722

3.5.1 Algoritmo TREPAN

El algoritmo TREPAN, presentado por Craven & Shavlic ([5]-[9]), trata el problema
de extraccin de hiptesis explicables de una red entrenada como una tarea de
aprendizaje inductivo. En esta tarea de aprendizaje el objetivo es la funcin
representada por la red. Las hiptesis producidas por el algoritmo de aprendizaje se
representan con un rbol de decisin que aproxima a la red.

TREPAN puede producir rboles de decisin que mantienen un alto grado de
fidelidad con la red, precisos y comprensibles. En Data Mining es importante
producir clasificadores que no sean slo precisos, sino tambin fciles de entender.
Las Redes Neuronales tienen limitaciones en este aspecto, ya que son difciles de
interpretar luego del entrenamiento.

El proceso de extraccin de reglas utilizado refina progresivamente el modelo de la
red entera. El modelo, en este caso, es un rbol de decisin que crece de la mejor
manera posible.

El algoritmo TREPAN es similar a los algoritmos convencionales de rboles de
decisin que aprenden directamente de un conjunto de entrenamiento. Estos
algoritmos construyen rboles de decisin particionando el espacio recursivamente.
Cada nodo interno representa un criterio de particin, y cada hoja representa una
clase.

Al construir el rbol, TREPAN mantiene una cola de hojas que son expandidas en
subrboles cuando son removidas de la cola. Cada nodo en la cola tiene asociado:

(i) un subconjunto de ejemplos de entrenamiento,

(ii) otro conjunto de instancias, las instancias de consulta (query instances),
y,

(iii) un conjunto de restricciones.

El subconjunto de ejemplos de entrenamiento consiste en aquellos ejemplos que
alcanzan el nodo. Las instancias de consulta se utilizan, junto con los ejemplos de
entrenamiento, para decidir como particionar un nodo, si este es interno, o
determinar su clase si es una hoja. El conjunto de restricciones describen las
condiciones que deben cumplir las instancias para alcanzar el nodo; esta
informacin es utilizada para armar un conjunto de instancias de consulta para un
nuevo nodo.

El algoritmo TREPAN ser explicado en profundidad en la prxima seccin, dado
que es el mtodo tomado como base para el desarrollo de esta tesis.

3.5.2 Algoritmo Dec-Text

Dec-Text - Decision Tree Extractor - (Boz, [3]) es un algoritmo de extraccin de
rboles de decisin. Al igual que TREPAN, Dec-Text extrae rboles a partir de Redes
Neuronales. Estos rboles de decisin imitan el comportamiento de la red.

Utiliza la red neuronal como orculo para clasificar las instancias. Tambin genera
instancias al azar para seleccionar la mejor particin. A diferencia de TREPAN,
construye rboles de decisin convencionales, que pueden ser fcilmente traducidos
en reglas if-then.


Romina Laura Bot 21
Padrn 75722

Presenta cuatro tipos de test de particin diferentes: SetZero evala las salidas de
la red neuronal para cada atributo, para encontrar el atributo relevante. SSE
selecciona el atributo que maximiza la posibilidad de que una nica clase domine
cada particin creada. Esto lo hace calculando la sumatoria del error cuadrtico de
cada particin (SSE), y seleccionando el atributo con menor SSE. ClassDiff utiliza la
diferencia entre el valor mximo de salida de la red, y el segundo valor mximo de
salida de la red de cada subconjunto para medir que tan buena es una particin. El
atributo con mayor ClassDiff es el seleccionado. Fidelity selecciona el atributo que
maximiza la fidelidad entre el rbol de decisin y la red neuronal.

Nuestro trabajo es otro ejemplo de este ltimo enfoque, pero difiere con el mtodo
TREPAN en el formalismo utilizado para describir el modelo aprendido por la red. En
lugar de extraer rboles de decisin, nuestros mtodos construyen rboles difusos
y rboles modelo. De esta forma es posible comprender el mtodo de clasificacin
de una Red Neuronal entrenada para dominios con valores continuos. A
continuacin se presenta en ms detalle el algoritmo TREPAN.

3.6 Algoritmo TREPAN

El algoritmo TREPAN es similar a los algoritmos convencionales de rboles de
decisin que aprenden directamente de un conjunto de entrenamiento. Estos
algoritmos construyen rboles de decisin particionando el espacio en forma
recursiva. Cada nodo interno representa un criterio de particin y cada hoja
representa una clase.

Aunque TREPAN tiene muchas similitudes con los algoritmos de rboles de decisin
convencionales, es sustancialmente diferente en varios aspectos:

Consultas de Pertenencia y Orculo. Al inducir un rbol de decisin para
describir la red dada, TREPAN toma ventaja del hecho de poder hacer consultas de
pertenencia. Una consulta de pertenencia es una pregunta a un orculo sobre una
instancia del espacio de instancias. El rol del orculo es devolver la clase a la que
pertenece la instancia. Lo que se intenta aprender es la funcin representada por la
red, entonces, la red misma es la que se utiliza como orculo, y para responder una
consulta de pertenencia simplemente clasifica la instancia dada.

Las instancias utilizadas para hacer consultas de pertenencia provienen de dos
fuentes. Primero, los ejemplos utilizados para entrenar la red. Segundo, TREPAN
utiliza los datos de entrenamiento para construir modelos de la distribucin de los
datos, y con estos modelos genera nuevas instancias -instancias de consulta- para
hacer consultas de pertenencia. La ventaja es que al seleccionar un criterio de
particin para un nodo interno o al clasificar a una hoja, es posible decidir
basndose en una gran cantidad de ejemplos.

Expansin del rbol. TREPAN construye su rbol usando el criterio de mejor
expansin. El mejor nodo es, en este caso, aquel que tiene el mayor potencial para
incrementar la fidelidad del rbol extrado de la red. Se entiende por fidelidad el
grado de coincidencia entre la clasificacin del rbol y la de la red. Al construir el
rbol de esta manera, se da al usuario un mayor grado de control sobre el tamao
del rbol a generar: el proceso de expansin del rbol puede detenerse en cualquier
punto.

Test de Particin. El algoritmo utiliza expresiones m-de-n para producir
descripciones ms compactas. Una expresin m-de-n se satisface cuando al menos
m de sus n condiciones son satisfechas

Romina Laura Bot 22
Padrn 75722

Criterio de Detencin. TREPAN utiliza tres criterios para decidir cuando detener el
crecimiento del rbol extrado. El primero es un test estadstico para decidir si, con
alta probabilidad, un nodo cubre slo las instancias de una sola clase. Si es as, el
nodo pasa a ser una hoja. Segundo, TREPAN emplea un parmetro que permite al
usuario establecer un lmite en el tamao del rbol. Este parmetro indica la
mxima cantidad de nodos y da al usuario algn control sobre la complejidad del
rbol. Tercero, el algoritmo permite utilizar un conjunto de validacin, junto con el
parmetro antes mencionado, para decidir cuando detener el crecimiento del rbol.
TREPAN usa el conjunto de validacin para medir la fidelidad del rbol.

Algoritmo TREPAN.
TREPAN(ejemplos_entrenamiento, atributos)

Cola := O f* cola ordenada de nodos a expandir *f

para cada ejemplo E ejemplos_entrenamiento f* usar la red para clasificar los ejemplos *f
clasificar E := ORACLE(E)

inicializar la raiz del arbol, T, como un nodo hoja
poner ( T, ejemplo_entrenamiento, {) ) en la Cola

mientras la Cola no est vacia y tamano(T) < limite_tamano_arbol f* expandir un nodo *f
remover el nodo N de la cabeza de la Cola
ejemplos
N
:= conjunto de ejemplos guardados con N
restricciones
N
:= conjunto de restricciones guardados con N

utilizar atributos para construir un conjunto de particiones candidatas
utilizar ejemplos
N
y llamar a ORACULO(restricciones
N
) para evaluar las particiones
S := mejor particin binaria
buscar la mejor particin m-de-n, S', utilizando S como semilla
hacer a N un nodo interno con particin S'

para cada rama, s, de S' f* armar nodos hijos *f
hacer a C un nuevo nodo hijo de N
restricciones
C
:= restricciones
N
U {S' = s)
utilizar llamadas a ORACULO(restricciones
C
) para determinar si C es una hoja
sino
ejemplos
C
:= miembros de ejemplosN con resultado s en la particin S'
poner ( C, ejemplos
C
, restricciones
C
) en la Cola

Retorno: T

Ventajas del Algoritmo.

- puede ser aplicado a una gran variedad de Redes Neuronales, ya que la
interaccin con la red consiste slo en realizar consultas de pertenencia.
TREPAN no requiere una arquitectura especial para la red ni un mtodo de
entrenamiento en particular.

- permite al usuario tener un mayor control sobre la complejidad de las
hiptesis producidas por el proceso de extraccin de reglas. TREPAN primero
extrae una descripcin muy simple de la red entrenada (p.e. un nodo), y
luego refina esta descripcin para incrementar su fidelidad con la red.

Romina Laura Bot 23
Padrn 75722

El algoritmo ha sido utilizado para extraer reglas de una amplia variedad de
problemas. La Tabla 3.I muestra la precisin y la complejidad del rbol resultante
para cinco problemas, en los que se utilizaron Redes Neuronales feed-forward,
rboles de decisin extrados con TREPAN, y rboles de decisin que aprenden
directamente de un conjunto de entrenamiento utilizando el algoritmo C4.5. Puede
observarse que para el mismo conjunto de datos, las Redes Neuronales son ms
precisas al predecir que los rboles de decisin de C4.5. A su vez, para los cinco
dominios, los rboles extrados con TREPAN son ms precisos que los rboles de
C4.5. Este resultado indica que para un amplio rango de dominios de problemas
donde las redes neuronales predicen con ms precisin que los algoritmos
convencionales, TREPAN puede utilizarse para extraer rboles de decisin que
aproximan las hiptesis aprendidas por la red.

Precisin Complejidad del rbol
Dominio del problema
Redes TREPAN C4.5 TREPAN C4.5
Reconocimiento de
regiones de cdigos de
protenas
94.1 93.1 90.4 70.5 153.3
Diagnosis de enfermedades
coronarias
84.5 83.2 74.6 24.4 15.5
Identificacin de genes y
promotores de ADN
90.6 87.4 85.0 105.5 7.0
Diagnosis de fallas en
circuitos telefnicos
65.3 63.3 60.7 26.3 35.0
Prediccin de cambios de
cotizacin
61.6 60.0 54.0 14.0 53.0

Tabla 3.I - Precisin del conjunto de prueba (%) y complejidad del rbol.

Las columnas derechas de la Tabla 3.I muestran la complejidad de los rboles
producidos por TREPAN y C4.5. La medida de complejidad utilizada es el nmero de
referencias a los atributos de los test de particin de los rboles. Un test de
particin de un nico atributo, como los utilizados por C4.5, se cuenta como una
referencia a un atributo. Un test m-de-n, como los utilizados en TREPAN, se cuenta
como n referencias a atributos. Los resultados en la tabla indican que, en general,
los rboles producidos por ambos algoritmos son comparables en trminos de
tamao.

3.7 Una Implementacin del Algoritmo TREPAN

En el presente trabajo se ha implementado una nueva versin del algoritmo
TREPAN. Este algoritmo difiere con el mtodo propuesto por Craven en los
siguientes aspectos:

Formalismo de Representacin. El rbol de decisin utiliza reglas if-then en
lugar de reglas m-de-n en la particin de los nodos. Los rboles de decisin con
reglas m-de-n son ms difciles de entender que los rboles de decisin regulares
(Boz, [3]), aunque a simple vista sean rboles ms compactos.

Orculo. Es posible elegir el mtodo de clasificacin que ser utilizado como
orculo para la construccin del rbol.

Criterios de Detencin. El algoritmo emplea dos parmetros ingresados por el
usuario. El primero permite al usuario establecer un lmite en el tamao del rbol, y

Romina Laura Bot 24
Padrn 75722

el segundo indica la proporcin de instancias de una misma clase que determina si
un nodo es hoja.

Test de Particin. Se utilizar la Ganancia de Informacin como criterio para
generar la mejor particin en cada nodo.

Dado un dataset S, el test de particin para evaluar un nodo es el siguiente:

1. si S contiene una o ms instancias y la proporcin de ejemplos
pertenecientes a una misma clase es mayor a PropC, entonces el nodo es
hoja y se asigna la clase predominante C.

2. si S no contiene instancias, el nodo es hoja y la clase asociada es la clase
ms frecuente en el nodo padre.

3. si S contiene instancias pertenecientes a diferentes clases, calcular la
Ganancia de Informacin para cada particin posible. Expandir el nodo
utilizando el atributo que maximiza la Ganancia de Informacin:

) ; ( ) ( S A E S E IG =

Definicin. Sean k clases c
1
,...,c
k
, y sea p(c
j
,S) la proporcin de ejemplos de S que
pertenecen a la clase k. La entropa E(S) se expresa como:

=
=
k
j
j j
S c p S c p S E
1
2
) , ( log ) , ( ) (

Para cada atributo A
i
se calcula:

=
A A
i
i
i
S E
S
S
S A E ) (
| |
| |
) ; (

Test de Particin para atributos continuos. Los atributos continuos se
discretizan encontrando un punto de corte T que divida el dataset S en dos
intervalos, segn el valor del atributo A: S
1
= [min(A), T] y S
2
= (T, max(A)]. El
valor T se determina calculando la ganancia de informacin para cada punto de
corte candidato, y seleccionando aquel punto que maximiza la ganancia de
informacin. Ese valor se tomar como la ganancia de informacin del atributo A.

Para encontrar los puntos de corte candidatos, las instancias son ordenadas en
forma ascendente por el valor del atributo A. Cada par de puntos adyacentes
generan un punto de corte candidato T = (a
i
+a
i+1
)/2. Se seleccionan slo aquellos
puntos medios de las instancias donde la clasificacin de la red neuronal difiere, o
sea, la instancia i y la instancia i+1 no deben pertenecer a la misma clase. Para
cada punto de corte candidato, el dataset se divide en dos subconjuntos S
1
y S
2
, y
se calcula la ganancia de informacin de la particin:

) (
| |
| |
) (
| |
| |
) (
2
2
1
1
S E
S
S
S E
S
S
S E IG =

El punto de corte para el que IG es mxima es utilizado como punto de corte para
el atributo A.

Romina Laura Bot 25
Padrn 75722

Si el atributo con mayor ganancia de informacin es discreto, el nodo se particiona
en tantas ramas como valores tenga el atributo. Si el atributo es continuo, se
generan dos ramas: A<=T se asigna a la rama izquierda y A>T se asigna a la rama
derecha.

Generacin de nuevas instancias. Como se ha mencionado, TREPAN genera
nuevas instancias -instancias de consulta- para alcanzar la cantidad mnima de
instancias necesarias para evaluar la particin de un nodo.

Para generar nuevas instancias, se tiene en cuenta la distribucin marginal de cada
uno de los atributos de las instancias a procesar. La distribucin marginal de una
variable es su distribucin independiente de cualquier otra variable.

TREPAN utiliza distribuciones empricas para modelar atributos discretos, y el
estimador de densidad kernel para modelar atributos continuos.

La distribucin emprica de un atributo es simplemente la distribucin de los valores
del atributo, dado un conjunto de ejemplos. La distribucin emprica para un
atributo discreto se representa con un parmetro para cada valor posible del
atributo indicando la frecuencia de ese valor en el conjunto de entrenamiento.

El mtodo de estimacin kernel modela la funcin de densidad de probabilidad para
un atributo continuo x como:

(
(
(
=
|
|
.
|
\
|
m
j
x
j
e
m
x f
2
2
2
1 1
) (

donde m es el nmero de instancias de entrenamiento utilizadas en el estimador,
j

es el valor del atributo para la j-sima instancia y es la amplitud del kernel.
TREPAN utiliza = 1/m
1/2
.

Este mtodo de modelado sufre de una limitacin: como estima distribuciones
marginales, no toma en cuenta dependencias entre atributos.

Otra ventaja de generar nuevas instancias es que, al clasificarlas con el orculo,
mejora la fidelidad del rbol con respecto a la red.

Instancias con valores desconocidos. Esta implementacin de TREPAN permite
generar rboles a partir de instancias con valores desconocidos para algunos de sus
atributos. Luego de entrenar la Red Neuronal con las instancias de entrenamiento,
el algoritmo aplica un filtro a estas instancias. Este filtro reemplaza los valores
desconocidos por los valores mas frecuentes del atributo. Por ltimo se clasifican
las instancias con la Red Neuronal.

3.7.1 Parmetros de entrada del algoritmo

Los parmetros de entrada del algoritmo TREPAN son los siguientes:

Romina Laura Bot 26
Padrn 75722

Parmetro Descripcin
Valor por
defecto
ORACLE Clasificador utilizado como orculo. Por
defecto, el orculo es una Red Neuronal,
pero es posible elegir cualquiera de los
algoritmos implementados en Weka.

Red Neuronal
BEST FIRST Indica si se debe construir el rbol
utilizando el criterio de mejor expansin.

Falso
PROP. INSTANCES Porcentaje de instancias de una clase
que debe existir en un nodo para
transformarlo en una hoja

0.95
MAX. NODES Mxima cantidad de nodos del rbol. El
valor cero indica que no hay restricciones
en el tamao del rbol.

0
PRUNNING Indica si se desea hacer una poda
(pruning) del rbol, eliminando aquellos
nodos hoja que predicen la misma clase.

Falso
MIN. SAMPLES Cantidad mnima de instancias
requeridas para evaluar un nodo.

0

Tabla 3.II - Parmetros de Entrada del Algoritmo TREPAN

3.7.2 Ejemplo

Esquema: Weather

Atributos:
Outlook (discreto).
Temperature (numrico).
Humidity (numrico).
Windy (discreto).
Play (discreto). Atributo clase.

Parmetros:
Oracle: Red Neuronal
Best First: false
Prop. Instances:0.95
Max. Nodes:0
Prunning: False
Min. Samples: 25

=== Run information ===

Scheme: weka.classifiers.trepan.Trepan -m 25 -M 0 -I 0.95 -W
weka.classifiers.neural.NeuralNetwork -- -L 0.3 -M 0.2 -N 500 -V 0 -S 0 -E 20 -H a
Relation: weather
Instances: 14
Attributes: 5

Romina Laura Bot 27
Padrn 75722

outlook
temperature
humidity
windy
play
Test mode: 10-fold cross-validation

=== Classifier model (full training set) ===

Trepan

outlook = sunny (R= 0.4, F= 0.6, B= 0.16)
| humidity <= 84.71055 (R= 0.176, F= 1.0, B= 0.0) : yes
| humidity > 84.71055 (R= 0.224, F= 1.0, B= 0.0) : no
outlook = overcast (R= 0.28, F= 0.96, B= 0.011): yes
outlook = rainy (R= 0.32, F= 0.52, B= 0.154)
| windy = TRUE (R= 0.154, F= 1.0, B= 0.0): no
| windy = FALSE (R= 0.166, F= 1.0, B= 0.0): yes

Number of Leaves : 5

Size of the tree : 3

Time taken to build model: 0.27 seconds

=== Stratified cross-validation ===

Trepan Fidelity = 80 %

=== Summary ===

Correctly Classified Instances 13 92.8571 %
Incorrectly Classified Instances 1 7.1429 %
Kappa statistic 0.8372
Mean absolute error 0.0829
Root mean squared error 0.2694
Relative absolute error 17.8462 %
Root relative squared error 56.1828 %
Total Number of Instances 14

=== Detailed Accuracy By Class ===

TP Rate FP Rate Precision Recall F-Measure Class
1 0.2 0.9 1 0.947 yes
0.8 0 1 0.8 0.889 no

=== Confusion Matrix ===

a b <-- classified as
9 0 | a = yes
1 4 | b = no

Junto a cada nodo del rbol, pueden observarse tres valores: B es el valor de "Best
First e indica el potencial que tiene el nodo para incrementar la fidelidad del rbol,
R (reach) indica la proporcin de instancias que alcanzaron ese nodo, y F es la
fidelidad del nodo.


Romina Laura Bot 28
Padrn 75722

Una vez construido el rbol, estos valores son informativos. El algoritmo los utiliza
al realizar la expansin del rbol de decisin.

El algoritmo tambin calcula la fidelidad del rbol con respecto a la Red Neuronal
(Trepan Fidelity). Para este ejemplo, la fidelidad es del 80%. Esto significa que en
un 80% de los casos la clasificacin del rbol de decisin coincide con la
clasificacin de la Red Neuronal.

3.8 Limitaciones de TREPAN

Para cierto tipo de dominios el algoritmo TREPAN presenta algunas limitaciones
(Craven et al., [9]):

- TREPAN extrae rboles de decisin. Los rboles de decisin no pueden
describir predicciones de Redes Neuronales entrenadas para realizar tareas
de regresin.

- Algunas veces el rbol de decisin extrado no es lo suficientemente conciso,
lo que implica una gran cantidad de reglas de clasificacin.

Ante estas limitaciones, en este trabajo se han desarrollado dos nuevos mtodos
que extraen rboles difusos y rboles modelo para describir predicciones de Redes
Neuronales entrenadas en aquellos dominios no cubiertos por TREPAN. En el
prximo capitulo se presentan los nuevos mtodos.


Romina Laura Bot 29
Padrn 75722

4. Mejoras al mtodo TREPAN

En esta tesis se presentan dos nuevos algoritmos que resuelven las limitaciones del
mtodo TREPAN:

- El algoritmo TREPAN M5 extrae rboles modelo a partir de una Red Neuronal
entrenada. Un rbol modelo tiene una estructura similar a la de un rbol de
decisin, pero sus hojas son funciones de valores reales en lugar de
identificadores de clases (Quinlan, [27]).

- El algoritmo TREPAN Fuzzy extrae rboles difusos. Un rbol de decisin
difuso indica el grado de pertenencia de una instancia a cada una de las
clases. De acuerdo a los resultados, los usuarios pueden tomar la decisin
final. Se obtienen rboles ms concisos y la tasa de error en la clasificacin
puede reducirse.

A continuacin se explicarn las caractersticas de los rboles modelo y los rboles
difusos. En las siguientes secciones se presentan en detalle los nuevos algoritmos.

4.1 rboles Modelo

Para tareas de clasificacin, los algoritmos que generan rboles de decisin son
eficientes, robustos y relativamente simples. Algunas tareas de clasificacin
requieren modelos para predecir valores numricos en lugar de clases para un
caso. Por ejemplo, un caso podra ser la composicin de una aleacin y como valor
asociado la temperatura en la que funde.

Existen varios mtodos de aprendizaje efectivos para predecir valores reales. El
algoritmo CART (Classification And Regression Trees) construye rboles de
regresin en los que cada hoja est asociada a un valor real en lugar de una clase
(Mc Connell, [23]).

M5 es otro mtodo utilizado para predecir valores continuos. Al igual que CART, M5
construye modelos basados en rboles pero, mientras que los rboles de regresin
tienen valores en sus hojas, los rboles construidos por M5 pueden tener modelos
lineales. Por lo tanto, estos "rboles modelo (model trees) son anlogos a un
conjunto de funciones lineales. La ventaja de M5 sobre CART es que los rboles
modelos son generalmente mas compactos que los rboles de regresin y han
demostrado ser ms precisos (Quinlan, [27]).

4.2 rboles Difusos

Los rboles de decisin se construyen a travs de un proceso recursivo de divisin
del conjunto de datos. Para el caso de instancias de entrenamiento con valores
continuos, los atributos deben ser discretizados antes o durante el proceso de
aprendizaje. El mtodo ms comnmente utilizado para discretizar los atributos
numricos es particionar el rango de atributos en dos o ms intervalos utilizando
uno o ms "puntos de corte (cut points). Una desventaja inherente en estos
mtodos es que el uso de puntos de corte "rgidos (crisp cut points) hace que los
rboles sean sensibles al ruido (Peng et al. [25]).


Romina Laura Bot 30
Padrn 75722

Un rbol de decisin sensible al ruido disminuye notablemente su precisin al
clasificar datasets con objetos "ruidosos. Los objetos ruidosos son objetos raros en
vencindarios cuyos objetos corresponden a la misma clase, y suelen ser clasificados
errneamente. Un objeto es considerado como ruido cuando, al ser descartado, la
precisin en los resultados de la clasificacin se incrementa.

Para solucionar este problema existen mtodos alternativos basados en lgica
difusa. En lugar de asignar una nica clase como resultado final de la clasificacin,
los rboles de decisin difusos asocian un conjunto de posibilidades para una o ms
clases. Como resultado, an si existen incertidumbres en el caso a clasificar, el
rbol de decisin no dar un resultado completamente errneo sino un conjunto de
valores posibles.

Los rboles de decisin difusos proveen una forma ms robusta de evitar los
errores de clasificacin. El potencial de los rboles de decisin difusos de mejorar
la robustez y la generalizacin en la clasificacin se debe al uso de razonamiento
difuso.

Existen varios algoritmos que construyen rboles difusos. En su mayora se basan
en los mtodos de construccin de rboles de decisin convencionales. Un ejemplo
es el algoritmo desarrollado por Dong basado en el mtodo ID3 (Dong, [13]).


Romina Laura Bot 31
Padrn 75722

5. TREPAN M5

Se implement el algoritmo TREPAN M5 como una extensin del algoritmo M5 (M5
Prime) existente en el sistema Weka.

TREPAN M5 construye rboles modelos, regresiones lineales y rboles de regresin
utilizando una Red Neuronal (u otro clasificador a eleccin) como orculo.

5.1 Algoritmo M5

Esta tcnica de aprendizaje supervisado usa la siguiente idea: dividir el espacio de
datos en reas (subespacios) y construir un modelo de regresin lineal en cada una
de ellas. El modelo resultante puede verse como un modelo modular formado por
modelos lineales especializados en un conjunto particular del espacio de entrada. La
combinacin de modelos especializados (modelos "locales) es frecuentemente
utilizada.

M5 se basa en el principio de la teora de informacin. El test de particin es similar
al de un rbol de decisin, pero en lugar de clases asigna funciones de regresin
lineal a las hojas del rbol. Los rboles modelos generalizan el concepto de los
rboles de regresin, que tienen valores constantes en sus hojas. Los rboles
modelos son eficientes y pueden manejar dominios de grandes dimensiones y
cientos de atributos. La mayor ventaja de los rboles modelos sobre los rboles de
regresin es que los rboles modelos son mucho ms compactos que los de
regresin y son ms precisos. Adems, las funciones de regresin normalmente no
involucran muchas variables.

5.1.1 Construccin de rboles Modelo

El algoritmo M5 induce rboles modelos. Dado un conjunto de instancias de
entrenamiento T, cada instancia se caracteriza por el valor correspondiente a cada
uno de los atributos de entrada, discretos o continuos, y por la clase asociada. El
objetivo es construir un modelo que relacione los valores de las clases de las
instancias de entrenamiento con los valores de los atributos de entrada. El modelo
es evaluado por la precisin con que se predice la clase para un caso desconocido.

Los rboles modelos se construyen con un mtodo del tipo "divide-y-conquistars.
El dataset T se asocia a una hoja o se realiza un test para particionar T en
subconjuntos. El mismo proceso se aplica recursivamente a cada subconjunto.
Muchas veces este mtodo produce estructuras sobre-ajustadas. Una rbol sobre-
ajustado clasifica con gran precisin las instancias del dataset a partir del cual fue
construido, y con poca precisin a las instancias no incluidas en dicho dataset. Para
estos casos se hace una "poda (pruning) del rbol, por ejemplo, reemplazando un
conjunto de nodos por una hoja.

El criterio de particin para el algoritmo M5 se basa en el clculo del desvo
estndar de los valores del atributo clase de las instancias que alcanzan el nodo,
como una medida de error en ese nodo. Luego, calcula la reduccin esperada de
este error testeando cada atributo en ese nodo. Cada test se evala determinando
el conjunto de instancias asociadas con cada salida, donde T
i
denota el subconjunto
de instancias con salida i para el test. Si tomamos el desvo estndar sd(T
i
) de los
valores del atributo clase de las instancias en T
i
como una medida de error, la
reduccin del error esperada puede expresarse como:

Romina Laura Bot 32
Padrn 75722

=
i
i
i
T sd
T
T
T sd error ) (
| |
| |
) (

Luego de examinar todos los tests posibles, M5 selecciona aquel que maximiza la
reduccin del error esperado. Un nodo es hoja cuando los valores de las clases de
todas las instancias que alcanzan un nodo vara muy poco, o cuando el nodo
contiene muy pocas instancias.

Como paso final, se realiza un proceso de "pulido (smoothing). El pulido del rbol
mejora la precisin en la clasificacin. Cuando el rbol modelo predice el valor de
una instancia, el valor dado por el modelo en una hoja se ajusta para reflejar los
valores que predicen los nodos que conforman la rama desde la raz a la hoja. El
mtodo es el siguiente:

- El valor que predice la hoja es el valor calculado por el modelo en esa hoja.

- Si la instancia sigui la rama S
i
del subrbol S, sea n
i
el nmero de
instancias de entrenamiento en S
i
, PV(S
i
) el valor que se predice en S
i
, y
M(S) el valor dado por el modelo en S. El valor que el rbol predice para la
instancia ser:

k n
S M k S PV n
S PV
i
i i
+
+
=
) ( ) (
) (

donde k es una constante de pulido (por defecto 15).

El pulido mejora la precisin, especialmente para aquellos casos donde los modelos
a lo largo de las ramas predicen valores muy diferentes, y cuando los modelos son
construidos a partir de datasets pequeos.

Ejemplo de un rbol modelo M5:

Qt <=51.2 :
| Qt <=28.7 : LM1 (903/5.66%)
| Qt > 28.7 : LM2 (379/13.1%)
Qt > 51.2 : LM3 (572/66.7%)

Los modelos lineales generados son los siguientes:

LM1: Qt+3 = -0.0118 + 0.317REt + 0.124REt-1 + 0.0844REt-2 -0.109REt-3 +
1.09Qt - 0.0826Qt-1
LM2: Qt+3 = -0.262 + 11.9REt + 0.182REt-1 + 8.9REt-2 - 0.198REt-3 + 3.66Qt -
2.67Qt-1
LM3: Qt+3 = 15.5 + 25.7REt + 7.59REt-1 - 0.0923REt-3 + 1.44Qt - 0.732Qt-1

5.2 Implementacin del algoritmo TREPAN M5

La implementacin consisti en agregar al algoritmo M5, el orculo. O sea, previo a
la construccin del modelo de regresin, se clasifican las instancias con el orculo
ingresado como parmetro del algoritmo. Adems, en cada test de particin de
instancias es posible determinar la cantidad mnima de instancias para realizar la
evaluacin. De no llegar a esa cantidad mnima, se crean las instancias faltantes tal
como lo hace TREPAN.

Romina Laura Bot 33
Padrn 75722

Es posible construir tres tipos de modelos:

- Regresin Lineal: devuelve una funcin de regresin lineal que modela la
salida como una combinacin lineal de los atributos de entrada.

- rbol Modelo: devuelve un rbol de decisin, en el que cada nodo hoja
est asociado a una funcin de regresin lineal.

- rbol de Regresin: devuelve un rbol de decisin, en el que cada nodo
hoja est asociado a un valor numrico constante.


Los parmetros de entrada del algoritmo TREPAN M5 son los siguientes:

Parmetro Descripcin
Valor por
defecto

Red Neuronal

0
USE UNSMOOTHED Indica si se realiza el pulido del rbol.

Falso
PRUNNING FACTOR Factor de poda del rbol. A mayor valor,
mayor es la poda del rbol.

2.0
MODEL TYPE Tipo de modelo a generar:
- Model Tree
- Simple Linear Regression
- Regression Tree

Model Tree
VERBOSITY Nivel de verbosidad del modelo
extrado.

0

Tabla 5.I - Parmetros de Entrada del Algoritmo Trepan M5

5.2.2 Ejemplo

Esquema: CPU

Atributos:
Vendor: Nombre del proveedor (discreto).
MYCT: Tiempo de ciclo de mquina en nanosegundos (numrico).
MMin: Memoria mnima en kbytes (numrico).
MMax: Memoria mxima en kbytes (numrico).
Cach: Cach en kbytes (numrico).
CHMin: Canales mnimos, en unidades (numrico).
CHMax: Canales mximos, en unidades (numrico).
Class: Performance relativa de la CPU (numrico). Atributo clase.

Romina Laura Bot 34
Padrn 75722

Parmetros:
Min. Samples: 50
Use Unsmoothed: Falso
Prunning Factor: 2.0
Model Type: Model Tree
Verbosity: 0


Scheme: weka.classifiers.trepanM5.TrepanM5 -O m -F 2.0 -V 0 -m 50 -W
Relation: cpu
Instances: 209
Attributes: 8
vendor
MYCT
MMIN
MMAX
CACH
CHMIN
CHMAX
class


Pruned training model tree:

MMAX <= 14000 : LM1 (141/4.11%)
MMAX > 14000 :
| MMAX <= 22500 : LM2 (37/6.37%)
| MMAX > 22500 :
| | MMAX <= 33500 : LM3 (27/12.8%)
| | MMAX > 33500 : LM4 (4/2.12e-12%)

Models at the leaves:

Smoothed (complex):

LM1: class = 16.7 - 6.91vendor = burroughs, cambex, magnuson, honeywell, ipl, ibm,
cdc, ncr, basf,gould, siemens, nas, adviser, sperry, amdahl - 7.91vendor = adviser, sperry,
amdahl + 11.3vendor = sperry, amdahl + 0.00469MMIN + 0.00314MMAX + 0.543CACH +
0.642CHMIN + 0.104CHMAX

LM2: class = -58.2 - 5.23vendor = burroughs, cambex, magnuson, honeywell, ipl, ibm,
cdc, ncr, basf, gould, siemens, nas, adviser, sperry, amdahl- 14.9vendor = adviser, sperry,
0.508CHMAX

LM3: class = -162 - 5.23vendor = burroughs, cambex, magnuson, honeywell, ipl, ibm,
cdc, ncr, basf, gould, siemens, nas, adviser, sperry,amdahl - 14.9vendor = adviser, sperry,
0.567CHMIN + 0.803CHMAX

LM4: class = -155 - 5.23vendor = burroughs, cambex, magnuson, honeywell, ipl, ibm,
cdc, ncr, basf, gould, siemens, nas, adviser, sperry, amdahl - 14.9vendor = adviser, sperry,
1.33CHMAX


Romina Laura Bot 35
Padrn 75722

Number of Rules : 4


=== Cross-validation ===

=== Summary ===

Correlation coefficient 0.9844

Para evaluar las ecuaciones, simplemente se deben reemplazar los atributos
numricos con sus valores para la instancia a clasificar. Para el caso de atributos
discretos, estos se reemplazan por el valor 1 (verdadero) cuando el valor del
atributo es igual a alguno de los valores de la lista de atributos, o con 0 (falso)
cuando el valor no se encuentra en la lista.

Por ejemplo, para obtener la clase de la siguiente instancia:

Vendor = amdahl
MYCT = 29
MMin = 8000
MMax = 32000
Cach = 32
CHMin = 8
CHMax = 32
Class = ?

Dado que MMax > 14000, MMax > 22500 y MMax <= 33500, el rbol de decisin
nos indica que debemos evaluar la instancia utilizando la funcin LM3:

LM3: class = -162 - 5.23vendor = burroughs, cambex, magnuson, honeywell, ipl,
ibm, cdc, ncr, basf, gould, siemens, nas, adviser, sperry,amdahl - 14.9vendor =
adviser, sperry, amdahl + 21.2vendor = sperry, amdahl + 0.0122MMIN +
0.00892MMAX + 0.94CACH + 0.567CHMIN + 0.803CHMAX

Reemplazando los atributos por sus valores correspondientes obtenemos:

Class = -162 - 5.23 x 1 - 14.9 x 1 + 21.2 x 1 + 0.0122 x 8000 + 0.00892 x 32000
+ 0.94 x 32 + 0.567 x 8 + 0.803 x 32

Por lo tanto:

CLASS = 282.422


Romina Laura Bot 36
Padrn 75722

6. TREPAN Fuzzy

Se implement el algoritmo TREPAN Fuzzy como una extensin del algoritmo
TREPAN. TREPAN Fuzzy construye rboles difusos utilizando una Red Neuronal (u
otro clasificador a eleccin) como orculo.

Para la implementacin, se modific el algoritmo TREPAN para adaptarlo al mtodo
de construccin de rboles difusos propuesto por Yonghohg Peng y Peter Flash
(Peng et al., [25]). Este mtodo de induccin se basa en la discretizacin "suave
(soft discretization) de los atributos continuos en conjuntos difusos.

6.1 Discretizacin Suave

La discretizacin "rgida (crisp discretization) divide el espacio de decisin en un
conjunto de subespacios excluyentes. Por el contrario, un rbol de decisin difuso
da resultados dentro del rango [0,1], indicando el grado de posibilidad de un objeto
de pertenecer a cada clase. De acuerdo a estos resultados los usuarios pueden
tomar la decisin final o realizar una investigacin ms profunda. Como resultado,
la tasa de error en la clasificacin puede reducirse.

La discretizacin suave puede verse como una extensin de la discretizacin
clsica. La medida de informacin clsica definida en el dominio de las
probabilidades ha sido extendida a una nueva definicin en el dominio de las
posibilidades, basada en la teora de lgica difusa: un conjunto rgido A
r
puede ser
expresado con la funcin Ar(a): {0,1}, mientras que un conjunto difuso A se
caracteriza por una funcin de membership A(a): [0,1]. El membership A(a) es
la posibilidad de A de tomar un valor a .

Siendo Q = {A1,...,Ak} una familia de conjuntos difusos en . Q es una particin
difusa de cuando:
=
=
k
a a A
1
, 1 ) (

(6.1)

Una discretizacin rgida, como se ve en la figura 61, se define con un umbral que
determina el lmite entre dos conjuntos rgidos. La discretizacin suave se define
con un par de conjuntos difusos que forman una particin difusa (ec. (6.1)) como
se muestra en 6.2. En contraste con el mtodo clsico de particiones excluyentes,
la discretizacin suave se superpone.

Figura 6.1 - Discretizacin convencional

Figura 6.2 - Discretizacin suave

La discretizacin suave se define con tres parmetros / funciones: uno es el punto
de corte T y los otros dos son las funciones de membership del par de conjuntos
difusos A
1
y A
2
, siendo A1 + A2 = 1. El punto de corte T es determinado por el

Romina Laura Bot 37
Padrn 75722

valor que maximiza la ganancia de informacin y las funciones de membership se
determinan de acuerdo a las caractersticas de los datos a clasificar. Se utilizar la
distancia promedio de los valores del atributo como el ancho de superposicin.

La entropa difusa de un conjunto de datos S se define como

=
=
k
j
j j F
S c p S c p S E
1
2
) , ( log ) , ( ) (

donde p(cj,S) es la proporcin difusa de ejemplos en S:

S
F
c a
i i
j
N
a A a A
S c p
j i
+
=
)) ( ) ( (
) , (
2 1

Luego de la discretizacin suave, la entropa se calcula con la probabilidad de la
particin difusa como:

) ( ) ( ) ; , (
2 1
2 1
S E
N
N
S E
N
N
S T A E
F
S
F
S
F
F
S
F
S
F
F
+ =

=
=
k
j
j j F
S c p S c p S E
1
1 1 1
) , ( log ) , ( ) (
=
=
k
j
j j F
S c p S c p S E
1
2 2 2
) , ( log ) , ( ) (
2 , 1 , ) , ( = = k
N
N
S c p
k
j k
S
F
c S
F
k j

donde
=
+ =
| |
1
2 1
)) ( ) ( (
S
i
i i
S
F
a A a A N

=
=
| |
1
1
) (
1
S
i
i
S
F
a A N
=
=
| |
1
2
) (
2
S
i
i
S
F
a A N

2 , 1 ), (
= =
j i
j k
c a
i k
c S
F
k a A N

En forma similar a la induccin clsica, se utiliza la ganancia de informacin como
criterio para generar la mejor discretizacin para cada atributo:

) ; , ( ) ( S T A E S E IG
F F
=

Test de Particin. Cuando el atributo es discreto, se procede de forma idntica
que en el algoritmo TREPAN. Para el caso de atributos continuos, los pasos a seguir
son los siguientes:


Romina Laura Bot 38
Padrn 75722

1. Asumiendo que el nodo actual contiene N instancias que conforman S,
ordenar las instancias de acuerdo a los valores del atributo A.

2. Generar puntos de corte candidatos T = (a
i
+a
i+1
)/2, donde a
i
son los valores
de A tal que a
i
a
i+1
y clase(instancia
i
) clase(instancia
i+1
).

3. Calcular d como la distancia promedio entre los valores a
i
del atributo.

4. Generar puntos de corte difusos T a partir de los puntos de corte candidatos,
utilizando A
1
y A
2
para formar la particin difusa, siendo:

d
x
d
T
x A
|
.
|
\
|
+
=
2
) (
1

d
d
T x
x A
|
.
|
\
|

=
2
) (
2

5. Evaluar cada particin difusa calculando la ganancia de informacin difusa
para cada particin.

6. Seleccionar la discretizacin suave con mayor ganancia de informacin para
el atributo A.

7. Repetir los pasos 1 a 6 para cada atributo A
j
. Seleccionar el atributo con
mayor ganancia de informacin para particionar el nodo y generar dos
ramas en el rbol S
1
y S
2
:

} , ) ( | {
1 1
S a a A s S
i i
=

} , ) ( | {
2 2
S a a A s S
i i
=

El parmetro indica el grado de "membership mnimo para asignar una instancia
a una de las ramas del rbol. Usualmente se toma el valor = 0.5.

6.2 Implementacin del Algoritmo TREPAN Fuzzy

El algoritmo TREPAN Fuzzy se implement modificando la versin del algoritmo
TREPAN desarrollada en el sistema Weka. Esta modificacin consiste principalmente
en el reemplazo del mtodo de discretizacin de variables continuas y del test de
particin de las instancias en cada nodo, por el mtodo de "Discretizacin Suave
presentado en la seccin anterior. Por lo tanto, en lugar de obtener rboles de
decisin, se extraern rboles difusos a partir de una Red Neuronal entrenada.


Los parmetros de entrada del algoritmo TREPAN Fuzzy coinciden con los de
TREPAN: es posible determinar la cantidad mnima de instancias necesarias para
evaluar un nodo, limitar el tamao del rbol indicando una cantidad mxima de
nodos internos, construir el rbol con los nodos ms fieles a la Red Neuronal y
realizar una poda del rbol para eliminar aquellos nodos hoja que predicen la
misma clase. Adems, existe un parmetro adicional para indicar el grado de
membership para las particiones difusas:


Romina Laura Bot 39
Padrn 75722

Parmetro Descripcin
Valor por
defecto

Red Neuronal
BEST FIRST Indica si se debe construir el rbol
utilizando el criterio de mejor
expansin.

Falso
PROP. INSTANCES Porcentaje de instancias de una clase
que debe existir en un nodo para
transformarlo en una hoja

0.95
MAX. NODES Mxima cantidad de nodos del rbol. El
valor cero indica que no hay
restricciones en el tamao del rbol.

0
PRUNNING Indica si se desea hacer una poda del
rbol.

Falso

0
MEMBERSHIP Grado de membership de la funcin
difusa ().

0.5

Tabla 6.I - Parmetros de Entrada del Algoritmo Trepan M5

6.2.2 Ejemplo

Esquema: Labor

Atributos:
Duration: duracin del acuerdo (numrico).
Wage-increase-first-year: aumento de salario durante el primer ao de
contrato (numrico).
Wage-increase-second-year: aumento de salario durante el segundo ao de
contrato (numrico).
Wage-increase-third-year: aumento de salario durante el tercer ao de
contrato (numrico).
Cost-of-living-adjustment: ajuste del costo de vida (discreto).
Working-hours: horas de trabajo semanales (numrico).
Pension: contribucin del empleador al plan de pensiones (discreto).
Standby-pay: pago atrasado (numrico).
Shift-differential: pago diferencial (numrico).
Education-allowance: permite estudios (discreto).
Statutory-holidays: das de vacaciones (numrico).
Vacation: das de vacaciones pagos (discreto).
Longterm-disability-assistance: ayuda del empleador (discreto).
Contribution-to-dental-plan: contribucin del empleador al plan dental
(discreto).

Romina Laura Bot 40
Padrn 75722

Bereavement-assistance: contribucin del empleador en caso de
fallecimiento (discreto).
Contribution-to-health-plan: contribucin del empleador al plan de salud
(discreto).
Class: sentencia final en las negociaciones laborales en la industria
canadiense (discreto). Atributo clase.

Parmetros:
Max. Nodes:0
Min. Samples: 25
Membership: 0.5
Best First: False
Prunning: False


Scheme: weka.classifiers.trepanFuzzy.TrepanFuzzy -m 25 -M 0 -I 0.95 -s 0.5 -W
Relation: labor-neg-data
Instances: 57
Attributes: 17
duration
wage-increase-first-year
wage-increase-second-year
wage-increase-third-year
cost-of-living-adjustment
working-hours
pension
standby-pay
shift-differential
education-allowance
statutory-holidays
vacation
longterm-disability-assistance
contribution-to-dental-plan
bereavement-assistance
contribution-to-health-plan
class


Trepan

wage-increase-first-year <= 2.9 [2.8561 \ 2.9439]: bad [0.92,0.08]
wage-increase-first-year > 2.9 [2.8561 / 2.9439]
| longterm-disability-assistance = yes
| | wage-increase-third-year <= 3.20667 [3.1667 \ 3.2467]: bad [1.0,0.0]
| | wage-increase-third-year > 3.20667 [3.1667 / 3.2467]: good [0.0,1.0]
| longterm-disability-assistance = no: bad [1.0,0.0]




Romina Laura Bot 41
Padrn 75722

[m1 / m2] = x-m1 / m2-m1
[m1 \ m2] = m2-x / m2-m1
Class Distribution = [bad,good]



Trepan Fidelity = 89.33 %

=== Summary ===



0.8 0.081 0.842 0.8 0.821 bad
0.919 0.2 0.895 0.919 0.907 good


16 4 | a = bad
3 34 | b = good

Junto a cada nodo interno del rbol pueden observarse los valores m
1
y m
2
,
utilizados para calcular el grado de membership de cada instancia durante la
particin difusa. Adems, junto a cada nodo hoja se indica la distribucin de clases
para ese nodo, o sea, la proporcin de instancias de cada clase que alcanzaron el
nodo. Este valor es utilizado al momento de predecir la clase de una instancia.

El algoritmo tambin calcula la fidelidad del rbol con respecto a la Red Neuronal
(Trepan Fidelity). Para este ejemplo, la fidelidad es del 89.33%.

El rbol extrado puede ser interpretado como un rbol de decisin o como un rbol
difuso.

rbol de Decisin

wage-increase-first-year <= 2.9 : bad
wage-increase-first-year > 2.9
| | wage-increase-third-year <= 3.20667: bad
| | wage-increase-third-year > 3.20667: good
| longterm-disability-assistance = no: bad

En este rbol, la decisin en cada nodo divide el espacio en conjuntos excluyentes.


Romina Laura Bot 42
Padrn 75722

rbol Difuso

wage-increase-first-year [2.8561 \ 2.9439]: bad [0.92,0.08]
wage-increase-first-year [2.8561 / 2.9439]
| | wage-increase-third-year [3.1667 \ 3.2467]: bad [1.0,0.0]
| | wage-increase-third-year [3.1667 / 3.2467]: good [0.0,1.0]
| longterm-disability-assistance = no : bad [1.0,0.0]

El rbol difuso, en lugar de asignar una nica clase como resultado final de la
clasificacin, asocia un conjunto de posibilidades para una o ms clases. En cada
nodo del rbol encontramos una funcin del tipo [m
1
/ m
2
] o [m
1
\ m
2
] que indica el
grado de membership de la instancia para ese nodo. Adems, en cada hoja se
indica la distribucin de las clases de las instancias que la alcanzan.

La funcin decreciente que se denota como [m
1
\ m
2
] determina el membership de
las instancias que alcanzan la rama izquierda de un nodo. El membership es 1 si el
valor del atributo x es menor a m
1
, y 0 si x es mayor a m
2
. Para valores del atributo
comprendidos entre m
1
y m
2
utilizamos la funcin A
1
(x) correspondiente a la
particin difusa S
1
del nodo:

d
x
d
T
x A
|
.
|
\
|
+
=
2
) (
1

Donde T + d/2 = m
2
y d = m
2
- m
1
.

1 ) ( = x f para x < m
1
1 2
2
) (
m m
x m
x f
= para m
1
x m
2
0 ) ( = x f para x > m
2

Anlogamente, la funcin creciente que se denota como [m
1
/ m
2
] determina el
membership de las instancias que alcanzan la rama derecha de un nodo. El
membership es 0 si el valor del atributo x es menor a m
1
, y 1 si x es mayor a m
2
.
Para valores del atributo comprendidos entre m
1
y m
2
utilizamos la funcin A
2
(x)
correspondiente a la particin difusa S
2
del nodo:


Romina Laura Bot 43
Padrn 75722

d
d
T x
x A
|
.
|
\
|

=
2
) (
2

Donde T - d/2 = m
1
y d = m
2
- m
1
.

0 ) ( = x f para x < m
1
1 2
1
) (
m m
m x
x f
= para m
1
x m
2
1 ) ( = x f para x > m
2

Para el caso de atributos discretos, el grado de membership es 1 si el valor del
atributo coincide con el valor en el nodo, caso contrario es 0.

Como ejemplo, se clasificar la siguiente instancia para observar la diferencia entre
la clasificacin del rbol de decisin y el rbol difuso:

duration = 3
wage-increase-first-year = 2.9
wage-increase-second-year = 3
wage-increase-third-year = 3.18
cost-of-living-adjustment = none
working-hours = 40
pension = ret_allw
standby-pay = 2
shift-differential = 3
education-allowance = no
statutory-holidays = 9
vacation = below_average
longterm-disability-assistance = yes
contribution-to-dental-plan = full
bereavement-assistance = yes
contribution-to-health-plan = full
class = ?


Romina Laura Bot 44
Padrn 75722

rbol de Decisin

wage-increase-first-year <= 2.9 : bad
wage-increase-first-year > 2.9
| | wage-increase-third-year <= 3.20667: bad
| | wage-increase-third-year > 3.20667: good
| longterm-disability-assistance = no: bad

Dado que el valor del atributo wage-increase-first-year es igual a 2.9, el rbol de
decisin clasifica a la instancia como `bad.

rbol Difuso

wage-increase-first-year [2.8561 \ 2.9439]: bad [0.92,0.08]
wage-increase-first-year [2.8561 / 2.9439]
| | wage-increase-third-year [3.1667 \ 3.2467]: bad [1.0,0.0]
| | wage-increase-third-year [3.1667 / 3.2467]: good [0.0,1.0]
| longterm-disability-assistance = no : bad [1.0,0.0]

Class Distribution = [bad,good]

Para clasificar la instancia con el rbol difuso debemos calcular el membership de la
instancia en cada nodo del rbol. Luego, los valores de membership de los nodos y
el membership de la hoja se multiplican para obtener el membership de la rama,
para cada clase. El membership de una clase se calcula como la suma de estos
productos en cada rama (mtodo x-x-+).

Primero, se calcular el membership de la instancia en cada nodo:

Nodo 1. wage-increase-first-year [2.8561 \ 2.9439]

Para este nodo m
1
= 2.8561 y m
2
= 2.9439. Para calcular el valor de membership
debemos utilizar la funcin decreciente:

1 ) ( = x f para x < m
1
1 2
2
) (
m m
x m
x f
= para m
1
x m
2
0 ) ( = x f para x > m
2

Siendo x = 2.9 para la instancia a clasificar, m
1
x m
2
y el membership se
calcula como 2.9439 - 2.9 / 2.9439 - 2.8561 = 0.5.

Nodo 2. wage-increase-first-year [2.8561 / 2.9439]

En este caso se debe utilizar la funcin creciente, con m
1
= 2.8561 y m
2
= 2.9439:

0 ) ( = x f para x < m
1
1 2
1
) (
m m
m x
x f
= para m
1
x m
2
1 ) ( = x f para x > m
2


Romina Laura Bot 45
Padrn 75722

Como x = 2.9 para la instancia a clasificar, m
1
x m
2
y el membership es 1

Nodo 3. longterm-disability-assistance = yes

Dado que el valor en el nodo coincide con el valor del atributo longterm-disability-
assistance para la instancia, el valor de membership es 1.

Nodo 4. wage-increase-third-year [3.1667 \ 3.2467]

En este nodo utilizamos la funcin decreciente con m
1
= 3.1667 y m
2
= 3.2467.
Como wage-increase-third-year = 3.18 para la instancia a clasificar, el valor de
membership es 0.834 y se obtiene mediante la siguiente expresin:

1 2
2
) (
m m
x m
x f
=

Nodo 5. wage-increase-third-year [3.1667 / 3.2467]

En este nodo utilizamos la funcin creciente con m
1
= 3.1667 y m
2
= 3.2467. Como
wage-increase-third-year = 3.18 para la instancia a clasificar, el valor de
membership es 0.166.

Nodo 6. longterm-disability-assistance = no

Dado que el valor en el nodo no coincide con el valor del atributo longterm-
disability-assistance para la instancia, el valor de membership es 0.

Luego, calculamos el membership de cada rama. Recordemos que el membership
de una rama se calcula como el producto de los valores de membership de cada
nodo y el valor de membership de cada clase en los nodos hoja.

Rama 1.
wage-increase-first-year [2.8561 \ 2.9439] 0.5 : bad [0.92,0.08]

Membership Rama1 Clase `bad = 0.5 x 0.92 = 0.46
Membership Rama1 Clase `good = 0.5 x 0.08 = 0.04

Rama 2.
wage-increase-first-year [2.8561 / 2.9439] 0.5
| longterm-disability-assistance = no 0 : bad [1.0,0.0]

Membership Rama2 Clase `bad = 0.5 x 0 x 1 = 0
Membership Rama2 Clase `good = 0.5 x 0 x 0 = 0

Rama 3.
| longterm-disability-assistance = yes 1
| | wage-increase-third-year [3.1667 \ 3.2467] 0.834 : bad [1.0,0.0]


Romina Laura Bot 46
Padrn 75722

Membership Rama3 Clase `bad = 0.5 x 1 x 0.834 x 1 = 0.417
Membership Rama3 Clase `good = 0.5 x 1 x 0.834 x 0 = 0

Rama 4.
| longterm-disability-assistance = yes 1
| | wage-increase-third-year [3.1667 / 3.2467] 0.166 : good [0.0,1.0]

Membership Rama4 Clase `bad = 0.5 x 1 x 0.166 x 0 = 0
Membership Rama4 Clase `good = 0.5 x 1 x 0.166 x 1 = 0.083

Por ultimo, se calcula el membership de cada clase:

Membership Clase 'bad' = Membership Rama1 Clase `bad + Membership Rama2
Clase `bad + Membership Rama3 Clase `bad + Membership Rama4 Clase `bad =
0.46 + 0 + 0.417 + 0 = 0.877

Membership Clase 'good' = Membership Rama1 Clase `good + Membership
Rama2 Clase `good + Membership Rama3 Clase `good + Membership Rama4 Clase
`good = 0.04 + 0 + 0 +0.083 = 0.123

Por lo tanto, el rbol difuso clasific a la instancia como `bad con un 87.7% de
posibilidad.

Con este ejemplo podemos observar que el rbol difuso provee mas informacin
que el rbol de decisin.


Romina Laura Bot 47
Padrn 75722

7. Criterios de Evaluacin de los Clasificadores

Los algoritmos desarrollados se evaluarn segn los siguientes criterios (Craven,
[6]):

- Comprensibilidad: es el grado en que una representacin extrada de la
Red Neuronal es comprensible para el ser humano.

- Fidelidad: es el grado de exactitud en que la representacin modela a la
red a partir de la cual fue extrada.

- Precisin: es la habilidad de las representacin extrada de hacer
predicciones correctas para casos nunca vistos.

- Escalabilidad: es la habilidad del mtodo de clasificacin de escalar a redes
con gran cantidad de entradas, y gran cantidad de nodos y conexiones.

- Generalidad: es el grado en que el mtodo requiere regmenes especiales
de entrenamiento, o restricciones en la arquitectura de la red.

A continuacin se explica en detalle cada uno de estos criterios.

7.1 Comprensibilidad

Como se ha dicho, un criterio importante al evaluar un algoritmo de aprendizaje es
la comprensibilidad de las representaciones extradas por el algoritmo. El algoritmo
debe codificar la informacin aprendida para que pueda ser inspeccionada y
entendida por el ser humano. Existen al menos cinco razones que determinan la
importancia de este criterio (Craven, [10]):

- Validacin: Si los diseadores y usuarios finales de un sistema de
aprendizaje van a confiar en la performance del sistema, ellos deben
entender como toma las decisiones.

- Descubrimiento: Los algoritmos de aprendizaje pueden descubrir
caractersticas salientes en los datos de entrada, cuya importancia no ha
sido reconocida previamente. Si las representaciones extradas son
comprensibles entonces estos descubrimientos pueden ser accesibles.

- Explicacin: Si las representaciones son comprensibles entonces puede
explicarse la clasificacin de un caso en particular.

- Mejora la generalizacin: La representacin de los atributos utilizada para
una tarea de aprendizaje inductivo puede tener un impacto significativo en
la performance en cuanto a generalizacin. El entender la representacin de
un concepto puede facilitar el diseo de una mejor representacin de los
atributos para un problema dado.

- Refinamiento: Los sistemas de aprendizaje inductivo son muchas veces
utilizados para refinar la teora de un dominio. Cuando un sistema de
aprendizaje se utiliza con estos fines, es importante entender los cambios en
la base de conocimiento que ocurren a partir del proceso de entrenamiento.


Romina Laura Bot 48
Padrn 75722

La comprensibilidad de un conjunto de reglas es difcil de medir. Para evaluar la
comprensibilidad de las reglas extradas por los algoritmos desarrollados, se
considerar el nmero de reglas y antecedentes generados, es decir, la complejidad
sintctica del conjunto de reglas.

7.2 Fidelidad

Se entiende por fidelidad el grado de coincidencia entre la clasificacin del rbol y la
de la red. Si deseamos extraer un modelo que represente el mtodo de clasificacin
de una red neuronal, al clasificar un caso dicho modelo debera ser fiel a la red a
partir de la cual fue extrado, independientemente si la clasificacin es correcta o
no.

Para decidir cual ser el prximo nodo a expandir, TREPAN utiliza una funcin para
evaluar todos los nodos hoja del rbol, y elige el mejor. El mejor nodo es aquel que
tiene mayor potencial para incrementar la fidelidad del rbol extrado. La funcin
utilizada para evaluar el nodo N es:

)) ( 1 ( ) ( ) ( N fidelity N reach N f =

donde reach(N) es la fraccin de instancias que alcanzan el nodo N, y fidelity(N) es
la fidelidad estimada entre la red y el rbol para esas instancias.

Para maximizar la fidelidad, TREPAN clasifica las instancias de entrenamiento con
las Red Neuronal antes de construir el rbol de decisin.

7.3 Precisin

La precisin de un clasificador es la probabilidad de clasificar correctamente una
instancia seleccionada al azar.

Estimar la precisin de un clasificador inducido por algoritmos de aprendizaje
supervisado es importante, no slo para predecir la precisin del clasificador a
futuro, sino tambin para seleccionar el clasificador adecuado para el dominio a
estudiar.

Para determinar la precisin de los clasificadores se utilizar el mtodo 10-fold
cross-validation, que ha demostrado ser uno de los mejores mtodos para la
seleccin de un clasificador (Kohavi, [22]).

El mtodo 10-fold cross-validation, divide en forma aleatoria el conjunto de datos D
en 10 subconjuntos (folds) D
1
, D
2
, ...., D
10
de tamao aproximadamente igual. El
clasificador se entrena y testea 10 veces: cada vez t, t {1, 2, ..., 10}, se entrena
con los datos de D\D
t
y se testea con D
t
. La estimacin de precisin del mtodo
cross-validation es el nmero promedio de clasificaciones correctas, dividido el
nmero de instancias del conjunto de datos. Formalmente, siendo D
(i)
el conjunto
de datos de testeo que incluye a la instancia x
i
= <v
i
, y
i
>, luego la estimacin de
precisin de cross-validation es:

( ) ( )
> <
=
D yi vi
i cv
yi vi D D I
n
precisin
,
) (
, , \
1


Romina Laura Bot 49
Padrn 75722

7.4 Escalabilidad

La escalabilidad se refiere a como el tiempo de ejecucin de un algoritmo de
extraccin de reglas y la comprensibilidad de el modelo extrado vara como funcin
de factores tales como la red utilizada, las caractersticas de los datos a procesar, y
el tamao de los datos de entrenamiento. Como vemos, la escalabilidad est
relacionada con la comprensibilidad.

Los mtodos son mejores si pueden aplicarse a un amplio rango de dominios de
aplicacin. Esto significa, poder aplicar mtodos de extraccin de reglas a
problemas "grandes. Es por este motivo que es muy deseable que los algoritmos
sean escalables.

7.5 Generalidad

Muchos de los algoritmos de extraccin de reglas desarrollados pueden aplicarse a
Redes Neuronales con cierta arquitectura determinada, o a redes entrenadas
utilizando un rgimen especial.

Es deseable que los mtodos de extraccin de reglas presenten un alto grado de
generalidad para que puedan ser aplicados a Redes Neuronales de diferentes
topologas, funciones de transferencia y mtodos de entrenamiento.

Los mtodos de extraccin de reglas deben ser tan generales que no deben asumir
que modelan Redes Neuronales.


Romina Laura Bot 50
Padrn 75722

8. Resultados Experimentales

En esta seccin se detallan los resultados obtenidos al clasificar los siguientes
datasets con los nuevos algoritmos. Estos datasets forman parte del repositorio de
bases de datos de la UCI.

Dataset #Inst #Atrib
#At.
Nominales
#At.
Numricos
Valores
Desconoc
#
Clases
heart-c 303 14 7 6 s 5
ionosphere 351 35 0 34 no 2
waveform 5000 41 0 40 no 3
cpu 209 8 0 7 no continua
autoHorse 205 26 8 17 s continua
pollution 60 16 0 15 no continua

Tabla 8.I - Datasets UCI

Se seleccionaron aquellos datasets para los cuales las Redes Neuronales clasifican
con mayor precisin que el resto de los algoritmos. Los datasets con clases
discretas se clasificaron con la Red Neuronal y con los mtodos TREPAN Fuzzy y
J48. Los datasets con clases continuas se clasificaron con la Red Neuronal y con los
mtodos TREPAN M5 y M5. Para todos los casos, se eligi como orculo una Red
Neuronal Back Propagation. Los tiempos de ejecucin de los algoritmos TREPAN M5
y TREPAN Fuzzy incluyen el tiempo que insume el entrenamiento de la Red
Neuronal utilizada como orculo.

8.1 TREPAN M5

A continuacin se detallan los resultados obtenidos al clasificar los datasets con
clases continuas utilizando el algoritmo TREPAN M5 para generar rboles modelo.
Cada hoja del rbol modelo esta asociada a una regla, que en este caso es una
funcin lineal. Por lo tanto, el nmero de reglas obtenidas es equivalente a la
cantidad de hojas del rbol resultante.

8.1.1 CPU

Este dataset, presentado en la seccin 8.2.2, se ha utilizado para la prediccin de la
performance relativa de una CPU.

Se clasific el dataset con una Red Neuronal de 35 neuronas de entrada, una capa
oculta compuesta por 18 neuronas y una nica neurona de salida representando la
clase a predecir. Los resultados de la clasificacin son los siguientes:


Scheme: weka.classifiers.neural.NeuralNetwork -L 0.3 -M 0.2 -N 500 -V 0 -S 0 -E 20 -H
a
Relation: cpu
Instances: 209
Attributes: 8

Romina Laura Bot 51
Padrn 75722

vendor
MYCT
MMIN
MMAX
CACH
CHMIN
CHMAX
class



=== Summary ===


Luego, se clasific el dataset con el algoritmo M5 para construir un rbol modelo. A
continuacin se detallan los resultados obtenidos:


Scheme: weka.classifiers.m5.M5Prime -O m -F 2.0 -V 0
Relation: cpu
Instances: 209
Attributes: 8
vendor
MYCT
MMIN
MMAX
CACH
CHMIN
CHMAX
class



MMAX <= 14000 : LM1 (141/4.18%)
MMAX > 14000 : LM2 (68/51.8%)


Smoothed (complex):

LM1: class = 4.15
-
2.05vendor=honeywell,ipl,ibm,cdc,ncr,basf,gould,siemens,nas,adviser,sperry,amdahl
+ 5.43vendor=adviser,sperry,amdahl - 5.78vendor=amdahl
+ 0.00638MYCT + 0.00158MMIN + 0.00345MMAX + 0.552CACH
+ 1.14CHMIN + 0.0945CHMAX


Romina Laura Bot 52
Padrn 75722

LM2: class = -113
-
56.1vendor=honeywell,ipl,ibm,cdc,ncr,basf,gould,siemens,nas,adviser,sperry,amdahl
+ 10.2vendor=adviser,sperry,amdahl - 10.9vendor=amdahl
+ 0.012MYCT + 0.0145MMIN + 0.0089MMAX + 0.808CACH + 1.29CHMAX

Number of Rules : 2



=== Summary ===


Dado que la clasificacin con la Red Neuronal result ms precisa, se obtuvo el
rbol modelo que representa el mtodo de clasificacin de la red utilizando el
algoritmo TREPAN M5. Los parmetros de entrada son los siguientes:

Model Type:Model Tree
Min. Samples: 25
Use Unsmoothed: False
Verbosity: 0

Como puede observarse, se establece que sern necesarias al menos 25 instancias
para evaluar un nodo. En caso de no alcanzar esa cantidad, TREPAN M5 deber
crear las instancias faltantes utilizando a la Red Neuronal como orculo.


Relation: cpu
Instances: 209
Attributes: 8
vendor
MYCT
MMIN
MMAX
CACH
CHMIN
CHMAX
class



MMAX <= 14000 : LM1 (141/4.46%)

Romina Laura Bot 53
Padrn 75722

MMAX > 14000 :
| MMAX <= 22500 : LM2 (37/9.19%)
| MMAX > 22500 :
| | CHMIN <= 10 : LM3 (16/5.31%)
| | CHMIN > 10 :
| | | MMAX <= 36500 :
| | | | MMIN <= 10600 : LM4 (6/13.9%)
| | | | MMIN > 10600 : LM5 (5/4.16%)
| | | MMAX > 36500 : LM6 (4/2.12e-12%)


Smoothed (complex):

LM1: class = 14
-
1.9vendor=magnuson,honeywell,ipl,ibm,cdc,ncr,basf,gould,siemens,nas,adviser,sperry,amda
hl
- 3.81vendor=nas,adviser,sperry,amdahl + 0.0035MMIN
+ 0.00342MMAX + 0.533CACH + 0.633CHMIN + 0.103CHMAX
LM2: class = 6.04
-
17.9vendor=magnuson,honeywell,ipl,ibm,cdc,ncr,basf,gould,siemens,nas,adviser,sperry,amd
ahl
+ 0.00992MMIN + 0.00323MMAX + 0.654CACH + 0.659CHMAX
LM3: class = -147
-
ahl
LM4: class = -195
-
ahl
LM5: class = -183
-
ahl
LM6: class = -182
-
ahl
+ 0.0144MMIN + 0.00953MMAX + 1CACH + 1.33CHMAX

Number of Rules : 6



=== Summary ===



Romina Laura Bot 54
Padrn 75722

En el siguiente cuadro comparativo se detallan los resultados obtenidos para cada
uno de los mtodos aplicados:

Clasificador
Tiempo
(seg.)
Coef
Correl
Error
medio
abs
Raz err
cuad
medio
Error
abs.
relativo
Raz
error
cuad rel
#
Reglas
Red Neuronal 26.24 0,9936 7,1281 17,9644 8,16% 11,64% -
M5 0,13 0,9763 13,3864 35,6149 15,32% 23,07% 2
TREPAN M5 116.15 0,9852 11,2033 28.1359 12,82% 18.22% 6

Tabla 8.II - Resultados clasificacin CPU

Se observa que el rbol modelo obtenido con TREPAN M5 es ms preciso que el
construido por M5. Aunque este ltimo es ms conciso (slo consta de dos nodos
hojas) el rbol modelo de TREPAN M5 tambin es conciso y comprensible.

Se graficaron las curvas del coeficiente de correlacin, los errores y la cantidad de
reglas extradas, variando la cantidad de instancias mnimas requeridas para
evaluar un nodo:

0,976
0,978
0,98
0,982
0,984
0,986
0,988
0 5 10 15 20 25 30 35 40 45 50
Coeficiente de Correlacin

Figura 8.1 - Coeficiente de Correlacin de Trepan M5 para el dataset CPU. El eje x
indica la cantidad de instancias mnimas necesarias para evaluar un nodo. El eje y
indica el coeficiente de correlacin de los rboles extrados.


Romina Laura Bot 55
Padrn 75722

0
5
10
15
20
25
30
35
40
0 5 10 15 20 25 30 35 40 45 50
Error Medio Absoluto
Raz del Error Cuadrtico
Medio

Figura 8.2 - Curvas de Errores absolutos de Trepan M5 para el dataset CPU. El eje x
indica el error de los rboles extrados.

0%
5%
10%
15%
20%
25%
30%
0 5 10 15 20 25 30 35 40 45 50
Error Absoluto Relativo
Raz del Error Cuadrtido Relativo

Figura 8.3 - Curvas de Errores relativos de Trepan M5 para el dataset CPU. El eje x
indica el porcentaje de error de los rboles extrados.


Romina Laura Bot 56
Padrn 75722

0
1
2
3
4
5
6
7
8
9
0 5 10 15 20 25 30 35 40 45 50

Figura 8.4 - Comprensibilidad de Trepan M5 para el dataset CPU. El eje x indica la
cantidad de instancias mnimas necesarias para evaluar un nodo. El eje y indica la
cantidad de reglas generadas por Trepan M5.

Los grficos muestran que al generar rboles modelo con mayor cantidad de
instancias mnimas para evaluar un nodo, se obtienen rboles ms precisos: el
coeficiente de correlacin aumenta y los errores disminuyen. Tambin aumenta la
cantidad de reglas extradas, por lo tanto los rboles son ms complejos y menos
comprensibles. Los mejores resultados se obtuvieron para rboles modelo
construidos con alrededor de 20 instancias mnimas requeridas para evaluar un
nodo. Se observa que para estos valores los rboles son ms precisos y
comprensibles.

8.1.2 AutoHorse

Este dataset contiene la especificacin de un automvil en trmino de sus
caractersticas, la tasa del seguro contra riesgos y los costos anuales de uso
comparado con otros automviles. A continuacin se detallan los atributos del
mismo:

Symboling: factor de riesgo (numrico).
Normalized-losses: gasto promedio anual en seguros (numrico).
Make: marca del automvil (discreto). Valores posibles: alfa-romero, audi, bmw,
chevrolet, dodge, honda, isuzu, jaguar, mazda, mercedes-benz, mercury,
mitsubishi, nissan, peugot, plymouth, porsche, renault, saab, subaru, toyota,
volkswagen, volvo.
Fuel-type: tipo de combustible (discreto). Valores posibles: gas, diesel.
Aspiration: aspiracin (discreto). Valores posibles: std, turbo.
Num-of-doors: cantidad de puertas (numrico).
Body-style: estilo de carrocera (discreto). Valores posibles: convertible, hatchback,
sedan, wagon, hardtop.
Drive-wheels: direccin de los neumticos (discreto). Valores posibles: rwd, fwd,
4wd.
Engine-location: ubicacin del motor (discreto). Valores posibles: front, rear.

Romina Laura Bot 57
Padrn 75722

Wheel-base: base del neumtico (numrico).
Length: longitud (numrico).
Width: ancho (numrico).
Height: alto (numrico).
Curb-weight: peso (numrico).
Engine-type: tipo de motor (discreto). Valores posibles: dohc, ohcv, ohc, l, rotor,
ohcf, dohcv.
Num-of-cylinders: cantidad de cilindros (numrico).
Engine-size: tamao del motor (numrico).
Fuel-system: sistema de combustible (discreto). Valores posibles: mpfi, 2bbl, mfi,
1bbl, spfi, 4bbl, idi, spdi.
Bore (numrico).
Stroke (numrico).
Compression-ratio: relacin de compresin (numrico).
Peak-rpm: revoluciones por minuto mximas (numrico).
City-mpg: millas por galn en ciudad (numrico).
Highway-mpg: millas por galn en autopista (numrico).
Price: precio (numrico).
Class: atributo clase (numrico).

En primer lugar se clasific el dataset con una Red Neuronal de 60 neuronas de
entrada, una capa de 4 neuronas ocultas y una neurona de salida para la clase a
predecir. Los resultados de la clasificacin fueron los siguientes:


Scheme: weka.classifiers.neural.NeuralNetwork -L 0.01 -M 0.02 -N 500 -V 0 -S 0 -E 20 -
H 4
Relation: autoHorse.names
Instances: 205
Attributes: 26
symboling
normalized-losses
make
fuel-type
aspiration
num-of-doors
body-style
drive-wheels
engine-location
wheel-base
length
width
height
curb-weight
engine-type
num-of-cylinders
engine-size
fuel-system
bore
stroke
compression-ratio
peak-rpm
city-mpg
highway-mpg
price
class


Romina Laura Bot 58
Padrn 75722


=== Summary ===

Ignored Class Unknown Instances 2

Luego se clasific el dataset con el algoritmo M5 para obtener un rbol modelo:


Scheme: weka.classifiers.m5.M5Prime -O m -U -F 2.0 -V 0
Instances: 205
Attributes: 26
symboling
normalized-losses
make
fuel-type
aspiration
num-of-doors
body-style
drive-wheels
engine-location
wheel-base
length
width
height
curb-weight
engine-type
num-of-cylinders
engine-size
fuel-system
bore
stroke
compression-ratio
peak-rpm
city-mpg
highway-mpg
price
class



highway-mpg <= 30.5 :
| city-mpg <= 20.5 :
| | engine-size <= 177 :
| | | engine-size <= 121 :
| | | | symboling <= 1.5 : LM1 (5/3.21%)
| | | | symboling > 1.5 : LM2 (4/1.92%)
| | | engine-size > 121 :

Romina Laura Bot 59
Padrn 75722

| | | | height <= 51.1 : LM3 (6/2.44%)
| | | | height > 51.1 :
| | | | | engine-type=l,rotor,ohcf,dohc,ohcv,dohcv <= 0.5 :
| | | | | | aspiration=turbo <= 0.5 : LM4 (7/5.63%)
| | | | | | aspiration=turbo > 0.5 :
| | | | | | | width <= 68.9 : LM5 (5/18.6%)
| | | | | | | width > 68.9 : LM6 (2/42.6%)
| | | | | engine-type=l,rotor,ohcf,dohc,ohcv,dohcv > 0.5 :
| | | | | | wheel-base <= 106 :
| | | | | | | symboling <= 1.5 : LM7 (3/3.09%)
| | | | | | | symboling > 1.5 : LM8 (4/1.64%)
| | | | | | wheel-base > 106 : LM9 (2/13.1%)
| | engine-size > 177 :
| | | compression-ratio <= 9.25 : LM10 (15/25.8%)
| | | compression-ratio > 9.25 :
| | | | symboling <= 2 : LM11 (2/42.6%)
| | | | symboling > 2 : LM12 (3/0%)
| city-mpg > 20.5 : LM13 (49/14.6%)
highway-mpg > 30.5 :
| engine-size <= 106 :
| | bore <= 3.07 :
| | | normalized-losses <= 143 :
| | | | peak-rpm <= 5250 :
| | | | | normalized-losses <= 92.5 : LM14 (6/0%)
| | | | | normalized-losses > 92.5 :
| | | | | | highway-mpg <= 44 : LM15 (6/0%)
| | | | | | highway-mpg > 44 : LM16 (5/11%)
| | | | peak-rpm > 5250 :
| | | | | engine-size <= 91 : LM17 (8/0.109%)
| | | | | engine-size > 91 : LM18 (5/0%)
| | | normalized-losses > 143 : LM19 (9/0%)
| | bore > 3.07 : LM20 (18/1.89%)
| engine-size > 106 :
| | fuel-type=gas <= 0.5 :
| | | normalized-losses <= 142 : LM21 (5/6.55%)
| | | normalized-losses > 142 : LM22 (3/0%)
| | fuel-type=gas > 0.5 :
| | | price <= 8900 :
| | | | engine-type=l,rotor,ohcf,dohc,ohcv,dohcv <= 0.5 : LM23 (10/4.96%)
| | | | engine-type=l,rotor,ohcf,dohc,ohcv,dohcv > 0.5 : LM24 (5/2.28e-14%)
| | | price > 8900 :
| | | | symboling <= -0.5 : LM25 (4/0%)
| | | | symboling > -0.5 :
| | | | | engine-size <= 121 : LM26 (9/6.33%)
| | | | | engine-size > 121 : LM27 (3/0%)


Unsmoothed (simple):

LM1: class = 96.2
LM2: class = -582 + 0.287curb-weight
LM3: class = 145
LM4: class = 110 + 8.67drive-wheels=4wd,rwd
LM5: class = 164
LM6: class = 127
LM7: class = 155
LM8: class = 161
LM9: class = 138
LM10: class = 406 - 28.1compression-ratio
LM11: class = 275
LM12: class = 207


Romina Laura Bot 60
Padrn 75722

LM13: class = -26.9
+ 20.2make=toyota,peugot,nissan,mitsubishi,renault,audi,alfa-
romero,saab,volvo,bmw,mercedes-benz,mercury,jaguar,porsche
- 22.8make=peugot,nissan,mitsubishi,renault,audi,alfa-
+ 17.4make=nissan,mitsubishi,renault,audi,alfa-
+ 12.6aspiration=turbo + 1.63width + 0.229engine-size
- 1.64compression-ratio
LM14: class = 62
LM15: class = 68
LM16: class = 53
LM17: class = 180
-
4.26make=honda,volkswagen,mazda,subaru,dodge,plymouth,toyota,peugot,nissan,mitsubis
hi,renault,audi,alfa-romero,saab,volvo,bmw,mercedes-benz,mercury,jaguar,porsche
- 11.5compression-ratio
LM18: class = 76
LM19: class = 68
LM20: class = 69.3
LM21: class = -129 + 1.94wheel-base
LM22: class = 95
LM23: class = 85.9
LM24: class = 82 - 4.5symboling
LM25: class = 92
LM26: class = 179 + 5.63symboling - 0.016peak-rpm
LM27: class = 84

Number of Rules : 27



=== Summary ===


El rbol obtenido es casi tan preciso como la red, pero no es conciso. No slo es
profundo sino que adems consta de 27 reglas posibles. Por lo tanto se ejecutar el
algoritmo TREPAN M5 para intentar obtener un rbol modelo similar en precisin y
ms comprensible. Los parmetros de entrada seleccionados son los siguientes:

Min. Samples: 25
Verbosity: 0

Como condicin el algoritmo deber evaluar cada nodo con un mnimo de 25
instancias. De esta manera se busca mejorar la precisin en cada evaluacin y
obtener un rbol preciso y comprensible.

Romina Laura Bot 61
Padrn 75722


weka.classifiers.neural.NeuralNetwork -- -L 0.01 -M 0.02 -N 500 -V 0 -S 0 -E 20 -H 4
Instances: 205
Attributes: 26
symboling
normalized-losses
make
fuel-type
aspiration
num-of-doors
body-style
drive-wheels
engine-location
wheel-base
length
width
height
curb-weight
engine-type
num-of-cylinders
engine-size
fuel-system
bore
stroke
compression-ratio
peak-rpm
city-mpg
highway-mpg
price
class



highway-mpg <= 30.5 :
| city-mpg <= 20.5 :
| | engine-size <= 177 :
| | | engine-size <= 121 : LM1 (9/3.76%)
| | | engine-size > 121 :
| | | | engine-size <= 141 : LM2 (14/16.3%)
| | | | engine-size > 141 : LM3 (15/18.6%)
| | engine-size > 177 : LM4 (20/32.8%)
| city-mpg > 20.5 : LM5 (49/20.2%)
highway-mpg > 30.5 : LM6 (96/7.99%)


Smoothed (complex):

-
0.686make=dodge,plymouth,toyota,peugot,nissan,mitsubishi,renault,audi,alfa-
+ 15.6make=porsche + 11.5fuel-type=gas + 20.1aspiration=turbo

Romina Laura Bot 62
Padrn 75722

- 2.63num-of-doors - 3.25body-style=sedan,convertible,hardtop
- 0.125height + 0.0011curb-weight
+ 4.17engine-type=rotor,ohcf,dohc,ohcv,dohcv
+ 24.5engine-type=dohcv + 0.353engine-size
+ 3.39fuel-system=spfi,4bbl,spdi,mpfi,mfi
+ 10.3fuel-system=mpfi,mfi - 0.949bore + 2.11stroke
+ 0.655compression-ratio - 3.06city-mpg - 3.08highway-mpg
LM2: class = 72.8 - 0.802symboling
-
+ 0.655compression-ratio - 3.06city-mpg + 1.81highway-mpg
-
-
- 8.31num-of-doors - 0.125height + 0.0011curb-weight
+ 47engine-type=dohcv + 0.265engine-size
LM5: class = 73.9 - 0.877symboling - 0.0528normalized-losses
-
- 1.45num-of-doors + 6.02drive-wheels=rwd - 0.125height
+ 0.0011curb-weight

Romina Laura Bot 63
Padrn 75722

- 3.62make=dodge,plymouth,toyota,peugot,nissan,mitsubishi,renault,audi,alfa-
- 0.394num-of-doors - 0.833height + 0.0012curb-weight
+ 7.85fuel-system=mpfi,mfi + 16.4bore + 15.5stroke

Number of Rules : 6



=== Summary ===


A continuacin se observan los resultados obtenidos al ejecutar cada uno de los
mtodos:

Clasificador
Tiempo
(seg.)
Coef
Correl
Error
medio
abs
Raz err
cuad
medio
Error
abs.
relativo
Raz
error
cuad rel
#
Reglas
Red Neuronal 8.7 0,9479 7,1875 12.626 23.56% 31.87% -
M5 0,46 0,9412 8,819 13,431 28,91% 33,90% 27
TREPAN M5 46.09 0,9385 7.9235 13.7037 25.97% 34.59% 6

Tabla 8.III - Resultados clasificacin AutoHorse

Puede observarse que los rboles modelo extrados con los mtodos TREPAN M5 y
M5 son similares en cuanto a precisin. An as, es preferible el rbol obtenido con
TREPAN M5 debido a que es ms comprensible: es ms conciso y menos profundo,
lo que equivale a una menor cantidad de antecedentes en las reglas. Adems, la
cantidad de reglas resultante es considerablemente menor.

Se graficaron las curvas del coeficiente de correlacin, los errores y la cantidad de
reglas extradas, variando la cantidad de instancias mnimas requeridas para
evaluar un nodo:


Romina Laura Bot 64
Padrn 75722

0,91
0,915
0,92
0,925
0,93
0,935
0,94
0,945
0,95
0,955
0,96
0 5 10 15 20 25 30 35 40 45 50

Figura 8.5 - Coeficiente de Correlacin de Trepan M5 para el dataset AutoHorse. El
eje x indica la cantidad de instancias mnimas necesarias para evaluar un nodo. El
eje y indica el coeficiente de correlacin de los rboles extrados.

6
7
8
9
10
11
12
13
14
15
16
0 5 10 15 20 25 30 35 40 45 50
Raz del Error Cuadrtico Medio

Figura 8.6 - Curvas de Errores absolutos de Trepan M5 para el dataset AutoHorse.
El eje x indica la cantidad de instancias mnimas necesarias para evaluar un nodo.
El eje y indica el error de los rboles extrados.


Romina Laura Bot 65
Padrn 75722

20%
22%
24%
26%
28%
30%
32%
34%
36%
38%
40%
0 5 10 15 20 25 30 35 40 45 50

Figura 8.7 - Curvas de Errores relativos de Trepan M5 para el dataset AutoHorse. El
eje y indica el porcentaje de error de los rboles extrados.

0
2
4
6
8
10
12
14
16
18
0 5 10 15 20 25 30 35 40 45 50

Figura 8.8 - Comprensibilidad de Trepan M5 para el dataset AutoHorse. El eje x
indica la cantidad de reglas generadas por Trepan M5.

Los grficos muestran, para este caso, que al aumentar la cantidad de instancias
mnimas necesarias para evaluar un nodo, se obtienen rboles ms precisos y

Romina Laura Bot 66
Padrn 75722

disminuyen los errores. Tambin se observa que la cantidad de reglas extradas
tiende a disminuir, es decir, los rboles son ms concisos y comprensibles.

8.1.3 Pollution

Este dataset contiene datos sobre contaminacin, relacionados con la tasa de
fallecimientos por contaminacin del aire. Las instancias constan de 16 atributos:

PREC: promedio de precipitaciones anuales en pulgadas (numrico).
JANT: temperatura promedio del mes de Enero en grados F (numrico).
JULT: temperatura promedio del mes de Julio en grados F (numrico).
OVR65: porcentaje de poblacin de 1960 mayores a 65 aos (numrico).
POPN: tamao promedio de vivienda (numrico).
EDUC: aos de escuela media completos por mayores de 22 aos (numrico).
HOUS: porcentaje de hogares con comodidades (numrico).
DENS: poblacin por manzana en zonas urbanizadas en 1960 (numrico).
NONW: porcentaje de poblacin de color en zonas urbanizadas en 1960 (numrico).
WDRK: porcentaje de empleados administrativos (numrico).
POOR: porcentaje de familias con ingresos menores a $3000 (numrico).
HC: contaminacin potencial de hidrocarburo relativa (numrico).
NOX: contaminacin potencial de xidos ntricos (numrico).
SO@: contaminacin potencial de dixido sulfrico relativa (numrico).
HUMID: promedio anual de humedad relativa a 1pm (numrico).
MORT: tasa de mortalidad por 100000 total (numrico). Atributo clase.

Se clasific el dataset con una Red Neuronal de 15 neuronas de entrada (una por
atributo, excepto el atributo clase), una capa oculta compuesta por una nica
neurona y una neurona de salida correspondiente al atributo clase.

Tabla 8.IV - Pollution - Red Neuronal Back Propagation

Romina Laura Bot 67
Padrn 75722

Los resultados obtenidos luego de la clasificacin con la Red Neuronal son los
siguientes:


Scheme: weka.classifiers.neural.NeuralNetwork -L 0.01 -M 0.02 -N 500 -V 0 -S 0 -E 20 -
H 1
Relation: pollution
Instances: 60
Attributes: 16
PREC
JANT
JULT
OVR65
POPN
EDUC
HOUS
DENS
NONW
WWDRK
POOR
HC
NOX
SO@
HUMID
MORT


Linear Node 0
Inputs Weights
Threshold -0.9324316182041238
Node 1 1.8792607422025969
Sigmoid Node 1
Inputs Weights
Threshold 0.3895378163821913
Attrib PREC 0.6902233348498833
Attrib JANT -0.5480716637382733
Attrib JULT -0.28899810430673345
Attrib OVR65 0.009088366169682614
Attrib POPN -0.08203844695997857
Attrib EDUC -0.12780837857754643
Attrib HOUS -0.24021652583999634
Attrib DENS 0.2935128022338174
Attrib NONW 1.2451643429677848
Attrib WWDRK -0.1350600557325014
Attrib POOR -0.05552566454882846
Attrib HC -0.2550032204712716
Attrib NOX -0.06510227363711019
Attrib SO@ 0.5471023879010722
Attrib HUMID 0.2046184929126627
Class
Input
Node 0



=== Summary ===

Romina Laura Bot 68
Padrn 75722


Luego se clasificaron los datos con el algoritmo M5 obteniendo el siguiente
resultado:


Scheme: weka.classifiers.m5.M5Prime -O m -F 2.0 -V 0
Relation: pollution
Instances: 60
Attributes: 16
PREC
JANT
JULT
OVR65
POPN
EDUC
HOUS
DENS
NONW
WWDRK
POOR
HC
NOX
SO@
HUMID
MORT



LM1 (60/61.1%)


Smoothed (complex):

LM1: MORT = 1930 + 1.86PREC - 2.26JANT - 3.32JULT - 10.9OVR65 - 137POPN
- 23.4EDUC + 4.66NONW - 0.922HC + 1.87NOX

Number of Rules : 1



=== Summary ===


Romina Laura Bot 69
Padrn 75722


Dado que la red clasifica mejor que el rbol modelo extrado con M5, se ejecut el
mtodo TREPAN M5 para obtener una descripcin del mtodo que utiliza la Red
Neuronal para clasificar. Los parmetros de entrada de TREPAN M5 son los
siguientes:

Min. Samples: 0
Verbosity: 0

Se obtuvo el siguiente rbol modelo como representacin del mtodo de
clasificacin de la red:


weka.classifiers.neural.NeuralNetwork -- -L 0.01 -M 0.02 -N 500 -V 0 -S 0 -E 20 -H 1
Relation: pollution
Instances: 60
Attributes: 16
PREC
JANT
JULT
OVR65
POPN
EDUC
HOUS
DENS
NONW
WWDRK
POOR
HC
NOX
SO@
HUMID
MORT



LM1 (60/16.5%)


Smoothed (complex):

LM1: MORT = 1300 + 1.57PREC - 1.14JANT - 2.53JULT - 23POPN - 11.8EDUC
- 0.627HOUS + 4.51NONW + 0.131HC - 0.435NOX + 0.336SO@

Number of Rules : 1


Romina Laura Bot 70
Padrn 75722



=== Summary ===


La tabla 8.V muestra los resultados obtenidos:

Clasificador
Tiempo
(seg.)
Coef
Correl
Error
medio
abs
Raz err
cuad
medio
Error
abs.
relativo
Raz
error
cuad rel
#
Reglas
Red Neuronal 0.41 0,755 29,9736 40,9585 60,33% 66,40% -
M5 0.13 0,6847 35,7613 46,4166 71,98% 75,25% 1
TREPAN M5 0.37 0,7552 30,1949 40.8559 60,78% 66.23% 1

Tabla 8.V - Resultados clasificacin Pollution

El rbol modelo extrado por TREPAN M5 es tan preciso como la Red Neuronal. A su
vez, supera en precisin al rbol modelo generado por el mtodo M5. En este caso
no se han generado instancias adicionales para evaluar los nodos y es por este
motivo que el tiempo de ejecucin del algoritmo TREPAN M5 no result tan elevado
teniendo en cuenta que incluye el tiempo que insume el entrenamiento de la Red
Neuronal.

A continuacin se observan los grficos obtenidos al ejecutar el algoritmo variando
la cantidad de instancias mnimas necesarias para evaluar un nodo.

0,7
0,72
0,74
0,76
0,78
0,8
0 5 10 15 20 25 30 35 40 45 50

Figura 8.9 - Coeficiente de Correlacin de Trepan M5 para el dataset Pollution. El
eje y indica el coeficiente de correlacin de los rboles extrados.

Romina Laura Bot 71
Padrn 75722

20
25
30
35
40
45
0 5 10 15 20 25 30 35 40 45 50
Raz del Error Cuadrtico Medio

Figura 8.10 - Curvas de Errores absolutos de Trepan M5 para el dataset Pollution. El
eje y indica el error de los rboles extrados.

54%
56%
58%
60%
62%
64%
66%
68%
70%
72%
0 5 10 15 20 25 30 35 40 45 50

Figura 8.11 - Curvas de Errores relativos de Trepan M5 para el dataset Pollution. El
eje y indica el porcentaje de error de los rboles extrados.


Romina Laura Bot 72
Padrn 75722

0
1
2
0 5 10 15 20 25 30 35 40 45 50

Figura 8.12 - Comprensibilidad de Trepan M5 para el dataset Pollution. El eje x
indica la cantidad de reglas generadas por Trepan M5.

Los mejores resultados se obtuvieron para una cantidad mnima de instancias entre
30 y 40. Para estos valores los rboles extrados son ms precisos y los errores
disminuyen. En cuanto a la complejidad de los rboles modelo, para todos los casos
el resultado de la clasificacin es una nica regla o funcin lineal.

Se observa que para los casos en que la clasificacin de la Red Neuronal es ms
precisa, TREPAN M5 genera un clasificador que se aproxima en precisin a la red.
Los tiempos de ejecucin del algoritmo TREPAN M5 son elevados, an as se
justifica su uso debido a que permite obtener una descripcin del mtodo de
clasificacin de la Red Neuronal. Las reglas extradas explican el razonamiento de la
red.

8.2 TREPAN Fuzzy

A continuacin se detallan los resultados obtenidos al clasificar los datasets
utilizando el algoritmo TREPAN Fuzzy para generar rboles difusos.

8.2.1 Heart-C

Este dataset contiene 303 casos de diagnstico de enfermedades cardacas. Cada
instancia consta de 14 atributos:

Age: edad del paciente (numrico).
Sex: sexo del paciente (discreto). Valores posibles: female, male.
Cp: tipo de afeccin en el pecho (discreto). Valores posibles: typ_angina, asympt,
non_anginal, atyp_angina.
Trestbps: presin sangunea en estado de reposo (numrico).

Romina Laura Bot 73
Padrn 75722

Chol: colesterol (numrico).
Fbs: azcar en la sangre (discreto). Valores posibles: t, f.
Restecg: resultado del ecocardiograma en reposo (discreto). Valores posibles:
left_vent_hyper, normal, st_t_wave_abnormality.
Thalach: frecuencia cardiaca mxima (numrico).
Exang: el ejercicio induce dolor en el pecho (discreto). Valores posibles: no, yes.
Oldpeak: diferencia de presin entre el ejercicio y el reposo (numrico).
Slope: pendiente de la diferencia de presin entre el ejercicio y el reposo (discreto).
Valores posibles: up, flat, down.
Ca: nmero de vasos coloreados por fluoroscopia (numrico).
Thal: discreto. Valores posibles: fixed_defect, normal, reversable_defect.
Num: diagnstico de enfermedad cardiaca (discreto). Atributo Clase. Valores
posibles: <50, >50_1, >50_2, >50_3, >50_4.

Se clasific el dataset con una Red Neuronal de 22 neuronas de entrada, con dos
capas ocultas de 13 neuronas cada una y 5 neuronas de salida.

Tabla 8.VI - Heart C - Red Neuronal Back Propagation

El resultado obtenido es el siguiente:


"a, a"
Relation: cleveland-14-heart-disease
Instances: 303
Attributes: 14

Romina Laura Bot 74
Padrn 75722

age
sex
cp
trestbps
chol
fbs
restecg
thalach
exang
oldpeak
slope
ca
thal
num



=== Summary ===



0.861 0.217 0.826 0.861 0.843 <50
0.783 0.139 0.824 0.783 0.803 >50_1
0 0 0 0 0 >50_2
0 0 0 0 0 >50_3
0 0 0 0 0 >50_4


a b c d e <-- classified as
142 23 0 0 0 | a = <50
30 108 0 0 0 | b = >50_1
0 0 0 0 0 | c = >50_2
0 0 0 0 0 | d = >50_3
0 0 0 0 0 | e = >50_4

Observamos que la red clasific las instancias con una buena precisin. Luego, se
clasific el dataset con el algoritmo J48. Se obtuvo el siguiente rbol de decisin:


Scheme: weka.classifiers.j48.J48 -R -N 3 -M 2
Instances: 303
Attributes: 14
age

Romina Laura Bot 75
Padrn 75722

sex
cp
trestbps
chol
fbs
restecg
thalach
exang
oldpeak
slope
ca
thal
num


J48 pruned tree
------------------

thal = fixed_defect
| ca <= 0: <50 (6.12/2.06)
| ca > 0: >50_1 (6.0)
thal = normal
| exang = no: <50 (93.56/15.0)
| exang = yes
| | cp = typ_angina: <50 (2.0)
| | cp = asympt
| | | ca <= 0: <50 (5.56/2.55)
| | | ca > 0: >50_1 (7.0)
| | cp = non_anginal: <50 (2.0)
| | cp = atyp_angina: <50 (2.0)
thal = reversable_defect
| cp = typ_angina: >50_1 (5.0/2.0)
| cp = asympt: >50_1 (50.39/4.0)
| cp = non_anginal
| | slope = up: <50 (4.39/1.0)
| | slope = flat: >50_1 (10.0/4.0)
| | slope = down: <50 (1.0)
| cp = atyp_angina: <50 (7.0/3.0)





=== Summary ===




Romina Laura Bot 76
Padrn 75722

0.788 0.304 0.756 0.788 0.772 <50
0.696 0.212 0.733 0.696 0.714 >50_1
0 0 0 0 0 >50_2
0 0 0 0 0 >50_3
0 0 0 0 0 >50_4


130 35 0 0 0 | a = <50
42 96 0 0 0 | b = >50_1
0 0 0 0 0 | c = >50_2
0 0 0 0 0 | d = >50_3
0 0 0 0 0 | e = >50_4

Como la Red Neuronal clasific con ms precisin que J48, se tom este caso para
obtener el rbol de difuso que modele el mtodo de clasificacin de la red,
utilizando el algoritmo TREPAN Fuzzy con los siguientes parmetros:

Max. Nodes:5
Min. Samples: 40
Membership: 0.5
Best First: True
Prunning: True

Como se observa, se restringi el tamao del rbol a una cantidad mxima de 5
nodos internos. Para obtener un rbol preciso determinamos en 40 la cantidad
mnima de instancias necesarias para evaluar un nodo. Si no se alcanza esta
cantidad, TREPAN Fuzzy crear las instancias faltantes utilizando a la Red Neuronal
como orculo. Adems los parmetros Best First y Prunning indican que el rbol se
debe construir con los nodos ms "fieles a la Red Neuronal, y que se debe hacer
una poda del rbol para eliminar aquellos nodos hoja que predicen la misma clase.
Los resultados obtenidos son los siguientes:


Scheme: weka.classifiers.trepanFuzzy.TrepanFuzzy -m 40 -M 5 -B -P -I 0.95 -s 0.5 -W
weka.classifiers.neural.NeuralNetwork -- -L 0.3 -M 0.2 -N 500 -V 0 -S 0 -E 20 -H "a, a"
Instances: 303
Attributes: 14
age
sex
cp
trestbps
chol
fbs
restecg
thalach
exang
oldpeak
slope
ca
thal
num

Romina Laura Bot 77
Padrn 75722



Trepan

thal = fixed_defect: >50_1 [0.325,0.675,0.0,0.0,0.0]
thal = normal
| cp = typ_angina: <50 [0.725,0.275,0.0,0.0,0.0]
| cp = asympt
| | ca <= 0.5 [0.4717 \ 0.5283] : <50 [0.825,0.175,0.0,0.0,0.0]
| | ca > 0.5 [0.4717 / 0.5283] : >50_1 [0.15,0.85,0.0,0.0,0.0]
| cp = non_anginal: <50 [0.952,0.048,0.0,0.0,0.0]
| cp = atyp_angina: <50 [0.9,0.1,0.0,0.0,0.0]
thal = reversable_defect
| cp = typ_angina: <50 [0.5,0.5,0.0,0.0,0.0]
| cp = asympt: >50_1 [0.064,0.936,0.0,0.0,0.0]
| cp = non_anginal
| | slope = up: <50 [0.775,0.225,0.0,0.0,0.0]
| | slope = flat: >50_1 [0.175,0.825,0.0,0.0,0.0]
| | slope = down: <50 [1.0,0.0,0.0,0.0,0.0]
| cp = atyp_angina: >50_1 [0.425,0.575,0.0,0.0,0.0]



[m1 / m2] = x-m1 / m2-m1
[m1 \ m2] = m2-x / m2-m1
Class Distribution = [<50,>50_1,>50_2,>50_3,>50_4]




=== Summary ===



0.836 0.217 0.821 0.836 0.829 <50
0.783 0.164 0.8 0.783 0.791 >50_1
0 0 0 0 0 >50_2
0 0 0 0 0 >50_3
0 0 0 0 0 >50_4


138 27 0 0 0 | a = <50
30 108 0 0 0 | b = >50_1

Romina Laura Bot 78
Padrn 75722

0 0 0 0 0 | c = >50_2
0 0 0 0 0 | d = >50_3
0 0 0 0 0 | e = >50_4

Comparamos los resultados luego de clasificar el dataset con los tres algoritmos:

Clasificador
Tiempo
(seg.)
Precisin Fidelidad #Nodos #Hojas
Red Neuronal 26.6 82,51 % - - -
J48 0,11 74,59 % - 7 14
TREPAN Fuzzy 37.46 81.19 % 86.17 % 5 12

Tabla 8.VII - Resultados clasificacin Heart-C

El rbol difuso obtenido con TREPAN Fuzzy es ms comprensible y ms preciso que
el rbol de decisin de J48. Adems, el valor de fidelidad nos indica que en un
86.17% de los casos el rbol clasifica de la misma forma que lo hace la red.
Entonces, hemos obtenido la representacin del mtodo de clasificacin de una Red
Neuronal de 22 neuronas de entrada, 18 neuronas distribuidas en dos capas ocultas
y 5 neuronas de salida, en un rbol difuso de tan slo 5 nodos internos y 12 nodos
hoja, fcilmente comprensible para un ser humano.

Fijando la cantidad de instancias mnimas para evaluar un nodo en 40, se
graficaron las curvas de fidelidad y de precisin variando la cantidad de nodos
internos del rbol:

65%
70%
75%
80%
85%
90%
95%
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Precision
Fidelidad

Figura 8.13 - Curvas de Fidelidad y Precisin de Trepan Fuzzy para el dataset
Heart-C. El eje x indica la cantidad de nodos internos del rbol difuso. El eje y
indica la precisin y la fidelidad de los rboles extrados.


Romina Laura Bot 79
Padrn 75722

65%
70%
75%
80%
85%
90%
95%
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Precision
Fidelidad

Figura 8.14 - Curvas de Fidelidad y Precisin de Trepan Fuzzy para rboles
construidos con el mtodo Best First para el dataset Heart-C. El eje x indica la
cantidad de nodos internos del rbol difuso. El eje y indica la precisin y la fidelidad
de los rboles extrados.

Se observa que para rboles ms complejos la precisin y la fidelidad del rbol con
respecto a la red aumentan. Los mejores resultados se obtuvieron para aquellos
rboles difusos construidos con el mtodo Best First, con 5 o ms nodos internos.

Tomando como valor fijo la cantidad de nodos internos del rbol difuso en 5, se
graficaron las curvas de fidelidad y de precisin variando la cantidad de instancias
mnimas:

71%
72%
73%
74%
75%
76%
77%
78%
79%
80%
81%
0 5 10 15 20 25 30 35 40 45 50 55 60
Precisin
Fidelidad

Heart-C. El eje x indica la cantidad de instancias mnimas necesarias para evaluar
un nodo. El eje y indica la precisin y la fidelidad de los rboles extrados.


Romina Laura Bot 80
Padrn 75722

77%
78%
79%
80%
81%
82%
83%
84%
85%
86%
87%
0 5 10 15 20 25 30 35 40 45 50 55 60
Precisin
Fidelidad

Figura 8.16 - Curvas de Fidelidad y Precisin de Trepan Fuzzy para rboles
construidos con el mtodo Best First para el dataset Heart-C. El eje x indica la
cantidad de instancias mnimas necesarias para evaluar un nodo. El eje y indica la
precisin y la fidelidad de los rboles extrados.

Los mejores resultados se obtuvieron al utilizar el mtodo Best First para la
expansin del rbol difuso. Los rboles ms precisos fueron los construidos con
alrededor de 20 instancias mnimas para evaluar el test de particin en cada nodo.
Los rboles ms fieles a la red requieren una mayor cantidad de instancias
mnimas. Sin embargo, se observa que para ms de 55 instancias mnimas los
valores de precisin y fidelidad disminuyen. Es posible que esto se deba a que los
rboles se sobreajustan a las instancias de entrenamiento utilizadas.

8.2.2 Ionosphere

Este dataset esta conformado por datos obtenidos a partir de mediciones realizadas
sobre radares que emiten seales hacia la ionosfera. Cada instancia consta de 34
atributos numricos (a01..a34) representando los pulsos de la seal recibida por el
radar, y un atributo discreto (class) que indica si el radar es bueno o malo. Este
ltimo es el atributo clase y sus valores posibles son `g (good) y `b (bad). El
retorno de un buen radar da evidencias de algn tipo de estructura en la ionosfera.
En cambio, las seales de un radar malo pasan a travs de la ionosfera.

Para clasificar este dataset se utiliz una Red Neuronal de 34 neuronas de entrada
(una por atributo), una capa oculta compuesta por 18 neuronas, y 2 neuronas de
salida (una por clase). Los resultados obtenidos son los siguientes:


a
Relation: ionosphere
Instances: 351
Attributes: 35

Romina Laura Bot 81
Padrn 75722

a01
a02
a03
a04
a05
a06
a07
a08
a09
a10
a11
a12
a13
a14
a15
a16
a17
a18
a19
a20
a21
a22
a23
a24
a25
a26
a27
a28
a29
a30
a31
a32
a33
a34
class



=== Summary ===



0.817 0.022 0.954 0.817 0.88 b
0.978 0.183 0.905 0.978 0.94 g


103 23 | a = b
5 220 | b = g


Romina Laura Bot 82
Padrn 75722

La clasificacin con el mtodo J48 result en un rbol de decisin de 17 nodos,
menos preciso que la red:


Scheme: weka.classifiers.j48.J48 -C 0.25 -M 2
Instances: 351
Attributes: 35
a01
a02
a03
a04
a05
a06
a07
a08
a09
a10
a11
a12
a13
a14
a15
a16
a17
a18
a19
a20
a21
a22
a23
a24
a25
a26
a27
a28
a29
a30
a31
a32
a33
a34
class


J48 pruned tree
------------------

a05 <= 0.0409: b (67.0)
a05 > 0.0409
| a01 <= 0: b (19.0)
| a01 > 0
| | a08 <= -0.67273
| | | a28 <= -0.21793
| | | | a06 <= -1: b (2.0)
| | | | a06 > -1: g (4.0)
| | | a28 > -0.21793: b (11.0)
| | a08 > -0.67273

Romina Laura Bot 83
Padrn 75722

| | | a03 <= 0.26667
| | | | a03 <= 0.10135: b (9.0)
| | | | a03 > 0.10135: g (4.0)
| | | a03 > 0.26667
| | | | a16 <= 0.86284
| | | | | a21 <= 0.67213
| | | | | | a19 <= 0.79113
| | | | | | | a06 <= 0.21908
| | | | | | | | a17 <= 0.19672
| | | | | | | | | a07 <= 0.21572: g (4.0)
| | | | | | | | | a07 > 0.21572: b (5.0)
| | | | | | | | a17 > 0.19672
| | | | | | | | | a21 <= 0.57399: g (36.0)
| | | | | | | | | a21 > 0.57399
| | | | | | | | | | a10 <= 0.09237: g (10.0/1.0)
| | | | | | | | | | a10 > 0.09237: b (2.0)
| | | | | | | a06 > 0.21908: g (57.0)
| | | | | | a19 > 0.79113
| | | | | | | a04 <= 0.04528: b (4.0)
| | | | | | | a04 > 0.04528: g (2.0)
| | | | | a21 > 0.67213: g (103.0)
| | | | a16 > 0.86284
| | | | | a27 <= 0.36547: g (6.0)
| | | | | a27 > 0.36547: b (6.0)





=== Summary ===



0.833 0.084 0.847 0.833 0.84 b
0.916 0.167 0.907 0.916 0.912 g


105 21 | a = b
19 206 | b = g

Se ejecut el algoritmo TREPAN Fuzzy para construir un rbol difuso de no ms de
10 nodos internos, evaluando cada nodo con una cantidad mnima de 100
instancias. A continuacin se detallan los parmetros de entrada:


Romina Laura Bot 84
Padrn 75722

Max. Nodes:10
Min. Samples: 100
Membership: 0.5
Best First: False
Prunning: True

Clasificando el dataset con el algoritmo TREPAN Fuzzy se obtuvieron los siguientes
resultados:


Scheme: weka.classifiers.trepanFuzzy.TrepanFuzzy -m 100 -M 10 -P -I 0.95 -s 0.5 -W
Instances: 351
Attributes: 35
a01
a02
a03
a04
a05
a06
a07
a08
a09
a10
a11
a12
a13
a14
a15
a16
a17
a18
a19
a20
a21
a22
a23
a24
a25
a26
a27
a28
a29
a30
a31
a32
a33
a34
class


Trepan

a05 <= 0.04144 [0.0386 \ 0.0443] : b [0.97,0.03]

Romina Laura Bot 85
Padrn 75722

a05 > 0.04144 [0.0386 / 0.0443]
| a27 <= 0.99995 [0.9964 \ 1.0035]
| | a03 <= 0.14081 [0.1365 \ 0.1451] : b [0.85,0.15]
| | a03 > 0.14081 [0.1365 / 0.1451]
| | | a08 <= -0.53701 [-0.5414 \ -0.5326] : b [0.59,0.41]
| | | a08 > -0.53701 [-0.5414 / -0.5326] : g [0.041,0.959]
| a27 > 0.99995 [0.9964 / 1.0035]
| | a01 <= 0.88572 [0.8796 \ 0.8918] : b [0.93,0.07]
| | a01 > 0.88572 [0.8796 / 0.8918] : g [0.48,0.52]



[m1 / m2] = x-m1 / m2-m1
[m1 \ m2] = m2-x / m2-m1
Class Distribution = [b,g]




=== Summary ===



0.73 0.004 0.989 0.73 0.84 b
0.996 0.27 0.868 0.996 0.928 g


92 34 | a = b
1 224 | b = g

Los resultados finales son los siguientes:

Clasificador
Tiempo
(seg.)
Red Neuronal 39.7 92,02 % - - -
J48 0,26 88,60 % - 17 18
TREPAN Fuzzy 47.12 90.03 % 90.6 % 5 6

Tabla 8.VIII - Resultados clasificacin Ionosphere

Nuevamente con TREPAN Fuzzy se obtuvo un rbol ms preciso y conciso que el
rbol de decisin extrado por J48. Adems la profundidad del rbol difuso es

Romina Laura Bot 86
Padrn 75722

menor. Esto implica que las reglas extradas son ms simples, con menos
antecedentes. Por lo tanto, es ms comprensible. En cuanto a la fidelidad obtenida,
el rbol difuso se aproxima a la red en un 90.6%.

Se ejecut el algoritmo TREPAN Fuzzy fijando la cantidad de instancias mnimas
para evaluar un nodo en 100 y variando la cantidad de nodos internos del rbol.
Las curvas de fidelidad y de precisin resultantes son las siguientes:

80%
82%
84%
86%
88%
90%
92%
94%
2 4 6 8 10 12 14 16 18
Precision
Fidelidad

Ionosphere. El eje x indica la cantidad de nodos internos del rbol difuso. El eje y

Se observa que para rboles ms complejos la precisin y la fidelidad del rbol con
respecto a la red aumentan. Los mejores resultados se obtuvieron para aquellos
rboles difusos construidos con 10 nodos internos. A partir de este valor, la
precisin y fidelidad se mantienen constantes.

Al clasificar el dataset con el parmetro BestFirst activo, se obtuvieron valores de
precisin y fidelidad similares.

Tomando como valor fijo la cantidad de 10 nodos internos del rbol difuso, se
mnimas:


Romina Laura Bot 87
Padrn 75722

83%
84%
85%
86%
87%
88%
89%
90%
91%
0 25 50 75 100 125 150
Precisin
Fidelidad

Ionosphere. El eje x indica la cantidad de instancias mnimas necesarias para
evaluar un nodo. El eje y indica la precisin y la fidelidad de los rboles extrados.

Los rboles ms precisos fueron los construidos con 100 instancias mnimas para
evaluar el test de particin en cada nodo. Los rboles ms precisos y fieles a la red
requieren una mayor cantidad de instancias.

8.2.3 Waveform

El dataset contiene informacin sobre generacin de ondas. Cada instancia consta
de 40 atributos numricos y un atributo discreto que determina la clase de onda
generada (1, 2 o 3).

Se clasific el dataset con una Red Neuronal de 40 neuronas de entrada (una por
atributo), una capa oculta compuesta por 21 neuronas, y tres neuronas de salida.
Se obtuvieron los siguientes resultados:


a
Relation: waveform
Instances: 5000
Attributes: 41
x1
x2
x3
x4
x5
x6
x7
x8
x9

Romina Laura Bot 88
Padrn 75722

x10
x11
x12
x13
x14
x15
x16
x17
x18
x19
x20
x21
x22
x23
x24
x25
x26
x27
x28
x29
x30
x31
x32
x33
x34
x35
x36
x37
x38
x39
x40
class



=== Summary ===



0.817 0.091 0.821 0.817 0.819 0
0.852 0.071 0.855 0.852 0.854 1
0.841 0.083 0.833 0.841 0.837 2


a b c <-- classified as
1382 136 174 | a = 0
140 1408 105 | b = 1
161 102 1392 | c = 2


Romina Laura Bot 89
Padrn 75722

Al clasificar el dataset con J48 se observa que la precisin obtenida es inferior a la
de la red. Adems el rbol de decisin extrado tiene una gran cantidad de nodos:


Scheme: weka.classifiers.j48.J48 -R -N 3 -M 2
Relation: waveform
Instances: 5000
Attributes: 41
x1
x2
x3
x4
x5
x6
x7
x8
x9
x10
x11
x12
x13
x14
x15
x16
x17
x18
x19
x20
x21
x22
x23
x24
x25
x26
x27
x28
x29
x30
x31
x32
x33
x34
x35
x36
x37
x38
x39
x40
class


J48 pruned tree
------------------

x7 <= 2.49
| x11 <= 3.13
| | x15 <= 1.55: 0 (25.0/10.0)
| | x15 > 1.55

Romina Laura Bot 90
Padrn 75722

| | | x13 <= 3.53
| | | | x5 <= 0.2
| | | | | x4 <= 0.83
| | | | | | x10 <= 1.54: 0 (36.0/15.0)
| | | | | | x10 > 1.54: 2 (44.0/9.0)
| | | | | x4 > 0.83: 0 (18.0/3.0)
| | | | x5 > 0.2: 0 (237.0/31.0)
| | | x13 > 3.53
| | | | x12 <= 3.45
| | | | | x5 <= -0.88: 2 (26.0/3.0)
| | | | | x5 > -0.88
| | | | | | x6 <= 0.88
| | | | | | | x11 <= 0.66: 0 (8.0)
| | | | | | | x11 > 0.66: 2 (115.0/45.0)
| | | | | | x6 > 0.88
| | | | | | | x7 <= -0.9: 2 (8.0/1.0)
| | | | | | | x7 > -0.9: 0 (61.0/10.0)
| | | | x12 > 3.45: 2 (149.0/27.0)
| x11 > 3.13
| | x15 <= 2.59
| | | x16 <= 2.19
| | | | x5 <= 1.33
| | | | | x13 <= 1.86: 1 (16.0)
| | | | | x13 > 1.86
| | | | | | x9 <= 4.25
| | | | | | | x35 <= -1.57: 1 (6.0)
| | | | | | | x35 > -1.57
| | | | | | | | x15 <= 0.66: 1 (15.0/4.0)
| | | | | | | | x15 > 0.66
| | | | | | | | | x14 <= 3.17
| | | | | | | | | | x9 <= 2.13: 2 (10.0)
| | | | | | | | | | x9 > 2.13
| | | | | | | | | | | x17 <= 0.94
| | | | | | | | | | | | x6 <= 1.31
| | | | | | | | | | | | | x38 <= -0.54: 1 (5.0)
| | | | | | | | | | | | | x38 > -0.54: 2 (17.0/5.0)
| | | | | | | | | | | | x6 > 1.31: 1 (12.0)
| | | | | | | | | | | x17 > 0.94
| | | | | | | | | | | | x1 <= 0.52: 2 (8.0)
| | | | | | | | | | | | x1 > 0.52: 1 (2.0/1.0)
| | | | | | | | | x14 > 3.17
| | | | | | | | | | x18 <= -0.33
| | | | | | | | | | | x5 <= 0.72
| | | | | | | | | | | | x28 <= 0.87: 2 (12.0)
| | | | | | | | | | | | x28 > 0.87: 1 (2.0/1.0)
| | | | | | | | | | | x5 > 0.72: 1 (6.0/1.0)
| | | | | | | | | | x18 > -0.33: 2 (41.0/1.0)
| | | | | | x9 > 4.25
| | | | | | | x14 <= 4.76
| | | | | | | | x19 <= 0.97
| | | | | | | | | x15 <= 2.03: 1 (29.0)
| | | | | | | | | x15 > 2.03
| | | | | | | | | | x31 <= 0.42: 1 (9.0/1.0)
| | | | | | | | | | x31 > 0.42: 2 (3.0)
| | | | | | | | x19 > 0.97
| | | | | | | | | x1 <= -0.65: 1 (2.0/1.0)
| | | | | | | | | x1 > -0.65: 2 (4.0)
| | | | | | | x14 > 4.76: 2 (4.0)
| | | | x5 > 1.33: 1 (57.0/7.0)
| | | x16 > 2.19: 2 (80.0/8.0)
| | x15 > 2.59
| | | x5 <= 1.55
| | | | x17 <= 0.89
| | | | | x8 <= 3.27: 2 (102.0/6.0)

Romina Laura Bot 91
Padrn 75722

| | | | | x8 > 3.27
| | | | | | x6 <= 0.78: 2 (8.0)
| | | | | | x6 > 0.78: 1 (22.0/8.0)
| | | | x17 > 0.89
| | | | | x17 <= 4.05
| | | | | | x4 <= 1.47: 2 (350.0/9.0)
| | | | | | x4 > 1.47
| | | | | | | x13 <= 3.23: 0 (6.0/1.0)
| | | | | | | x13 > 3.23: 2 (12.0)
| | | | | x17 > 4.05: 2 (33.0/11.0)
| | | x5 > 1.55
| | | | x16 <= 1.6: 1 (15.0/6.0)
| | | | x16 > 1.6
| | | | | x12 <= 2.8: 0 (14.0/1.0)
| | | | | x12 > 2.8: 2 (22.0/5.0)
x7 > 2.49
| x11 <= 3.36
| | x16 <= 1.66
| | | x10 <= 2.98
| | | | x17 <= 0.04
| | | | | x10 <= 0.75: 0 (6.0)
| | | | | x10 > 0.75
| | | | | | x16 <= -0.63: 1 (20.0/1.0)
| | | | | | x16 > -0.63
| | | | | | | x8 <= 5.76
| | | | | | | | x12 <= 1.9
| | | | | | | | | x39 <= 0.77
| | | | | | | | | | x39 <= 0.53
| | | | | | | | | | | x30 <= 0.42
| | | | | | | | | | | | x35 <= 0.78
| | | | | | | | | | | | | x35 <= -0.47: 0 (5.0/1.0)
| | | | | | | | | | | | | x35 > -0.47: 1 (11.0/1.0)
| | | | | | | | | | | | x35 > 0.78: 0 (5.0)
| | | | | | | | | | | x30 > 0.42: 0 (14.0/1.0)
| | | | | | | | | | x39 > 0.53: 1 (4.0)
| | | | | | | | | x39 > 0.77: 0 (10.0)
| | | | | | | | x12 > 1.9: 1 (17.0/4.0)
| | | | | | | x8 > 5.76: 1 (14.0/1.0)
| | | | x17 > 0.04
| | | | | x16 <= -0.47
| | | | | | x11 <= 1.39: 0 (12.0/2.0)
| | | | | | x11 > 1.39: 1 (23.0/7.0)
| | | | | x16 > -0.47
| | | | | | x7 <= 5.75
| | | | | | | x17 <= 0.77
| | | | | | | | x28 <= -1.67: 1 (3.0)
| | | | | | | | x28 > -1.67: 0 (45.0/7.0)
| | | | | | | x17 > 0.77: 0 (108.0)
| | | | | | x7 > 5.75
| | | | | | | x11 <= 1.95: 0 (16.0/1.0)
| | | | | | | x11 > 1.95: 1 (18.0/6.0)
| | | x10 > 2.98
| | | | x12 <= 2.38
| | | | | x17 <= 1.12
| | | | | | x22 <= 1.31
| | | | | | | x6 <= 5.89
| | | | | | | | x16 <= 1.05
| | | | | | | | | x15 <= 0.59
| | | | | | | | | | x11 <= 2.15
| | | | | | | | | | | x7 <= 4.93: 1 (16.0)
| | | | | | | | | | | x7 > 4.93
| | | | | | | | | | | | x4 <= 2.18: 1 (8.0)
| | | | | | | | | | | | x4 > 2.18
| | | | | | | | | | | | | x31 <= 0.42: 1 (11.0/3.0)

Romina Laura Bot 92
Padrn 75722

| | | | | | | | | | | | | x31 > 0.42: 0 (5.0)
| | | | | | | | | | x11 > 2.15: 1 (28.0)
| | | | | | | | | x15 > 0.59
| | | | | | | | | | x12 <= 0.44: 0 (6.0)
| | | | | | | | | | x12 > 0.44
| | | | | | | | | | | x5 <= 3.36: 1 (34.0/4.0)
| | | | | | | | | | | x5 > 3.36: 0 (25.0/10.0)
| | | | | | | | x16 > 1.05: 0 (24.0/9.0)
| | | | | | | x6 > 5.89: 0 (7.0)
| | | | | | x22 > 1.31: 1 (20.0)
| | | | | x17 > 1.12: 0 (48.0/12.0)
| | | | x12 > 2.38: 1 (113.0/9.0)
| | x16 > 1.66
| | | x13 <= 3.37
| | | | x17 <= 0.36
| | | | | x9 <= 3.5: 0 (38.0/3.0)
| | | | | x9 > 3.5
| | | | | | x11 <= 2.75: 0 (21.0/7.0)
| | | | | | x11 > 2.75: 1 (8.0)
| | | | x17 > 0.36: 0 (225.0/5.0)
| | | x13 > 3.37
| | | | x12 <= 3.18: 0 (24.0)
| | | | x12 > 3.18: 2 (15.0/4.0)
| x11 > 3.36
| | x8 <= 2.15
| | | x10 <= 2.85
| | | | x5 <= 0.36
| | | | | x31 <= -0.73: 0 (2.0/1.0)
| | | | | x31 > -0.73: 2 (5.0)
| | | | x5 > 0.36: 0 (12.0)
| | | x10 > 2.85
| | | | x6 <= 2.4: 2 (58.0/18.0)
| | | | x6 > 2.4
| | | | | x18 <= 1.67: 1 (14.0)
| | | | | x18 > 1.67: 0 (2.0/1.0)
| | x8 > 2.15
| | | x6 <= 0.88
| | | | x4 <= 2.01
| | | | | x14 <= 4.32
| | | | | | x36 <= 0.25
| | | | | | | x39 <= 1.21
| | | | | | | | x7 <= 2.62: 2 (4.0)
| | | | | | | | x7 > 2.62: 1 (24.0/5.0)
| | | | | | | x39 > 1.21: 2 (6.0)
| | | | | | x36 > 0.25: 1 (22.0)
| | | | | x14 > 4.32: 2 (14.0/2.0)
| | | | x4 > 2.01: 0 (3.0/1.0)
| | | x6 > 0.88
| | | | x17 <= 1.45: 1 (455.0/29.0)
| | | | x17 > 1.45
| | | | | x12 <= 3.24
| | | | | | x10 <= 2.37: 0 (12.0)
| | | | | | x10 > 2.37: 1 (20.0/6.0)
| | | | | x12 > 3.24: 1 (23.0/6.0)






Romina Laura Bot 93
Padrn 75722

=== Summary ===



0.693 0.116 0.753 0.693 0.722 0
0.778 0.117 0.766 0.778 0.772 1
0.802 0.13 0.753 0.802 0.776 2


1173 243 276 | a = 0
207 1286 160 | b = 1
178 150 1327 | c = 2

Se utiliz el algoritmo TREPAN Fuzzy para clasificar el dataset para obtener un rbol
de decisin ms conciso y comprensible que el de J48, manteniendo la precisin en
la clasificacin. Los parmetros de entrada del algoritmo son los siguientes:

Max. Nodes:50
Min. Samples: 50
Membership: 0.5
Best First: False
Prunning: True

Se busca construir un rbol difuso ms conciso que el de J48. Para lograrlo, se
establece en 50 la mxima cantidad de nodos internos del rbol, y se realiza una
poda del rbol para eliminar nodos hoja que predicen la misma clase. Adems, para
obtener un rbol ms preciso se parametriza en 50 la cantidad mnima de
instancias necesarias para evaluar un nodo. A continuacin se observa el rbol
difuso obtenido:


Scheme: weka.classifiers.trepanFuzzy.TrepanFuzzy -m 50 -M 50 -P -I 0.95 -s 0.5 -W
Relation: waveform
Instances: 5000
Attributes: 41
x1
x2
x3
x4
x5
x6

Romina Laura Bot 94
Padrn 75722

x7
x8
x9
x10
x11
x12
x13
x14
x15
x16
x17
x18
x19
x20
x21
x22
x23
x24
x25
x26
x27
x28
x29
x30
x31
x32
x33
x34
x35
x36
x37
x38
x39
x40
class


Trepan

x7 <= 2.495 [2.4939 \ 2.4962]
| x11 <= 3.275 [3.2732 \ 3.2768]
| | x6 <= 0.825 [0.8212 \ 0.8288]
| | | x12 <= 3.6 [3.5933 \ 3.6067]
| | | | x13 <= 3.255 [3.247 \ 3.263] : 0 [0.648,0.0,0.352]
| | | | x13 > 3.255 [3.247 / 3.263] : 2 [0.333,0.0,0.666]
| | | x12 > 3.6 [3.5933 / 3.6067]
| | | | x11 <= 2.645 [2.6353 \ 2.6547] : 2 [0.198,0.0,0.806]
| | | | x11 > 2.645 [2.6353 / 2.6547]
| | | | | x15 <= 1.36 [1.322 \ 1.398] : 1 [0.0,1.0,0.0]
| | | | | x15 > 1.36 [1.322 / 1.398] : 2 [0.0,0.0,1.0]
| | x6 > 0.825 [0.8212 / 0.8288]
| | | x5 <= 0.845 [0.8374 \ 0.8526]
| | | | x9 <= 2.805 [2.7925 \ 2.8175]
| | | | | x12 <= 2.645 [2.6332 \ 2.6568] : 0 [0.792,0.0,0.208]
| | | | | x12 > 2.645 [2.6332 / 2.6568] : 2 [0.425,0.0,0.575]
| | | | x9 > 2.805 [2.7925 / 2.8175]
| | | | | x16 <= 0.78 [0.7175 \ 0.8425] : 1 [0.0,0.98,0.02]
| | | | | x16 > 0.78 [0.7175 / 0.8425] : 2 [0.0,0.02,0.98]
| | | x5 > 0.845 [0.8374 / 0.8526]
| | | | x9 <= 3.58 [3.5675 \ 3.5925] : 0 [0.957,0.0,0.0435]
| | | | x9 > 3.58 [3.5675 / 3.5925]

Romina Laura Bot 95
Padrn 75722

| | | | | x4 <= 0.185 [0.1239 \ 0.2461] : 1 [0.1,0.78,0.12]
| | | | | x4 > 0.185 [0.1239 / 0.2461] : 0 [0.68,0.32,0.0]
| x11 > 3.275 [3.2732 / 3.2768]
| | x16 <= 2.565 [2.5614 \ 2.5686]
| | | x15 <= 2.475 [2.4695 \ 2.4805]
| | | | x5 <= 0.65 [0.6416 \ 0.6584]
| | | | | x7 <= 1.335 [1.3269 \ 1.3431] : 2 [0.0,0.173,0.827]
| | | | | x7 > 1.335 [1.3269 / 1.3431] : 1 [0.0,0.533,0.467]
| | | | x5 > 0.65 [0.6416 / 0.6584] : 1 [0.025,0.756,0.224]
| | | x15 > 2.475 [2.4695 / 2.4805]
| | | | x16 <= 0.965 [0.9587 \ 0.9713]
| | | | | x13 <= 3.125 [3.0847 \ 3.1653] : 1 [0.0,0.92,0.08]
| | | | | x13 > 3.125 [3.0847 / 3.1653] : 2 [0.0,0.338,0.662]
| | | | x16 > 0.965 [0.9587 / 0.9713] : 2 [0.03,0.061,0.909]
| | x16 > 2.565 [2.5614 / 2.5686]
| | | x10 <= 2.685 [2.6776 \ 2.6924]
| | | | x6 <= 1.175 [1.1612 \ 1.1888] : 2 [0.092,0.0,0.908]
| | | | x6 > 1.175 [1.1612 / 1.1888]
| | | | | x5 <= 0.725 [0.6846 \ 0.7654] : 2 [0.22,0.0,0.78]
| | | | | x5 > 0.725 [0.6846 / 0.7654] : 0 [0.84,0.0,0.16]
| | | x10 > 2.685 [2.6776 / 2.6924]
| | | | x8 <= 4.975 [4.9629 \ 4.9871] : 2 [0.01,0.0,0.986]
| | | | x8 > 4.975 [4.9629 / 4.9871] : 1 [0.0,0.8,0.2]
x7 > 2.495 [2.4939 / 2.4962]
| x11 <= 3.335 [3.3332 \ 3.3368]
| | x15 <= 1.345 [1.342 \ 1.348]
| | | x10 <= 2.805 [2.7997 \ 2.8103]
| | | | x9 <= 3.59 [3.5778 \ 3.6022] : 0 [0.764,0.236,0.0]
| | | | x9 > 3.59 [3.5778 / 3.6022]
| | | | | x8 <= 4.265 [4.2461 \ 4.2839] : 0 [0.619,0.381,0.0]
| | | | | x8 > 4.265 [4.2461 / 4.2839] : 1 [0.296,0.704,0.0]
| | | x10 > 2.805 [2.7997 / 2.8103]
| | | | x16 <= -0.035 [-0.0442 \ -0.0258] : 1 [0.089,0.911,0.0]
| | | | x16 > -0.035 [-0.0442 / -0.0258]
| | | | | x12 <= 1.86 [1.8486 \ 1.8714] : 0 [0.552,0.448,0.0]
| | | | | x12 > 1.86 [1.8486 / 1.8714] : 1 [0.183,0.817,0.0]
| | x15 > 1.345 [1.342 / 1.348]
| | | x17 <= 0.825 [0.8199 \ 0.8301]
| | | | x10 <= 3.375 [3.3612 \ 3.3888] : 0 [0.791,0.203,0.007]
| | | | x10 > 3.375 [3.3612 / 3.3888] : 1 [0.314,0.686,0.0]
| | | x17 > 0.825 [0.8199 / 0.8301] : 0 [0.925,0.041,0.035]
| x11 > 3.335 [3.3332 / 3.3368]
| | x15 <= 2.605 [2.601 \ 2.609] : 1 [0.057,0.885,0.057]
| | x15 > 2.605 [2.601 / 2.609]
| | | x12 <= 2.985 [2.9652 \ 3.0048]
| | | | x16 <= 1.515 [1.4618 \ 1.5682] : 1 [0.18,0.82,0.0]
| | | | x16 > 1.515 [1.4618 / 1.5682] : 0 [0.92,0.02,0.06]
| | | x12 > 2.985 [2.9652 / 3.0048]
| | | | x16 <= 1.905 [1.8778 \ 1.9322] : 1 [0.0,0.538,0.462]
| | | | x16 > 1.905 [1.8778 / 1.9322] : 2 [0.08,0.0,0.92]



[m1 / m2] = x-m1 / m2-m1
[m1 \ m2] = m2-x / m2-m1
Class Distribution = [0,1,2]




Romina Laura Bot 96
Padrn 75722


=== Summary ===



0.727 0.121 0.755 0.727 0.741 0
0.783 0.113 0.773 0.783 0.778 1
0.788 0.117 0.768 0.788 0.778 2


1230 216 246 | a = 0
212 1294 147 | b = 1
188 163 1304 | c = 2

Se detallan los resultados finales de la clasificacin del dataset utilizando los
mtodos anteriores:

Clasificador
Tiempo
(seg.)
Red Neuronal 655.27 83.64 % - - -
J48 4,55 75,72 % - 93 94
TREPAN Fuzzy 1290.08 76.56 % 77.66 % 36 37

Tabla 8.IX - Resultados clasificacin Waveform

En este caso, aunque la precisin del rbol difuso construido por TREPAN Fuzzy no
es mucho mayor a la del rbol de decisin de J48, se obtuvo un rbol ms conciso
con reglas ms simples: un rbol menos profundo implica menos antecedentes en
las reglas de decisin. Por lo tanto, es ms comprensible.

Se ejecut el algoritmo TREPAN Fuzzy para clasificar el dataset fijando la cantidad
de instancias mnimas para evaluar un nodo en 50 y variando la cantidad de nodos
internos del rbol. Las curvas de fidelidad y de precisin resultantes se observan en
la figura 8.19.

Para rboles ms complejos, la precisin y la fidelidad del rbol con respecto a la
red aumentan. Debido a la gran cantidad de atributos del dataset, los mejores
resultados se obtuvieron para aquellos rboles difusos compuestos por ms de 40
nodos internos. Aunque los rboles son ms complejos, aumenta la precisin y
fidelidad con respecto a la red.


Romina Laura Bot 97
Padrn 75722

68%
70%
72%
74%
76%
78%
10 20 30 40 50 60
Precision
Fidelidad

Waveform. El eje x indica la cantidad de nodos internos del rbol difuso. El eje y

Tomando como valor fijo la cantidad de 50 nodos internos del rbol difuso, se
mnimas:

74%
75%
75%
76%
76%
77%
77%
0 25 50 75 100 125
Precisin
Fidelidad

Waveform. El eje x indica la cantidad de instancias mnimas necesarias para
evaluar un nodo. El eje y indica la precisin y la fidelidad de los rboles extrados.

En este caso, los rboles ms precisos fueron los construidos con ms de 75
instancias mnimas para evaluar el test de particin en cada nodo. Los rboles ms
precisos y fieles a la red requieren una mayor cantidad de instancias.

Romina Laura Bot 98
Padrn 75722

Se observa que al aplicar TREPAN Fuzzy a datasets clasificados con la Red
Neuronal, se obtienen clasificadores precisos y con alta fidelidad. Aunque los
tiempos de ejecucin del algoritmo TREPAN Fuzzy son mayores con respecto a J48,
es posible obtener rboles ms concisos, que modelan el mtodo de clasificacin de
la Red Neuronal en un lenguaje de representacin comprensible para el ser
humano. Esta diferencia se debe al tiempo que insume el entrenamiento de la red
utilizada como orculo, y la creacin de nuevas instancias de consulta.

Romina Laura Bot 99
Padrn 75722

9. Conclusiones y Trabajo Futuro

Se presentaron dos nuevas tcnicas de extraccin de reglas a partir de Redes
Neuronales entrenadas, que producen rboles de decisin difusos y rboles modelo,
basadas en el mtodo TREPAN. El algoritmo TREPAN FUZZY extrae rboles difusos.
Estos rboles son concisos y proveen ms informacin que un rbol de decisin ya
que indican el grado de pertenencia de una instancia a cada una de las clases. El
segundo algoritmo, TREPAN M5, extrae rboles modelo en aquellos dominios donde
en lugar de asignar una clase como resultado de la clasificacin se asignan valores
numricos.

En la experimentacin realizada se observ que para aquellos casos donde las
Redes Neuronales clasifican con mayor precisin que los mtodos correspondientes
a otras tcnicas, es posible obtener una descripcin del mtodo de clasificacin de
la red, con gran precisin y con un alto grado de fidelidad.

Cabe destacar la generalidad de los nuevos algoritmos, que no requieren regmenes
especiales de entrenamiento o restricciones en la arquitectura de la red. Adems,
es posible seleccionar cualquier mtodo de clasificacin como orculo.

Los algoritmos TREPAN, TREPAN M5 y TREPAN Fuzzy se han implementado en el
lenguaje Java integrndolos al sistema Weka.

Como trabajo futuro se ha previsto:

- Analizar la reduccin de los tiempos de ejecucin para mejorar la
escalabilidad de los algoritmos.

- Optimizar las tcnicas de construccin de rboles modelo y rboles difusos,
y utilizar nuevos formalismos de representacin del mtodo de clasificacin
de la Red Neuronal.

- Experimentar sobre datasets grandes, de ms de 10000 instancias, y
evaluar la escalabilidad de los algoritmos en esos casos.


Romina Laura Bot 100
Padrn 75722

10. Referencias

[1] Axer, H. et al. Aphasia Classification Using Neural Networks. ESIT 2000.

[2] Bot, R. L. & Ale J. M. Data Mining utilizando Redes Neuronales. X Congreso
Argentino de Ciencias de la Computacin CACIC 2004. Octubre 2004.

[3] Boz, O. Converting A Trained Neural Network To A Decision Tree. DecText -
Decision Tree Extractor. ICMLA 2002, pp. 110-116, Junio 2002.

[4] Bylander, T. Learning Linear Threshold Approximations Using Perceptrons.
Neural Computation, vol. 7, no. 2, pp. 370-379, 1995.

[5] Craven, M. W. & Shavlik, J. W. Using Neural Networks for Data Mining. Future
Generation Computer Systems, 13, pp. 211-229, Noviembre 1997.
[6] Craven, M. W. & Shavlik, J. W. Extracting Tree-Structured Representations of
Trained Networks. Advances in Neural Information Processing Systems, pp. 24-30,
Denver, CO. MIT Press, 1996
[7] Craven, M. W. & Shavlik, J. W. Extracting Comprehensible Concept
Representations from Trained Neural Networks. IJCAI Workshop on
Comprehensibility in Machine Learning, Montreal, Quebec, Canada, 1995.
[8] Craven, M. W. & Shavlik, J. W. Rule Extraction: Where Do We Go from Here?.
Department of Computer Sciences, University of Wisconsin, Machine Learning
Research Group Working Paper 99-1, 1999.
[9] Craven, M. W. & Shavlik, J. W. Understanding Time-Series Networks: A Case
Study in Rule Extraction. International Journal of Neural Systems, 8, pp. 373-384,
Agosto 1997
[10] Craven, M. W. & Shavlik, J. W. Learning Symbolic Rules Using Artificial Neural
Networks. Proceedings of the Tenth International Conference on Machine Learning,
pp. 73-80, Amherst, MA. Morgan Kaufmann, 1993.
[11] Craven, M. W. & Shavlik, J. W. Using Sampling and Queries to Extract Rules
from Trained Neural Networks. Proceedings of the Eleventh International
Conference on Machine Learning, pp. 37-45, New Brunswick, NJ, 1994.
[12] Da Rosa, J., Veiga, A. & Medeiros M. Tree Structured Smooth Transition
Regression Models Based on CART Algorithm, Enero 2003.

[13] Dong, M. Look-Ahead Based Fuzzy Decision Tree Induction. IEEE Transactions
on Fuzzy System, vol. 9, no. 3, pp. 461-468, Junio 2001.

[14] Duch W., Adamczak R. & Grabczewski K. A new methodology of extraction,
optimization and application of crisp and fuzzy logical rules. IEEE Transactions on
Neural Networks, vol. 11(2), pp. 1-31, Marzo 2000.

[15] Duch W., Adamczak R. & Grabczewski K. Methodology of extraction,
optimization and application of logical rules. IEEE Transactions on Neural Networks,
vol. 12, pp. 277-306, 2001.


Padrn 75722

[16] Duch W. et al. Neural Methods of knowledge extraction. Control & Cybernetics
vol. 29, no. 4, 2000.

[17] Fung, G., Mangasarian, O. L. & Shavlic J. Knowledge-Based Support Vector
Machine Classifiers. Neural Information Processing Systems NIPS 2002.

[18] Girolami M. & He, C. Probability Density Estimation from Optimally Condensed
Data Samples. IEEE Transactions Pattern Analysis and Machine Intelligence, vol.
25(10), pp. 1253-1264.

[19] Grzymala-Busse, J. & Hu, M. A Comparison of Several Approaches to Missing
Attribute Values in Data Mining. Proceedings of the Second International
Conference on Rough Sets and Current Trends in Computing RSCTC'2000, Banff,
Canada, pp. 340-347, Octubre 2000.

[20] Ianova, I. & Kubat, M. Initialization of Neural Networks by Means of Decision
Trees. Knowledge-Based Systems8, pp. 333-344, 1995.
[21] Janikow, C. Z. Exemplar Learning in Fuzzy Decision Trees. Proceedings of the
Fifth IEEE International Conference on Fuzzy Systems, vol. 2, pp. 1500 -1505,
1996.
[22] Kohavi, R. A Study of Cross-Validation and Boostrap for Accurancy Estimation
and Model Selection. International Joint Conference on Artificial Intelligence IJCAI-
95, 1995.

[23] Mc Connell, C. Classification And Regression Trees (CART), Septiembre 1989.

[24] Novak, S. Generalized kernel density estimator. Theory of Probability & Its
Applications, vol. 44, no. 3, pp. 570-583, 2000.

[25] Peng, Y & Flach P. A. Soft Discretization to Enhance the Continuous Decision
Tree Induction. Integrating Aspects of Data Mining, Decision Support and Meta-
Learning, Christophe Giraud-Carrier, Nada Lavrac and Steve Moyle, editors, pp.
109-118. ECML/PKDD'01 workshop notes, Septiembre 2001.

[26] Prodromidis, A. L. & Stolfo, S. Mining databases with different schemas:
Integrating incompatible classifiers. Proc. KDD-98, Agosto 1998.

[27] Quinlan, J. R. Learning with Continuous Classes. Proceedings of the 5
th

Australian Joint Conference on Artificial Intelligence, pp. 343-348, 1992.

[28] Schetinin, V. G. & Brazhnikov, A. I. Diagnostic Rule Extraction Using Neural
Networks. Published in Biomedical Engineering, vol. 1, pp.16-21, 2000.

[29] Setiono, R. & Leow, W. K. FERNN: An Algorithm form Fast Extraction of Rules
from Neural Networks Applied Intelligence, vol.12, no.1-2, pp.15-25, Enero - Abril
2000.

[30] Setiono, R. Extracting rules from neural networks by pruning and hidden-unit
splitting. Neural Computation, vol. 9, no. 1, pp. 205-225.

[31] Taha, I. & Gosh, J. Evaluation and Ordering of Rules Extracted from
Feedforward Networks. Proceedings of the IEEE International Conference on Neural
Networks, pp. 221-226, Junio 1997.


Padrn 75722

[32] Thrun, S. Extracting Symbolic Knowledge from Artificial Neural Networks.
Advances in Neural Information Processing Systems, vol. 7, 1995.

[33] Towel, G. G., Craven M. W. & Shavlik, J. W. Constructive Induction in
Knowledge-Based Neural Networks. Proceedings of the Eighth International Machine
Learning Workshop, Morgan Kaufmann, 1991.

[34] Towel, G. G. & Shavlik, J. W. Extracting Refined Rules from Knowledge-Based
Neural Networks. Machine Learning, vol. 13, no. 1, pp. 71-101, Octubre 1993.

[35] Zeidler, J. & Schlosser M. Continuous-Valued Attributes in Fuzzy Decision
Trees. Proceedings of Information Processing and Management of Uncertainty in
Knowledge-Based Systems, Granada, pp. 395-400, Julio 1996.

[36] Zeng, X. & Martinez, T. R. Using A Neural Network to Approximate An
Ensemble of Classifiers. Neural Processing Letters, vol. 12, no. 3, Diciembre 2000.

[37] Zheng, Z. Constructing X-of-N Attributes for Decision Tree Learning. Machine
Learning 40, pp. 1-43, 2000.

[38] Witten, I. H. & Frank E. WEKA. Machine Learning Algorithms in Java. Morgan
Kaufmann, 2000.


Padrn 75722

A. Diseo de la Solucin

Como hemos mencionado, los algoritmos se han desarrollado en Java para
integrarlos al sistema Weka. En Weka, la implementacin de un algoritmo de
aprendizaje se representa con una clase. Cuando el algoritmo es complejo y se
utiliza ms de una clase, estas se agrupan en paquetes (packages). Un paquete es
simplemente un directorio que contiene un conjunto de clases relacionadas. Por
ejemplo, el paquete J48 contiene las clases que implementan al algoritmo J48.
Como cada paquete corresponde a un directorio, los paquetes se organizan en
jerarquas: el paquete J48 es un subpaquete del paquete classifiers, que a su vez,
es un subpaquete del paquete Weka.

El paquete classifiers contiene la implementacin de todos los algoritmos de
clasificacin del sistema. La clase ms importante en este paquete es la clase
Classifier, que define la estructura general de cualquier esquema de clasificacin.
Contiene dos mtodos: buildClassifier() y classifyInstance() que todos los
algoritmos clasificadores tienen que implementar ya que derivan de esta clase.

Otra clase importante es DistributionClassifier. Esta subclase de Classifier define el
mtodo distributionForInstance(), que devuelve una distribucin de probabilidades
para una instancia dada. Cualquier clasificador que pueda calcular estas
probabilidades es una subclase de DistributionClassifier e implementa este mtodo.

Los algoritmos TREPAN, TREPAN Fuzzy y TREPAN M5 son subclases de
DistributionClassifier. Como fue necesario implementar ms de una clase para
desarrollar cada algoritmo, se crearon tres paquetes para agrupar estas clases:
trepan, trepanFuzzy y trepanM5. Estos son subpaquetes del paquete classifier.

A continuacin se presentan los diagramas que representan la solucin propuesta.

A.1 Diagrama de Paquetes

Figura A.1 - Diagrama de Paquetes


Padrn 75722

Se crearon tres paquetes, incluidos en el paquete classifier, que contienen las
clases que implementan los nuevos algoritmos. Las clases se agruparon de la
siguiente forma:

Paquete trepan

Clase / Interfase Descripcin
Interfaz TrepanEstimator Define los mtodos necesarios para estimar valores
de una variable que sigue una determinada
distribucin.

Clase NumericEstimator Implementa un estimador para atributos numricos.

Clase NominalEstimator Implementa un estimador para atributos discretos.

Clase Trepan Clasificador TREPAN

Clase TrepanNode Nodo del rbol TREPAN

Tabla A.I - Paquete trepan

Paquete trepanFuzzy

Clase TrepanFuzzy Clasificador TREPAN Fuzzy

Clase FuzzyNode Nodo del rbol TREPAN Fuzzy

Tabla A.II - Paquete trepanFuzzy

Paquete trepanM5

Clase TrepanM5 Clasificador TREPAN M5

Clase Node Nodo del rbol TREPAN M5

Dvector Utilizada para la construccin del rbol M5.

Errors Utilizada para la construccin del rbol M5.

Function Utilizada para la construccin del rbol M5.

Impurity Utilizada para la construccin del rbol M5.

Ivector Utilizada para la construccin del rbol M5.

M5Utils Utilizada para la construccin del rbol M5.

Matrix Utilizada para la construccin del rbol M5.


Padrn 75722

Measures Utilizada para la construccin del rbol M5.

Options Utilizada para la construccin del rbol M5.

SplitInfo Utilizada para la construccin del rbol M5.

Values Utilizada para la construccin del rbol M5.

Tabla A.III - Paquete trepanM5

A.2 Diagrama de Clases

La siguiente figura indica las relaciones entre las clases creadas para la
implementacin de los algoritmos:

Figura A.2 - Diagrama de Clases

Padrn 75722

A.3 Casos de Uso

A continuacin se presentan los casos de uso que modelan los algoritmos a
desarrollar:

Clasificar Dataset

Pre-Condicin: Dataset sin clasificar
1. Seleccionar orculo
2. Ingresar parmetros de entrada
3. Clasificar dataset con orculo
4. Construir rbol
5. Desplegar resultados de la clasificacin
Post-Condicin: Dataset clasificado

El caso de uso "Clasificar Dataset puede expandirse en casos ms especficos,
como se observa a continuacin:


Padrn 75722

Clasificar Dataset con Orculo

Pre-Condicin: Dataset sin clasificar
1. Seleccionar orculo
2. Ingresar parmetros de entrada
3. Entrenar orculo con dataset
4. Reemplazar valores desconocidos en dataset
5. Clasificar instancias con orculo
6. Asignar nuevas clases a las instancias del dataset
Post-Condicin: Dataset clasificado con Orculo

Construir rbol

Pre-Condicin: Dataset clasificado con Orculo
Para cada nodo del rbol:
1. Evaluar si el nodo es hoja
2. Crear instancias necesarias para evaluar un nodo
3. Clasificar nuevas instancias con el orculo
4. Obtener mejor atributo para particin
5. Particionar el nodo

6. Seleccionar mejores nodos
7. Podar el rbol
Post-Condicin: rbol construido

Desplegar Resultados

Pre-Condicin: rbol construido
1. Imprimir el rbol construido
2. Calcular fidelidad del rbol con respecto al orculo
3. Clasificar instancias de testeo con el rbol obtenido
4. Desplegar resultados de clasificacin
Post-Condicin: rbol y resultados de clasificacin impresos en pantalla


Padrn 75722

B. Manual de Usuario

B.1 Weka

Los algoritmos presentados en este trabajo han sido implementados para formar
parte del sistema Weka. Weka (Waikato Environment for Knowledge Analisis) es un
sistema de cdigo abierto, desarrollado en la Universidad de Waikato, Nueva
Zelanda. El sistema ha sido desarrollado en Java, un lenguaje de programacin
orientado a objetos.

B.2 Instalacin de Weka

Para instalar el sistema Weka los pasos a seguir son los siguientes:

1. Ejecutar la aplicacin weka-3-2-2jre.exe ubicada en el directorio /Weka
del CD de instalacin.

2. Reemplazar el archivo weka.jar del directorio donde se instal Weka, por el
archivo ubicado en el directorio /Reemplazar del CD de instalacin.

El archivo weka.jar del directorio /Reemplazar contiene las modificaciones
realizadas en el sistema Weka para la implementacin de los nuevos algoritmos
presentados en este trabajo.

B.3 Clasificar un dataset utilizando el sistema Weka

A continuacin se indican los pasos a seguir para clasificar un dataset utilizando el
sistema Weka:

1. Abrir Weka y seleccionar la opcin Explorer.

Se desplegar la siguiente pantalla:

Padrn 75722

2. Seleccionar el dataset a clasificar mediante la opcin de men Open file...

Una vez elegido el dataset presionar el botn Open. Weka cargar el archivo
seleccionado en pantalla, mostrando las caractersticas del dataset: atributos,
cantidad de instancias, tipos de dato, etc.


Padrn 75722

3. Abrir la solapa Classify

4. Haciendo doble clic sobre Classifier. Se abrir un men desplegando todos
los clasificadores implementados en el sistema. Seleccionar el clasificador
deseado y presionar Enter.

Padrn 75722

5. Ingresar los parmetros de entrada del clasificador y presionar Ok.

6. Seleccionar el mtodo de testeo de la clasificacin (Test Options). Los
valores posibles son:
a. Use training set
b. Supplied test set
c. Cross-validation
d. Percentaje split

7. Seleccionar el atributo clase del dataset.

8. Presionar el botn Start para iniciar la clasificacin. Sobre el panel derecho
se visualizarn los resultados obtenidos (Classifier output).


Padrn 75722

C. Cdigo Fuente

C.1 Package weka.classifiers.trepan

C.1.1 Interfaz TrepanEstimator

/*
* TrepanEstimator.java
* 2004 Romina Laura Bot
*
*/

package weka.classifiers.trepan;

import java.util.*;
import java.io.*;

/**
* @author Romina Laura Bot (rbot@fi.uba.ar)
*/

public interface TrepanEstimator extends Serializable {

/**
* Add a new data value to the current estimator.
*
* @data the new data value
* @weight the weight assigned to the data value
*/
public void addValue(double data, double weight);

/**
* Get a probability estimate for a value.
*
* @data the value to estimate the probability of
* @return the estimated probability of the supplied value
*/
public double getProbability(double data);

/**
* Generates a random value according to the estimator distribution
*
* @seed random seed
* @return the value generated
*/
public double newValue(long seed);

}

C.1.2 Clase NominalEstimator

/*
* NominalEstimator.java
*

Padrn 75722

*/


import java.util.*;
import weka.core.*;

/**
* Simple symbolic probability estimator based on symbol counts.
*
*/

public class NominalEstimator implements TrepanEstimator {

/** Hold the counts */
private double [] m_Counts;

/** Hold the sum of counts */
private double m_SumOfCounts;

/** Hold the accumulated probabilities */
private double [] m_AcumCounts;

/**
* Constructor
*
* @param numSymbols the number of possible symbols (remember to include 0)
* @param laplace if true, counts will be initialised to 1
*/
public NominalEstimator(int numSymbols, boolean laplace) {

m_Counts = new double [numSymbols];
m_AcumCounts = new double [numSymbols];
m_SumOfCounts = 0;
if (laplace) {
for(int i = 0; i < numSymbols; i++) {
m_Counts[i] = 1;
}
m_SumOfCounts = (double)numSymbols;
}
}

/**
*
* @param data the new data value
* @param weight the weight assigned to the data value
*/
public void addValue(double data, double weight) {
m_Counts[(int)data] += weight;
m_SumOfCounts += weight;
}

/**
* Get a probability estimate for a value
*
* @param data the value to estimate the probability of
*/

Padrn 75722

public double getProbability(double data) {
if (m_SumOfCounts == 0) {
return 0;
}
return (double)m_Counts[(int)data] / m_SumOfCounts;
}

/**
* Gets the number of symbols this estimator operates with
*
* @return the number of estimator symbols
*/
public int getNumSymbols() {

return (m_Counts == null) ? 0 : m_Counts.length;
}

/**
*
* @seed random seed
*/
public double newValue(long seed) {

//If no values then return missing value
if (m_SumOfCounts == 0) {
return Double.NaN;
}

Random random = new Random(seed);
double r;
double sum = 0;
int value = 0;

//Accumulate probabilities
for (int i = 0; i < m_AcumCounts.length; i++) {
sum = sum + getProbability((double)i);
m_AcumCounts[i] = sum;
}

//Sum of probabilities = 1
m_AcumCounts[m_AcumCounts.length - 1] = 1;

//Generate a random value to choose the value to be returned
r = random.nextDouble();
int j = 0;
boolean found = false;
while ((found == false) && (j < m_Counts.length)){
if (m_AcumCounts[j] >= r) {
value = j;
found = true;
}
j++;
}

return (double)value;
}

/**
* Display a representation of this estimator
*/

Padrn 75722

public String toString() {

String result = "Discrete Estimator. Counts = ";
if (m_SumOfCounts > 1) {
for(int i = 0; i < m_Counts.length; i++) {
result += " " + Utils.doubleToString(m_Counts[i], 2);
}
result += " (Total = " + Utils.doubleToString(m_SumOfCounts, 2)
+ ")\n";
} else {
for(int i = 0; i < m_Counts.length; i++) {
result += " " + m_Counts[i];
}
result += " (Total = " + m_SumOfCounts + ")\n";
}
return result;
}

/**
* Main method for testing this class.
*
* @param argv should contain a sequence of integers which
* will be treated as symbolic.
*/
public static void main(String [] argv) {

try {
if (argv.length == 0) {
System.out.println("Please specify a set of instances.");
return;
}
int current = Integer.parseInt(argv[0]);
int max = current;
for(int i = 1; i < argv.length; i++) {
current = Integer.parseInt(argv[i]);
if (current > max) {
max = current;
}
}
NominalEstimator newEst = new NominalEstimator(max + 1, true);
for(int i = 0; i < argv.length; i++) {
current = Integer.parseInt(argv[i]);
System.out.println(newEst);
System.out.println("Prediction for " + current
+ " = " + newEst.getProbability(current));
newEst.addValue(current, 1);
}
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}

C.1.3 Clase NumericEstimator

/*
* NumericEstimator.java
*
*/


Padrn 75722


import java.util.*;
import weka.core.*;

/**
* Simple kernel density estimator. Uses one gaussian kernel per observed
* data value.
*
*/

public class NumericEstimator implements TrepanEstimator {

/** Vector containing all of the values seen */
private double [] m_Values;

/** Vector containing the associated weights */
private double [] m_Weights;

/** Number of values stored in m_Weights and m_Values so far */
private int m_NumValues;

/** The sum of the weights so far */
private double m_SumOfWeights;

/** The standard deviation */
private double m_StandardDev;

/** The precision of data values */
private double m_Precision;

/** Whether we can optimise the kernel summation */
private boolean m_AllWeightsOne;

/** Maximum percentage error permitted in probability calculations */
private static double MAX_ERROR = 0.01;

/**
* Execute a binary search to locate the nearest data value
*
* @param the data value to locate
* @return the index of the nearest data value
*/
private int findNearestValue(double key) {

int low = 0;
int high = m_NumValues;
int middle = 0;
while (low < high) {
middle = (low + high) / 2;
double current = m_Values[middle];
if (current == key) {
return middle;
}
if (current > key) {
high = middle;
} else if (current < key) {
low = middle + 1;
}
}

Padrn 75722

return low;
}

/**
* Round a data value using the defined precision for this estimator
*
* @param data the value to round
* @return the rounded data value
*/
private double round(double data) {

return Math.rint(data / m_Precision) * m_Precision;
}

// ===============
// Public methods.
// ===============

/**
* Constructor that takes a precision argument.
*
* @param precision the precision to which numeric values are given. For
* example, if the precision is stated to be 0.1, the values in the
* interval (0.25,0.35] are all treated as 0.3.
*/
public NumericEstimator(double precision) {

m_Values = new double [50];
m_Weights = new double [50];
m_NumValues = 0;
m_SumOfWeights = 0;
m_AllWeightsOne = true;
m_Precision = precision;
m_StandardDev = m_Precision / (2 * 3);
}

/**
*
* @param data the new data value
* @param weight the weight assigned to the data value
*/
public void addValue(double data, double weight) {

if (weight == 0) {
return;
}
data = round(data);
int insertIndex = findNearestValue(data);
if ((m_NumValues <= insertIndex) || (m_Values[insertIndex] != data)) {
if (m_NumValues < m_Values.length) {
int left = m_NumValues - insertIndex;
System.arraycopy(m_Values, insertIndex,
m_Values, insertIndex + 1, left);
System.arraycopy(m_Weights, insertIndex,
m_Weights, insertIndex + 1, left);

m_Values[insertIndex] = data;
m_Weights[insertIndex] = weight;
m_NumValues++;
} else {
double [] newValues = new double [m_Values.length * 2];

Padrn 75722

double [] newWeights = new double [m_Values.length * 2];
int left = m_NumValues - insertIndex;
System.arraycopy(m_Values, 0, newValues, 0, insertIndex);
System.arraycopy(m_Weights, 0, newWeights, 0, insertIndex);
newValues[insertIndex] = data;
newWeights[insertIndex] = weight;
System.arraycopy(m_Values, insertIndex,
newValues, insertIndex + 1, left);
System.arraycopy(m_Weights, insertIndex,
newWeights, insertIndex + 1, left);
m_NumValues++;
m_Values = newValues;
m_Weights = newWeights;
}
if (weight != 1) {
m_AllWeightsOne = false;
}
} else {
m_Weights[insertIndex] += weight;
m_AllWeightsOne = false;
}
m_SumOfWeights += weight;
double range = m_Values[m_NumValues - 1] - m_Values[0];
if (range > 0) {
m_StandardDev = Math.max(range / Math.sqrt(m_SumOfWeights),
// allow at most 3 sds within one interval
m_Precision / (2 * 3));
}
}

/**
*
* @seed random seed
*/
public double newValue(long seed) {

//If no values then return missing value
if (m_NumValues == 0) {
return Double.NaN;
}

//Accumulate probabilities
double sumProb = 0;
double[] m_Prob = new double[m_NumValues];
for (int k = 0; k < m_NumValues; k++) {
sumProb = sumProb + getProbability(m_Values[k]);
m_Prob[k] = sumProb;
}

//Generate a random value to choose the value to be returned
Random random = new Random(seed);
double r = random.nextDouble();
while (r > sumProb) {
}

//Find interval containing random value
int interval = 0;
while (m_Prob[interval] < r) {
interval++;

Padrn 75722

}

//Choose the sign of the desviation
double sign;
if (Math.abs(r) < 0.5) {
sign = 1;
} else {
sign = -1;
}

//Generate value X = mu + sign.random.desviation (with mu = interval)
double value;
value = (double)(m_Values[interval] + (sign * r * m_StandardDev));

return value;
}

/**
* Get a probability estimate for a value.
*
* @param data the value to estimate the probability of
*/
public double getProbability(double data) {

double delta = 0, sum = 0, currentProb = 0;
double zLower = 0, zUpper = 0;
zLower = (data - (m_Precision / 2)) / m_StandardDev;
zUpper = (data + (m_Precision / 2)) / m_StandardDev;
return (Statistics.normalProbability(zUpper)
- Statistics.normalProbability(zLower));
}
double weightSum = 0;
int start = findNearestValue(data);
for (int i = start; i < m_NumValues; i++) {
delta = m_Values[i] - data;
zLower = (delta - (m_Precision / 2)) / m_StandardDev;
zUpper = (delta + (m_Precision / 2)) / m_StandardDev;
currentProb = (Statistics.normalProbability(zUpper)
sum += currentProb * m_Weights[i];
weightSum += m_Weights[i];
if (currentProb * (m_SumOfWeights - weightSum) < sum * MAX_ERROR) {
break;
}
}
for (int i = start - 1; i >= 0; i--) {
delta = m_Values[i] - data;
zLower = (delta - (m_Precision / 2)) / m_StandardDev;
zUpper = (delta + (m_Precision / 2)) / m_StandardDev;
currentProb = (Statistics.normalProbability(zUpper)
sum += currentProb * m_Weights[i];
weightSum += m_Weights[i];
if (currentProb * (m_SumOfWeights - weightSum) < sum * MAX_ERROR) {
break;
}
}
return sum / m_SumOfWeights;
}

Padrn 75722

/**
* Display a representation of this estimator
*/

String result = m_NumValues + " Normal Kernels. \nStandardDev = "
+ Utils.doubleToString(m_StandardDev,6,4)
+ " Precision = " + m_Precision;
result += " \nMean = 0";
} else {
result += " \nMeans =";
for (int i = 0; i < m_NumValues; i++) {
result += " " + m_Values[i];
}
if (!m_AllWeightsOne) {
result += "\nWeights = ";
for (int i = 0; i < m_NumValues; i++) {
result += " " + m_Weights[i];
}
}
}
return result + "\n";
}

/**
* Main method for testing this class.
*
* @param argv should contain a sequence of numeric values
*/
public static void main(String [] argv) {

try {
if (argv.length < 2) {
System.out.println("Please specify a set of instances.");
return;
}
NumericEstimator newEst = new NumericEstimator(0.01);
for (int i = 0; i < argv.length - 3; i += 2) {
newEst.addValue(Double.valueOf(argv[i]).doubleValue(),
Double.valueOf(argv[i + 1]).doubleValue());
}
System.out.println(newEst);

double start = Double.valueOf(argv[argv.length - 2]).doubleValue();
double finish = Double.valueOf(argv[argv.length - 1]).doubleValue();
for (double current = start; current < finish;
current += (finish - start) / 50) {
System.out.println("Data: " + current + " "
+ newEst.getProbability(current));
}
System.out.println(e.getMessage());
}
}
}


Padrn 75722

C.1.4 Clase Trepan

/*
* Trepan.java
*
*/


import java.io.*;
import java.util.*;
import weka.core.*;
import weka.classifiers.*;
import weka.estimators.*;
import weka.core.Option;
import weka.core.OptionHandler;
import weka.core.SelectedTag;
import weka.core.Tag;
import weka.core.Utils;
import weka.filters.*;

/**
* Class for running Trepan classifier.
*
*/

public class Trepan extends DistributionClassifier
implements OptionHandler {

/** Class attribute of dataset. */
private Attribute m_ClassAttribute;

/** Used to set the max number of nodes alowed in the tree */
private int m_maxNodes = 0;

/** Used to set the min number of examples required to test a node */
private int m_minSamples = 0;

/** Proportion of instances belonging to the same class that makes the node
a leaf */
private double m_propInst = 0.95;

/** Oracle used to classify instances */
protected Classifier m_Oracle = new weka.classifiers.neural.NeuralNetwork();

/** Instances classified by the Oracle. */
private Instances newData;

/** Queue of leaves */
private Queue m_Queue;

/** Construct the tree using the best nodes */
private boolean m_BestFirst = false;

/** Prune the tree */
private boolean m_Pruning = false;

/** Root Node */
private TrepanNode m_RootNode;


Padrn 75722

/** Filter to replace missing values */
private Filter m_Filter;

/** Counters */
private int m_CountNodes = 0;
private int m_CountLeaves = 0;

/** Tree fidelity */
private double m_Fidelity;

/**
* Builds Trepan decision tree classifier.
*
* @param data the training data
* @exception Exception if classifier can't be built successfully
*/
public void buildClassifier(Instances data) throws Exception {

if (data.numInstances() == 0) {
throw new IllegalArgumentException("No training instances.");
}

// Class must be nominal
if (!data.classAttribute().isNominal()) {
throw new Exception("Trepan: nominal class, please.");
}

// Check string attributes
if (data.checkForStringAttributes()) {
throw new Exception("Trepan: no string attributes, please.");
}

data = new Instances(data);

// Class attribute
m_ClassAttribute = data.classAttribute();

// Build Oracle's Classifier
m_Oracle.buildClassifier(data);

// Replace missing values
m_Filter = new ReplaceMissingValuesFilter();
m_Filter.inputFormat(data);
Instances filteredData = Filter.useFilter(data, m_Filter);
data = new Instances(filteredData);

// Classify data with the Oracle
newData = new Instances(classifyWithOracle(data));

// Make Trepan Tree with new data
makeTree(newData);
}

/**
* Check missing values in data
*
* @data dataset
* @return true if data contains missing values
*/
private boolean withMissingValues(Instances data) {
boolean missing = false;


Padrn 75722

Enumeration enumAtt = data.enumerateAttributes();
while (enumAtt.hasMoreElements() && !missing) {
Attribute attr = (Attribute) enumAtt.nextElement();
Enumeration enum = data.enumerateInstances();
while (enum.hasMoreElements() && !missing) {
if (((Instance) enum.nextElement()).isMissing(attr)) {
missing = true;
}
}
}
return missing;
}

/**
* Replace the instances's classes with the class predicted by the Oracle.
*
* @data the training data
* @exception if there is an error
* @return data classified with the oracle
*/
private Instances classifyWithOracle (Instances data) throws Exception {

Instance newInstance;
double newClassValue;
Instances newData = new Instances(data,data.numInstances());

while (enum.hasMoreElements()) {
newInstance = (Instance) enum.nextElement();
newClassValue = m_Oracle.classifyInstance(newInstance);
newInstance.setClassValue(newClassValue);
newData.add(newInstance);
}
return newData;
}

/**
* Build Trepan tree.
*
* @exception if decision tree can't be built successfully
*/
private void makeTree(Instances data) throws Exception {

// Inicialize the root node
m_RootNode = new TrepanNode(data);
m_RootNode.setNodeType("R");
m_RootNode.setReach(1);

// Create new instances
m_RootNode.drawSample(m_minSamples, m_Oracle);

// Set node's main class
m_RootNode.setClassLabelNodo();

// Inicialize queue inserting the root node
Queue m_Queue = new Queue();
m_Queue.push(m_RootNode);

// Make the Trepan Tree

Padrn 75722

TrepanNode m_Node;

// Num of nodes in the tree
int m_NumNodes = 0;

// Max nodes in the tree
int m_LongTree = 0;
// If Best First -> we need to make the tree and then prune it
// Else we generate the tree pruned
if (!m_BestFirst && m_maxNodes > 0) {
m_LongTree = m_maxNodes;
} else {
m_LongTree = 99999;
}

// Expand root node to make decison Tree
while ((!m_Queue.empty()) && m_NumNodes <= m_LongTree) {
// Get node from queue
m_Node = (TrepanNode) m_Queue.pop();
// Set node ID
m_Node.setIdNodo(m_NumNodes);
m_NumNodes ++;
// Split node
m_Node.constructTest(m_propInst);
// Get node's children
TrepanNode [] m_ChildNode = m_Node.getChildren();
for (int j = 0; j < m_Node.getCountChildren(); j++){
if (!(localStopCriteria(m_ChildNode[j]))){
// Node is not a leaf, add children in queue
m_ChildNode[j].drawSample(m_minSamples, m_Oracle);
m_ChildNode[j].setClassLabelNodo();
m_Queue.push(m_ChildNode[j]);
} else {
// Node is a leaf
m_ChildNode[j].setIdNodo(m_NumNodes);
m_NumNodes++;
}
}
}

// If max nodes reached then make leafs with remaining nodes
int i = m_NumNodes;
while (!m_Queue.empty()) {
m_Node.setIdNodo(i);
m_Node.makeALeaf();
i ++;
}

// If BestFirst then choose the best nodes
if (m_maxNodes > 0) {
if (m_NumNodes > m_maxNodes) {
if (m_BestFirst) {
// Make BestFirst tree
GetBestTree(m_NumNodes);
}
}
}

// Prune the tree to eliminate redundant nodes
if (m_Pruning) {
pruneTree();
}

Padrn 75722

// Compute Fidelity between the tree and the oracle
m_Fidelity = computeFidelity(newData);

}

/**
* Indicates if node must be expanded
*
* @node node to be evaluated
* @return true if node is a leaf
*/
private boolean localStopCriteria (TrepanNode node){
if (node.getNodeType() == "L") {
return true;
}
else {
return false;
}
}

/**
* Make a new pruned tree using the Best nodes
*
* @m_NumNodes num of nodes of the original tree
*/
private void GetBestTree(int m_NumNodes) {

// Vector containing all the tree's nodes
TrepanNode[] vNodos = new TrepanNode[m_NumNodes];
cargarVectorNodos(m_RootNode, vNodos);

// Vector containing the best nodes
int[] vValidos = new int[m_maxNodes];
// Vector containing BestFirst values
double[] vBF = new double[m_NumNodes];
// ID valid node
int ID;
// Counts best nodes
int i = 0;
// Aux variable
int IdNodo;

// Inicialize vector BF
for (int j = 0; j < m_NumNodes; j++) {
vBF[j]= 0;
}

// Root node is always a Best Node
ID = m_RootNode.getIdNodo();
vValidos[i] = ID;
i++;

while (i < m_maxNodes) {
// Insert child nodes into vNodos
for (int k = 0; k < vNodos[ID].getCountChildren(); k++) {
IdNodo = vNodos[ID].getChild(k).getIdNodo();
vBF[IdNodo] = vNodos[ID].getChild(k).getBestFirst();
}

// Choose the Best Node

Padrn 75722

ID = Utils.maxIndex(vBF);
vValidos[i] = ID;
i++;

// Eliminate the node selected
vBF[ID] = -1;
}

// Make leafs with the remaining nodes

TrepanNode m_Node;
while ((!m_Queue.empty())) {
// Check if the node is a Best Node
if (NodoEncontrado(m_Node.getIdNodo(), vValidos) == false) {
// If node is not a Best Node then make a leaf
m_Node.makeALeaf();
} else {
// Is a BF Node. Insert children into queue
if (m_Node.getNodeType() != "L") {
for (int m = 0; m < m_Node.getCountChildren(); m++){
m_Queue.push(m_ChildNode[m]);
}
}
}
}
}

/**
* Check if a node is found in a vector
*
* @idNodo node to be found
* @return true if the node is found
*/
private boolean NodoEncontrado (int IdNodo, int[] vect) {
boolean bfound = false;
int i = 0;

while (!bfound && i < m_maxNodes) {
if (vect[i] == IdNodo) {
bfound = true;
}
i++;
}
return bfound;
}

/**
* Insert all the tree's nodes into a vector (recursive)
*
* @m_Node node to be inserted
* @vNodos vector
*/
private void cargarVectorNodos(TrepanNode m_Node, TrepanNode[] vNodos) {
vNodos[m_Node.getIdNodo()] = m_Node;

Padrn 75722

cargarVectorNodos(m_ChildNode[j], vNodos);
}
}
}

/**
* Prune the tree
*/
private void pruneTree() {

boolean again = true;

TrepanNode m_Node;
double Class;
boolean IdemClass;
boolean AllLeaves;

while (again) {
again = false;




//Check if all the children are leafs
AllLeaves = true;
for (int i = 0; i < m_Node.getCountChildren(); i++) {
if (m_ChildNode[i].getNodeType() != "L") {
AllLeaves = false;
}
}

if (AllLeaves == true) {
// Check if all the nodes predict the same class
IdemClass = true;
Class = m_ChildNode[0].getClassLabel();
if (m_ChildNode[m].getClassLabel() != Class) {
IdemClass = false;
}
}
if (IdemClass == true) {
// Make parent node a leaf
m_Node.setClassLabel(Class);
m_Node.makeALeaf();
again = true;
}
} else {
}
}

}
}

Padrn 75722

}
}

/**
* Method computing the fidelity of the classifier with the Oracle
*
* @return the fidelity
*/
public double computeFidelity (Instances data) throws Exception {

Instance instance;
double classValue;
double classValueOracle;
double countFidelity = 0;

instance = (Instance) enum.nextElement();
// Classify instance with Tree
classValue = classifyInstance(instance);
// Classify instance with Oracle
classValueOracle = m_Oracle.classifyInstance(instance);
if (classValue == classValueOracle) {
countFidelity++;
}
}
// Compute Fidelity
return (double)((double)countFidelity / (double)data.numInstances());
}

/**
* Classifies a given test instance using the decision tree.
*
* @instance the instance to be classified
* @return the classification
*/
public double classifyInstance(Instance instance) throws Exception {

m_Filter.input(instance);
m_Filter.batchFinished();
instance = m_Filter.output();

return classifyTrepanInstance(m_RootNode, instance);
}

/**
* Classifies a given test instance using the TREPAN tree.
*
* @node root node
*/
private double classifyTrepanInstance(TrepanNode node, Instance instance){

Attribute m_SplitAttribute = node.getSplitAttribute();
if (node.getSplitAttribute() == null) {

Padrn 75722

return node.getClassLabel();
} else {
// Get the child node according to attribute value
double dValue = instance.value(m_SplitAttribute);
TrepanNode childNode;
if (m_SplitAttribute.isNominal()) {
childNode = node.getChild((int) dValue);
} else {
double splitValue = node.getSplitValue(m_SplitAttribute);
if (dValue <= splitValue) {
childNode = node.getChild(0);
} else {
}
}
return classifyTrepanInstance(childNode, instance);
}

}

/**
* Computes class distribution for instance using decision tree.
*
* @instance the instance for which distribution is to be computed
* @return the class distribution for the given instance
*/
public double[] distributionForInstance(Instance instance) throws Exception {


return distributionForTrepanInstance(m_RootNode, instance);
}

/**
* Computes class distribution for instance using TREPAN tree.
*
* @node root node
* @instance the instance for which distribution is to be computed
*/
private double[] distributionForTrepanInstance(TrepanNode node, Instance instance) {

Attribute m_Attribute = node.getSplitAttribute();
if (m_Attribute == null) {
double [] classMembership = node.getDistribution();
return node.getDistribution();
} else {
// Get the child node according to attribute value
double dValue = instance.value(m_Attribute);
TrepanNode childNode;
if (m_Attribute.isNominal()) {
childNode = node.getChild((int) dValue);
} else {
double splitValue = node.getSplitValue(m_Attribute);
if (dValue <= splitValue) {
} else {

Padrn 75722

}
}
return distributionForTrepanInstance(childNode, instance);
}
}

/****************************************************/
/******************* TO STRING ***********************/
/****************************************************/

/**
* Prints the decision tree using the private toString method from below.
*
* @return a textual description of the classifier
*/

m_CountLeaves = 0;
m_CountNodes = 0;

if ((m_RootNode.getDistribution() == null) &&
(m_RootNode.getChildren() == null)) {
return "Trepan: No model built yet.";
}

StringBuffer text = new StringBuffer();
text.append("Trepan\n\n" + toString(m_RootNode, 0));

text.append("\n\nNumber of Leaves : \t"+ getCountLeaves()+"\n");
text.append("\nSize of the tree : \t"+ getCountNodes()+"\n");

return text.toString();

}

private String toString(TrepanNode node, int level) {

double dClass = node.getClassLabel();

m_CountLeaves ++;
if (Instance.isMissingValue(dClass)) {
text.append(": null");
} else {
text.append(": "+ m_ClassAttribute.value((int) dClass));
}
} else {

m_CountNodes ++;
for (int j = 0; j < node.getCountChildren(); j++) {
text.append("\n");
for (int i = 0; i < level; i++) {
text.append("| ");
}
text.append(m_Attribute.name() + " = " + m_Attribute.value(j)
+ " (R= "+ Utils.roundDouble(node.getChild(j).getReach(),3) + ","

Padrn 75722

+ " F= "+ Utils.roundDouble(node.getChild(j).getFidelity(),3) + ","
+ " B= "+ Utils.roundDouble(node.getChild(j).getBestFirst(),3) + ")");
} else {
if (j == 0) {
text.append(m_Attribute.name() + " <= " +
Utils.roundDouble(node.getSplitValue(m_Attribute),5)
+ " B= "+ Utils.roundDouble(node.getChild(j).getBestFirst(),3) + ") ");
} else {
text.append(m_Attribute.name() + " > " +
+ " B= "+ Utils.roundDouble(node.getChild(j).getBestFirst(),3) + ") ");
}
}

TrepanNode childNode = node.getChild(j);
text.append(toString(childNode, level + 1));
}
}
}

/*********************************************/
/************ SET & GET METHODS ***************/
/*********************************************/

/**
* @i Max number of Nodes in the Tree.
*/
public void setMaxNodes(int i) {
if (i >= 0) {
m_maxNodes = i;
}
}

/**
* @return Max number of Nodes in the Tree.
*/
public int getMaxNodes() {
return m_maxNodes;
}

/**
* @i min number of examples to test a node.
*/
public void setMinSamples(int i) {
if (i >= 0) {
m_minSamples = i;
} else {
m_minSamples = 0;
}
}

/**
* @return Min number of examples to test a node.

Padrn 75722

*/
public int getMinSamples() {
return m_minSamples;
}

/**
* @return data classified wit Oracle
*/
public Instances getDataNN() {
return newData;
}

/**
* @return num of leaves of the tree
*/
public int getCountLeaves() {
return m_CountLeaves;
}

/**
* @return num of nodes of the tree
*/
public int getCountNodes() {
return m_CountNodes;
}

/**
* @return TREPAN's oracle
*/
public Classifier getOracle() {
return m_Oracle;
}

/**
* @c Classifier used as the Oracle
*/
public void setOracle(Classifier c) {
m_Oracle = c;
}

/**
* @b Best First value
*/
public void setBestFirst(boolean b) {
m_BestFirst = b;
}

/**
* @return Best First value
*/
public boolean getBestFirst() {
return m_BestFirst;
}

/**
* @b Pruning value

Padrn 75722

*/
public void setPruning (boolean b) {
m_Pruning = b;
}

/**
* @return Pruning value
*/
public boolean getPruning() {
return m_Pruning;
}

/**
* @i Prop of instances to make a leaf
*/
public void setPropInstances(double i) {
m_propInst = i;
}

/**
* @return Prop of instances to make a leaf
*/
public double getPropInstances() {
return m_propInst;
}

/**
* @return Fidelity
*/
public double getFidelity() {
return m_Fidelity;
}

/********************************************/
/************* OPTION HANDLER ***************/
/********************************************/

/**
* Returns an enumeration describing the available options
*
* @return an enumeration of all the available options
*/
public Enumeration listOptions() {

Vector newVector = new Vector(6);

newVector.addElement(new Option(
"\tMin number of samples to test a node.\n"
+"\t(Default = 100).",
"m", 1, "-m <number of samples>"));
"\tMax number of nodes in the tree.\n"
+"\t(Default = 10).",
"M", 1,"-M <number of nodes>"));
newVector.addElement(new Option("\tBest Tree.",
"B", 0, "-B"));
newVector.addElement(new Option("\tPruning.",
"P", 0, "-P"));
newVector.addElement(new Option("\tProp. Inst.",

Padrn 75722

"I", 0, "-I"));
"\tFull name of classifier to use as Oracle. "
+ "\tNot optional."
+ "\teg: weka.classifiers.neural.NeuralNetwork",
"W", 1, "-W <classifier class name>"));

if ((m_Oracle != null) &&
(m_Oracle instanceof OptionHandler)) {
"",
"", 0,
"\nOptions specific to sub-classifier "
+ m_Oracle.getClass().getName()
+ ":\n(use -- to signal start of sub-classifier options)"));
Enumeration enum = ((OptionHandler)m_Oracle).listOptions();
newVector.addElement(enum.nextElement());
}
}
return newVector.elements();
}

/**
* Parses a given list of options.
*
* @param options the list of options as an array of strings
* @exception Exception if an option is not supported
*/
public void setOptions(String[] options) throws Exception {

String minSampleString = Utils.getOption('m', options);
if (minSampleString.length() != 0) {
setMinSamples(Integer.parseInt(minSampleString));
} else {
setMinSamples(0);
}
String maxNodesString = Utils.getOption('M', options);
if (maxNodesString.length() != 0) {
setMaxNodes(Integer.parseInt(maxNodesString));
} else {
setMaxNodes(0);
}

m_BestFirst = Utils.getFlag('B', options);
m_Pruning = Utils.getFlag('P', options);

String propInstances = Utils.getOption('I', options);
if (propInstances.length() != 0) {
double prop = (new Double(propInstances)).doubleValue();
if (prop <= 0 || prop > 1 ) {
setPropInstances(0.95);
} else {
setPropInstances(prop);
}
} else {
}

String classifierName = Utils.getOption('W', options);
if (classifierName.length() == 0) {
throw new Exception("A classifier must be specified with"
+ " the -W option.");
}

Padrn 75722

setOracle(Classifier.forName(classifierName,
Utils.partitionOptions(options)));
}

/**
* Gets the current settings of Trepan.
*
* @return an array of strings suitable for passing to setOptions()
*/
public String [] getOptions() {
String [] classifierOptions = new String [0];
classifierOptions = ((OptionHandler)m_Oracle).getOptions();
}

String [] options = new String [classifierOptions.length + 11];
int current = 0;
options[current++] = "-m"; options[current++] = "" + getMinSamples();
options[current++] = "-M"; options[current++] = "" + getMaxNodes();
if (m_BestFirst) {
options[current++] = "-B";
}
if (m_Pruning) {
options[current++] = "-P";
}
options[current++] = "-I"; options[current++] = "" + getPropInstances();
options[current++] = "-W";
options[current++] = getOracle().getClass().getName();
options[current++] = "--";

System.arraycopy(classifierOptions, 0, options, current,
classifierOptions.length);
current += classifierOptions.length;

while (current < options.length) {
options[current++] = "";
}
return options;
}

/***********************************************/
/**************** MAIN METHOD ******************/
/***********************************************/
/**
* Main method.
*
* @param args the options for the classifier
*/
public static void main(String[] args) {

try {
System.out.println(Evaluation.evaluateModel(new Trepan(), args));
System.err.println(e.getMessage());
}
}
}


Padrn 75722

C.1.5 Clase TrepanNode

/*
* TrepanNode.java
*
*/


import java.io.*;
import java.util.*;
import weka.core.*;
import weka.estimators.Estimator;
import java.lang.*;

/**
*/

public class TrepanNode {

/** Subset of training examples that reach the node */
private Instances trainExamples;

/** Set of query instances to be created */
private Instances queryExamples;

/** Num of training instances and query instances */
private int m_CountTrainEx = 0;
private int m_CountQueryEx = 0;

/** Attributes Distributions */
private TrepanEstimator [] m_Distributions;

/** Class value if node is leaf */
private double m_ClassLabel;

/** Attribute used for splitting */
private Attribute m_Attribute;

/** Class distribution at node */
private double[] m_ClassDistribution;

/** Nodes Children */
private TrepanNode [] m_Children;

/** Num of children nodes*/
private int m_CountChildren = 0;

/** Nodes Parent */
private TrepanNode m_Parent;

/** Node Type - Values R: Root, L: Leaf, N: Node */
private String m_NodeType;

/** Num of attributes of the instances */
private int m_NumAttr;

/** Num of classes in the dataset */
private int m_NumClass;

Padrn 75722

/** Candidate values for splitting */
private double[] attrValues;

/** Prop of instances that reach the node */
private double m_Reach;

/** Fidelity of the extracted tree */

/** BF value for the node */
private double m_Best_First;

/** ID node */
private int m_IdNodo;

/** Random value */
private Random random;

/**
* Class Constructor. Inicialize node and distributions.
*
* @data the data reaching the node
*/
public TrepanNode(Instances data) {

m_CountTrainEx = data.numInstances();

setTrainExamples(data);

m_NumAttr = data.numAttributes();
m_NumClass = data.numClasses();

//Inicialize random variable
random = new Random(0);

// Inicialize class distributions
m_ClassDistribution = new double[m_NumClass];

}

/**
* Generates new instances to evaluate the node.
*
* @minSamples min num of instances required to evaluate a node
* @oracle to classify new instances
*/
public void drawSample (int minSamples, Classifier oracle)
throws Exception {

// Num of instances to be created
m_CountQueryEx = minSamples - m_CountTrainEx;

if (m_CountQueryEx > 0) {

// Distribution
m_Distributions = new TrepanEstimator [m_NumAttr];

Enumeration enumAtt = trainExamples.enumerateAttributes();
while (enumAtt.hasMoreElements()) {

Padrn 75722

if (attr.isNominal()) {
m_Distributions[attr.index()] = new NominalEstimator(attr.numValues(), false);
} else {
m_Distributions[attr.index()] = new NumericEstimator(0.01);
}
}

// Generate distibution for each attribute
Enumeration enumInst = trainExamples.enumerateInstances();
while (enumInst.hasMoreElements()) {
Instance inst = (Instance) enumInst.nextElement();
enumAtt = inst.enumerateAttributes();
m_Distributions[attr.index()].addValue(inst.value(attr),1);
}
}

queryExamples = new Instances(trainExamples, m_CountQueryEx);
queryExamples.delete();
for (int j = 0; j < m_CountQueryEx ; j++) {
// Create a new instance
Instance inst = drawInstance();
// Classify new instance
double dClass = oracle.classifyInstance(inst);
// Add instance in dataset
inst.setClassValue(dClass);
queryExamples.add(inst);
}
} else {
m_CountQueryEx = 0;
}
}

/**
* Generates a new instance according to the distributions
*
* @return new instance
*/
private Instance drawInstance () {

// Create new instance
Instance newInst = new Instance(m_NumAttr);
newInst.setDataset(queryExamples);

// Get values for each attribute
Enumeration enumAtt = newInst.enumerateAttributes();
newInst.setValue(attr, setAttrValues(attr));
}

return newInst;
}

/**
* Generate a random value for an attribute
*
* @attr attribute

Padrn 75722

* @return random value
*/
private double setAttrValues(Attribute attr) {
long randomSeed = random.nextLong();
return m_Distributions[attr.index()].newValue(randomSeed);
}

/**
* Get Class Label. Generates class distribution at the node.
* Computes Fidelity and BestFirst value.
*/
public void setClassLabelNodo() {

Enumeration instEnum = trainExamples.enumerateInstances();
while (instEnum.hasMoreElements()) {
Instance inst = (Instance) instEnum.nextElement();
m_ClassDistribution[(int) inst.classValue()]++;
}
Enumeration instQEnum = queryExamples.enumerateInstances();
while (instQEnum.hasMoreElements()) {
Instance inst = (Instance) instQEnum.nextElement();
}
}

// Get main class at node
Utils.normalize(m_ClassDistribution);
m_ClassLabel = Utils.maxIndex(m_ClassDistribution);

// Fidelity
m_Fidelity = m_ClassDistribution[(int)m_ClassLabel];

// Best First
m_Best_First = m_Reach * (1 - m_Fidelity);
}

/**
* Split Node
*
* @PropC Prop instances that make a node to be a leaf
*/
public void constructTest(double PropC) throws Exception {

// If prop > PropC then make a leaf
double prop = 1;

if (m_CountTrainEx + m_CountQueryEx > 0) {
prop = (double)m_ClassDistribution[(int)m_ClassLabel] /
(double)(m_CountTrainEx + m_CountQueryEx);
}

if (prop > PropC) {
// Node -> Leaf
makeALeaf();
} else {
// Internal node -> Split Node

// Join Training Examples + QueryExamples to calculate values
Instances data;

Padrn 75722

data = new Instances(trainExamples);
Enumeration enumInst = queryExamples.enumerateInstances();
data.add(inst);
}
} else {
data = trainExamples;
}

// Compute attribute with maximum information gain.
double[] infoGains = new double[m_NumAttr];

// Split values for numeric attributes
attrValues = new double[m_NumAttr];

// Compute information gain for each attribute
Enumeration attEnum = data.enumerateAttributes();
while (attEnum.hasMoreElements()) {
Attribute att = (Attribute) attEnum.nextElement();
infoGains[att.index()] = computeInfoGain(data, att);
}

// Select best attribute for split
m_Attribute = data.attribute(Utils.maxIndex(infoGains));

// Make leaf if information gain is zero.
// Otherwise create successors.
if (Utils.eq(infoGains[m_Attribute.index()], 0)) {
makeALeaf();
}
else {
splitNode(m_Attribute);
}
}
}

/**
* Split a node generating children
*
* @attr Split attribute
*/
private void splitNode(Attribute att) throws Exception {

int numVal = 0;
if (att.isNominal()) {
numVal = att.numValues();
} else {
numVal = 2;
}

// Split data using selected attribute
Instances[] splitData = splitData(trainExamples, att, attrValues[att.index()]);

// Split query instances to compute Reach
Instances[] splitQueryData = new Instances[numVal];
splitQueryData = splitData(queryExamples, att, attrValues[att.index()]);
}


Padrn 75722

// Create child nodes
m_Children = new TrepanNode [numVal];
m_CountChildren = numVal;
double reach;
int n = 0;
for (int j = 0; j < m_CountChildren; j++) {
m_Children[j] = new TrepanNode(splitData[j]);
m_Children[j].setParent(this);
if (splitData[j].numInstances() > 0) {
// Node is not a leaf
m_Children[j].setNodeType("N");
// Compute Reach
reach = m_Reach * (double)((splitData[j].numInstances() +
splitQueryData[j].numInstances())
/ (double) (m_CountTrainEx + m_CountQueryEx));
} else {
reach = m_Reach * (double)(splitData[j].numInstances() / (double)
m_CountTrainEx);
}
m_Children[j].setReach(reach);
n++;
} else {
// Node is a leaf
m_Children[j].setReach(0);
m_Children[j].setFidelity(0);
m_Children[j].setBestFirst(0);
// Class Label = parents class label
m_Children[j].setClassLabel(m_ClassLabel);
double [] m_ChildDistribution = new double[m_NumClass];
m_ChildDistribution[(int)m_ClassLabel] = 1;
m_Children[j].setDistribution(m_ChildDistribution);
m_Children[j].makeALeaf();
}
}

// If only one child then make a leaf
if (n <= 1) {
makeALeaf();
}
}

/**
* Given an attribute compute Information Gain
*
* @data the data for which Information Gain is to be computed
* @att the attribute to be used for splitting
* @return information gain
*/
private double computeInfoGain(Instances data, Attribute att)
throws Exception {

double infoGain = 0;

if (att.isNumeric()) {
// Information Gain for numeric attributes
infoGain = getMaxInfoGain(data, att);

} else {

// Compute Entropy
infoGain = computeEntropy(data);
Instances[] splitData = splitData(data, att, 0);

Padrn 75722

int k = att.numValues();

// Compute Information Gain
for (int j = 0; j < k; j++) {
int numInst = splitData[j].numInstances();
if (numInst > 0) {
infoGain -= ((double) numInst / (double) data.numInstances()) *
computeEntropy(splitData[j]);
}
}
}

return infoGain;
}

/**
* Computes the entropy of a dataset.
*
* @param data the data for which entropy is to be computed
* @return the entropy of the data's class distribution
*/
private double computeEntropy(Instances data) throws Exception {

double [] classCounts = new double[m_NumClass];
Enumeration instEnum = data.enumerateInstances();
classCounts[(int) inst.classValue()]++;
}
double entropy = 0;
for (int j = 0; j < m_NumClass; j++) {
if (classCounts[j] > 0) {
entropy -= classCounts[j] * Utils.log2(classCounts[j]);
}
}

int numInst = data.numInstances();

entropy /= (double) numInst;
return entropy + Utils.log2(numInst);
}

/**
* Splits a dataset according to the values of a nominal or numeric attribute.
*
* @param data the data which is to be split
* @param att the attribute to be used for splitting
* @param value is the split value for numeric attributes
* @return the sets of instances produced by the split
*/
private Instances[] splitData(Instances data, Attribute att, double value)
throws Exception {

int k = 2;
k = att.numValues();
}

// Cointains splits

Padrn 75722

Instances[] splitData = new Instances[k];
for (int j = 0; j < k; j++) {
splitData[j] = new Instances(data, data.numInstances());
splitData[j].delete();
}

splitData[(int) inst.value(att)].add(inst);
}
}

if (inst.value(att) <= value) {
splitData[0].add(inst);
} else {
}
}
}

return splitData;
}

/**
* Given a numeric attribute compute Information Gain
*
* @instances the data for which Information Gain is to be computed
*/
private double getMaxInfoGain(Instances instances, Attribute att)
throws Exception {

int i = 0;
double actual = 0; // Attribute value
double value = 0; // Split value
double maxInfoGain = 0;
double infoGainData = 0;
double minSplit = 0;

// Sort instances by att
Instances data = new Instances(instances);
data.sort(att);

// Split data for each attribute value
Instances [] splitData;

// Contains attribute values
double[] attValues = new double[numInst];
attValues = data.attributeToDoubleArray(att.index());
// Contains class values
double[] classValues = new double[numInst];
classValues = data.attributeToDoubleArray(data.classAttribute().index());


Padrn 75722

// Candidate values
double[] candValues = new double[numInst];
double first = 0;
double last = 0;
int k = 0; // Counter
int pos = 0; // Counter

while (k < attValues.length - 2) {
// Find values where val(k) <> val(k+1) and class(k) <> class(k+1)
if ((attValues[k] != attValues[k+1]) && (classValues[k] != classValues[k+1]))
{
candValues[pos] = (attValues[k] + attValues[k+1]) / 2;
pos++;
}
k++;
}

infoGainData = computeEntropy(data);

while (i < pos) {
actual = candValues[i];

// Split data using actual value
splitData = splitData(data, att, actual);

infoGain = infoGainData;
for (int j = 0; j < 2; j++) {
infoGain -= ((double) splitData[j].numInstances() /
(double) numInst) * computeEntropy(splitData[j]);
}
}

// Select max Info. Gain
if (infoGain > maxInfoGain) {
maxInfoGain = infoGain;
value = actual;
}

i++;
}

attrValues[att.index()] = value;
return maxInfoGain;
}

/**
* Make a node to be a leaf
*/
public void makeALeaf() {
m_Attribute = null;
m_NodeType = "L";
m_CountChildren = 0;
m_Children = null;
}

/**********************************/
/***** SET & GET METHODS ***********/
/**********************************/

Padrn 75722

/**
* @i num of children
*/
public void setCountChildren (int i) {
m_CountChildren = i;
}

/**
* @return num of children
*/
public int getCountChildren () {
return m_CountChildren;
}

/**
* @inst Training Examples
*/
public void setTrainExamples(Instances inst) {
trainExamples = inst;
}

/**
* @return Training Examples
*/
public Instances getTrainExamples() {
return trainExamples;
}

/**
* @inst Query Examples
*/
public void setQueryExamples(Instances inst) {
queryExamples = inst;
}

/**
* @return Query Examples
*/
public Instances getQueryExamples() {
return queryExamples;
}

/**
* @e Class Distribution
*/
public void setDistribution(double [] e) {
m_ClassDistribution = e;
}

/**
* @return Class Distribution
*/
public double [] getDistribution() {
return m_ClassDistribution;
}

/**
* @n Nodes children
*/
public void setChildren(TrepanNode [] n) {
m_Children = n;
}


Padrn 75722

/**
* @return nodes children
*/
public TrepanNode [] getChildren() {
return m_Children;
}

/**
* @return ith children
*/
public TrepanNode getChild(int i) {
return m_Children[i];
}

/**
* @s Node Type
*/
public void setNodeType(String s) {
m_NodeType = s;
}

/**
* @return Node Type
*/
public String getNodeType() {
return m_NodeType;
}

/**
* @n Parent Node
*/
public void setParent(TrepanNode n) {
m_Parent = n;
}

/**
* @return Parent Node
*/
public TrepanNode getParent() {
return m_Parent;
}

/**
* @return Split Attribute
*/
public Attribute getSplitAttribute() {
return m_Attribute;
}

/**
* @return Class Label
*/
public double getClassLabel() {
return m_ClassLabel;
}

/**
* @c Class Label
*/
public void setClassLabel(double c) {

Padrn 75722

m_ClassLabel = c;
}

/**
* @att Attribute
* @return Split value
*/
public double getSplitValue (Attribute att) {
return attrValues[att.index()];
} else {
return 0;
}
}

/**
* @return Fidelity
*/
return m_Fidelity;
}

/**
* @d Fidelity
*/
public void setFidelity(double d) {
m_Fidelity = d;
}

/**
* @return Reach
*/
public double getReach() {
return m_Reach;
}

/**
* @d Reach
*/
public void setReach(double d) {
m_Reach = d;
}

/**
* @return BestFirst value
*/
public double getBestFirst() {
return m_Best_First;
}

/**
* @d BestFirst value
*/
public void setBestFirst(double d) {
m_Best_First = d;
}

/**

Padrn 75722

* @return Node ID
*/
public int getIdNodo() {
return m_IdNodo;
}

/**
* @i Node ID
*/
public void setIdNodo(int i) {
m_IdNodo = i;
}

}

C.2 Package weka.classifiers.trepanFuzzy

C.2.1 Clase TrepanFuzzy

/*
* TrepanFuzzy.java
*
*/

package weka.classifiers.trepanFuzzy;

import java.io.*;
import java.util.*;
import weka.core.*;
import weka.estimators.*;
import weka.core.Option;
import weka.core.OptionHandler;
import weka.core.SelectedTag;
import weka.core.Tag;
import weka.core.Utils;
import weka.filters.*;

/**
* Class for running Trepan Fuzzy classifier.
*
*/

public class TrepanFuzzy extends DistributionClassifier
implements OptionHandler {

/** Class attribute of dataset. */
private Attribute m_ClassAttribute;

/** Used to set the max number of nodes alowed in the tree. */
private int m_maxNodes = 0;

/** Used to set the min number of examples required to test a node. */
private int m_minSamples = 0;

/** Proportion of instances belonging to the same class that makes the node
a leaf */
private double m_propInst = 0.95;

Padrn 75722

/** Oracle used to classify instances */
protected Classifier m_Oracle = new weka.classifiers.neural.NeuralNetwork();

/** Instances classified by the Oracle. */
private Instances newData;

/** Queue of leaves */
private Queue m_Queue;

/** Construct the tree using the best nodes */
private boolean m_BestFirst = false;

/** Prune the tree */
private boolean m_Pruning = false;

/** Root Node */
private FuzzyNode m_RootNode;

/** Filter to replace missing values */
private Filter m_Filter;

/** Tree fidelity */

/** Counters */
private int m_CountNodes = 0;
private int m_CountLeaves = 0;

/** Fuzzy Variables */
private double m_Membership = 0.5;
private double m_MinTL = 0;
private double m_MaxTL = 1;

/**
* Builds Trepan Fuzzy decision tree classifier.
*
* @exception Exception if classifier can't be built successfully
*/
public void buildClassifier(Instances data) throws Exception {

if (data.numInstances() == 0) {
throw new IllegalArgumentException("No training instances.");
}

//System.out.println("Entre al buildClassifier");

// Class must be nominal
if (!data.classAttribute().isNominal()) {
throw new Exception("Trepan: nominal class, please.");
}

// Check string attributes
if (data.checkForStringAttributes()) {
throw new Exception("Trepan: no string attributes, please.");
}

data = new Instances(data);

// Class attribute
m_ClassAttribute = data.classAttribute();


Padrn 75722

// Build Oracle's Classifier
m_Oracle.buildClassifier(data);

m_Filter = new ReplaceMissingValuesFilter();
m_Filter.inputFormat(data);
Instances filteredData = Filter.useFilter(data, m_Filter);
data = new Instances(filteredData);

// Classify data with Oracle
newData = new Instances(classifyWithOracle(data));

// Make Trepan Fuzzy Tree with new data
makeTree(newData);
}

/**
* Replace the instances's classes with the class predicted by the Oracle.
*
* @return data classified with the oracle
*/
private Instances classifyWithOracle (Instances data) throws Exception {

Instance newInstance;
double newClassValue;
Instances newData = new Instances(data,data.numInstances());

newInstance = (Instance) enum.nextElement();
newClassValue = m_Oracle.classifyInstance(newInstance);
newInstance.setClassValue(newClassValue);
newData.add(newInstance);
}
return newData;
}

/**
* Build Trepan Fuzzy tree.
*
* @exception if decision tree can't be built successfully
*/
private void makeTree(Instances data) throws Exception {

// Inicialize the root of the tree
m_RootNode = new FuzzyNode(data);
m_RootNode.setNodeType("R");
m_RootNode.setReach(1);
m_RootNode.setChildId(-1);

m_RootNode.drawSample(m_minSamples, m_Oracle);

// Set node's main class
m_RootNode.setClassLabelNodo();

// Inicialize queue inserting the root node

Padrn 75722


// Make the Trepan Fuzzy Tree
FuzzyNode m_Node;

// Num of nodes in the tree
int m_NumNodes = 0;

// Max nodes in the tree
int m_LongTree = 0;
// If Best First -> we need to make the tree and then prune it
// Else we generate the tree pruned
if (!m_BestFirst && m_maxNodes > 0) {
m_LongTree = m_maxNodes;
} else {
m_LongTree = 999999;
}

// Expand root node to make decison Tree
while ((!m_Queue.empty()) && m_NumNodes <= m_LongTree) {
// Get node from queue
m_Node = (FuzzyNode) m_Queue.pop();
// Set node ID
m_Node.setIdNodo(m_NumNodes);
m_NumNodes ++;
// Split node
m_Node.constructTest(m_propInst, m_Membership, m_MinTL, m_MaxTL);
FuzzyNode [] m_ChildNode = m_Node.getChildren();
if (!(localStopCriteria(m_ChildNode[j]))){
// Node is not a leaf, add children in queue
m_ChildNode[j].drawSample(m_minSamples, m_Oracle);
m_ChildNode[j].setClassLabelNodo();
} else {
// Node is a leaf
m_ChildNode[j].setIdNodo(m_NumNodes);
m_NumNodes++;
}
}
}

// If max nodes reached then make leafs with remaining nodes
int i = m_NumNodes;
while (!m_Queue.empty()) {
m_Node.setIdNodo(i);
m_Node.makeALeaf();
i ++;
}

// If BestFirst then choose the best nodes
if (m_maxNodes > 0) {
if (m_NumNodes > m_maxNodes) {
if (m_BestFirst) {
// Make BestFirst tree
GetBestTree(m_NumNodes);
}
}

Padrn 75722

}

// Prune the tree to eliminate redundant nodes
if (m_Pruning) {
pruneTree();
}

//Calculamos la fidelidad entre el arbol y la red
m_Fidelity = computeFidelity(newData);

}

/**
* Indicates if node must be expanded
*
* @node node to be evaluated
* @return true if node is a leaf
*/
private boolean localStopCriteria (FuzzyNode node){
if (node.getNodeType() == "L") {
return true;
}
else {
return false;
}
}

/**
* Make a new pruned tree using the Best nodes
*
* @m_NumNodes num of nodes of the original tree
*/
private void GetBestTree(int m_NumNodes) {

// Vector containing all the tree's nodes
FuzzyNode[] vNodos = new FuzzyNode[m_NumNodes];
cargarVectorNodos(m_RootNode, vNodos);

// Vector containing the best nodes
int[] vValidos = new int[m_maxNodes];
// Vector containing BestFirst values
double[] vBF = new double[m_NumNodes];
// Aux variable
int i = 0;
//Variable para guardar Ids de Nodos
int IdNodo;
// ID valid node
int ID;

// Inicialize vector BF
for (int j = 0; j < m_NumNodes; j++) {
vBF[j]= 0;
}

// Root node is always a Best Node
ID = m_RootNode.getIdNodo();
vValidos[i] = ID;
i++;


Padrn 75722

while (i < m_maxNodes) {

// Insert child nodes into vNodos
for (int k = 0; k < vNodos[ID].getCountChildren(); k++) {
IdNodo = vNodos[ID].getChild(k).getIdNodo();
vBF[IdNodo] = vNodos[ID].getChild(k).getBestFirst();
}

// Choose the Best Node
ID = Utils.maxIndex(vBF);
vValidos[i] = ID;
i++;

// Eliminate the node selected
vBF[ID] = -1;
}

// Make leaves with the remaining nodes

FuzzyNode m_Node;
// Check if the node is a Best Node
if (NodoEncontrado(m_Node.getIdNodo(), vValidos) == false) {
// If node is not a Best Node then make a leaf
m_Node.makeALeaf();
} else {
// Is a BF Node. Insert children into queue
}
}
}
}
}

/**
* Check if a node is found in a vector
*
* @idNodo node to be found
* @return true if the node is found
*/
private boolean NodoEncontrado (int IdNodo, int[] vect) {
boolean bfound = false;
int i = 0;

while (!bfound && i < m_maxNodes) {
if (vect[i] == IdNodo) {
bfound = true;
}
i++;
}
return bfound;
}

/**
* Insert all the tree's nodes into a vector (recursive)

Padrn 75722

*
* @m_Node node to be inserted
* @vNodos vector
*/
private void cargarVectorNodos(FuzzyNode m_Node, FuzzyNode[] vNodos) {

vNodos[m_Node.getIdNodo()] = m_Node;
cargarVectorNodos(m_ChildNode[j], vNodos);
}
}
}

/**
* Prune the tree
*/
private void pruneTree() {

boolean again = true;

FuzzyNode m_Node;
double Class;
boolean IdemClass;
boolean AllLeaves;

while (again) {
again = false;




//Check if all the children are leaves
AllLeaves = true;
for (int i = 0; i < m_Node.getCountChildren(); i++) {
if (m_ChildNode[i].getNodeType() != "L") {
AllLeaves = false;
}
}

if (AllLeaves == true) {
// Check if all the nodes predict the same class
IdemClass = true;
Class = m_ChildNode[0].getClassLabel();
if (m_ChildNode[m].getClassLabel() != Class) {
IdemClass = false;
}
}
if (IdemClass == true) {
// Make parent node a leaf
m_Node.setClassLabel(Class);
m_Node.makeALeaf();

Padrn 75722

again = true;
}
} else {
}
}
}
}
}
}

/**
* Method computing the fidelity of the classifier with the Oracle
*
* @exception Exception if there is an error
* @return the fidelity
*/
public double computeFidelity (Instances data) throws Exception {

Instance instance;
double classValue;
double classValueOracle;
double countFidelity = 0;

instance = (Instance) enum.nextElement();
// Classify instance with Tree
classValue = classifyInstance(instance);
// Classify instance with Oracle
classValueOracle = m_Oracle.classifyInstance(instance);
if (classValue == classValueOracle) {
countFidelity++;
}
}

return (double)((double)countFidelity / (double)data.numInstances());
}

/**
* Classifies a given test instance using the decision tree.
*
*/
public double classifyInstance(Instance instance) throws Exception {


double[] classMembership = new double[m_ClassAttribute.numValues()];
double[] membership;
double membershipRama = 0;
FuzzyNode m_Node;

// Queue containing internal nodes

Padrn 75722


// Insert internal nodes into queue
FuzzyNode[] m_ChildNode = m_Node.getChildren();
}
} else {
// If node is a leaf, get membership
membership = new double[m_Node.getDistribution().length];
for (int i = 0; i < membership.length; i++) {
membership[i] = m_Node.getDistribution()[i];
}

membershipRama = ObtenerMembershipRama(m_Node, instance, -1);

membership[i] = membership[i] * membershipRama;
}

//Sum membership
classMembership[i] = classMembership[i] + membership[i];
}
}
}

// Get class with best membership
return Utils.maxIndex(classMembership);
}

/**
* Calculates the branch membership given a node
*
* @node parent node
* @childId Node ID
* @return the branch membership
*/
private double ObtenerMembershipRama(FuzzyNode node, Instance instance, int childId) {

double membership = 0;
Attribute m_SplitAttribute = node.getSplitAttribute();

// Leaf Node
if (m_SplitAttribute == null) {
membership = 1;
} else {
// Internal Node
if (m_SplitAttribute.isNominal()) {
// Nominal Attribute
if (childId == (int)instance.value(m_SplitAttribute)) {
membership = 1;
} else {
membership = 0;
}
} else {
// Numeric Attribute
if (childId == 0) {

Padrn 75722

membership =
node.MLeft(node.getM1(m_SplitAttribute),node.getM2(m_SplitAttribute),instance.value(m_S
plitAttribute));
} else {
membership =
node.MRight(node.getM1(m_SplitAttribute),node.getM2(m_SplitAttribute),instance.value(m_
SplitAttribute));
}
}
}

// If node is not root node and membership <> 0 then compute parents membership
if ((node.getNodeType() != "R") && (membership != 0) && (node.getChildId() != -1)) {
FuzzyNode padre = node.getParent();
return membership * ObtenerMembershipRama(padre, instance, node.getChildId());
} else {
return membership;
}
}

/**
* Computes class distribution for instance using decision tree.
*
* @param instance the instance for which distribution is to be computed
*/
public double[] distributionForInstance(Instance instance) throws Exception {


double[] classMembership = new double[m_ClassAttribute.numValues()];
double[] membership;
double membershipRama = 0;
FuzzyNode node;

// Queue containing internal nodes

node = (FuzzyNode) m_Queue.pop();
if (node.getNodeType() != "L") {
// Internal node
FuzzyNode [] m_ChildNode = node.getChildren();
for (int j = 0; j < node.getCountChildren(); j++){
}
} else {
// Leaf Node
membership = new double[node.getDistribution().length];

membership[i] = node.getDistribution()[i];
}

membershipRama = ObtenerMembershipRama(node, instance, -1);


Padrn 75722

membership[i] = membership[i] * membershipRama;
}

//Sum membership
classMembership[i] = classMembership[i] + membership[i];
}
}
}

Utils.normalize(classMembership);
return classMembership;
}

/*********************************************/
/************* TO STRING *********************/
/*********************************************/

/**
* Prints the decision tree using the private toString method from below.
*
* @return a textual description of the classifier
*/

m_CountLeaves = 0;
m_CountNodes = 0;

if ((m_RootNode.getDistribution() == null) &&
(m_RootNode.getChildren() == null)) {
return "Trepan: No model built yet.";
}

text.append("Trepan\n\n" + toString(m_RootNode, 0));

text.append("\n\nNumber of Leaves : \t"+ getCountLeaves()+"\n");
text.append("\nSize of the tree : \t"+ getCountNodes()+"\n");

text.append("\n\n[m1 / m2] = x-m1 / m2-m1");
text.append("\n[m1 \\ m2] = m2-x / m2-m1");
text.append("\nClass Distribution = ");

// Class Distribution
for (int i = 0; i < m_ClassAttribute.numValues(); i++) {
if (i == 0) {
text.append("["+ m_ClassAttribute.value(i));
} else {
text.append(","+ m_ClassAttribute.value(i));
}
}
text.append("]");

}

private String toString(FuzzyNode node, int level) {


Padrn 75722

double dClass = node.getClassLabel();

m_CountLeaves ++;
if (Instance.isMissingValue(dClass)) {
text.append(": null");
} else {
text.append(": "+ m_ClassAttribute.value((int) dClass));

// Class distribution
for (int i = 0; i < node.getDistribution().length; i++) {
if (i == 0) {
text.append(" ["+ Utils.roundDouble(node.getDistribution()[i],3));
} else {
text.append(","+ Utils.roundDouble(node.getDistribution()[i],3));
}
}
text.append("]");

}
} else {

m_CountNodes ++;

for (int j = 0; j < node.getCountChildren(); j++) {
text.append("\n");
for (int i = 0; i < level; i++) {
text.append("| ");
}
text.append(m_Attribute.name() + " = " + m_Attribute.value(j));
} else {
if (j == 0) {
text.append(m_Attribute.name() + " <= " +
+ " ["+ Utils.roundDouble(node.getM1(m_Attribute),4) + " \\ "
+ Utils.roundDouble(node.getM2(m_Attribute),4) + "] ");
} else {
text.append(m_Attribute.name() + " > " +
+ " ["+ Utils.roundDouble(node.getM1(m_Attribute),4) + " / "
+ Utils.roundDouble(node.getM2(m_Attribute),4) + "] ");
}
}

FuzzyNode childNode = node.getChild(j);
text.append(toString(childNode, level + 1));
}
}
}

/*********************************************/
/********** SET & GET METHODS ****************/
/*********************************************/

/**
* @i Max number of Nodes in the Tree.
*/

Padrn 75722

public void setMaxNodes(int i) {
if (i >= 0) {
m_maxNodes = i;
}
}

/**
* @return Max number of Nodes in the Tree.
*/
public int getMaxNodes() {
return m_maxNodes;
}

/**
* @i min number of examples to test a node.
*/
public void setMinSamples(int i) {
if (i >= 0) {
m_minSamples = i;
} else {
m_minSamples = 0;
}
}

/**
* @return data classified wit Oracle
*/
public Instances getDataNN() {
return newData;
}

/**
* @return Min number of examples to test a node.
*/
public int getMinSamples() {
return m_minSamples;
}

/**
* @return num of leaves of the tree
*/
public int getCountLeaves() {
return m_CountLeaves;
}

/**
* @return num of nodes of the tree
*/
public int getCountNodes() {
return m_CountNodes;
}

/**
* @return TREPAN's oracle
*/
public Classifier getOracle() {
return m_Oracle;
}

Padrn 75722

/**
* @c Classifier used as the Oracle
*/
public void setOracle(Classifier c) {
m_Oracle = c;
}

/**
* @b Best First value
*/
public void setBestFirst(boolean b) {
m_BestFirst = b;
}

/**
* @return Best First value
*/
public boolean getBestFirst() {
return m_BestFirst;
}

/**
* @b Pruning value
*/
public void setPruning (boolean b) {
m_Pruning = b;
}

/**
* @return Pruning value
*/
public boolean getPruning() {
return m_Pruning;
}

/**
* @i Prop of instances to make a leaf
*/
public void setPropInstances(double i) {
m_propInst = i;
}

/**
* @return Fidelity
*/
return m_Fidelity;
}

/**
* @return Prop of instances to make a leaf
*/
public double getPropInstances() {
return m_propInst;
}

Padrn 75722

/**
* @return membership
*/
public double getMembership() {
return m_Membership;
}

/**
* @d membership
*/
public void setMembership(double d) {
m_Membership = d;
}

/************************************/
/****** OPTION HANDLER **************/
/************************************/

/**
* Returns an enumeration describing the available options
*
* @return an enumeration of all the available options
*/
public java.util.Enumeration listOptions() {

Vector newVector = new Vector(7);

"\tMin number of samples to test a node.\n"
+"\t(Default = 100).",
"m", 1, "-m <number of samples>"));
"\tMax number of nodes in the tree.\n"
+"\t(Default = 10).",
"M", 1,"-M <number of nodes>"));
newVector.addElement(new Option("\tBest Tree.",
"B", 0, "-B"));
newVector.addElement(new Option("\tPruning.",
"P", 0, "-P"));
newVector.addElement(new Option("\tProp. Inst.",
"I", 0, "-I"));
newVector.addElement(new Option("\tMembership.",
"s", 0, "-s"));
"\tFull name of classifier to use as Oracle. "
+ "\tNot optional."
+ "\teg: weka.classifiers.neural.NeuralNetwork",
"W", 1, "-W <classifier class name>"));

"",
"", 0,
"\nOptions specific to sub-classifier "
+ m_Oracle.getClass().getName()
+ ":\n(use -- to signal start of sub-classifier options)"));
Enumeration enum = ((OptionHandler)m_Oracle).listOptions();
newVector.addElement(enum.nextElement());

Padrn 75722

}
}
return newVector.elements();
}

/**
* Parses a given list of options.
*
* @param options the list of options as an array of strings
* @exception Exception if an option is not supported
*/

public void setOptions(String[] options) throws Exception {

String minSampleString = Utils.getOption('m', options);
if (minSampleString.length() != 0) {
setMinSamples(Integer.parseInt(minSampleString));
} else {
setMinSamples(0);
}

String maxNodesString = Utils.getOption('M', options);
if (maxNodesString.length() != 0) {
setMaxNodes(Integer.parseInt(maxNodesString));
} else {
setMaxNodes(0);
}

m_BestFirst = Utils.getFlag('B', options);

m_Pruning = Utils.getFlag('P', options);

String propInstances = Utils.getOption('I', options);
if (propInstances.length() != 0) {
double prop = (new Double(propInstances)).doubleValue();
if (prop <= 0 || prop > 1 ) {
} else {
setPropInstances(prop);
}
} else {
}

String membership = Utils.getOption('s', options);
if (membership.length() != 0) {
double m = (new Double(membership)).doubleValue();
if (m <= 0 || m > 1 ) {
setMembership(0.5);
} else {
setMembership(m);
}
} else {
setMembership(0.5);
}

String classifierName = Utils.getOption('W', options);
if (classifierName.length() == 0) {
throw new Exception("A classifier must be specified with"
+ " the -W option.");
}

setOracle(Classifier.forName(classifierName,

Padrn 75722

Utils.partitionOptions(options)));
}

/**
* Gets the current settings of Trepan.
*
* @return an array of strings suitable for passing to setOptions()
*/
public java.lang.String[] getOptions() {

String [] classifierOptions = new String [0];
classifierOptions = ((OptionHandler)m_Oracle).getOptions();
}

String [] options = new String [classifierOptions.length + 13];
int current = 0;
options[current++] = "-m"; options[current++] = "" + getMinSamples();
options[current++] = "-M"; options[current++] = "" + getMaxNodes();
if (m_BestFirst) {
options[current++] = "-B";
}
if (m_Pruning) {
options[current++] = "-P";
}
options[current++] = "-I"; options[current++] = "" + getPropInstances();
options[current++] = "-s"; options[current++] = "" + getMembership();
options[current++] = "-W";
options[current++] = getOracle().getClass().getName();
options[current++] = "--";

System.arraycopy(classifierOptions, 0, options, current,
classifierOptions.length);
current += classifierOptions.length;

while (current < options.length) {
options[current++] = "";
}
return options;
}

/*******************************/
/******** MAIN METHOD **********/
/*******************************/

/**
* Main method.
*
* @param args the options for the classifier
*/
public static void main(String[] args) {

try {
System.out.println(Evaluation.evaluateModel(new TrepanFuzzy(), args));
System.err.println(e.getMessage());
}
}

}


Padrn 75722

C.2.2 Clase FuzzyNode

/*
* FuzzyNode.java
*
*/

package weka.classifiers.trepanFuzzy;

import java.io.*;
import java.util.*;
import weka.core.*;
import weka.estimators.Estimator;
import java.lang.*;
import weka.classifiers.trepan.TrepanEstimator;
import weka.classifiers.trepan.NumericEstimator;
import weka.classifiers.trepan.NominalEstimator;

/**
*/

public class FuzzyNode {

/** Subset of training examples that reach the node */
private Instances trainExamples;

/** Set of query instances */
private Instances queryExamples;

/** Num of training instances and query instances */
private int m_CountTrainEx = 0;
private int m_CountQueryEx = 0;

/** Attributes Distributions */
private TrepanEstimator [] m_Distributions;

/** Class value if node is leaf */
private double m_ClassLabel;

/** Attribute used for splitting */
private Attribute m_Attribute;

/** Class distribution at node */
private double[] m_ClassDistribution;

/** Nodes Children */
private FuzzyNode [] m_Children;

/** Num of children nodes*/
private int m_CountChildren = 0;

/** Nodes Parent */
private FuzzyNode m_Parent;

/** Node Type - Values R: Root, L: Leaf, N: Node */
private String m_NodeType;


Padrn 75722

/** Num of attributes of the instances */
private int m_NumAttr;

/** Candidate values for splitting */
/** 0 -> value
1 -> m1
2 -> m2
*/
private double[][] attrValues;

/** Prop of instances that reach the node */
private double m_Reach;

/** Fidelity of the extracted tree */

/** BF value for the node */
private double m_Best_First;

/** Id. de nodo */
private int m_IdNodo;

/** ID node */
private Random random;

/** Truth level of the branch */
private double m_TruthLevel;

/** Membership values m1 y m2 for continuous attributes */
private double m_FuzzyPoints;

/** Child Node ID */
private int m_ChildId;

/**
* Class Constructor. Inicialize node and distributions.
*
* @data the data reaching the node
*/
public FuzzyNode(Instances data) {

m_CountTrainEx = data.numInstances();

setTrainExamples(data);

m_NumAttr = data.numAttributes();

//Inicialize random variable
random = new Random(0);

// Inicialize class distributions
m_ClassDistribution = new double[trainExamples.numClasses()];
}

/**
*

Padrn 75722

*/
public void drawSample (int minSamples, Classifier oracle)
throws Exception {

// Num of instances to be created
m_CountQueryEx = minSamples - m_CountTrainEx;


// Distribution
m_Distributions = new TrepanEstimator [m_NumAttr];

Enumeration enumAtt = trainExamples.enumerateAttributes();
} else {
}
}

Enumeration enumInst = trainExamples.enumerateInstances();
}
}

queryExamples = new Instances(trainExamples, m_CountQueryEx);
queryExamples.delete();
Instance inst = drawInstance();
double dClass = oracle.classifyInstance(inst);
// Add instance in dataset
queryExamples.add(inst);
}
} else {
m_CountQueryEx = 0;
}
}

/**
*
*/
private Instance drawInstance () {

/** Creo la nueva instancia */
Instance newInst = new Instance(m_NumAttr);
newInst.setDataset(queryExamples);

/** Asigno un valor a cada atributo de la instancia */

Padrn 75722

newInst.setValue(attr, setAttrValues(attr));
}

return newInst;
}

/**
* Generate a random value for an attribute
*
* @attr attribute
* @return random value
*/
private double setAttrValues(Attribute attr) {
long randomSeed = random.nextLong();
return m_Distributions[attr.index()].newValue(randomSeed);
}

/**
* Get Class Label. Generates class distribution at the node.
* Computes Fidelity and BestFirst value.
*/
public void setClassLabelNodo() {

Enumeration instEnum = trainExamples.enumerateInstances();
}
Enumeration instQEnum = queryExamples.enumerateInstances();
while (instQEnum.hasMoreElements()) {
Instance inst = (Instance) instQEnum.nextElement();
}
}

// Get main class at node
Utils.normalize(m_ClassDistribution);
m_ClassLabel = Utils.maxIndex(m_ClassDistribution);

// Fidelity
m_Fidelity = m_ClassDistribution[(int)m_ClassLabel];

// Best First
m_Best_First = m_Reach * (1 - m_Fidelity);

}

/**
* Split Node
*
* @PropC Prop instances that make a node to be a leaf
* @Membership value used to split numeric attributes

Padrn 75722

* @MinTL value used to split numeric attributes
* @MaxTL value used to split numeric attributes
*/
public void constructTest(double PropC, double Membership, double MinTL,
double MaxTL) throws Exception {

// If prop > PropC then make a leaf
double prop = 1;

if (m_CountTrainEx + m_CountQueryEx > 0) {
prop = (double)m_ClassDistribution[(int)m_ClassLabel] /
(double)(m_CountTrainEx + m_CountQueryEx);
}

if (prop > PropC) {
// Node -> Leaf
makeALeaf();
} else {
// Internal node -> Split Node

// Join Training Examples + QueryExamples to calculate values
Instances data;
data = new Instances(trainExamples);
Enumeration enumInst = queryExamples.enumerateInstances();
data.add(inst);
}
} else {
data = trainExamples;
}

// Compute attribute with maximum information gain.
double[] infoGains = new double[m_NumAttr];

// Split values for numeric attributes
attrValues = new double[m_NumAttr][3];

// Compute information gain for each attribute
Enumeration attEnum = data.enumerateAttributes();
while (attEnum.hasMoreElements()) {
Attribute att = (Attribute) attEnum.nextElement();
infoGains[att.index()] = computeInfoGain(data, att);
}

// Select best attribute for split
m_Attribute = data.attribute(Utils.maxIndex(infoGains));

// Make leaf if information gain is zero or truth level is reached.
// Otherwise create successors.
if (Utils.eq(infoGains[m_Attribute.index()], 0)) {
makeALeaf();
}
else {
splitNode(m_Attribute, Membership, MinTL, MaxTL);
}
}
}

/**
* Compute nodes truth level

Padrn 75722

*
* @data dataset to split
* @attr split attribute
* @minTL value used to compute truth level
* @maxTL value used to compute truth level
*/
private boolean truthLevel(Instances data, Attribute attr, double minTL,
double maxTL) {

boolean ret = false;

double Totals = 0;
double fuzzyValueL = 0;
double fuzzyValueR = 0;
double rightTotals = 0;
double leftTotals = 0;
double max = 0;

if (attr.isNumeric()) {

double [] classCountsLeft = new double[data.numClasses()];
double [] classCountsRight = new double[data.numClasses()];

fuzzyValueL = MLeft(attrValues[attr.index()][1],
attrValues[attr.index()][2],inst.value(attr));
leftTotals += fuzzyValueL;
classCountsLeft[(int)inst.classValue()] += fuzzyValueL;

fuzzyValueR = MRight(attrValues[attr.index()][1],
attrValues[attr.index()][2],inst.value(attr));
rightTotals += fuzzyValueR;
classCountsRight[(int)inst.classValue()] += fuzzyValueR;

Totals = Totals + fuzzyValueL + fuzzyValueR;
}

if ( ((double)((double)leftTotals /(double)Totals) < minTL) ||
((double)((double)rightTotals / (double)Totals) < minTL) ) {
ret = true;

} else {

for (int j = 0; j < data.numClasses(); j++) {

if ( (double)((double)classCountsLeft[j] / (double)leftTotals) > maxTL ) {
ret = true;
}

if ( (double)((double)classCountsRight[j] / (double)rightTotals) > maxTL ) {
ret = true;
}
}
}
}

return ret;
}

/**
* Split a node generating children

Padrn 75722

*
* @attr Split attribute
* @membership value used to split numeric attributes
* @minTL value used to split numeric attributes
* @maxTL value used to split numeric attributes
*/
private void splitNode(Attribute att, double membership,
double minTL, double maxTL) throws Exception {

int numVal = 0;
Instances[] splitData;
Instances[] splitQueryData;

numVal = att.numValues();

splitData = new Instances[numVal];
splitData = splitData(trainExamples, att, attrValues[att.index()][0]);

splitQueryData = new Instances[numVal];
splitQueryData = splitData(queryExamples, att, attrValues[att.index()][0]);
}

} else {
numVal = 2;

splitData = new Instances[numVal];
splitData = splitFuzzyData(trainExamples, att, membership);

splitQueryData = new Instances[numVal];
splitQueryData = splitFuzzyData(queryExamples, att, membership);
}
}

// Create child nodes
m_Children = new FuzzyNode [numVal];
m_CountChildren = numVal;
double reach;
int n = 0;
for (int j = 0; j < m_CountChildren; j++) {
m_Children[j] = new FuzzyNode(splitData[j]);
m_Children[j].setParent(this);
m_Children[j].setChildId(j);

// Node is not a leaf
m_Children[j].setNodeType("N");
// Compute Reach
reach = m_Reach * (double)((splitData[j].numInstances() +
splitQueryData[j].numInstances())
/ (double) (m_CountTrainEx + m_CountQueryEx));
} else {
reach = m_Reach * (double)(splitData[j].numInstances() / (double)
m_CountTrainEx);
}

Padrn 75722

m_Children[j].setReach(reach);
n++;
} else {
// Node is a leaf
m_Children[j].setReach(0);
m_Children[j].setFidelity(0);
m_Children[j].setBestFirst(0);
// Class Label = parents class label
m_Children[j].setClassLabel(m_ClassLabel);
double [] m_ChildDistribution = new double[trainExamples.numClasses()];
m_ChildDistribution[(int)m_ClassLabel] = 1;
m_Children[j].setDistribution(m_ChildDistribution);
m_Children[j].makeALeaf();
}
}

// If only one child then make a leaf
if (n <= 1) {
makeALeaf();
}

}

/**
* Computes information gain for an attribute.
*
* @param data the data for which info gain is to be computed
* @param att the attribute
* @return the information gain for the given attribute and data
*/
private double computeInfoGain(Instances data, Attribute att)
throws Exception {

double aux = 0;

// Information Gain for numeric attributes
infoGain = getMaxInfoGain(data, att);

} else {

// Compute Entropy
infoGain = computeFuzzyEntropy(data);

Instances[] splitData = splitData(data, att, 0);

int k = att.numValues();

for (int j = 0; j < k; j++) {
int numInst = splitData[j].numInstances();
if (numInst > 0) {
infoGain -= ((double) numInst / (double) data.numInstances()) *
computeFuzzyEntropy(splitData[j]);
}
}
}

return infoGain;
}


Padrn 75722

/**
* Computes the entropy of a dataset.
*
*/
private double computeEntropy(Instances data) throws Exception {

double [] classCounts = new double[data.numClasses()];
}
double entropy = 0;
entropy -= classCounts[j] * Utils.log2(classCounts[j]);
}
}

entropy /= (double) numInst;
return entropy + Utils.log2(numInst);
}

/**
* Computes the fuzzy entropy of a dataset (nominal attributes).
*
*/
private double computeFuzzyEntropy(Instances data) throws Exception {

}

double frec = 0;
double entropy = 0;

// Compute Fuzzy Entropy
frec = (double)((double)classCounts[j] / (double)data.numInstances());
entropy -= frec * Utils.log2(frec);
}
}
return entropy;
}

/**
* Computes the fuzzy entropy of a dataset (numeric attributes).
*

Padrn 75722

* @m1 membership left branch
* @m2 membership right branch
* @j indicates left or right branch
*/
private double computeFuzzyEntropy(Instances data, Attribute attr, double m1,
double m2, int j) throws Exception {

double fuzzyValue = 0;
double classTotals = 0;

if (j == 0) {
fuzzyValue = MLeft(m1,m2,inst.value(attr));
} else {
fuzzyValue = MRight(m1,m2,inst.value(attr));
}
classCounts[(int) inst.classValue()] += fuzzyValue;
classTotals += fuzzyValue;
}

double frec = 0;
double entropy = 0;

for (int k = 0; k < data.numClasses(); k++) {
if (classCounts[k] > 0) {
frec = (double)(classCounts[k] / classTotals);
}
}

return entropy;
}

/**
* Computes the fuzzy entropy of a dataset (numeric attributes).
*
* @m1 membership left branch
* @m2 membership right branch
*/
private double computeFuzzyEntropy(Instances data, Attribute attr, double m1,
double m2) throws Exception {

double fuzzyValue = 0;
double classTotals = 0;

fuzzyValue = MLeft(m1,m2,inst.value(attr));

Padrn 75722

fuzzyValue += MRight(m1,m2,inst.value(attr));
classCounts[(int) inst.classValue()] += fuzzyValue;
classTotals += fuzzyValue;
}

double frec = 0;
double entropy = 0;

frec = (double)(classCounts[j] / classTotals);
}
}

return entropy;
}

/**
* Computes the membership of the left branch.
*
* @m1 value
* @m2 value
* @x value used to compute membership
* @return the membership
*/
public double MLeft(double m1, double m2, double x) {

double m = 0;

if (Utils.smOrEq(x,m1)) {
m = 1;
} else {
if (Utils.grOrEq(x,m2)) {
m = 0;
} else {
m = (double)((double)(m2 - x) / (double)(m2 - m1));
}
}
return m;
}

/**
* Computes the membership of the right branch.
*
* @m1 value
* @m2 value
* @x value used to compute membership
* @return the membership
*/
public double MRight(double m1, double m2, double x) {

double m = 0;

if (Utils.smOrEq(x,m1)) {
m = 0;
} else {
if (Utils.grOrEq(x,m2)) {
m = 1;
} else {
m = (double)((double)(x - m1) / (double)(m2 - m1));

Padrn 75722

}
}
return m;
}

/**
* Splits a dataset according to the values of a nominal or numeric attribute.
*
* @param data the data which is to be split
* @param att the attribute to be used for splitting
* @param value is the split value for numeric attributes
*/
private Instances[] splitData(Instances data, Attribute att, double value)
throws Exception {

int k = 2;
k = att.numValues();
}

// Cointains splits
Instances[] splitData = new Instances[k];
for (int j = 0; j < k; j++) {
}

splitData[(int) inst.value(att)].add(inst);
}
}

if (inst.value(att) <= value) {
} else {
}
}
}

return splitData;
}

/**
* Splits a dataset according to the values of a numeric attribute.
*
* @data the data which is to be split
* @membership membership value for fuzzy partition
*/
private Instances[] splitFuzzyData(Instances data, Attribute att,
double membership) throws Exception {


Padrn 75722

double value = attrValues[att.index()][0];
double m1 = attrValues[att.index()][1];
double m2 = attrValues[att.index()][2];

// Cointains splits
Instances[] splitData = new Instances[2];
for (int j = 0; j < 2; j++) {
}

// if Mleft or Mright < membership the instance is not longer used
if (MLeft(m1,m2,inst.value(att)) >= membership) {
}
if (MRight(m1,m2,inst.value(att)) >= membership) {
}
}

return splitData;
}

/**
* Given a numeric attribute compute Information Gain
*
* @instances the data for which Information Gain is to be computed
*/
private double getMaxInfoGain(Instances instances, Attribute att)
throws Exception {

int i = 0;
double maxInfoGain = 0;
double infoGainData = 0;

double FuzzyCount;
double FuzzyTotal;
double Distance;

Instances[] splitData;

// Sort instances by att
Instances data = new Instances(instances);
data.sort(att);

// Compute mean distance between attribute values
Distance = (double)((data.lastInstance().value(att)
- data.firstInstance().value(att)) / data.numInstances());

// Contains attribute values
double[] attValues = new double[data.numInstances()];
attValues = data.attributeToDoubleArray(att.index());

// Contains class values
double[] classValues = new double[data.numInstances()];
classValues = data.attributeToDoubleArray(data.classAttribute().index());


Padrn 75722

// Candidate values
// 0 -> Cut Point
// 1 -> next right value
// 2 -> next left value
double[][] cutPoints = new double[data.numInstances()][3];

int k = 0; // Counter
int pos = 0; // Counter

while (k < attValues.length - 2) {
// Find values where val(k) <> val(k+1) and class(k) <> class(k+1)
if ((attValues[k] != attValues[k+1]) && (classValues[k] != classValues[k+1]))
{
cutPoints[pos][0] = (double) ((attValues[k] + attValues[k+1]) / 2);

//m1
cutPoints[pos][1] = (double)(cutPoints[pos][0] - (Distance / 2));

//m2
cutPoints[pos][2] = (double)(cutPoints[pos][0] + (Distance / 2));

pos++;
}
k++;
}

while (i < pos) {

// Split data using actual value
splitData = splitData(data, att, cutPoints[i][0]);

infoGain = computeFuzzyEntropy(data,att,cutPoints[i][1],cutPoints[i][2]);

Instance inst;
FuzzyTotal = 0;
Enumeration EnumTot = data.enumerateInstances();
while (EnumTot.hasMoreElements()) {
inst = (Instance) EnumTot.nextElement();
FuzzyTotal += MLeft(cutPoints[i][1],cutPoints[i][2],inst.value(att));
FuzzyTotal += MRight(cutPoints[i][1],cutPoints[i][2],inst.value(att));
}

for (int j = 0; j < 2; j++) {
FuzzyCount = 0;
Enumeration EnumFuzzy = splitData[j].enumerateInstances();
while (EnumFuzzy.hasMoreElements()) {
inst = (Instance) EnumFuzzy.nextElement();
if (j == 0) {
FuzzyCount += MLeft(cutPoints[i][1],cutPoints[i][2],inst.value(att));
} else {
FuzzyCount += MRight(cutPoints[i][1],cutPoints[i][2],inst.value(att));
}
}
infoGain -= ((double) FuzzyCount / (double) FuzzyTotal) *
(double) computeFuzzyEntropy(splitData[j],att,cutPoints[i][1],cutPoints[i][2],j);

}
}

// Select max Info. Gain
if (infoGain > maxInfoGain) {
maxInfoGain = infoGain;

Padrn 75722

attrValues[att.index()][0] = cutPoints[i][0];
}

i++;
}

return maxInfoGain;
}

/**
* Make a node to be a leaf
*/
public void makeALeaf() {
m_Attribute = null;
m_NodeType = "L";
m_CountChildren = 0;
m_Children = null;
}

/**********************************/
/******** SET & GET METHODS *******/
/**********************************/

/**
* @i num of children
*/
public void setCountChildren (int i) {
m_CountChildren = i;
}

/**
* @return num of children
*/
public int getCountChildren () {
return m_CountChildren;
}

/**
* @inst Training Examples
*/
public void setTrainExamples(Instances inst) {
trainExamples = inst;
}

/**
* @return Training Examples
*/
public Instances getTrainExamples() {
return trainExamples;
}

/**
* @inst Query Examples
*/
public void setQueryExamples(Instances inst) {
queryExamples = inst;
}

/**

Padrn 75722

* @return Query Examples
*/
public Instances getQueryExamples() {
return queryExamples;
}

/**
* @e Class Distribution
*/
public void setDistribution(double [] e) {
m_ClassDistribution = e;
}

/**
* @return Class Distribution
*/
public double [] getDistribution() {
return m_ClassDistribution;
}

/**
* @t Truth Level
*/
public void setTruthLevel(double t) {
m_TruthLevel = t;
}

/**
* @return Truth Level
*/
public double getTruthLevel() {
return m_TruthLevel;
}

/**
* @n Nodes children
*/
public void setChildren(FuzzyNode [] n) {
m_Children = n;
}

/**
* @return nodes children
*/
public FuzzyNode [] getChildren() {
return m_Children;
}

/**
* @return ith children
*/
public FuzzyNode getChild(int i) {
return m_Children[i];
}

/**
* @s Node Type
*/
public void setNodeType(String s) {
m_NodeType = s;
}

Padrn 75722

/**
* @return Node Type
*/
public String getNodeType() {
return m_NodeType;
}

/**
* @n Parent Node
*/
public void setParent(FuzzyNode n) {
m_Parent = n;
}

/**
* @return Parent Node
*/
public FuzzyNode getParent() {
return m_Parent;
}

/**
* @return Split Attribute
*/
public Attribute getSplitAttribute() {
return m_Attribute;
}

/**
* @return Class Label
*/
public double getClassLabel() {
return m_ClassLabel;
}

/**
* @c Class Label
*/
public void setClassLabel(double c) {
m_ClassLabel = c;
}

/**
* @att Attribute
* @return Split value
*/
public double getSplitValue (Attribute att) {
return attrValues[att.index()][0];
} else {
return 0;
}
}

/**
* @att Attribute
* @return M1
*/

Padrn 75722

public double getM1 (Attribute att) {
} else {
return 0;
}
}

/**
* @att Attribute
* @return M2
*/
public double getM2 (Attribute att) {
} else {
return 0;
}
}

/**
* @return Fidelity
*/
return m_Fidelity;
}

/**
* @d Fidelity
*/
public void setFidelity(double d) {
m_Fidelity = d;
}

/**
* @return Reach
*/
public double getReach() {
return m_Reach;
}

/**
* @d Reach
*/
public void setReach(double d) {
m_Reach = d;
}

/**
* @return BestFirst value
*/
public double getBestFirst() {
return m_Best_First;
}

/**
* @d BestFirst value

Padrn 75722

*/
public void setBestFirst(double d) {
m_Best_First = d;
}

/**
* @return Node ID
*/
public int getIdNodo() {
return m_IdNodo;
}

/**
* @i Node ID
*/
public void setIdNodo(int i) {
m_IdNodo = i;
}

/**
* @return child node ID
*/
public int getChildId() {
return m_ChildId;
}

/**
* @i Child node ID
*/
public void setChildId(int i) {
m_ChildId = i;
}

}

C.3 Package weka.classifiers.trepanM5

C.3.1 Clase TrepanM5

/*
* Node.java
* Created by Romina Laura Bot, 2004
*
*/

package weka.classifiers.trepanM5;

import java.io.*;
import java.util.*;
import weka.core.*;

/**

Padrn 75722

* Class for handing a node in the tree or the subtree under this node
*/

public final class Node implements Serializable {
boolean type; // = true, NODE; = false, LEAF
int splitAttr; // splitting attribute
double splitValue; // the value of the splitting attribute at the
// splitting position
Function unsmoothed; // unsmoothed function
Function smoothed; // smoothed function
boolean valueNode; // =true, if use the constant term as the
// predicting function
Node upNode; // pointer of the up node
Node leftNode; // pointer of the left node
Node rightNode; // pointer of the right node
Errors errors; // evaluation errors of the model under this node
int numParameters; // number of parameters of the chosen model for this
// node, either the subtree model or the linear model
SplitInfo sf; // Spliting infomation
int lm; // linear model number at the leaf; for NODE, lm = 0;
Instances instances; // instances reaching this node

int model; // model type: LINEAR REGRESSION, REGRESSION_TREE,
// MODEL_TYPE
double pruningFactor; // to control the tree size
double deviation; // deviation of the gobal class variable

final static int LINEAR_REGRESSION=1;
final static int REGRESSION_TREE=2;
final static int MODEL_TREE=3;
final static double SPLIT_NUM = 3.5; // a node will not be further split
// if it contains instances less than SPLIT_NUM

/**** TREPAN ****/

// Random variable
private Random random = new Random(0);

/**** END TREPAN ****/

/**
* Constructs a new node
* @param inst instances
* @param up the parent node
*/
public Node(Instances inst, Node up){
int i;

type = true;
unsmoothed = new Function();
smoothed = new Function();
valueNode = true;
upNode = up;
leftNode = null;
rightNode = null;
errors = null;
numParameters = 0;
instances = inst;
lm = 0;
if(up != null) {
model = up.model;
pruningFactor = up.pruningFactor;

Padrn 75722

deviation = up.deviation;
}
}

/**
* Constructs the root of a tree
* @param options the options
*/
public Node(Instances inst, Node up,Options options){
int i;

type = true;
valueNode = true;
upNode = up;
leftNode = null;
rightNode = null;
errors = null;
numParameters = 0;
instances = inst;
lm = 0;

model = options.model;
pruningFactor = options.pruningFactor;
deviation = options.deviation;
}

/**
* Converts the information stored at this node to a string
* @return the converted string
* @exception Exception if something goes wrong
*/
public final String singleNodeToString() throws Exception {


text.append("Print single node (" + instances.numInstances() + "):\n");
if(type==true)text.append(" Type:\t\t\tNODE\n");
else text.append(" Type:\t\t\tLEAF\n");
text.append(" Unsmoothed function:\t\t");
unsmoothed.toString(instances,0);
System.out.print(" Smoothed function:\t\t");
smoothed.toString(instances,0);
text.append(" Value node:\t\t\t" + valueNode + "\n");
if(errors!=null)text.append(errors.toString());
if(upNode != null) text.append(" upNode:\t\t\tyes\n");
else text.append(" upNode:\t\t\tnull\n");
if(leftNode != null) text.append(" leftNode:\t\t\tyes\n");
else text.append(" leftNode:\t\t\tnull\n");
if(rightNode != null) text.append(" rightNode:\t\t\tyes\n");
else text.append(" rightNode:\t\t\tnull\n");
text.append(" number of parameters:\t" + numParameters +"\n");
text.append(" LEAF number(lm):\t\t" + lm +"\n");
text.append(" Number of instances\t\t" + instances.numInstances() +"\n");

}

/**

Padrn 75722

* Converts the tree under this node to a string
* @param treeLevel the depth of this node;
* the root of a tree should have treeLevel = 0
* @param deviation the global deviation of the class column,
* used for evaluating relative errors
*/
public final String treeToString(int treeLevel,double deviation) {

int i;

if(type == true) {
text.append("\n");
for(i=1;i<=treeLevel;i++)text.append("| ");
if(instances.attribute(splitAttr).name().charAt(0) != '[')
text.append(instances.attribute(splitAttr).name() + " <= " +
M5Utils.doubleToStringG(splitValue,1,3) + " : ");
else text.append(instances.attribute(splitAttr).name() + " false : ");
treeLevel++;
text.append(leftNode.treeToString(treeLevel,deviation));
treeLevel--;
text.append(instances.attribute(splitAttr).name() + " > " +
else text.append(instances.attribute(splitAttr).name() + " true : ");
treeLevel++;
text.append(rightNode.treeToString(treeLevel,deviation));
treeLevel--;
}
else{ // LEAF
text.append("LM" + lm);
if(deviation > 0.0)
text.append(" (" + instances.numInstances() + "/" +
M5Utils.doubleToStringG((100. * errors.rootMeanSqrErr /
deviation),1,3) + "%)\n");
else text.append(" (" + instances.numInstances() + ")\n");
}

}

/**
* Counts the number of linear models in the tree.
*/
public final int numberOfLinearModels() {

if (type == false) {
return 1;
} else {
return leftNode.numberOfLinearModels() +
rightNode.numberOfLinearModels();
}
}

/**
* Converts all the linear models at the leaves under the node to a string
* @param smooth either the smoothed models if true, otherwise
* the unsmoothed are converted
*/
public final String formulaeToString(boolean smooth) throws Exception {

Padrn 75722

int startingPoint;

if(type == true) {
text.append(leftNode.formulaeToString(smooth));
text.append(rightNode.formulaeToString(smooth));
}
else {
text.append(" LM" + lm + ": ");
startingPoint = 6 + (int)(Math.log(lm +0.5)/Math.log(10)) + 1 + 3;
if(smooth == true) text.append(smoothed.toString(instances,startingPoint));
else text.append(unsmoothed.toString(instances,startingPoint));
text.append("\n");
}

}

/**
* Sets the leaves' numbers
* @param leafCounter the number of leaves counted
* @return the number of the total leaves under the node
*/
public final int numLeaves(int leafCounter)
{
if(type == true) { // NODE
lm = 0;
leafCounter = leftNode.numLeaves(leafCounter);
leafCounter = rightNode.numLeaves(leafCounter);
}
else{ // LEAF
leafCounter++;
lm = leafCounter;
}
return leafCounter;
}

/**
* Splits the node recursively, unless there are few instances or
* instances have similar values of the class attribute
*/
public final void split(Instances inst, int minSamples, Classifier oracle)
throws Exception {
SplitInfo s,sMax;
int j, partition;
Instances leftInst,rightInst;
Instances trainExamples;

instances = inst;

/**** TREPAN ****/
// Create new instances to evaluate split at node

trainExamples = new Instances(instances);

// Create query instances
if (minSamples > trainExamples.numInstances()) {
trainExamples = drawSample (minSamples, oracle, trainExamples);
}


Padrn 75722

if(trainExamples.numInstances() < SPLIT_NUM ||
M5Utils.stdDev(instances.classIndex(),instances) < deviation * 0.05)
type = false;
else {

sMax = new SplitInfo(0,trainExamples.numInstances()-1,-1);
s = new SplitInfo(0,trainExamples.numInstances()-1,-1);
for(j=0;j<trainExamples.numAttributes();j++){
if(j != trainExamples.classIndex()){
trainExamples.sort(trainExamples.attribute(j));
s.attrSplit(j,trainExamples);
if((Math.abs(s.maxImpurity - sMax.maxImpurity) > 1.e-6) &&
(s.maxImpurity > sMax.maxImpurity + 1.e-6))
sMax = s.copy();
}
}

if(sMax.splitAttr < 0 || sMax.position < 1 || sMax.position >
trainExamples.numInstances()-1) type = false;
if(type == true){
sf = sMax;
splitAttr = sMax.splitAttr; // split attribute
splitValue = sMax.splitValue; // split value
unsmoothed = new Function(splitAttr); // unsmoothed function

trainExamples = null;


leftInst = new Instances(instances, instances.numInstances());
rightInst = new Instances(instances, instances.numInstances());
for (int i = 0; i < instances.numInstances(); i++)
if (instances.instance(i).value(splitAttr) <= splitValue)
leftInst.add(instances.instance(i));
else
rightInst.add(instances.instance(i));
leftInst.compactify();
rightInst.compactify();

if (leftInst.numInstances() == 0 || rightInst.numInstances() == 0) {
type = false;
//splitAttr = null;
//splitValue = null;
} else {

leftNode = new Node(leftInst,this);
//System.out.println("split left");
leftNode.split(leftInst, minSamples, oracle); // split left node

rightNode = new Node(rightInst,this);
//System.out.println("split right");
rightNode.split(rightInst, minSamples, oracle); // split right node

this.valueNode(); // function of the constant value

if(model != REGRESSION_TREE){
unsmoothed = Function.combine(unsmoothed,leftNode.unsmoothed);
// passes up the attributes found under the left node
unsmoothed = Function.combine(unsmoothed,rightNode.unsmoothed);
// passes up the attributes found under the right node
}
else unsmoothed = new Function();

Padrn 75722

}
}
}

if(type==false){ // a leaf node
this.leafNode();
errors = unsmoothed.errors(instances);
}
}

/****************/
/**** TREPAN ****/
/****************/

/**
*
* @data instances that reached the node
*/
public Instances drawSample (int minSamples, Classifier oracle, Instances data)
throws Exception {

/**
m_Distributions = Vector de distribuciones, una posicion por atributo de
las instancias. Cada posicion del vector corresponde a la distribucion
de un atributo de la instancia, y se identifica con el indice del
atributo dentro de la instancia. Cada distribucion, es la distribucion
de los valores de ese atributo
*/

double dClass;
Instance inst;
int m_NumAttr = data.numAttributes();
TrepanEstimator [] m_Distributions = new TrepanEstimator [m_NumAttr];

// Distributions
} else {
}
}

// Instances to be created
int m_CountQueryEx = minSamples - data.numInstances();

double classIndex = data.classIndex();
Enumeration enumInst = data.enumerateInstances();
inst = (Instance) enumInst.nextElement();
/** Para cada instancia tomo los atributos */

Padrn 75722

if (attr.index() != classIndex){
}
}
}

inst = drawInstance(data, m_Distributions);
dClass = oracle.classifyInstance(inst);
// Add instance to dataset
data.add(inst);
}

return data;
}

/**
*
* @data dataset
* @m_Distributions attribute distributions
*/
private Instance drawInstance (Instances data,
TrepanEstimator [] m_Distributions) {

long randomSeed;
double attValue;

Instance newInst = new Instance(data.numAttributes());
newInst.setDataset(data);

// Get class label
randomSeed = random.nextLong();
attValue = m_Distributions[attr.index()].newValue(randomSeed);
newInst.setValue(attr, attValue);
}
}

return newInst;
}

/********************/
/********************/

/**
* Sets the node to a leaf
*/
public final void leafNode() throws Exception {

Padrn 75722

type = false;
unsmoothed.terms[0] = 0;
this.valueNode();
}

/**
* Takes a constant value as the function at the node
*/
public final void valueNode() throws Exception {
int i;

valueNode = true;
unsmoothed.coeffs[0] = 0.0;
for(i=0;i<=instances.numInstances()-1;i++)
unsmoothed.coeffs[0] += instances.instance(i).classValue();
unsmoothed.coeffs[0] /= instances.numInstances();
}

/**
* Prunes the model tree
* @param modelType determines what kind a model is constructed, a model tree,
* a regression tree or a simple linear regression
* @param pruningFactor the pruning factor influences the size of the pruned tree
*/
public final void prune() throws Exception {

int list[];
double eps1,eps2,va;
Errors e1,e2;
Function function;

if(type == false){ // LEAF
numParameters = 1;
}
else { // NODE
if(model == LINEAR_REGRESSION){ // outputs linear regression model
function = new Function(instances);
if(function.terms[0] < Math.sqrt(instances.numInstances())*2.0 &&
function.terms[0] < 50)unsmoothed = function;
this.regression(unsmoothed);
valueNode = false;
type = false;
}
else {
leftNode.prune(); // prunes the left node
rightNode.prune(); // pruned the right node

if(model != REGRESSION_TREE){ // model tree
}
else unsmoothed = new Function(); // regression tree

numParameters = leftNode.numParameters + rightNode.numParameters + 1;

this.function(); // computes linear model at node

e1 = unsmoothed.errors(instances); // errors of the linear model
eps1 = e1.rootMeanSqrErr * this.factor(instances.numInstances(),
unsmoothed.terms[0]+1,pruningFactor);

Padrn 75722

e2 = this.errors(instances,false); // errors of the subtree
numParameters,pruningFactor);
errors = e2;
if(eps1 <= eps2 || eps1 < deviation * 0.00001) { // chooses linear model
type = false;
numParameters = unsmoothed.terms[0]+1;
errors = e1;
}
}
}
}

/**
* Computes the coefficients of a linear model using the instances at this
* node
* @param function the linear model containing the index of the attributes;
* coefficients are to be computed
*/
public final void regression(Function function){

int i,j,n,k;
Matrix x,y;

n = instances.numInstances();
k = function.terms[0]+1;
x = new Matrix(n,k);
y = new Matrix(n,1);
for(i=0;i<=n-1;i++){
x.elements[i][0] = 1.0;
for(j=1;j<=k-1;j++)
x.elements[i][j] = instances.instance(i).value(function.terms[j]);
y.elements[i][0] = instances.instance(i).value(instances.classIndex());
}

function.coeffs = x.regression(y,n,k);
}

/**
* Finds the appropriate order of the unsmoothed linear model at this node
*/
public final void function() throws Exception {

int n,jmin,flag=0;
double err1,err2,sdy;
Errors e1,e2;
Function f1 = unsmoothed;
Function f2;

if(f1.terms[0]!=0){
sdy = M5Utils.stdDev(instances.classIndex(),instances);
this.regression(f1);
valueNode = false;
if(model != LINEAR_REGRESSION){
e1 = f1.errors(instances);
err1 = e1.rootMeanSqrErr * this.factor(instances.numInstances(),
f1.terms[0]+1,pruningFactor);
flag = 0;

while(flag==0){
jmin = f1.insignificant(sdy,instances);
if(jmin==-1)flag = 1;
else {

Padrn 75722

f2 = f1.remove(jmin);
if(err2 > err1 && err2 > deviation * 0.00001) flag = 1;
else { // compare estimated error with and without attr jmin
f1 = f2;
err1 = err2;
if(f1.terms[0]==0) flag = 1;
}
}
}
}
unsmoothed = f1;
}
if(unsmoothed.terms[0] == 0){ // constant function without attributes
this.valueNode();
}
}

/**
* Calculates a multiplication factor used at this node
* @param n the number of instances
* @param v the number of the coefficients
* @pruningFactor the pruning factor
* @return multiplication factor
*/
public final double factor(int n,int v,double pruningFactor) {

double factor=0.0;

if(n <= v)return 10.0; /* Caution */
factor = (double)(n+pruningFactor*v)/(double)(n-v);

return factor;
}

/**
* Smoothens all unsmoothed formulae at the tree leaves under this node.
*/
public final void smoothen()
{
smoothed = unsmoothed.copy();
if(upNode != null)
this.smoothenFormula(this);
}
else {
leftNode.smoothen();
rightNode.smoothen();
}
}

/**
* Recursively smoothens the unsmoothed linear model at this node with the
* unsmoothed linear models at the nodes above this
* @param current the unsmoothed linear model at the up node of the
* 'current' will be used for smoothening
*/
public final void smoothenFormula(Node current) {

int i=smoothed.terms[0],j=current.upNode.unsmoothed.terms[0],k,l,
smoothingConstant=15;

Padrn 75722

Function function;

function = Function.combine(smoothed,current.upNode.unsmoothed);

function.coeffs[0] =
M5Utils.smoothenValue(smoothed.coeffs[0],
current.upNode.unsmoothed.coeffs[0],
current.instances.numInstances(),
smoothingConstant);
for(k=function.terms[0];k>=1;k--){
if(i>=1 && j>=1){
if(function.terms[k]==smoothed.terms[i] && function.terms[k]==
current.upNode.unsmoothed.terms[j]){
function.coeffs[k] =
M5Utils.smoothenValue(smoothed.coeffs[i],
current.upNode.unsmoothed.coeffs[j],
smoothingConstant);
i--;j--;
}
else if(function.terms[k]==smoothed.terms[i] &&
function.terms[k]!=current.upNode.unsmoothed.terms[j]){
0.0,
smoothingConstant);
i--;
}
else if(function.terms[k]!=smoothed.terms[i] &&
function.terms[k]==current.upNode.unsmoothed.terms[j]){
M5Utils.smoothenValue(0.0,
smoothingConstant);
j--;
}
else M5Utils.errorMsg("wrong terms value in smoothing_formula().");
}
else if(i<1&&j<1)break;
else if(j>=1){
for(l=k;l>=1;l--)
function.coeffs[l] =
current.upNode.unsmoothed.coeffs[j--],
smoothingConstant);
break;
}
else {
for(l=k;l>=1;l--)
M5Utils.smoothenValue(smoothed.coeffs[i--],
0.0,
smoothingConstant);
break;
}
}
smoothed = function;
if(current.upNode.upNode != null) this.smoothenFormula(current.upNode);
}


Padrn 75722

/**
* Converts the predictions by the tree under this node to a string
* @param insta instances
* @param smooth =ture using the smoothed models; otherwise, the unsmoothed
*/
public final String predictionsToString(Instances inst,int lmNo,
boolean smooth) throws Exception {
int i,lmNum;
double value;

text.append(" Predicting test instances (" +
inst.attribute(inst.classIndex()).name() + ", column "
+ (inst.classIndex()+1) +")\n\n");
for(i=0;i<=inst.numInstances()-1;i++){
lmNum = this.leafNum(inst.instance(i));
if(lmNo==0 || lmNo==lmNum){
text.append(" Predicting " + i + " (LM" + lmNum + "): ");
text.append(inst.instance(i).toString() + "\n");
value = this.predict(inst.instance(i),smooth);
if(inst.instance(i).classIsMissing() == false)
text.append(" Actual value: " +
M5Utils.doubleToStringG(inst.instance(i).classValue(),9,4) +
" Prediction: " + M5Utils.doubleToStringG(value,9,4) +
" Abs. error: " +
M5Utils.doubleToStringG(Math.abs(inst.instance(i).classValue()-value),9,4) +
"\n\n");
else text.append(" Actual value: missing Prediction: " +
M5Utils.doubleToStringG(value,9,4) +
" Abs. Error: undefined\n\n");
}
}

}

/**
* Detects which leaf a instance falls into
* @param i instance i
* @return the leaf no.
*/
public final int leafNum(Instance instance) {

int lmNum=0;

if(type == false){
lmNum = lm;
}
else {
if (instance.value(splitAttr) <= splitValue)
lmNum = leftNode.leafNum(instance);
else lmNum = rightNode.leafNum(instance);
}

return lmNum;
}

/**
* Predicts the class value of an instance by the tree
* @smooth =true, uses the smoothed model; otherwise uses the unsmoothed

Padrn 75722

* @inst instances
* @return the predicted value
*/
public final double predict(Instance instance,boolean smooth) {

double y=0.0;

if(type == false) { // LEAF
if(smooth==true){
y = smoothed.predict(instance);
}
else {
if(valueNode == true) y = unsmoothed.coeffs[0];
else y = unsmoothed.predict(instance);
}
}
else { // NODE
if(instance.value(splitAttr) <= splitValue)
y = leftNode.predict(instance,smooth);
else y = rightNode.predict(instance,smooth);
}

return y;
}

/**
* Evaluates a tree
* @smooth =true, evaluates the smoothed models;
* =false, evaluats the unsmoothed models
* @return the evaluation results
*/
public final Errors errors(Instances inst,boolean smooth) throws Exception
{
int i;
double tmp;
Errors e = new Errors(0,inst.numInstances()-1);

tmp = this.predict(inst.instance(i),smooth) - inst.instance(i).classValue();
e.sumErr += tmp;
e.sumAbsErr += Math.abs(tmp);
e.sumSqrErr += tmp * tmp;
}

e.meanAbsErr = e.sumAbsErr / e.numInstances;
e.meanSqrErr = (e.sumSqrErr - e.sumErr * e.sumErr/e.numInstances)
/ e.numInstances;
e.meanSqrErr = Math.abs(e.meanSqrErr);
e.rootMeanSqrErr = Math.sqrt(e.meanSqrErr);

return e;
}

/**
* Computes performance measures of a tree
* @param smooth =true uses the smoothed models;
* otherwise uses the unsmoothed models
* @return the performance measures
*/
public final Measures measures(Instances inst,boolean smooth) throws Exception {

Padrn 75722

int i,numInstances,count;
double sd,y1[],y2[];
Measures measures = new Measures();

errors = this.errors(inst,smooth);
numInstances = errors.numInstances - errors.missingInstances;
y1 = new double[numInstances];
count=0;
y1[count] = this.predict(inst.instance(i),smooth);
y2[count] = inst.instance(i).classValue();
count++;
}

measures.correlation = M5Utils.correlation(y1,y2,numInstances);

sd = M5Utils.stdDev(inst.classIndex(),inst);
if(sd > 0.0){
measures.meanAbsErr = errors.meanAbsErr;
measures.meanSqrErr = errors.meanSqrErr;
measures.type=0;
}
else {
if(numInstances >= 1){
measures.type=1;
}
else {
measures.type=2;
measures.meanAbsErr = 0.0;
measures.meanSqrErr = 0.0;
}
}

return measures;
}

/**
* Computes performance measures for both unsmoothed and smoothed models
*/
public final Measures[] validation(Instances inst) throws Exception {

Measures measures[] = new Measures[2];

// without smoothing
measures[0] = this.measures(inst,false);

// with smoothing
if(model == MODEL_TREE){
measures[1] = this.measures(inst,true);
}
else measures[1] = new Measures();

return measures;
}

/**
* Makes a copy of the tree under this node
* @param up the parant node of the new node

Padrn 75722

* @return a copy of the tree under this node
*/
public final Node copy(Node up) throws Exception {

Node node = new Node(instances,upNode);

node.type = type;
node.splitAttr = splitAttr;
node.splitValue = splitValue;
node.unsmoothed = unsmoothed.copy();
node.smoothed = smoothed.copy();
node.valueNode = valueNode;
node.upNode = up;
if(errors == null) node.errors = null;
else node.errors = errors.copy();
node.numParameters = node.numParameters;
if(sf == null) node.sf = null;
else node.sf = sf.copy();
node.instances = new Instances(instances,0,
instances.numInstances());
node.lm = lm;

node.model = model;
node.pruningFactor = pruningFactor;
node.deviation = deviation;

if(leftNode != null) node.leftNode = leftNode.copy(node);
else node.leftNode = null;
if(rightNode != null) node.rightNode = rightNode.copy(node);
else node.rightNode = null;

return node;
}

/**
* Converts the performance measures into a string
* @param measures[] contains both the unsmoothed and smoothed measures
* @param inst the instances
* @param lmNo also converts the predictions by all linear models if lmNo=0,
* or one linear model spedified by lmNo.
* @param verbosity the verbosity level
* @param str the type of evaluation, one of
* "t" for training, "T" for testing,
* "f" for fold training, "F" for fold testing,
* "x" for cross-validation
*/
public final String measuresToString(Measures measures[],Instances
inst,int lmNo,int verbosity,String str) throws
Exception {

double absDev,sd;

absDev = M5Utils.absDev(inst.classIndex(),inst);

text.append(" Without smoothing:\n\n");
if((verbosity>=2 || lmNo !=0) &&
(str.equals("T") == true || str.equals("F") == true))
text.append(predictionsToString(inst,lmNo,false));
text.append(measures[0].toString(absDev,sd,str,"u") + "\n\n");

Padrn 75722

text.append(" With smoothing:\n\n");
text.append(this.predictionsToString(inst,lmNo,true));
text.append(measures[1].toString(absDev,sd,str,"s") + "\n\n");

}

}

C.3.2 Clase Node

/*
* Node.java
* Created by Romina Laura Bot, 2004
*
*/

package weka.classifiers.trepanM5;

import java.io.*;
import java.util.*;
import weka.core.*;

/**
* Class for handing a node in the tree or the subtree under this node
*/

public final class Node implements Serializable {
boolean type; // = true, NODE; = false, LEAF
int splitAttr; // splitting attribute
double splitValue; // the value of the splitting attribute at the
// splitting position
Function unsmoothed; // unsmoothed function
Function smoothed; // smoothed function
boolean valueNode; // =true, if use the constant term as the
// predicting function
Node upNode; // pointer of the up node
Node leftNode; // pointer of the left node
Node rightNode; // pointer of the right node
Errors errors; // evaluation errors of the model under this node
int numParameters; // number of parameters of the chosen model for this
// node, either the subtree model or the linear model
SplitInfo sf; // Spliting infomation
int lm; // linear model number at the leaf; for NODE, lm = 0;
Instances instances; // instances reaching this node

int model; // model type: LINEAR REGRESSION, REGRESSION_TREE,
// MODEL_TYPE
double pruningFactor; // to control the tree size
double deviation; // deviation of the gobal class variable

final static int LINEAR_REGRESSION=1;
final static int REGRESSION_TREE=2;
final static int MODEL_TREE=3;
final static double SPLIT_NUM = 3.5; // a node will not be further split

Padrn 75722

// if it contains instances less than SPLIT_NUM

/**** TREPAN ****/

// Random variable
private Random random = new Random(0);


/**
* Constructs a new node
*/
public Node(Instances inst, Node up){
int i;

type = true;
valueNode = true;
upNode = up;
leftNode = null;
rightNode = null;
errors = null;
numParameters = 0;
instances = inst;
lm = 0;
if(up != null) {
model = up.model;
pruningFactor = up.pruningFactor;
deviation = up.deviation;
}
}

/**
* Constructs the root of a tree
* @param options the options
*/
public Node(Instances inst, Node up,Options options){
int i;

type = true;
valueNode = true;
upNode = up;
leftNode = null;
rightNode = null;
errors = null;
numParameters = 0;
instances = inst;
lm = 0;

model = options.model;
pruningFactor = options.pruningFactor;
deviation = options.deviation;
}


Padrn 75722

/**
* Converts the information stored at this node to a string
*/
public final String singleNodeToString() throws Exception {


text.append("Print single node (" + instances.numInstances() + "):\n");
if(type==true)text.append(" Type:\t\t\tNODE\n");
else text.append(" Type:\t\t\tLEAF\n");
text.append(" Unsmoothed function:\t\t");
unsmoothed.toString(instances,0);
System.out.print(" Smoothed function:\t\t");
smoothed.toString(instances,0);
text.append(" Value node:\t\t\t" + valueNode + "\n");
if(errors!=null)text.append(errors.toString());
if(upNode != null) text.append(" upNode:\t\t\tyes\n");
else text.append(" upNode:\t\t\tnull\n");
if(leftNode != null) text.append(" leftNode:\t\t\tyes\n");
else text.append(" leftNode:\t\t\tnull\n");
if(rightNode != null) text.append(" rightNode:\t\t\tyes\n");
else text.append(" rightNode:\t\t\tnull\n");
text.append(" number of parameters:\t" + numParameters +"\n");
text.append(" LEAF number(lm):\t\t" + lm +"\n");
text.append(" Number of instances\t\t" + instances.numInstances() +"\n");

}

/**
* Converts the tree under this node to a string
* @param treeLevel the depth of this node;
* the root of a tree should have treeLevel = 0
* @param deviation the global deviation of the class column,
* used for evaluating relative errors
*/
public final String treeToString(int treeLevel,double deviation) {

int i;

if(type == true) {
text.append("\n");
text.append(instances.attribute(splitAttr).name() + " <= " +
else text.append(instances.attribute(splitAttr).name() + " false : ");
treeLevel++;
text.append(leftNode.treeToString(treeLevel,deviation));
treeLevel--;
text.append(instances.attribute(splitAttr).name() + " > " +
else text.append(instances.attribute(splitAttr).name() + " true : ");
treeLevel++;
text.append(rightNode.treeToString(treeLevel,deviation));
treeLevel--;
}

Padrn 75722

else{ // LEAF
text.append("LM" + lm);
if(deviation > 0.0)
text.append(" (" + instances.numInstances() + "/" +
M5Utils.doubleToStringG((100. * errors.rootMeanSqrErr /
deviation),1,3) + "%)\n");
else text.append(" (" + instances.numInstances() + ")\n");
}

}

/**
* Counts the number of linear models in the tree.
*/
public final int numberOfLinearModels() {

return 1;
} else {
return leftNode.numberOfLinearModels() +
rightNode.numberOfLinearModels();
}
}

/**
* Converts all the linear models at the leaves under the node to a string
* @param smooth either the smoothed models if true, otherwise
* the unsmoothed are converted
*/
public final String formulaeToString(boolean smooth) throws Exception {
int startingPoint;

if(type == true) {
text.append(leftNode.formulaeToString(smooth));
text.append(rightNode.formulaeToString(smooth));
}
else {
text.append(" LM" + lm + ": ");
startingPoint = 6 + (int)(Math.log(lm +0.5)/Math.log(10)) + 1 + 3;
if(smooth == true) text.append(smoothed.toString(instances,startingPoint));
else text.append(unsmoothed.toString(instances,startingPoint));
text.append("\n");
}

}

/**
* Sets the leaves' numbers
* @param leafCounter the number of leaves counted
* @return the number of the total leaves under the node
*/
public final int numLeaves(int leafCounter)
{
if(type == true) { // NODE
lm = 0;
leafCounter = leftNode.numLeaves(leafCounter);
leafCounter = rightNode.numLeaves(leafCounter);
}
else{ // LEAF

Padrn 75722

leafCounter++;
lm = leafCounter;
}
return leafCounter;
}

/**
* Splits the node recursively, unless there are few instances or
* instances have similar values of the class attribute
*/
public final void split(Instances inst, int minSamples, Classifier oracle)
throws Exception {
SplitInfo s,sMax;
int j, partition;
Instances leftInst,rightInst;
Instances trainExamples;

instances = inst;

/**** TREPAN ****/
// Create new instances to evaluate split at node

trainExamples = new Instances(instances);

// Create query instances
if (minSamples > trainExamples.numInstances()) {
trainExamples = drawSample (minSamples, oracle, trainExamples);
}

if(trainExamples.numInstances() < SPLIT_NUM ||
M5Utils.stdDev(instances.classIndex(),instances) < deviation * 0.05)
type = false;
else {

sMax = new SplitInfo(0,trainExamples.numInstances()-1,-1);
s = new SplitInfo(0,trainExamples.numInstances()-1,-1);
for(j=0;j<trainExamples.numAttributes();j++){
if(j != trainExamples.classIndex()){
trainExamples.sort(trainExamples.attribute(j));
s.attrSplit(j,trainExamples);
if((Math.abs(s.maxImpurity - sMax.maxImpurity) > 1.e-6) &&
(s.maxImpurity > sMax.maxImpurity + 1.e-6))
sMax = s.copy();
}
}

if(sMax.splitAttr < 0 || sMax.position < 1 || sMax.position >
trainExamples.numInstances()-1) type = false;
if(type == true){
sf = sMax;
splitAttr = sMax.splitAttr; // split attribute
splitValue = sMax.splitValue; // split value
unsmoothed = new Function(splitAttr); // unsmoothed function

trainExamples = null;


leftInst = new Instances(instances, instances.numInstances());

Padrn 75722

rightInst = new Instances(instances, instances.numInstances());
for (int i = 0; i < instances.numInstances(); i++)
if (instances.instance(i).value(splitAttr) <= splitValue)
leftInst.add(instances.instance(i));
else
rightInst.add(instances.instance(i));
leftInst.compactify();
rightInst.compactify();

if (leftInst.numInstances() == 0 || rightInst.numInstances() == 0) {
type = false;
//splitAttr = null;
//splitValue = null;
} else {

leftNode = new Node(leftInst,this);
//System.out.println("split left");
leftNode.split(leftInst, minSamples, oracle); // split left node

rightNode = new Node(rightInst,this);
//System.out.println("split right");
rightNode.split(rightInst, minSamples, oracle); // split right node

this.valueNode(); // function of the constant value

if(model != REGRESSION_TREE){
// passes up the attributes found under the left node
// passes up the attributes found under the right node
}
else unsmoothed = new Function();
}
}
}

if(type==false){ // a leaf node
this.leafNode();
}
}

/****************/
/**** TREPAN ****/
/****************/

/**
*
* @data instances that reached the node
*/
public Instances drawSample (int minSamples, Classifier oracle, Instances data)
throws Exception {

/**
m_Distributions = Vector de distribuciones, una posicion por atributo de
las instancias. Cada posicion del vector corresponde a la distribucion

Padrn 75722

de un atributo de la instancia, y se identifica con el indice del
atributo dentro de la instancia. Cada distribucion, es la distribucion
de los valores de ese atributo
*/

double dClass;
Instance inst;
int m_NumAttr = data.numAttributes();
TrepanEstimator [] m_Distributions = new TrepanEstimator [m_NumAttr];

// Distributions
} else {
}
}

// Instances to be created
int m_CountQueryEx = minSamples - data.numInstances();

Enumeration enumInst = data.enumerateInstances();
inst = (Instance) enumInst.nextElement();
/** Para cada instancia tomo los atributos */
}
}
}

inst = drawInstance(data, m_Distributions);
dClass = oracle.classifyInstance(inst);
// Add instance to dataset
data.add(inst);
}

return data;
}

/**
*
* @data dataset
* @m_Distributions attribute distributions
*/
private Instance drawInstance (Instances data,
TrepanEstimator [] m_Distributions) {

Padrn 75722

long randomSeed;
double attValue;

Instance newInst = new Instance(data.numAttributes());
newInst.setDataset(data);

// Get class label
randomSeed = random.nextLong();
attValue = m_Distributions[attr.index()].newValue(randomSeed);
newInst.setValue(attr, attValue);
}
}

return newInst;
}

/********************/
/********************/

/**
* Sets the node to a leaf
*/
public final void leafNode() throws Exception {
type = false;
unsmoothed.terms[0] = 0;
this.valueNode();
}

/**
* Takes a constant value as the function at the node
*/
public final void valueNode() throws Exception {
int i;

valueNode = true;
unsmoothed.coeffs[0] = 0.0;
for(i=0;i<=instances.numInstances()-1;i++)
unsmoothed.coeffs[0] += instances.instance(i).classValue();
unsmoothed.coeffs[0] /= instances.numInstances();
}

/**
* Prunes the model tree
* @param modelType determines what kind a model is constructed, a model tree,
* a regression tree or a simple linear regression
* @param pruningFactor the pruning factor influences the size of the pruned tree
*/
public final void prune() throws Exception {

int list[];
double eps1,eps2,va;
Errors e1,e2;

Padrn 75722

Function function;

if(type == false){ // LEAF
numParameters = 1;
}
else { // NODE
if(model == LINEAR_REGRESSION){ // outputs linear regression model
function = new Function(instances);
if(function.terms[0] < Math.sqrt(instances.numInstances())*2.0 &&
function.terms[0] < 50)unsmoothed = function;
this.regression(unsmoothed);
valueNode = false;
type = false;
}
else {
leftNode.prune(); // prunes the left node
rightNode.prune(); // pruned the right node

if(model != REGRESSION_TREE){ // model tree
}
else unsmoothed = new Function(); // regression tree

numParameters = leftNode.numParameters + rightNode.numParameters + 1;

this.function(); // computes linear model at node

e1 = unsmoothed.errors(instances); // errors of the linear model
unsmoothed.terms[0]+1,pruningFactor);
e2 = this.errors(instances,false); // errors of the subtree
numParameters,pruningFactor);
errors = e2;
if(eps1 <= eps2 || eps1 < deviation * 0.00001) { // chooses linear model
type = false;
numParameters = unsmoothed.terms[0]+1;
errors = e1;
}
}
}
}

/**
* Computes the coefficients of a linear model using the instances at this
* node
* @param function the linear model containing the index of the attributes;
* coefficients are to be computed
*/
public final void regression(Function function){

int i,j,n,k;
Matrix x,y;

n = instances.numInstances();
k = function.terms[0]+1;
x = new Matrix(n,k);
y = new Matrix(n,1);
for(i=0;i<=n-1;i++){
x.elements[i][0] = 1.0;
for(j=1;j<=k-1;j++)

Padrn 75722

x.elements[i][j] = instances.instance(i).value(function.terms[j]);
y.elements[i][0] = instances.instance(i).value(instances.classIndex());
}

function.coeffs = x.regression(y,n,k);
}

/**
* Finds the appropriate order of the unsmoothed linear model at this node
*/
public final void function() throws Exception {

int n,jmin,flag=0;
double err1,err2,sdy;
Errors e1,e2;
Function f1 = unsmoothed;
Function f2;

if(f1.terms[0]!=0){
sdy = M5Utils.stdDev(instances.classIndex(),instances);
valueNode = false;
if(model != LINEAR_REGRESSION){
flag = 0;

while(flag==0){
jmin = f1.insignificant(sdy,instances);
if(jmin==-1)flag = 1;
else {
f2 = f1.remove(jmin);
if(err2 > err1 && err2 > deviation * 0.00001) flag = 1;
else { // compare estimated error with and without attr jmin
f1 = f2;
err1 = err2;
if(f1.terms[0]==0) flag = 1;
}
}
}
}
unsmoothed = f1;
}
if(unsmoothed.terms[0] == 0){ // constant function without attributes
this.valueNode();
}
}

/**
* Calculates a multiplication factor used at this node
* @param n the number of instances
* @param v the number of the coefficients
* @pruningFactor the pruning factor
* @return multiplication factor
*/
public final double factor(int n,int v,double pruningFactor) {

double factor=0.0;

Padrn 75722

if(n <= v)return 10.0; /* Caution */
factor = (double)(n+pruningFactor*v)/(double)(n-v);

return factor;
}

/**
* Smoothens all unsmoothed formulae at the tree leaves under this node.
*/
public final void smoothen()
{
smoothed = unsmoothed.copy();
if(upNode != null)
this.smoothenFormula(this);
}
else {
leftNode.smoothen();
rightNode.smoothen();
}
}

/**
* Recursively smoothens the unsmoothed linear model at this node with the
* unsmoothed linear models at the nodes above this
* @param current the unsmoothed linear model at the up node of the
* 'current' will be used for smoothening
*/
public final void smoothenFormula(Node current) {

int i=smoothed.terms[0],j=current.upNode.unsmoothed.terms[0],k,l,
smoothingConstant=15;
Function function;

function = Function.combine(smoothed,current.upNode.unsmoothed);

function.coeffs[0] =
M5Utils.smoothenValue(smoothed.coeffs[0],
current.upNode.unsmoothed.coeffs[0],
smoothingConstant);
for(k=function.terms[0];k>=1;k--){
if(i>=1 && j>=1){
if(function.terms[k]==smoothed.terms[i] && function.terms[k]==
current.upNode.unsmoothed.terms[j]){
smoothingConstant);
i--;j--;
}
else if(function.terms[k]==smoothed.terms[i] &&
function.terms[k]!=current.upNode.unsmoothed.terms[j]){
0.0,
smoothingConstant);
i--;
}
else if(function.terms[k]!=smoothed.terms[i] &&
function.terms[k]==current.upNode.unsmoothed.terms[j]){

Padrn 75722

smoothingConstant);
j--;
}
else M5Utils.errorMsg("wrong terms value in smoothing_formula().");
}
else if(i<1&&j<1)break;
else if(j>=1){
for(l=k;l>=1;l--)
current.upNode.unsmoothed.coeffs[j--],
smoothingConstant);
break;
}
else {
for(l=k;l>=1;l--)
M5Utils.smoothenValue(smoothed.coeffs[i--],
0.0,
smoothingConstant);
break;
}
}
smoothed = function;
if(current.upNode.upNode != null) this.smoothenFormula(current.upNode);
}

/**
* Converts the predictions by the tree under this node to a string
* @param insta instances
* @param smooth =ture using the smoothed models; otherwise, the unsmoothed
*/
public final String predictionsToString(Instances inst,int lmNo,
boolean smooth) throws Exception {
int i,lmNum;
double value;

text.append(" Predicting test instances (" +
inst.attribute(inst.classIndex()).name() + ", column "
+ (inst.classIndex()+1) +")\n\n");
lmNum = this.leafNum(inst.instance(i));
if(lmNo==0 || lmNo==lmNum){
text.append(" Predicting " + i + " (LM" + lmNum + "): ");
text.append(inst.instance(i).toString() + "\n");
value = this.predict(inst.instance(i),smooth);
if(inst.instance(i).classIsMissing() == false)
text.append(" Actual value: " +
M5Utils.doubleToStringG(inst.instance(i).classValue(),9,4) +
" Prediction: " + M5Utils.doubleToStringG(value,9,4) +
" Abs. error: " +
M5Utils.doubleToStringG(Math.abs(inst.instance(i).classValue()-value),9,4) +
"\n\n");
else text.append(" Actual value: missing Prediction: " +
M5Utils.doubleToStringG(value,9,4) +

Padrn 75722

" Abs. Error: undefined\n\n");
}
}

}

/**
* Detects which leaf a instance falls into
* @return the leaf no.
*/
public final int leafNum(Instance instance) {

int lmNum=0;

if(type == false){
lmNum = lm;
}
else {
if (instance.value(splitAttr) <= splitValue)
lmNum = leftNode.leafNum(instance);
else lmNum = rightNode.leafNum(instance);
}

return lmNum;
}

/**
* Predicts the class value of an instance by the tree
* @smooth =true, uses the smoothed model; otherwise uses the unsmoothed
* @inst instances
* @return the predicted value
*/
public final double predict(Instance instance,boolean smooth) {

double y=0.0;

if(type == false) { // LEAF
if(smooth==true){
y = smoothed.predict(instance);
}
else {
if(valueNode == true) y = unsmoothed.coeffs[0];
else y = unsmoothed.predict(instance);
}
}
else { // NODE
if(instance.value(splitAttr) <= splitValue)
y = leftNode.predict(instance,smooth);
else y = rightNode.predict(instance,smooth);
}

return y;
}

/**
* Evaluates a tree
* @smooth =true, evaluates the smoothed models;
* =false, evaluats the unsmoothed models
* @return the evaluation results

Padrn 75722

*/
public final Errors errors(Instances inst,boolean smooth) throws Exception
{
int i;
double tmp;
Errors e = new Errors(0,inst.numInstances()-1);

tmp = this.predict(inst.instance(i),smooth) - inst.instance(i).classValue();
e.sumErr += tmp;
e.sumAbsErr += Math.abs(tmp);
e.sumSqrErr += tmp * tmp;
}

e.meanAbsErr = e.sumAbsErr / e.numInstances;
e.meanSqrErr = (e.sumSqrErr - e.sumErr * e.sumErr/e.numInstances)
/ e.numInstances;
e.meanSqrErr = Math.abs(e.meanSqrErr);
e.rootMeanSqrErr = Math.sqrt(e.meanSqrErr);

return e;
}

/**
* Computes performance measures of a tree
* @param smooth =true uses the smoothed models;
* otherwise uses the unsmoothed models
* @return the performance measures
*/
public final Measures measures(Instances inst,boolean smooth) throws Exception {

int i,numInstances,count;
double sd,y1[],y2[];
Measures measures = new Measures();

errors = this.errors(inst,smooth);
numInstances = errors.numInstances - errors.missingInstances;
count=0;
y1[count] = this.predict(inst.instance(i),smooth);
y2[count] = inst.instance(i).classValue();
count++;
}

measures.correlation = M5Utils.correlation(y1,y2,numInstances);

if(sd > 0.0){
measures.type=0;
}
else {
if(numInstances >= 1){
measures.type=1;
}
else {

Padrn 75722

measures.type=2;
measures.meanAbsErr = 0.0;
measures.meanSqrErr = 0.0;
}
}

return measures;
}

/**
* Computes performance measures for both unsmoothed and smoothed models
*/
public final Measures[] validation(Instances inst) throws Exception {

Measures measures[] = new Measures[2];

// without smoothing
measures[0] = this.measures(inst,false);

// with smoothing
if(model == MODEL_TREE){
measures[1] = this.measures(inst,true);
}
else measures[1] = new Measures();

return measures;
}

/**
* Makes a copy of the tree under this node
* @param up the parant node of the new node
* @return a copy of the tree under this node
*/
public final Node copy(Node up) throws Exception {

Node node = new Node(instances,upNode);

node.type = type;
node.splitAttr = splitAttr;
node.splitValue = splitValue;
node.unsmoothed = unsmoothed.copy();
node.smoothed = smoothed.copy();
node.valueNode = valueNode;
node.upNode = up;
if(errors == null) node.errors = null;
else node.errors = errors.copy();
node.numParameters = node.numParameters;
if(sf == null) node.sf = null;
else node.sf = sf.copy();
node.instances = new Instances(instances,0,
instances.numInstances());
node.lm = lm;

node.model = model;
node.pruningFactor = pruningFactor;
node.deviation = deviation;

if(leftNode != null) node.leftNode = leftNode.copy(node);
else node.leftNode = null;
if(rightNode != null) node.rightNode = rightNode.copy(node);
else node.rightNode = null;

Padrn 75722

return node;
}

/**
* Converts the performance measures into a string
* @param measures[] contains both the unsmoothed and smoothed measures
* @param inst the instances
* @param lmNo also converts the predictions by all linear models if lmNo=0,
* or one linear model spedified by lmNo.
* @param verbosity the verbosity level
* @param str the type of evaluation, one of
* "t" for training, "T" for testing,
* "f" for fold training, "F" for fold testing,
* "x" for cross-validation
*/
public final String measuresToString(Measures measures[],Instances
inst,int lmNo,int verbosity,String str) throws
Exception {

double absDev,sd;

absDev = M5Utils.absDev(inst.classIndex(),inst);

text.append(" Without smoothing:\n\n");
text.append(predictionsToString(inst,lmNo,false));
text.append(measures[0].toString(absDev,sd,str,"u") + "\n\n");
text.append(" With smoothing:\n\n");
text.append(this.predictionsToString(inst,lmNo,true));
text.append(measures[1].toString(absDev,sd,str,"s") + "\n\n");

}

}


Padrn 75722

D. Software

Bot Tesisdegradoingenieriainformatica

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Bot Tesisdegradoingenieriainformatica

Cargado por

Copyright:

Formatos disponibles

Facultad de Ingeniera de la Universidad de Buenos Aires

Universidad de Buenos Aires Data Mining utilizando Redes Neuronales

También podría gustarte