Ingenieria Informatica - Arboles de Decicion - ID3 C4.5

ALGORITMOS TDIDT APLICADOS A LA

MINERIA DE DATOS INTELIGENTE

TESIS DE GRADO EN INGENIERIA INFORMATICA

FACULTAD DE INGENIERIA UNIVERSIDAD DE BUENOS AIRES

LABORATORIO DE SISTEMAS INTELIGENTES

TESISTA: Srta. Magdalena SERVENTE DIRECTOR: Prof. Dr. Ramón GARCIA MARTINEZ

FEBRERO 2002

Algoritmos TDIDT aplicados a la Minería de Datos Inteligente

Resumen Magdalena Servente

RESUMEN La Minería de Datos (Data Mining) es la búsqueda de patrones interesantes y de regularidades

importantes en grandes bases de datos. El Aprendizaje Automático es el campo de la Ingeniería

Informática en el que se estudian y desarrollan algoritmos que implementan los distintos modelos de

aprendizaje y su aplicación a la resolución de problemas prácticos. La minería de datos inteligente utiliza

métodos de aprendizaje automático para descubrir y enumerar patrones presentes en los datos.

Uno de los métodos más conocidos para describir los atributos de una entidad de una base de datos es

utilizar un árbol de decisión o de clasificación, que puede transformarse sin inconveniente a un conjunto

de reglas de decisión.

En este contexto, el propósito de este proyecto es estudiar de que manera la familia TDIDT, que aborda el

problema de inducir árboles de decisión, puede utilizarse para descubrir automáticamente reglas de

negocio a partir de la información disponible en una base de datos. Se trabajó en particular con los

métodos ID3 y C4.5, miembros de dicha familia. El trabajo contempla el diseño, especificación e

implementación de un ambiente de minería de datos que integra ambos algoritmos. Además, se desarrolló

un método de evaluación de los resultados para determinar la calidad de las reglas obtenidas.

Palabras clave: minería de datos, aprendizaje automático, árboles de decisión, reglas de decisión,

TDIDT, ID3, C4.5

ABSTRACT Data mining is the search of interesting patterns and relevant regularities in large data bases. Machine

Learning is the Informatic Engineering’s field devoted to the analysis and development of algorithms

implementing the different learning models and their application to the solution of practical problems.

Intelligent data mining uses machine learning methods to find and list the patterns present in the data.

One of the best known methods to describe the attributes of an entity of a data base is the use of a

decision or classification tree, which can easily be turned into a set of decision rules.

Within this context, the purpose of the present project is to analyze the way in which the TDIDT family,

which studies the problem of inducing decision trees, can be used to discover automatically business rules

from the information available in a data base.


Resumen Magdalena Servente

The work was focused in the ID3 and C4.5 methods, which belong to the family above mentioned. The

work includes the design, specification and implementation of a data mining system that combines both

algorithms. Furthermore, to determine the quality of the rules obtained, an evaluation method of the

corresponding results was developed.

Keywords: data mining, machine learning, decision trees, decision rules, TDIDT, ID3, C4.5


Indice Magdalena Servente i


ii Magdalena Servente Indice

INDICE

CAPÍTULO 1: INTRODUCCIÓN 1

CAPÍTULO 2: ESTADO DEL ARTE 5

2.1. Aprendizaje Automático 6

2.1.1. Clasificación general de los sistemas de Aprendizaje Automático 8

2.1.2. Esquema general de un sistema de Aprendizaje Automático 8

2.1.2.1. Aprendizaje de conceptos 8

2.1.2.2. Representación de conceptos 10

2.1.3. Aprendizaje 11

2.1.3.1. Aprendizaje supervisado y no supervisado 11

2.1.3.2. Tipos de aprendizaje automático 12

2.1.3.3 Métodos clásicos de aprendizaje 14

2.2. Minería de Datos 14

2.2.1. Descubrimiento de conocimientos 15

2.2.2. Problemas inherentes al proceso de aprendizaje 16

2.2.3. Tareas realizadas por un sistema de Minería de Datos 17

2.2.4. Métodos de Minería de Datos 18

2.2.5. Componentes de la Minería de Datos 20

2.2.5.1. Algoritmos de Clasificación (Classification Algorithms) 20

2.2.5.2. Algoritmos de reglas de asociación 21

2.2.5.3. Análisis de Secuencias 22

2.3. Aprendizaje Automático y Minería de Datos 22

2.3.1. Aplicaciones 23

2.3.1.1. ID3 23

2.3.1.2. C4.5 24

2.3.1.3. AQ15 24

2.3.1.4. CN2 24

2.3.1.5. DBLearn 25

2.3.1.6. Meta-Dendral 25

2.3.1.7. RADIX/RX 26

2.3.1.8. BACON 26

2.3.1.9. SLIQ 26

2.4 La Familia TDIDT 27

2.4.1. Construcción de los árboles de decisión 27


Indice Magdalena Servente iii

2.4.1.1. Cálculo de la Ganancia de Información 28

2.4.1.2. Datos Numéricos 29

2.4.1.3. Poda de los árboles generados 30

2.4.1.4. El Principio de Longitud de Descripción Mínima 31

2.4.2. Atributos Desconocidos 32

2.4.2.1. Estudio sobre datos con atributos desconocidos en la Inducción 33

2.4.3. Transformación a Reglas de Decisión 35

2.5.Evaluación de los Métodos de Aprendizaje 36

2.5.1 Evaluación en la familia TDIDT 37

2.5.2. Métodos de evaluación 37

2.5.2.1. Evaluación Cruzada (Cross-Validation) 37

2.5.2.2 Dejar-uno-afuera (Leave-one-out) 39

2.5.2.3. Bootstrap 39

2.5.3. Estimación del costo 40

CAPÍTULO 3: DESCRIPCIÓN DEL PROBLEMA 43

3.1. Contexto del Problema 43

3.2. Aplicación de los Algoritmos de la Familia TDIDT a la Minería de Datos 44

CAPÍTULO 4: SOLUCIÓN PROPUESTA 47

4.1. Características Generales 48

4.1.1. Marco teórico 48

4.1.2. Datos de Entrada 49

4.1.3. Resultados Generados 50

4.1.3.1. Características de los árboles de decisión 50

4.1.3.2. Características de las reglas de decisión 51

4.1.3.3. Presentación de los resultados 51

4.2. Descripción General de los Algoritmos 52

4.2.1. División de los datos 52

4.2.1.1. Elección del criterio de división 53

4.3. ID3 55

4.3.1. Descripción del ID3 56

4.3.1.1. Algoritmo ID3 57

4.3.1.2. Poda de los árboles de decisión 57

4.3.1.3. Pasaje a reglas de decisión 57

4.3.1.4. Atributos desconocidos 58


iv Magdalena Servente Indice

4.3.1.5. Resolución de un ejemplo utilizando el ID3 58

4.3.2. Limitaciones al ID3 62

4.3.2.1. Valores continuos 62

4.3.2.3. Ventanas 63

4.4. C4.5 64

4.4.1. Algoritmo C4.5 64

4.4.2. Características particulares del C4.5 65

4.4.2.1. Pruebas utilizadas 65

4.4.2.2. Pruebas sobre atributos continuos 65

4.4.2.2. Atributos desconocidos 66

4.4.3. Poda de los Árboles de Decisión 68

4.4.3.1. ¿Cuándo debemos simplificar? 69

4.4.3.2. Poda en Base a Errores 70

4.4.4. Estimación de la Proporción de Errores para los Árboles de Decisión 72

4.4.5. Construcción de un árbol de decisión utilizando el C4.5 72

4.4.6. Generalización de reglas 76

4.4.6.1. Conjuntos de Reglas 77

4.4.6.2. Orden de las clases y elección de la clase por defecto 80

4.4.6.3. Generalización de un árbol de decisión a reglas de decisión utilizando el C4.5 80

4.5. Sistema integrador 83

4.5.1. Descripción general 83

4.5.2. Diseño del sistema integrador 85

4.5.2.1. Diseño para el ID3 85

4.5.2.2. Diseño para el C4.5 90

CAPÍTULO 5: RESULTADOS OBTENIDOS 97

5.1. Interpretación de los resultados 97

5.1.1. Interpretación de resultados en el ID3 97

5.1.1.1. Árboles de decisión 97

5.1.1.2. Reglas de decisión 98

5.1.2. Interpretación de resultados en el C4.5 98

5.1.2.1. Árboles de decisión 98

5.1.2.2. Reglas de decisión 100

5.2. Descripción de los dominios 100

5.2.1. Créditos 101

5.2.2. Cardiología 102

5.2.3. Votaciones 102


Indice Magdalena Servente v

5.2.4. Estudio sobre hongos 103

5.2.5. Elita: Base de Asteroides 104

5.2.6. Hipotiroidismo 105

5.2.7. Identificación de vidrios 106

5.3. Resultados Obtenidos con el ID3 107


5.3.1.1. ID3 utilizando la ganancia como criterio de decisión 108

5.3.1.2. ID3 utilizando la proporción ganancia como criterio de decisión 110

5.3.1.3. Conclusiones 112











5.3.4.2 ID3. utilizando la proporción ganancia como criterio de decisión 132


5.4. Resultados Obtenidos con el C4.5 135


5.4.1.1. Utilizando la ganancia como criterio de decisión 135

5.4.1.2. Utilizando la proporción de ganancia como criterio de decisión 137




5.4.2.2. Utilizando la proporción ganancia como criterio de decisión 142










5.4.5. Elita 158


vi Magdalena Servente Indice




5.4.6. Hipotiroidismo 163




5.4.7. Identificación de vidrios 169




5.5. Comparación de los resultados obtenidos con el ID3 y con el C4.5 177





5.6. Análisis general de los resultados obtenidos 187

5.6.1. Porcentaje de error 187

5.6.2. Cantidad de datos de entrenamiento 188

CAPÍTULO 6: CONCLUSIONES 191

6.1. Conclusiones Generales 191

6.1.1. Conceptos destacables 191

6.1.2. Espacio de hipótesis 192

6.2. Análisis de los Resultados Obtenidos 193

6.3. Análisis de la solución propuesta 193

6.4. Una mirada al futuro 195

6.4.1. Atributos multivaluados en el ID3 y el C4.5 195

6.4.2. El futuro de la Minería de Datos Inteligente 196

ANEXO A: MANUAL DEL USUARIO 197

A.1. Características Generales 197

A.2. Funcionalidad 198

A.2.1. Pantalla principal 198


Indice Magdalena Servente vii

A.2.2. Descripción del menú 198

A.2.2.1. Menú Resolución 199

A.2.2.2. Menú Evaluación 199

A.2.2.3. Menú Opciones 200

A.2.2.4. Menú Ayuda 201

ANEXO B: CONJUNTOS DE DATOS 203

ANEXO C: DOCUMENTACIÓN DEL SISTEMA 205

C.1. Interacción de los Módulos 205

C.2. Descripción de los archivos fuente 206

C.2.1. TDIDT.cpp 206

C.2.2. Módulos de pantallas principales 207

C.2.2.1. UPrincipal 207

C.2.2.2. UInfoGral 207

C.2.3. Módulos de opciones generales 207

C.2.3.1. UBD 207

C.2.3.2. UCambioTabla 207

C.2.3.3. frmOpcionesSist 207

C.2.3.4. UElegirRendimiento 208

C.2.3.5. URendimiento 208

C.2.3.6. UArbol 208

C.2.4. Módulos de minería de datos 208

C.2.4.1. UDMID3 208

C.2.4.2. UDMC45 209

C.2.5. Módulos de clases de datos 209

C.2.5.1. UTipos 209

C.2.5.2. Types.h 209

C.2.5.3. Defns.h 209

C.2.5.4. Rulex.h 209

C.3. Estructuras de datos 209

C.3.1. Estructuras de datos generales 209

C.3.2. Estructuras de datos del ID3 210

C.3.4. Estructuras de datos del C4.5 211

ANEXO D: CÓDIGO FUENTE 213

D.1. TDIDT.cpp 213


viii Magdalena Servente Indice

D.2. Módulos de Pantallas Principales 214

D.2.1. UPrincipal 214

D.2.1.1. UPrincipal.h 214

D.2.1.1. UPrincipal.cpp 215

D.2.2. UInfoGral 217

D.2.2.1. UInfoGral.h 217

D.2.2.2. UInfoGral.cpp 218

D.3. Módulos de opciones generales 219

D.3.1. UBD 219

D.3.1.1. UBD.h 219

D.3.1.2. UBD.cpp 219

D.3.2. UCambioTabla 220

D.3.2.1. UCambioTabla.h 220

D.3.2.2. UCambioTabla.cpp 220

D.3.3. frmOpcionesSist 223

D.3.3.1. frmOpcionesSist.h 223

D.3.3.2. frmOpcionesSist.cpp 224

D.3.4. UElegirRendimiento 225

D.3.4.1. UElegirRendimiento.h 225

D.3.4.2. UElegirRendmiento.cpp 226

D.3.5. URendimiento 228

D.3.5.1. URendimiento.h 228

D.3.5.2. URendmiento.cpp 228

D.3.6. Uarbol 229

D.3.6.1. UArbol.h 229

D.3.6.2. UArbol.cpp 229

D.4. Módulos de minería de datos 231

D.4.1. UDMID3 231

D.4.1.1. UDMID3.h 231

D.4.1.2. UDMID3.cpp 233

D.4.2. UDMC45 251

D.4.2.1. UDMC45.h 251

D.4.2.2. UDMC45.cpp 256

D.5. Módulos de clases de datos 332

D.5.1. UTipos 332

D.5.1.1. UTipos.h 332

D.5.1.2. UTipos.cpp 333

D.5.2. Types.h 337


Indice Magdalena Servente ix

D.5.3. Defns.h 339

D.5.4. Rulex.h 339

REFERENCIAS 341


Introducción Magdalena Servente 1

CAPÍTULO 1

INTRODUCCIÓN

La Minería de Datos (Data Mining) es la búsqueda de patrones interesantes y de regularidades

importantes en grandes bases de datos [Fayad et al., 1996- Grossman et al., 1999]. Al hablar de minería

de datos inteligente [Evangelos, 1996, Michalski et al., 1998] nos referimos específicamente a la

aplicación de métodos de aprendizaje automático u otros métodos similares, para descubrir y enumerar

patrones presentes en los datos.

El Aprendizaje Automático es el campo de la Ingeniería Informática en el que se estudian y desarrollan

algoritmos que implementan los distintos modelos de aprendizaje y su aplicación a la resolución de

problemas prácticos [Michalski, 1983- Dejong & Money 1986; Bergadano et al., 1992]. Entre los

problemas abordados en este campo, está el de inducir conocimientos a partir de datos o ejemplos

[Michalski, 1983,1991; Michie, 1988; García Martínez, 1994]. Esto resulta una alternativa de solución a

problemas que no pueden ser resueltos mediante algoritmos tradicionales, entre los cuales podemos

mencionar especificación de condiciones asociadas a diagnósticos técnicos o clínicos, identificación de

características que permitan reconocimiento visual de objetos, descubrimiento de patrones o regularidades

en estructuras de información (en particular en bases de datos de gran tamaño), entre otros.

Los métodos tradicionales de Análisis de Datos incluyen el trabajo con variables estadísticas, varianza,

desviación estándar, covarianza y correlación entre los atributos; análisis de componentes (determinación

de combinaciones lineales ortogonales que maximizan una varianza determinada), análisis de factores

(determinación de grupos correlacionados de atributos), análisis de clusters (determinación de grupos de

conceptos que están cercanos según una función de distancia dada), análisis de regresión (búsqueda de los

coeficientes de una ecuación de los puntos dados como datos), análisis multivariable de la varianza, y

análisis de los discriminantes [Michalski et al., 1982]. Todos estos métodos están orientados

numéricamente. Son esencialmente cuantitativos.

En contraposición, los métodos basados en Aprendizaje Automático, están orientados principalmente

hacia el desarrollo de descripciones simbólicas de los datos, que puedan caracterizar uno o más grupos de

conceptos [García Martínez et al., 1987, Mitchel, 1996], diferenciar entre distintas clases, crear nuevas

clases, crear una nueva clasificación conceptual, seleccionar los atributos más representativos, y ser

capaces de predecir secuencias lógicas [Michalski et al., 1983; 1986; Michalski, Tecuci, 1994]. Son

esencialmente cualitativos.


2 Magdalena Servente Introducción

En las bases de datos las entidades se caracterizan generalmente por el valor de los atributos y no por las

relaciones entre ellas, con lo cual se utilizan métodos atribucionales. Uno de los métodos más conocidos

para describir los atributos de una entidad es utilizar un árbol de decisión o de clasificación [Michalski et

al., 1998Grossman et al., 1999], cuyos nodos corresponden a los atributos, las ramas que salen de ellos

son los valores de los atributos, y las hojas son corresponden a clases individuales. La gran ventaja de los

árboles de clasificación es que se pueden transformar sin inconveniente a un conjunto de reglas de

decisión.

En este contexto, el propósito de este proyecto es estudiar de que manera la familia TDIDT [Quinlan,

1986; 1990], que aborda el problema de inducir árboles de decisión, puede utilizarse para descubrir

automáticamente reglas de negocio a partir de la información disponible en una base de datos.

En el capítulo 2 se presenta el estado actual del Aprendizaje Automático (Sección 2.1), en múltiples

aspectos, que incluyen la clasificación general de este tipo de sistemas (Sección 2.1.1) el esquema general

de un sistema de Aprendizaje Automático (Sección 2.1.2) y los distintos tipos de aprendizaje en general

(Sección 2.1.3). Luego, se presenta el estado actual de la Minería de Datos (Sección 2.2), incluyendo

descripciones de: el descubrimiento de conocimientos (Sección 2.2.1), los problemas inherentes al

aprendizaje de conceptos (Sección 2.2.2), las tareas realizadas por un sistema de Minería de Datos

(Sección 2.2.3), los principales métodos de la Minería de Datos (Sección 2.2.4) y sus componentes

(Sección 2.2.5). A partir de la presentación de estos dos grandes temas, se presentan varias aplicaciones

en las que se realiza Minería de Datos con sistemas de Aprendizaje Automático (Sección 2.3.1), entre los

cuales se encuentra la familia TDIDT (Top-Down-Induction-Trees) (Sección 2.4) en la cual centraremos

nuestra atención. Se explica la construcción de los árboles TDIDT (Sección 2.4.1), el tratamiento de los

atributos desconocidos (Sección 2.4.2), y la transformación de los árboles a reglas de decisión (Sección

2.4.3). Finalmente, se presentan varios métodos utilizados actualmente para evaluar los distintos métodos

de Aprendizaje Automático (Sección 2.5)

En el capítulo 3 se presenta el contexto de nuestro problema de interés (Sección 3.1) y las cuestiones que

los algoritmos ID3 y C4.5 pertenecientes a la familia TDIDT deben resolver (Sección 3.2).

En el capítulo 4 se presentan todos los aspectos de la solución propuesta. Para ello se describen las

características generales de la misma (Sección 4.1): el marco teórico (Sección 4.1.1), las condiciones que

deben cumplir los datos sobre los que se realiza la Minería de Datos (Sección 4.1.2) y los tipos de

resultados obtenidos (Sección 4.1.3). En la Sección 4.2 se presenta una descripción general de los

algoritmos ID3 y C4.5 que se utilizan para estudiar el problema. Se explica cómo realizar la división de

los datos de entrada (Sección 4.2.1) y la elección del criterio de división (Sección 4.2.1.1). Luego, se

presenta una descripción detallada del algoritmo ID3 (Sección 4.3.1) y de sus limitaciones (Sección

4.3.2). A modo de ejemplo, se muestra la utilización del ID3 para generar un árbol y reglas de decisión

(Sección 4.3.1.5). También se detalla el algoritmo C4.5 (Sección 4.4) y sus características particulares

(Sección 4.4.2), las cuales lo diferencian del ID3, resaltando la poda de los árboles de decisión (Sección


Introducción Magdalena Servente 3

4.4.3) y la estimación de errores en dichos árboles (Sección 4.4.4). En la sección 4.4.5 se ejemplifican los

métodos anteriores. La generalización de las reglas de decisión realizada por el C4.5 se explica en la

sección 4.4.6. A continuación, se detalla el diseño del sistema integrador utilizado para estudiar el éxito

de la solución propuesta (Sección 4.5). Para este sistema se presenta una descripción general (Sección

4.5.1) y el diseño de las secciones del sistema para el ID3 (Sección 4.5.2.1) y para el C4.5 (Sección

4.5.2.2)

En el capítulo 5 se presentan los resultados obtenidos. Primero, se explica la manera en que debe

realizarse la interpretación de los mismos (Sección 5.1), se presentan los formatos de los árboles y las

reglas de decisión tanto para el ID3 (Sección 5.1.1) como para el C4.5 (Sección 5.1.2). Luego, se

describen los dominios de datos sobre los que se trabajó (Sección 5.2), y se analizan los resultados

obtenidos con el ID3 (Sección 5.3) y con el C4.5 (Sección 5.4). En cada caso se presenta, el árbol y las

reglas de decisión obtenidos, y la evaluación de resultados sobre el conjunto de datos de prueba. En la

sección 5.5 se comparan los resultados obtenidos con el ID3 y con el C4.5 en los distintos dominios. Y en

la sección 5.6 se realiza un análisis general de los resultados.

En el capítulo 6 se presentan las conclusiones del trabajo realizado. Primero se destacan los conceptos

más importantes a tener en cuenta a la hora de aplicar algún método como el ID3 y el C4.5 (Sección

6.1.1). Luego, se analiza la búsqueda que realizan estos dos métodos en el espacio de hipótesis (Sección

6.1.2). Se extraen conclusiones a partir de los resultados obtenidos (Sección 6.2) y se analiza la solución

propuesta (Sección 6.3). Finalmente, se plantean mejoras y temas a tener en cuenta para continuar con el

desarrollo de este tipo de algoritmos de aprendizaje aplicados a la Minería de Datos (Sección 6.4).

El Anexo A describe el sistema en forma de un resumido manual del usuario. Se describen las

características generales del sistema (Sección A.1) y las funciones de cada uno de los menúes (Sección

A.2), detallando las acciones que pueden realizarse con cada una de las opciones disponibles.

En el Anexo B se detallan los conjuntos de datos utilizados para realizar las pruebas descriptas en el

Capítulo 5. Para cada uno de los dominios, se muestran los conjuntos de datos de entrenamiento y prueba.

Los datos presentados corresponden a los siguientes dominios: Créditos (Sección B.1), Cardiología

(Sección B.2), Votaciones (Sección B.3), Estudio sobre hongos (Sección B.4), Elita: Base de Asteroides

(Sección B.5), Hipotiroidismo (Sección B.6), Identificación de vidrios (Sección B.7).

El Anexo C es un complemento a la explicación de la funcionalidad del sistema de la Sección 4.5. En la

sección C.1 se detalla la interacción entre los módulos del sistema. Las principales funciones de cada uno

de estos módulos se presentan en la sección C.2. En la sección C.3 se detallan las principales estructuras

de datos utilizadas por el sistema


4 Magdalena Servente Introducción

Finalmente, en el anexo D se presenta el código fuente del sistema desarrollado. En la sección D.1 se

presenta el código fuente del archivo TDIDT.cpp que es el archivo inicial del proyecto y es quien

inicializa al resto de los formularios requeridos. En la sección D.2 se presenta el código fuente de las

pantallas principales. A continuación, se detallan los códigos fuentes de los módulos de opciones

generales (Sección D:3), de los módulos de minería de datos (Sección D.4) y de los módulos de clases o

estructuras de datos (Sección D.5)

En las Referencias se detallan la bibliografía y las referencias utilizadas para realizar el trabajo.


Estado del Arte Magdalena Servente 5

CAPÍTULO 2:

ESTADO DEL ARTE

Este capítulo presenta el estado actual del Aprendizaje Automático (Sección 2.1), en múltiples

aspectos, que incluyen la clasificación general de este tipo de sistemas (Sección 2.1.1) el

esquema general de un sistema de Aprendizaje Automático (Sección 2.1.2) y los distintos tipos

de aprendizaje en general (Sección 2.1.3). Luego, se presenta el estado actual de la Minería de

Datos (Sección 2.2), incluyendo descripciones de: el descubrimiento de conocimientos (Sección

2.2.1), los problemas inherentes al aprendizaje de conceptos (Sección 2.2.2), las tareas realizadas

por un sistema de Minería de Datos (Sección 2.2.3), los principales métodos de la Minería de

Datos (Sección 2.2.4) y sus componentes (Sección 2.2.5). A partir de la presentación de estos

dos grandes temas, se presentan varias aplicaciones en las que se realiza Minería de Datos con

sistemas de Aprendizaje Automático (Sección 2.3.1), entre los cuales se encuentra la familia

TDIDT (Top-Down-Induction-Trees) (Sección 2.4) en la cual centraremos nuestra atención. Se

explica la construcción de los árboles TDIDT (Sección 2.4.1), el tratamiento de los atributos

desconocidos (Sección 2.4.2), y la transformación de los árboles a reglas de decisión (Sección

2.4.3). Finalmente, se presentan varios métodos utilizados actualmente para evaluar los distintos

métodos de Aprendizaje Automático (Sección 2.5)

El Aprendizaje Automático (Machine Learning) es el campo dedicado al desarrollo de métodos

computacionales para los procesos de aprendizaje, y a la aplicación de los sistemas informáticos de

aprendizaje a problemas prácticos [Michalski et al, 1998]. La Minería de Datos (Data Mining) es la

búsqueda de patrones e importantes regularidades en bases de datos de gran volumen [Michalski et al,

1998].

Estos dos campos han ido creciendo a lo largo de los años, y han cobrado una importancia considerable.

Hoy en día, como se almacenan grandes volúmenes de información en todas las actividades humanas, la

Minería de Datos está cobrando gran importancia, se busca obtener información valiosa a partir de los

datos guardados. La Minería de Datos utiliza métodos y estrategias de otras áreas o ciencias, entre las

cuales podemos nombrar al Aprendizaje Automático. Cuando este tipo de técnicas se utilizan para realizar

la minería, decimos que estamos ante una Minería de Datos Inteligente.

El campo de aplicación del Aprendizaje Automático, no obstante, no se limita únicamente a la Minería de

Datos, existen múltiples aplicaciones de Aprendizaje Automático en funcionamiento. Si analizamos su

aplicación a la Minería de Datos en particular, encontramos que hay varios métodos que se utilizan con

éxito hoy en día, entre los cuales se encuentran los métodos de inducción. Nuestro análisis se centrará en


6 Magdalena Servente Estado del Arte

una familia de métodos de inducción conocida como la familia TDIDT (Top Down Induction Trees), y en

particular en los algoritmos ID3 y C4.5 desarrollados por Quinlan, pertenecientes a la misma.

2.1. APRENDIZAJE AUTOMÁTICO

El Aprendizaje Automático se enfrenta con el desafío de la construcción de programas computacionales

que automáticamente mejoren con la experiencia [Mitchell, 1997]. Estos programas computacionales son

sistemas de aprendizaje capaces de adquirir conocimientos de alto nivel y/o estrategias para la resolución

de problemas mediante ejemplos, en forma análoga a la mente humana [Michalski et al, 1998]. A partir

de los ejemplos provistos por un tutor o instructor y de los conocimientos de base o conocimientos

previos, el sistema de aprendizaje crea descripciones generales de conceptos.

¿Cómo sabemos si un sistema ha adquirido algún conocimiento? Siguiendo el análisis de Witten [Witten

y Frank, 2000], podemos plantearnos las siguientes preguntas: ¿qué es el aprendizaje?, y ¿qué es el

Aprendizaje Automático? Si buscamos la definición de Aprendizaje en la Enciclopedia, encontraremos

las siguientes definiciones o alguna similar: “Adquirir el conocimiento de alguna cosa por medio del

estudio, de la experiencia o al ser instruido; Concebir alguna cosa por meras apariencias o con poco

fundamento; Tomar algo en la memoria; Ser informado de; recibir instrucción” [Espasa-Calpe, 1974].

Todas estas definiciones se aplican con facilidad a los seres humanos, veamos si pueden aplicarse

también a los sistemas informáticos. En términos de Aprendizaje Automático lo primero que debemos ser

capaces de hacer es determinar si un sistema informático ha aprendido o no. En el caso de las dos

primeras definiciones esto es imposible: no existe ninguna manera de preguntarle si ha adquirido

conocimiento, ya que si le hacemos preguntas acerca de las cosas que debería haber aprendido, no

estaríamos midiendo sus nuevos conocimientos, sino su capacidad de responder preguntas. En cuanto a

las últimas dos definiciones, el hecho de guardar en memoria y recibir instrucciones son triviales para una

computadora, son actividades “vitales” para ella que realiza todo el tiempo. De esto se deduce que una

computadora sería capaz de aprender a la luz de las últimas dos definiciones.

Esta afirmación no tiene nada de novedoso para nosotros. Si un sistema de información es capaz de

aprender, entonces debe ser capaz de aplicar los conocimientos memorizados o instruidos en una nueva

situación. Esto es justamente lo que evaluamos para saber si un ser humano ha aprendido o no, evaluamos

su respuesta ante una nueva situación. Siguiendo esta línea de pensamiento, podemos afirmar entonces

que las cosas (y los seres humanos también) aprenden cuando cambian su comportamiento de manera tal

que les permite desarrollarse mejor en el futuro. A la luz de esta definición que asocia el aprendizaje a la

performance más que al conocimiento, el aprendizaje es más fácil de medir: podemos analizar si un

sistema ha aprendido al ponerlo en una situación en la que estuvo anteriormente y observando si se

desempeña mejor.



Esta definición sigue siendo engañosa. Una gran variedad de objetos modifican su comportamiento de

manera tal que los hacen desempeñarse mejor y, sin embargo, no se puede decir que hayan aprendido.

Tomemos por ejemplo, nuestras mejores pantuflas, ¿podemos decir que han aprendido la forma de

nuestro pie? Sin embargo, han cambiado su forma, su comportamiento para adaptarse mejor a nuestro pie

y ciertamente son más cómodas que cuando eran nuevas. Llamamos entrenamiento al tipo de aprendizaje

que se realiza sin pensar. Entrenamos a los animales y a las plantas, pero hablar del entrenamiento de una

pantufla sería ridículo. El aprendizaje, a diferencia del entrenamiento, requiere pensar, implica tener el

propósito, directo o indirecto, de aprender; alguien o algo que aprende debe tener la intención de hacerlo.

El aprendizaje sin pensar es meramente un entrenamiento. Los sistemas de Aprendizaje Automático

tienen la intención de construir un modelo a partir de los datos de entrada y cambian su comportamiento

de manera tal que son capaces de clasificar nuevos datos y desarrollarse mejor en antiguas situaciones. En

fin, podemos afirmar que los sistemas son capaces de aprender. Aún no sabemos, sin embargo, cómo

hacer para que los sistemas aprendan en el mismo grado que los humanos. No obstante, se han creado

algoritmos efectivos en ciertas tareas de aprendizaje, y el entendimiento teórico del aprendizaje está

comenzando a emerger [Mitchell, 1997].

Para complementar el enfoque anterior, debemos preguntarnos cómo aprenden los seres humanos y

analizar si los si los sistemas son capaces de aprender de la misma manera. Los humanos aprendemos

mediante tres mecanismos distinguibles: inducción, deducción y abducción. Podemos afirmar que los

sistemas aprenden cuando son capaces de generar nuevos conocimientos, por cualquiera de los tres

métodos anteriores [Monter, 2001]. En un sistema de Aprendizaje Automático, dicha generación de

conocimientos se realiza cuando los datos se transforman a un nivel superior que nos es más útil. Por

ejemplo, cuando los datos presentes en una base de datos se transforman en un modelo de datos que los

clasifica según sus características o atributos.

Los algoritmos de la familia TDIDT que analizaremos, justamente construyen un modelo de nivel

superior. ¿Podemos afirmar entonces que son sistemas de Aprendizaje Automático?

El tema fundamental para construir un sistema de aprendizaje automático es, según Mitchell [Mitchell,

1997], plantear el problema de aprendizaje de manera correcta. Para ello, debe contar con las tres partes

esenciales de la siguiente definición:

“Se puede afirmar que un programa computacional es capaz de aprender a partir de la experiencia E con

respecto a un grupo de tareas T y según la medida de performance P, si su performance en las tareas T,

medida según P, mejora con la experiencia E.”

Veremos que esto se cumple para los algoritmos de la familia TDIDT.



2.1.1. Clasificación general de los sistemas de Aprendizaje

Automático

Los sistemas de aprendizaje se clasifican en dos categorías generales: métodos de caja negra y métodos

orientados al conocimiento [Michalski et al, 1998]. Los primeros desarrollan su propia representación de

conceptos, que por lo general no es comprensible para los humanos; normalmente, realizan cálculos

numéricos de coeficientes, distancias o vectores. Entre estos métodos, se encuentran las redes neuronales

y los métodos estadístico-matemáticos. Por otro lado, los métodos orientados al conocimiento tratan de

crear estructuras simbólicas de conocimiento que sean comprensibles para el usuario. El Aprendizaje

Automático pertenece al segundo grupo de métodos.

2.1.2. Esquema general de un sistema de Aprendizaje

Automático

El esquema general de un sistema de Aprendizaje Automático se detalla en la Figura 2.1. El sistema

recibe dos grupos de entradas: los ejemplos y los conocimientos previos y que genera una descripción de

conceptos como salida. Los ejemplos instancian un cierto concepto, lo describen mediante distintos

valores de sus atributos.

Figura 2.1 Características generales de un sistema de Aprendizaje Automático

Los conocimientos previos contienen la información acerca del lenguaje utilizado para describir los

ejemplos y los conceptos, es decir, son una suerte de metalenguaje. El sistema utiliza entonces, los

conocimientos previos para interpretar los ejemplos y para generar descripciones a partir de ellos.

2.1.2.1. Aprendizaje de conceptos

El Aprendizaje Automático trata de extraer conceptos de los datos que recibe como entrada. Por concepto

se entiende una abstracción para un conjunto de objetos que comparten ciertas propiedades que los

diferencian de otros conceptos [Michalski et al, 1998]. Por ejemplo, podríamos decir que el concepto

“ave” se refiere a todos los seres vivos que tienen picos y alas (estas son algunas de las características que

C

ejemplos

conocimientos previosdescripción de conceptos



comparten todas las aves y que las diferencias del resto de los seres vivos). A la luz de esta definición

vemos que si los límites entre conceptos no están claramente definidos, puede no ser fácil clasificar un

ejemplo en particular. Por ejemplo, cuál es el límite entre un edificio alto y un edificio bajo, entre una

mujer atractiva y una no atractiva.

Existen dos técnicas de inferencia generales que se utilizan para extraer descripciones a partir de los

conceptos: la deducción y la inducción. La deducción es la técnica que infiere información como una

consecuencia lógica de los ejemplos y conocimientos de base [Holsheimer, Siebes, 1994]. La inducción

es la técnica que infiere información generalizada de los ejemplos y conocimientos de base.

En la inducción, podemos trabajar con jerarquías de generalización, representadas por árboles o grafos

[Michalski et al, 1998]. En una jerarquía de generalización, un concepto puede describirse por los objetos

del nivel base o por cualquier objeto en un nivel superior. Analizando la Figura 2.2, podemos describir a

la Universidad de Buenos Aires con los objetos de nivel base, en cuyo caso decimos que es una

institución educativa, universitaria y pública; o podemos describirla con los objetos de nivel superior

diciendo que la Universidad de Buenos Aires es una institución educativa.

Figura 2.2 Jerarquía de generalización

En este tipo de jerarquías, podemos identificar tres nociones que relacionan los conceptos: efecto de nivel

básico (basic-level effect), tipicalidad (typicality) y dependencia contextual (contextual dependency)

[Michalski et al, 1998]. El efecto de nivel básico hace referencia al hecho de que los conceptos de nivel

base pueden ser descriptos por características fácilmente identificables por los humanos, lo cual hace que

su aprendizaje sea simple para nosotros. Mientras que los conceptos de nivel superior se definen como

grupos de conceptos de nivel básico que comparten alguna característica en común. La segunda noción,

la tipicalidad, analiza cuán típico es un concepto. Puede medirse de acuerdo a la cantidad de

características comunes que comparte con otros conceptos, y a la cantidad de características heredadas de

los superconceptos (conceptos de nivel superior). En el aprendizaje, la tipicalidad es muy importante, por

ejemplo, tratar de enseñar el concepto de pájaro con los ejemplos de un pingüino, un ganso y un avestruz,

InstitucionesEducativas

Primarias Secundarias Terciarias Universitarias

Públicas Privadas

UBA UTN



no será muy efectivo. En cambio, utilizar una golondrina, un gorrión y una paloma será exitoso. Por

último, la dependencia contextual es importante porque los conceptos aprendidos dependen del contexto

en el que estamos. Al definir estudiantes podemos estar pensando en estudiantes universitarios,

estudiantes primarios, o estudiantes del curso de Análisis Matemático; el concepto que estamos tratando

de enseñar, dependerá del contexto en el que estamos.

2.1.2.2. Representación de conceptos

La primera cuestión que debe solucionar el Aprendizaje Automático al encarar el problema de

aprendizaje, es cómo representar los conceptos, es decir, cómo llevar los ejemplos, conocimientos base y

conceptos obtenidos a un lenguaje entendible por una computadora, que sea también, fácilmente

interpretable por el usuario (recordemos que los métodos de Aprendizaje Automático son orientados al

conocimiento y no cajas negras). Algunos métodos que el Aprendizaje Automático utiliza para

representar los datos, en orden ascendente en cuanto a complejidad y capacidad expresiva, son [Michalski

et al, 1998]: Lógica de orden cero (lógica proposicional), lógica de atributos, lógica de predicados de

primer orden y lógica de segundo orden, entre otros.

En la lógica de orden cero, los ejemplos y conceptos se describen como conjunciones de constantes

booleanas que representan valores de los atributos. El poder descriptivo de este tipo de lógica es bajo, por

lo cual, el Aprendizaje Automático lo utiliza únicamente para describir conceptos muy simples. Un

ejemplo de una cláusula en lógica de orden cero es:

Juego_Tenis <= Día_soleado ^ No_hay_viento ^ Poca_humedad

Para solucionar el problema del bajo poder descriptivo de la lógica de orden cero, puede utilizarse la

lógica de atributos. La idea básica detrás de la lógica de atributos es caracterizar los ejemplos y conceptos

como valores de algunos atributos predefinidos. En lugar de utilizar conjunciones de valores fijos, cada

atributo es una variable. El poder descriptivo de la lógica de atributos es mayor que el de la lógica de

orden cero, aunque en sentido matemático la expresividad es la misma. Una cláusula en lógica de

atributos podría ser “Juego_Tenis <= Pronóstico ^ Viento ^ Humedad). Los ejemplos generalmente se

presentan en una tabla donde cada fila representa un ejemplo y cada columna, un atributo. La tabla 2.1

contiene ejemplos positivos y negativos para los días en que es posible jugar al tenis.

Objeto Pronóstico Viento Humedad Juego_TenisDía 1 Sol No Poca SiDía 2 Lluvia Ráfagas Poca NoDía 3 Nublado Ventoso Poca NoDía 4 Sol Ventoso Alta SiDía 5 Nublado No Alta No

Tabla 2.1 Ejemplos positivos y negativos del concepto Juego_Tenis <= Pronóstico ^ Viento ^ Humedad



Como lenguaje descriptivo, la lógica de atributos es mucho más práctica que la lógica de orden cero. Por

eso, es utilizada en muchos programas de Aprendizaje Automático, como los de la familia TDIDT

(Árboles inductivos de arriba hacia abajo - Top-Down Induction Trees).

La lógica de predicados de primer orden utiliza las cláusulas de Horn para representar conceptos. Estas

cláusulas simplifican las descripciones complicadas mediante el uso de predicados y variables. Son

bastante potentes, incluso permiten la expresión de conceptos recursivos. El lenguaje Prolog se basa en la

lógica de predicados de primer orden. Este tipo de lógica se utiliza en algunos programas de Aprendizaje

Automático, como el algoritmo FOIL. Un ejemplo de una cláusula de Horn sería:

Abuelo(X,Z) :- Padre(X,Y), Padre(Y,Z)

Por último, la lógica de predicados de segundo orden considera a los nombres de los predicados como

variables. La expresión anterior quedaría de la forma:

p(X,Z) :- q(X,Y), q(Y,Z)

donde p es Abuelo y q es Padre.

Este tipo de lógica es la de mayor poder descriptivo. Sin embargo, dada su complejidad rara vez se utiliza

en los sistemas de Aprendizaje Automático.

2.1.3. Aprendizaje

2.1.3.1. Aprendizaje supervisado y no supervisado

Existen dos tipos de aprendizaje: el supervisado y el no supervisado [Michalski et al, 1998], [Holsheimer,

Siebes, 1994]. En el aprendizaje supervisado o aprendizaje a partir de ejemplos, el instructor o experto

define clases y provee ejemplos de cada una. El sistema debe obtener una descripción para cada clase.

Cuando el instructor define una única clase, provee ejemplos positivos (pertenecen a la clase) y negativos

(no pertenecen a la clase). En este caso, los ejemplos importantes son los cercanos al límite, porque

proveen información útil sobre los límites de la clase. Cuando el instructor define varias clases, el sistema

puede optar por realizar descripciones discriminantes o no. Un conjunto de descripciones es discriminante

si el total de las descripciones cubren todas las clases, pero una descripción cubre una sola clase en

particular.



En el aprendizaje no supervisado o aprendizaje a partir de observaciones y descubrimientos, el sistema

debe agrupar los conceptos1 sin ayuda alguna de un instructor. El sistema recibe los ejemplos, pero no se

predefine ninguna clase. Por lo tanto, debe observar los ejemplos y buscar características en común que

permitan formar grupos. Como resultado, este tipo de aprendizaje genera un conjunto de descripciones de

clases, que juntas cubren todas las clases y en particular describen a una única clase.

2.1.3.2. Tipos de aprendizaje automático

Existen varios tipos de aprendizaje que pueden clasificarse como supervisados o no supervisados. A

continuación, se presentan los distintos tipos de aprendizaje automático[García Martínez, 1997].

• Aprendizaje por memorización

• Aprendizaje por instrucción

• Aprendizaje por deducción

• Aprendizaje por analogía

• Aprendizaje por inducción

• Aprendizaje por ejemplos

• Aprendizaje por observación - descubrimiento

• Observación pasiva

• Experimentación activa

En el aprendizaje por memorización los sistemas reciben conocimientos del medio ambiente y los

guardan sin ningún tipo de procesamiento. Su complejidad se encuentra en el almacenamiento de los

conocimientos y no en su adquisición. Lo importante en estos casos es que la información esté disponible

1 También conocido como formación de clusters.



cuando se requiera; no hay ningún tipo de inferencia ni procesamiento, por lo tanto, los conocimientos

deben ser adquiridos y almacenados en un nivel que los haga directamente utilizables.

En el caso del aprendizaje por instrucción, los conocimientos son provistos por un instructor o experto en

la materia (aprendizaje supervisado). La información provista es abstracta o de índole general, por lo

tanto, el sistema tendrá que inferir los detalles. Es decir, el sistema deberá transformar la información

provista en términos abstractos de alto nivel, a reglas que puedan ser utilizadas directamente en la tarea

del sistema.

El aprendizaje por deducción o aprendizaje guiado por la especificación destaca o especifica las

relaciones existentes entre conceptos. El sistema transforma las especificaciones recibidas como entrada

en un algoritmo que actualiza relaciones.

En el aprendizaje por analogía, el sistema, que recibe información relevante a problemas análogos a los

que está tratando de resolver, debe descubrir las analogías e inferir reglas aplicables al problema. Se trata

de generar nuevos conocimientos utilizando información preexistente.

En el aprendizaje por inducción, el sistema genera nuevos conocimientos que no están presentes en forma

implícita dentro del conocimiento disponible. El aprendizaje por inducción abarca el aprendizaje por

ejemplos y el aprendizaje por observación y descubrimiento.

En el aprendizaje por ejemplos, el sistema recibe varios ejemplos como entrada y debe generalizarlos en

un proceso inductivo para presentarlos como salida. Generalmente, en este tipo de aprendizaje existen dos

tipos de ejemplos, los positivos y los negativos. Los ejemplos positivos fuerzan la generalización,

mientras que los ejemplos negativos previenen que esta sea excesiva. Se trata de que el conocimiento

adquirido cubra todos los ejemplos positivos y ningún ejemplo negativo. A este tipo de aprendizaje

pertenece la familia TDIDT. Debe tenerse en cuenta, que los ejemplos a partir de los cuales aprende el

sistema, deben ser representativos de los conceptos que se está tratando de enseñar. Además, la

distribución de las clases en el conjunto de ejemplos de entrenamiento, a partir de los que el sistema

aprende, debe ser similar a la distribución existente en los datos sobre los cuales se aplicará el modelo

resultante.

En el aprendizaje por observación y descubrimiento, el sistema forma teorías o criterios de clasificación

en jerarquías taxonómicas, a partir de la inducción realizando tareas de descubrimiento. Pertenece al tipo

de aprendizaje no supervisado y, como tal, permite que el sistema clasifique la información de entrada

para formar conceptos. Existen dos formas en las que el sistema interactúa con el entorno: la observación

pasiva, en la cual el sistema clasifica las observaciones de múltiples puntos del medio; y la observación

activa, en la cual el sistema observa el entorno, realiza cambios en el mismo, y luego analiza los

resultados.



2.1.3.3 Métodos clásicos de aprendizaje

Existen dos métodos clásicos de aprendizaje inductivo a partir de ejemplos que debemos conocer: el

aprendizaje AQ y el aprendizaje según el método de divide y reinarás [Michalski et al, 1998].

2.1.3.3.1 Aprendizaje AQ

El aprendizaje AQ se basa en la idea de cubrir progresivamente los datos de entrenamiento a medida que

se generan reglas de decisión. Su esencia está en la búsqueda de un conjunto de reglas (conjunciones de

pares atributo-valor o predicados arbitrarios) que cubran todos los ejemplos positivos y ningún ejemplo

negativo. En lugar de dividir los ejemplos en subconjuntos, el aprendizaje AQ generaliza, paso a paso, las

descripciones de los ejemplos positivos seleccionados [Michalski et al, 1998].

2.1.3.3.2 Aprendizaje divide y reinarás

El aprendizaje “divide y reinarás” particiona el conjunto de ejemplos en subconjuntos sobre los cuales se

puede trabajar con mayor facilidad. En la lógica proposicional, por ejemplo, se parte el conjunto de

acuerdo a los valores de un atributo en particular, entonces, todos los miembros de un subconjunto

tendrán un mismo valor para dicho atributo. Dentro de este tipo de aprendizaje, encontramos la familia

TDIDT (Top-Down Induction Trees), la cual se explica con mayor detalle en la Sección 2.4

2.2. MINERÍA DE DATOS

La enorme cantidad de bases de datos en todas las áreas de aplicación humana, demanda nuevas y

poderosas técnicas de transformación de los datos en conocimientos útiles. Entre dichas técnicas podemos

nombrar a las pertenecientes al aprendizaje automático, el análisis estadístico de datos, la visualización de

datos, y las redes neuronales. La Minería de Datos se refiere a la aplicación de técnicas de aprendizaje

automático, entre otros métodos, para encontrar importantes patrones en los datos. El descubrimiento de

conocimientos pone su énfasis en el ciclo de análisis de datos en sí, analiza su ciclo de vida.

La Minería de Datos busca generar información similar a la que podría producir un experto humano, que

además satisfaga el Principio de Comprensibilidad. La Minería de Datos es el proceso de descubrir

conocimientos interesantes, como patrones, asociaciones, cambios, anomalías y estructuras significativas



a partir de grandes cantidades de datos almacenadas en bases de datos, data warehouses, o cualquier otro

medio de almacenamiento de información.

La Minería de Datos es un campo en pleno desarrollo en el que se aplican métodos de varias disciplinas

como los presentes en sistemas de bases de datos, data warehousing, estadística, el Aprendizaje

Automático, visualización de datos, obtención de información y computación de alta performance.

Además también se utilizan métodos de las áreas de redes neuronales, reconocimiento de patrones,

análisis espacial de datos, bases de datos de imágenes, procesamiento de señales y programación lógica

inductiva (ILP). Numerosos especialistas señalan que la Minería de Datos necesita de la integración de

enfoques de múltiples disciplinas [Mitchell, 1997].

Una gran cantidad de métodos de análisis de datos han sido desarrollados en estadística. El Aprendizaje

Automático ha contribuido en el área de clasificación e inducción. Las redes neuronales, por su lado, son

efectivas en la clasificación, predicción y clustering de datos. Sin embargo, con la gran cantidad de datos

almacenados en las bases de datos sobre los cuales se debe hacer la minería de datos, todos estos métodos

deben re-analizarse o escalarse para ser efectivos.

Además para procesar grandes volúmenes de datos de los cuales deben extraerse patrones

automáticamente, es necesario contar con una gran capacidad computacional de procesamiento. Es

necesario, entonces, desarrollar métodos de minería de datos distribuidos, paralelos e incrementales.

2.2.1. Descubrimiento de conocimientos

La Minería de Datos no debe confundirse con el descubrimiento de conocimientos (knowledge discovery),

aunque muchos investigadores consideran que la Minería de Datos no es más que un paso esencial en el

descubrimiento de conocimientos. En general, un proceso de descubrimiento de conocimientos consiste

de una repetición iterativa de los siguientes pasos [S/A, 1999]:

• Limpieza de datos (Data cleaning) procesamiento de los datos ruidosos, erróneos, faltantes o

irrelevantes

• Integración de datos (Data integration) integración de múltiples fuentes heterogéneas de datos en

una única fuente.

• Selección de datos (Data selection) extracción de los datos relevantes al área de análisis del

almacenamiento de datos.



• Transformación de datos (Data transformation) transformación o consolidación de los datos en

formas apropiadas para la minería mediante procedimientos de agregación.

• Minería de Datos: proceso esencial donde se aplican diversos métodos para extraer patrones de los

datos.

• Evaluación de patrones (Pattern evaluation) identificación de patrones interesantes basándose en

algún parámetro de comparación impuesto por el usuario.

• Presentación de los conocimientos (Knowledge presentation) técnicas de visualización y

representación de los conocimientos obtenidos.

Con los sistemas de bases de datos relacionales existentes hoy en día, los cuatro procesos iniciales:

limpieza, integración, selección y transformación de datos pueden realizarse mediante la construcción de

data warehouses. Los procesos de minería de datos, evaluación de patrones y presentación de

conocimientos generalmente se agrupan en el proceso que se conoce como Minería de Datos. De ahí la

confusión que puede llegar a existir con el nombre.

2.2.2. Problemas inherentes al proceso de aprendizaje

Una de las mayores clases de exploración de datos está basada en métodos para el aprendizaje inductivo

simbólico a partir de ejemplos. Dado un conjunto de ejemplos de clases de decisión diferentes y

conocimientos de base, el aprendizaje inductivo genera descripciones para cada clase. En este sentido

debe enfrentarse a varios problemas como [Michalski et al, 1998]:

• Aprendizaje a partir de datos incorrectos

• Aprendizaje a partir de datos incompletos

• Aprendizaje a partir de datos distribuidos

• Aprendizaje a partir de conceptos que evolucionan a través del tiempo

• Aprendizaje a partir de datos que se obtienen a través del tiempo

• Aprendizaje a partir de datos subjetivos



• Aprendizaje a partir de conceptos flexibles

• Aprendizaje de conceptos en distintos niveles de generalización

• Integración de descubrimientos cualitativos y cuantitativos.

• Predicción cualitativa

Cabe destacar que muchos de estos problemas son los mismos con los que se enfrenta un sistema de

Aprendizaje Automático que aprende a partir de ejemplos, que pueden tener imperfecciones o pueden

estar incompletos, o incluso, no ser representativos del problema que se está analizando.

2.2.3. Tareas realizadas por un sistema de Minería de Datos

Un sistema de Minería de Datos actual realiza una o más de las siguientes tareas:

• Descripción de clases: provee una clasificación concisa y resumida de un conjunto de datos y los

distingue unos de otros. La clasificación de los datos se conoce como caracterización, y la distinción

entre ellos como comparación o discriminación.

• Asociación: es el descubrimiento de relaciones de asociación o correlación en un conjunto de datos.

Las asociaciones se expresan como condiciones atributo-valor y deben estar presentes varias veces

en los datos.

• Clasificación: analiza un conjunto de datos de entrenamiento cuya clasificación de clase se conoce y

construye un modelo de objetos para cada clase. Dicho modelo puede representarse con árboles de

decisión o con reglas de clasificación, que muestran las características de los datos. El modelo puede

ser utilizado para la mayor comprensión de los datos existentes y para la clasificación de los datos

futuros.

• Predicción: esta función de la minería predice los valores posibles de datos faltantes o la distribución

de valores de ciertos atributos en un conjunto de objetos.

• Clustering: identifica clusters en los datos, donde un cluster es una colección de datos “similares”.

La similitud puede medirse mediante funciones de distancia, especificadas por los usuarios o por

expertos. La Minería de Datos trata de encontrar clusters de buena calidad que sean escalables a

grandes bases de datos y a data warehouses multidimensionales.



• Análisis de series a través del tiempo: analiza un gran conjunto de datos obtenidos con el correr del

tiempo para encontrar en él regularidades y características interesantes, incluyendo la búsqueda de

patrones secuenciales, periódicos, modas y desviaciones.

2.2.4. Métodos de Minería de Datos

La Minería de Datos abarca un terreno muy amplio, no es solamente aplicar un algoritmo existente a un

conjunto de datos. Las herramientas existentes actualmente incluyen mecanismos para la preparación de

los datos, su visualización y la interpretación de los resultados. Muchas de las herramientas funcionan

bien en espacios de pocas dimensiones con datos numéricos, pero sus limitaciones comienzan a aparecer

en espacios de mayores dimensiones o con datos no numéricos. A continuación se presentan algunos

métodos de minería de datos que resuelven distintos problemas inherentes a la misma [Thrun et al, 1998].

• Aprendizaje activo/Diseño Experimental (Active Learning/Experimental design): el aprendizaje

activo, por el lado de la Inteligencia Artificial, y el diseño experimental, por el lado de la Estadística,

tratan de resolver el problema de la elección del método a aplicar durante el aprendizaje. Suponen

que durante el proceso de aprendizaje, existe la oportunidad de influir sobre los datos, recordemos la

diferencia entre la exploración pasiva y la experimentación activa. El aprendizaje activo afronta el

problema de cómo explorar.

• Aprendizaje acumulativo (Cumulative learning): Muchas bases de datos crecen continuamente.

Tomemos por ejemplo, una base de datos sobre transacciones financieras en un banco. Aprender a

partir de bases de datos de este tipo es difícil ya que los datos deben ser analizados acumulativamente

a medida que se incorporan a la base. Nos encontramos entonces ante el desafío de diseñar

algoritmos que puedan incorporar nuevos datos y adaptarse a los cambios generados por la

incorporación de los mismos.

• Aprendizaje multitarea (Multitask learning): Muchos dominios se caracterizan por pertenecer a

familias de problemas de aprendizaje relacionados o similares. Tomemos, por ejemplo, el dominio

médico. Mientras que cada enfermedad posee su aprendizaje individual con bases de datos dedicadas,

muchas enfermedades tienen causas y/o síntomas en común, sería provechoso entonces favorecer el

intercambio de información entre los distintos resultados de los algoritmos.

• Aprendizaje a partir de datos tabulados y no tabulados (Learning from labeled and unlabeled

data): en muchas aplicaciones el problema no está en la obtención de los datos, sino en la tabulación

de los mismos.



• Aprendizaje relacional (Relational Learning): en muchos problemas de aprendizaje las entidades

no se describen a partir de un conjunto estático de atributos, sino a partir de las relaciones entre

entidades. En las bases de datos inteligentes encontrar patrones o relaciones entre entidades es un

problema primordial.

• Aprendiendo a partir de bases de datos de gran tamaño (Learning from extremely large

databases): muchas bases de datos son demasiado grandes como para ser leídas y procesadas por una

computadora más de una vez. Lo cual imposibilita el uso de algoritmos que requieran múltiples

pasadas sobre los datos. Debe afrontarse entonces, el desafío de encontrar algoritmos inteligentes que

sean escalables eficientemente a grandes bases de datos.

• Aprendiendo a partir de bases de datos extremadamente pequeñas (Learning from extremely

small databases): en el otro extremo, existen también bases de datos que son demasiado pequeñas

para los algoritmos existentes. Por ejemplo, en robótica la cantidad de ejemplos es limitada, sin

embargo, muchos de los métodos de aprendizaje actuales requieren un gran número de ejemplos.

Debe encontrarse entonces un método que trabaje eficientemente con un número limitado de datos, o

bien, que se base en el conocimiento previo.

• Aprendiendo con conocimientos previos (Learning with prior knowledge): En muchos casos, se

poseen conocimientos efectivos acerca del fenómeno en estudio. Deben existir métodos capaces de

incorporar conocimientos previos tanto abstractos, como diversos o inciertos.

• Aprendiendo a partir de datos de distintos tipos (Learning from mixed media data): Muchos

juegos de datos contienen varios tipos de datos. Un buen ejemplo, se presenta en las bases de datos

médicas que contienen estadísticas acerca de los pacientes, gráficos, rayos X, etc. La gran mayoría de

los algoritmos actuales sólo pueden trabajar con un único tipo de datos, con lo cual deben encontrarse

métodos capaces de manejar los distintos tipos o formatos de datos presentes en una base de datos.

• Aprendiendo relaciones casuales (Learning casual relationships): La mayoría de los algoritmos de

aprendizaje detectan la correlación entre los datos, pero son incapaces de determinar o modelar las

casualidades, y, por lo tanto, fallan al tratar de predecir algunos efectos externos. Deben diseñarse,

entonces, algoritmos que incorporen las casualidades.

• Visualización y Minería de Datos interactiva (Visualization and Interactive Data Mining): En

muchos casos, la minería de datos es un proceso interactivo, en el cual el análisis de datos automático

se mezcla con las decisiones de control de un experto de campo. Deben diseñarse herramientas que

contemplen el intercambio entre estas dos áreas.



2.2.5. Componentes de la Minería de Datos

La Minería de Datos cuenta con tres grandes componentes [Joshi, 1997]: Clustering o clasificación,

Reglas de asociación y Análisis de Secuencias.

En el Clustering o Clasificación se analizan los datos y se generan conjuntos de reglas que agrupen y

clasifiquen los datos futuros. Debe tenerse en cuenta que en la Minería de Datos se busca obtener reglas

que particionen los datos en clases predefinidas, esto se torna complicado cuando hay una gran cantidad

de atributos y millones de registros.

Una regla de asociación es una regla que implica o presenta ciertas relaciones entre un grupo de objetos

en una base de datos. En el proceso de la Minería de Datos se obtienen varias reglas de este tipo con

distintos niveles de abstracción. Nuevamente, no debemos olvidar que esto puede implicar el análisis

iterativo de bases de datos transaccionales o relacionales, con millones de registros, lo cual presenta un

elevado costo operativo. Por lo tanto, la obtención de reglas a partir de bases de datos relacionales o

transaccionales es un importante tema de estudio.

Por último, el análisis de secuencias trata de encontrar patrones que ocurren con una secuencia

determinada. Trabaja sobre datos que aparecen en distintas transacciones – a diferencia de los datos que

aparecen relacionados mediante reglas dentro de una misma transacción -.

A continuación se presentan ejemplos de algoritmos de Minería de Datos existentes, de cada uno de los

tipos presentados.

2.2.5.1. Algoritmos de Clasificación (Classification Algorithms)

En la Clasificación de Datos se desarrolla una descripción o modelo para cada una de las clases presentes

en la base de datos. Existen muchos métodos de clasificación como aquellos basados en los árboles de

decisión TDIDT como el ID3 y el C4.5, los métodos estadísticos, las redes neuronales, y los conjuntos

difusos, entre otros.

A continuación se describen brevemente aquellos métodos de Aprendizaje Automático que han sido

aplicados a la Minería de Datos con cierto éxito:

• Algoritmos estadísticos: Muchos algoritmos estadísticos han sido utilizados por los analistas para

detectar patrones inusuales en los datos y explicar dichos patrones mediante la utilización de modelos

estadísticos, como, por ejemplo, los modelos lineales. Estos métodos se han ganado su lugar y

seguirán siendo utilizados en los años venideros.



• Redes Neuronales: las redes neuronales imitan la capacidad de la mente humana para encontrar

patrones. Han sido aplicadas con éxito en aplicaciones que trabajan sobre la clasificación de los

datos.

• Algoritmos genéticos: técnicas de optimización que utilizan procesos como el entrecruzamiento

genético, la mutación y la selección natural en un diseño basado en los conceptos de la evolución

natural.

• Método del vecino más cercano: es una técnica que clasifica cada registro de un conjunto de datos

en base a la combinación de las clases de los k registros más similares. Generalmente se utiliza en

bases de datos históricas.

• Reglas de inducción: la extracción de reglas si-entonces a partir de datos de importancia estadística.

• Visualización de los datos: la interpretación visual de las relaciones entre datos multidimensionales

• Clasificadores basados en instancias o ejemplos: Una manera de clasificar un caso es a partir de un

caso similar cuya clase es conocida, y predecir que el caso pertenecerá a esa misma clase. Esta

filosofía es la base para los sistemas basados en instancias, que clasifican nuevos casos refiriéndose a

casos similares recordados. Un clasificador basado en instancias necesita teorías simbólicas. Los

problemas centrales de este tipo de sistemas se pueden resumir en tres preguntas: ¿cuáles casos de

entrenamiento deben ser recordados?, ¿cómo puede medirse la similitud entre los casos?, y ¿cómo

debe relacionarse el nuevo caso a los casos recordados?

Los métodos de aprendizaje basados en reglas de clasificación buscan obtener reglas o árboles de decisión

que particionen un grupo de datos en clases predefinidas. Para cualquier dominio real, el espacio de datos

es demasiado grande como para realizar una búsqueda exhaustiva en el mismo.

En cuanto a los métodos inductivos, la elección del atributo para cada uno de los nodos se basa en la

ganancia de entropía generada por cada uno de los atributos. Una vez que se ha recopilado la información

acerca de la distribución de todas las clases, la ganancia en la entropía se calcula utilizando la teoría de la

información o bien el índice de Gini [Joshi, 1997].

2.2.5.2. Algoritmos de reglas de asociación

Una regla de asociación es una regla que implica ciertas relaciones de asociación entre distintos objetos

de una base de datos, como puede ser: “ocurren juntos” o “uno implica lo otro”. Dado un conjunto de



transacciones, donde cada transacción es un conjunto de ítems, una regla de asociación es una expresión

de la forma XY, donde X e Y son conjuntos de ítems. Un ejemplo de regla de asociación sería: “30% de

las transacciones que contienen niños, también contienen pañales; 2% de las transacciones contienen

ambas cosas”. En este caso el 30% es el nivel de confianza de la regla y 2% es la cantidad de casos que

respaldan la regla. La cuestión está en encontrar todas las reglas de asociación que satisfagan los

requerimientos de confianza mínima y máxima impuestos por el usuario.

2.2.5.3. Análisis de Secuencias

En este caso se trabaja sobre datos que tienen una cierta secuencia entre sí. Cada dato es una lista

ordenada de transacciones (o ítems). Generalmente, existe un tiempo de transacción asociado con cada

dato. El problema consiste en encontrar patrones secuenciales de acuerdo a un límite mínimo impuesto

por el usuario, dicho límite se mide en función al porcentaje de datos que contienen el patrón. Por

ejemplo, un patrón secuencial puede estar dado por los usuarios de un video club que alquilan “Arma

Mortal”, luego “Arma Mortal 2”, “Arma Mortal 3” y finalmente “Arma Mortal 4”, lo cual no implica que

todos lo hagan en ese orden.

2.3. APRENDIZAJE AUTOMÁTICO Y MINERÍA DE DATOS

La automatización del proceso de aprendizaje se conoce como Aprendizaje Automático. La Minería de

Datos es un caso especial de Aprendizaje Automático donde el escenario observado es una base de datos.

Los gráficos que se encuentran a continuación explican este concepto [Holsheimer, Siebes, 1994].

Figura 2.6. Diagrama de Aprendizaje Automático

En la figura 2.6, el entorno E representa el mundo real, el entorno sobre el cual se realiza el aprendizaje. E

representa un número finito de observaciones u objetos que son codificados en algún formato legible para

Aprendizaje Automático. El conjunto de ejemplos codificados constituye el conjunto de entrenamiento

para el sistema de aprendizaje automático.

Por su lado, en la figura 2.7, la codificación C es reemplazada por una base de datos, que modela el

entorno. Cada estado en la base de datos refleja algún estado de E, y cada transición de estados en la base

Cejemplos

codificación de losejemplos

E ML



de datos representa una transición de estados en E. El algoritmo utilizado para realizar la minería de datos

construye entonces un modelo a partir de los datos en la base de datos.

Figura 2.7. Diagrama de Minería de Datos

Aunque a simple vista, la Minería de Datos parece muy similar a Aprendizaje Automático, hay

importantes diferencias que deben tenerse en cuenta. La base de datos generalmente se construye con

fines distintos a la Minería de Datos, con lo cual la base se diseña según los requerimientos del sistema y

no según los requerimientos del algoritmo de aprendizaje.

2.3.1. Aplicaciones

A continuación se describen algunos algoritmos de Aprendizaje Automático que han sido utilizados con

éxito en la Minería de Datos. Algunos de ellos son generales y pueden ser utilizados en varios dominios

de conocimiento, mientras que otros fueron diseñados para dominios particulares.

2.3.1.1. ID3

Este sistema ha sido el que más impacto ha tenido en la Minería de Datos. Desarrollado en los años

ochenta por Quinlan, ID3 significa Induction Decision Trees, y es un sistema de aprendizaje supervisado

que construye árboles de decisión a partir de un conjunto de ejemplos. Estos ejemplos son tuplas

compuestas por varios atributos y una única clase. El dominio de cada atributo de estas tuplas está

limitado a un conjunto de valores. Las primeras versiones del ID3 generaban descripciones para dos

clases: positiva y negativa. En las versiones posteriores, se eliminó esta restricción, pero se mantuvo la

restricción de clases disjuntas. ID3 genera descripciones que clasifican cada uno de los ejemplos del

conjunto de entrenamiento.

Este sistema tiene una buena performance en un amplio rango de aplicaciones, entre las cuales podemos

nombrar, aplicaciones de dominios médicos, artificiales y el análisis de juegos de ajedrez. El nivel de

precisión en la clasificación es alto. Sin embargo, el sistema no hace uso del conocimiento del dominio.

Además, muchas veces los árboles son demasiado frondosos, lo cual conlleva a una difícil interpretación.

En estos casos pueden ser transformados en reglas de decisión para hacerlos más comprensibles.

ejemploscodificación de los

ejemplosE DM

BD



2.3.1.2. C4.5

El C4.5 es una extensión del ID3 que permite trabajar con valores continuos para los atributos, separando

los posibles resultados en dos ramas: una para aquellos Ai<=N y otra para Ai>N. Este algoritmo fue

propuesto por Quinlan en 1993. El algoritmo C4.5 genera un árbol de decisión a partir de los datos

mediante particiones realizadas recursivamente. El árbol se construye mediante la estrategia de

profundidad-primero (depth-first). El algoritmo considera todas las pruebas posibles que pueden dividir el

conjunto de datos y selecciona la prueba que resulta en la mayor ganancia de información. Para cada

atributo discreto, se considera una prueba con n resultados, siendo n el número de valores posibles que

puede tomar el atributo. Para cada atributo continuo, se realiza una prueba binaria sobre cada uno de los

valores que toma el atributo en los datos.

2.3.1.3. AQ15

El AQ15 fue desarrollado por Michalski. Es un sistema de aprendizaje inductivo que genera reglas de

decisión, donde el antecedente es una fórmula lógica. Una característica particular de este sistema es la

inducción constructiva (constructive induction), es decir, el uso de conocimientos del dominio para

generar nuevos atributos que no están presentes en los datos de entrada.

Al igual que el ID3, el AQ15 está diseñado para la generación de reglas fuertes, es decir, que para cada

clase, se construye una regla que cubre todos los ejemplos positivos y ningún ejemplo negativo. El

sistema soluciona el problema de los ejemplos incompletos o inconsistentes mediante un pre o post

procesamiento. En el post procesamiento, además, se reduce de forma drástica la cantidad de reglas

generadas mediante el truncamiento de reglas, el cual no afecta la precisión de las reglas obtenidas.

AQ15 ha sido testeado en dominios médicos, como el diagnóstico en la limfografía, diagnóstico de cáncer

de mama y la ubicación del tumor primario. En estos casos, se obtuvieron reglas con el mismo nivel de

precisión que el de los expertos humanos. En todos los casos, los datos de entrenamiento son conjuntos

chicos, de unos cientos de ejemplos.

2.3.1.4. CN2

El sistema CN2, desarrollado por Clark y Niblett, es una adaptación del AQ15. La gran desventaja del

AQ15 es que elimina los ruidos mediante pre y post procesamiento y no durante la ejecución del

algoritmo. El objetivo del CN2 es, entonces, incorporar el manejo de datos ruidosos al algoritmo en sí.

Combina entonces las técnicas de poda utilizadas en el ID3, con las técnicas de reglas condicionales

utilizadas en el AQ15.



El CN2 genera reglas simples y comprensibles en dominios donde los datos pueden tener ruido.

Construye reglas probabilísticas, es decir, el antecedente en cada regla cubre ejemplos positivos de una

clase, pero también puede cubrir ejemplos de otra clase en menor número. De esta forma no restringe el

espacio de búsqueda únicamente a aquellas reglas inferibles a partir de los ejemplos.

La performance el ID3, AQ15 y CN2 ha sido comparada en dominios médicos y artificiales. Las

estructuras de conocimiento generadas en cada caso son de similar calidad y complejidad.

2.3.1.5. DBLearn

El sistema DBLearn fue diseñado por Cai, Han y Cercone y utiliza conocimientos del dominio para

generar descripciones para subconjuntos predefinidos de una base de datos relacional. Las características

especiales de este sistema son su estrategia de búsqueda de abajo hacia arriba (bottom up); el uso de

conocimientos del dominio como jerarquías de valores de atributos y el uso del álgebra relacional. El

conjunto de entrenamiento es una tabla de datos relacional con n-tuplas.

El sistema DBLearn es relativamente simple, ya que utiliza solo dos operaciones de generalización para

construir los descriptores. La generalización está orientada a los atributos, lo cual limita el conjunto de

descriptores que pueden ser construidos. La performance del sistema es buena, y la complejidad en el

tiempo está en el orden de los O(N logN), siendo N la cantidad inicial de tuplas.

2.3.1.6. Meta-Dendral

El sistema Meta-Dendral es un sistema especial para la generación de reglas de conocimiento en la

estereoscopia. Esta ciencia estudia la estructura tridimensional de la molécula. El Meta-Dendral es

interesante porque utiliza un sistema de representación de conocimientos totalmente diferente a los

anteriores. Al buscar generar reglas que puedan predecir dónde se romperá la estructura de una molécula,

toma las estructuras moleculares como entrada.

El sistema ha sido exitoso para encontrar reglas de fragmentación desconocidas hasta el momento. Sin

embargo, la estrategia de búsqueda es ineficiente, ya que genera muchas reglas de decisión que luego son

eliminadas en la etapa de optimización. Es muy difícil encontrar heurísticas que guíen la búsqueda y no

existen técnicas explícitas que ayuden a eliminar ruidos o a destacar casos especiales.



2.3.1.7. RADIX/RX

El sistema RX se utiliza para el descubrimiento de relaciones en bases de datos clínicas. La diferencia

importante con otros sistemas es que incorpora la noción de tiempo: un dato es un conjunto de ejemplos

que guardan información de un paciente en diferentes momentos, y los conocimientos generados son de

naturaleza causal. El sistema divide su proceso de descubrimiento en dos etapas: primero genera hipótesis

y, luego, utiliza técnicas avanzadas de estadística para validarlas.

El sistema RX fue utilizado en una base de reumatología y sirvió para probar hipótesis acerca de la

cantidad de droga prodnisone que aumenta el colesterol en la sangre. Sin embargo, la principal desventaja

de este sistema es que no utiliza información del dominio para guiar la búsqueda. Una versión mejorada

del RX, el RADIX, sí lo hace.

2.3.1.8. BACON

El sistema BACON utiliza algoritmos de análisis de datos para descubrir relaciones matemáticas entre

datos numéricos. Ha redescubierto leyes como la ley de Ohm para circuitos eléctricos y la ley de

desplazamiento de Arquímides. Los datos de entrenamiento son numéricos y, normalmente, son

generadas en algún experimento previo. Cada tupla esta constituida por los valores de las mediciones

durante el experimento.

El sistema BACON tiene varias desventajas: no considera el ruido en los datos, ni la inconsistencia o los

datos incompletos. Además, considera que todas las variables son relevantes, y explora todas las

soluciones posibles utilizando un grafo, lo cual empeora considerablemente su performance.

2.3.1.9. SLIQ

El algoritmo SLIQ (Supervised Learning In Quest) fue desarrollado por el equipo Quest de IBM. Este

algoritmo utiliza los árboles de decisión para clasificar grandes cantidades de datos. El uso de técnicas de

pre-ordenamiento en la etapa de crecimiento del árbol, evita los costos de ordenamiento en cada uno de

los nodos. SLIQ mantiene una lista ordenada independiente de cada uno de los valores de los atributos

continuos y una lista separada de cada una de las clases. Un registro en la lista ordenada de atributos

consiste en el valor del atributo y un índice a la clase correspondiente en la lista de clases. SLIQ

construye el árbol de forma ancho-primero (breadth-first). Para cada uno de los atributos busca en la lista

correspondiente y calcula los valores de entropía para cada uno de los nodos de la frontera

simultáneamente. A partir de la información obtenida se particionan los nodos de la frontera, y se

expanden para obtener una nueva frontera.



Aunque SLIQ trabaja con datos que pueden estar en disco mientras se ejecuta el algoritmo, necesita que

cierta información resida en memoria permanentemente durante la totalidad de la ejecución del mismo.

Dicha información crece proporcionalmente a la cantidad de registros de entrada, lo cual limita en gran

medida la cantidad de registros de entrenamiento. Para solucionar este problema el equipo de desarrollo

del Quest, ha desarrollado otro algoritmo de clasificación basado en árboles de decisión: el SPRINT

(Scalable PaRallelizable INduction of decision Trees). El SPRINT elimina todas las restricciones de

memoria presentes en el SLIQ.

2.4 LA FAMILIA TDIDTLa familia de los Top Down Induction Trees (TDIDT) pertenece a los métodos inductivos del Aprendizaje

Automático que aprenden a partir de ejemplos preclasificados. En Minería de Datos, se utiliza para

modelar las clasificaciones en los datos mediante árboles de decisión.

2.4.1. Construcción de los árboles de decisión

Los árboles TDIDT, a los cuales pertenecen los generados por el ID3 y pos el C4.5, se construyen a partir

del método de Hunt. El esqueleto de este método para construir un árbol de decisión a partir de un

conjunto T de datos de entrenamiento es muy simple. Sean las clases C1, C2,. . ., Ck. Existen tres

posibilidades:

1. T contiene uno o más casos, todos pertenecientes a un única clase Cj:

El árbol de decisión para T es una hoja identificando la clase Cj .

2. T no contiene ningún caso:

El árbol de decisión es una hoja, pero la clase asociada debe ser determinada por información

que no pertenece a T. Por ejemplo, una hoja puede escogerse de acuerdo a conocimientos de base

del dominio, como ser la clase mayoritaria.

3. T contiene casos pertenecientes a varias clases:

En este caso, la idea es refinar T en subconjuntos de casos que tiendan, o parezcan tender hacia

una colección de casos pertenecientes a una única clase. Se elige una prueba basada en un único



atributo, que tiene uno o más resultados, mutuamente excluyentes O1, O2,. . ., On. T se

particiona en los subconjuntos T1, T2,. . ., Tn donde Ti contiene todos los casos de T que tienen el

resultado Oi para la prueba elegida. El árbol de decisión para T consiste en un nodo de decisión

identificando la prueba, con una rama para cada resultado posible. El mecanismo de construcción

del árbol se aplica recursivamente a cada subconjunto de datos de entrenamientos, para que la i-

ésima rama lleve al árbol de decisión construido por el subconjunto Ti de datos de entrenamiento.

2.4.1.1. Cálculo de la Ganancia de Información

En los casos, en los que el conjunto T contiene ejemplos pertenecientes a distintas clases, se realiza una

prueba sobre los distintos atributos y se realiza una partición según el “mejor” atributo. Para encontrar el

“mejor” atributo, se utiliza la teoría de la información, que sostiene que la información se maximiza

cuando la entropía se minimiza. La entropía determina la azarosidad o desestructuración de un conjunto.

Supongamos que tenemos ejemplos positivos y negativos. En este contexto la entropía del subconjunto Si,

H(Si), puede calcularse como:

−−++ −−= iiiii ppppSH loglog)( (2.1)

Donde +ip es la probabilidad de que un ejemplo tomado al azar de Si sea positivo. Esta probabilidad

puede calcularse como

−+

++

+=

ii

ii nn

np (2.2)

Siendo +in la cantidad de ejemplos positivos de Si, y −

in la cantidad de ejemplos negativos.

La probabilidad −ip se calcula en forma análoga a +

ip , reemplazando la cantidad de ejemplos positivos

por la cantidad de ejemplos negativos, y viceversa.

Generalizando la expresión (2.1) para cualquier tipo de ejemplos, obtenemos la fórmula general de la

entropía:

∑=

−=n

iiii ppSH

1

log)( (2.3)



En todos los cálculos relacionados con la entropía, definimos 0log0 igual a 0.

Si el atributo at divide el conjunto S en los subconjuntos Si, i = 1,2, . .. . . , n, entonces, la entropía total

del sistema de subconjuntos será:

( ) ( )∑=

⋅=n

iii SHSPatSH

1

),( (2.4)

Donde ( )iSH es la entropía del subconjunto iS y ( )iSP es la probabilidad de que un ejemplo

pertenezca a iS . Puede calcularse, utilizando los tamaños relativos de los subconjuntos, como:

( )SS

SP ii = (2.5)

La ganancia en información puede calcularse como la disminución en entropía. Es decir:

( ) ( ) ( )atSHSHatSI ,, −= (2.6)

Donde ( )SH es el valor de la entropía a priori, antes de realizar la subdivisión, y ( )atSH , es el valor

de la entropía del sistema de subconjuntos generados por la partición según at.

El uso de la entropía para evaluar el mejor atributo no es el único método existente o utilizado en

Aprendizaje Automático. Sin embargo, es el utilizado por Quinlan al desarrollar el ID3 y su sucesor el

C4.5.

2.4.1.2. Datos Numéricos

Los árboles de decisión pueden generarse tanto a partir de atributos discretos como de atributos

numéricos. Cuando se trabaja con atributos discretos, la partición del conjunto según el valor de un

atributo es simple. Por ejemplo, agrupamos todos los animales que tengan pico, siendo tiene_pico un

atributo y sus posibles valores si y no. En el caso de los atributos numéricos esta división no es tan

simple. Por ejemplo, si queremos partir los días de un mes en función a la cantidad de lluvia caída, es casi

imposible que encontremos dos días con exactamente la misma cantidad de precipitaciones.



Para solucionar este problema, puede recurrirse a la binarización. Este método consiste en formar dos

rangos de valores de acuerdo al valor de un atributo, que pueden tomarse como simbólicos. Por ejemplo,

si en un día hubo 100ml de lluvia, pueden crearse los intervalos [0,100) y [100, +∝ ) y el cálculo de la

entropía se realiza como si los dos intervalos fueran los dos valores simbólicos que puede tomar el

atributo.

2.4.1.3. Poda de los árboles generados

Existen varias razones para la poda de los árboles generados por los métodos de TDIDT [Michalski et al,

1998]. Entre ellas podemos nombrar la sobregeneralización, la evaluación de atributos poco importantes o

significativos, y el gran tamaño del árbol obtenido. En el primer caso, un árbol puede haber sido

construido a partir de ejemplos con ruido, con lo cual algunas ramas del árbol pueden ser engañosas. En

cuanto a la evaluación de atributos no relevantes, éstos deben podarse ya que sólo agregan niveles en el

árbol y no contribuyen a la ganancia de información. Por último, si el árbol obtenido es demasiado

profundo o demasiado frondoso, se dificulta la interpretación por parte del usuario, con lo cual hubiera

sido lo mismo utilizar un método de caja negra.

Existen dos enfoques para podar los árboles: la pre-poda (preprunning) y la post-poda (postprunning). En

el primer caso se detiene el crecimiento del árbol cuando la ganancia de información producida al dividir

un conjunto no supera un umbral determinado. En la post-poda se podan algunas ramas una vez que se ha

terminado de construir el árbol.

El primer enfoque, tiene la atracción de que no se pierde tiempo en construir una estructura que luego será

simplificada en el árbol final. El método típico en estos casos es buscar la mejor manera de partir el

subconjunto y evaluar la partición desde el punto de vista estadístico mediante la teoría de la ganancia de

información, reducción de errores, etc. Si esta evaluación es menor que un límite predeterminado, la

división se descarta y el árbol para el subconjunto es simplemente la hoja más apropiada. Sin embargo,

este tipo de método tiene la contra de que no es fácil detener un particionamiento en el momento

adecuado, un límite muy alto puede terminar con la partición antes de que los beneficios de particiones

subsiguientes parezcan evidentes, mientras que un límite demasiado bajo resulta en una simplificación

demasiado leve.

El segundo enfoque es, entonces, el utilizado por el ID3 y el C4.5. Una vez construido el árbol se procede

a su simplificación según los criterios propios de cada uno de los algoritmos.



2.4.1.4. El Principio de Longitud de Descripción Mínima

El fin último de los sistemas de aprendizaje es aprender una “teoría” del dominio de los ejemplos, una

teoría que es predictiva en el sentido de que es capaz de predecir la clase de nuevos instancias. Al hablar

de teorías podemos estar refiriéndonos a árboles o reglas de decisión entre otros.

Existe un principio de la ciencia conocido como Afeitadora de Occam (Occam’s Razor) [Mitchell,

2000a], que determina que cuando todas las condiciones son iguales, se prefieren las teorías simples. Es

decir, la mejor teoría científica es aquella que explica todos los hechos y tiene el menor tamaño. Como

Einstein sostuvo: “Todo debe hacerse lo más simple posible, pero no más simple que eso”. ¿Cómo

aplicamos la Afeitadora de Occam al Aprendizaje Automático? En el caso de estos sistemas, todas las

teorías generadas contienen errores, podemos decir que estos errores son como las excepciones a la

misma. Entonces, para asegurarnos que todas las condiciones sean iguales, debemos incluir las

excepciones en la teoría.

El Principio de Longitud de Descripción Mínima (MDL) [Joachims et al, 1995], [Mitchell, 2000b],

[Quinlan, 1993d;1995], [Quinlan y Cameron-Jones, 1995] sostiene que la mejor teoría para un conjunto

de datos es aquella que minimiza el tamaño de la teoría y la cantidad de información necesaria para

especificar las excepciones. Desde el punto de vista del Aprendizaje Automático esto significa que dado

un conjunto de instancias, un sistema de aprendizaje infiere una teoría a partir de ellas. Supongamos una

analogía con el campo de las comunicaciones: la teoría con las excepciones debe ser transmitida por un

canal perfecto. El MDL sostiene que la mejor generalización es aquella que requiere la menor cantidad de

bits para transmitir la generalización junto con los ejemplos a partir de la cual fue generada. Esto evita las

teorías que satisfacen los datos al extremo sobreajuste, ya que los ejemplos se transmiten también, y las

teorías demasiado extensas serán penalizadas. Por otro lado, también se puede transmitir la teoría nula

que no ayuda en lo más mínimo al transmitir los ejemplos. Entonces, pueden transmitirse tanto las teorías

simples como aquellas muy complejas y el MDL provee una forma de medir la performance de los

algoritmos basándose en los datos de entrenamiento únicamente. Esta parece ser la solución ideal al

problema de medir la performance.

Veamos cómo aplicamos el principio MDL. Supongamos que un sistema de aprendizaje genera una teoría

T, basada en un conjunto de entrenamiento E, y requiere una cierta cantidad de bits L[T] para codificar la

teoría. Dada la teoría, el conjunto de entrenamiento puede codificarse en una cantidad L[E/T] de bits.

L[E/T] está dada por la función de ganancia de información sumando todos los miembros del conjunto de

entrenamiento. La longitud de descripción total de la teoría es L[E]+L[E/T]. El principio MDL

recomienda la teoría T que minimiza esta suma.

Recordemos que los algoritmos de la familia TDIDT realizan una búsqueda en el espacio de hipótesis

posibles, constituido por todos los árboles de decisión posibles. Su sesgo inductivo, siguiendo el principio



de la Afeitadora de Occam, es una preferencia sobre los árboles pequeños frente a los árboles más

profundos y frondosos.

2.4.2. Atributos Desconocidos

Cuando explicamos el método de Hunt, consideramos que todos los resultados de todas las pruebas para

todos los casos eran conocidos. Dividimos el conjunto T de datos de entrenamiento en los subconjuntos

Ti según los resultados de una prueba en particular, y, una vez construido el árbol, clasificamos un caso

tomando la rama correspondiente al resultado de la prueba de cada nodo de decisión. Como cada prueba

se basa en un único atributo, el resultado de una prueba no puede determinarse si no se conoce el valor del

atributo.

¿Qué pasa cuando los datos están incompletos como ocurre generalmente con cualquier conjunto de datos

de la vida real? Podemos tomar dos caminos posibles ante los datos incompletos: descartar una

proporción importante de los datos por incompletos y declarar algunos casos como inclasificables, o

adaptar los algoritmos para poder trabajar con valores de atributos faltantes. En la mayoría de los casos, la

primera opción es inaceptable. Para poder aplicar la segunda opción, hay tres cuestiones importantes que

deben ser tenidas en cuenta:

1. Selección de una prueba en la cual la partición del conjunto de entrenamiento se realiza en base a un

criterio heurístico como ser la ganancia o la proporción de ganancia. Si dos pruebas distintas utilizan

atributos con distinta cantidad de valores desconocidos, ¿cómo debe tenerse esto en cuenta al medir

su importancia relativa?

2. Una vez que una prueba ha sido seleccionada, los casos de entrenamiento con valores desconocidos

para los atributos relevantes no pueden ser asociados con una respuesta particular de la prueba, y, por

lo tanto, no pueden asignarse a un subconjunto Ti. ¿Cómo deben tratarse estos casos durante la

partición?

3. Cuando el árbol de decisión se utiliza para clasificar un caso nuevo, ¿cómo debe proceder el sistema

al encontrarse con un valor de atributo desconocido para el nodo de decisión que está tratando de

evaluar?

Varios autores han tratado de resolver estos problemas, generalmente rellenando los valores desconocidos

con los valores más frecuentes. En un estudio realizado por Quinlan, [Quinlan, 1989], se comparan las

soluciones más comunes a este problema. El autor llega a la conclusión general de que existen varios



enfoques que son notablemente inferiores, pero no existe ningún enfoque que sea claramente superior. A

continuación se presenta un resumen del estudio.

2.4.2.1. Estudio sobre datos con atributos desconocidos en la Inducción

2.4.2.1.1. Métodos analizados

Todos los enfoques descriptos a continuación fueron implementados como variantes de un programa que

construye un árbol de decisión utilizando la proporción de ganancia [Quinlan, 1989]. Los árboles

producidos no fueron podados. Varios enfoques para solucionar los tres problemas planteados fueron

explorados. Cada uno de ellos tiene una letra identificatoria, tal que una combinación de letras implica

una combinación de métodos.

Al evaluar una prueba basada en el atributo A

I - Ignorar los casos del conjunto de entrenamiento con valores desconocidos

R - Reducir la ganancia de información aparente al testear A en la proporción de casos convalores desconocidos para A: si A tiene una proporción de valores desconocidos del x%, laprueba sobre A no dará información x% del tiempo.

S - “Completar” los valores desconocidos de A antes de calcular la ganancia de A [Shapiro,1983], basándose en los valores de otros atributos

C - Completar los valores de A con el valor más frecuente para el atributo antes de calcular laganancia.

Al partir el conjunto de entrenamiento utilizando una prueba sobre el atributo A y un caso de

entrenamiento tiene un valor desconocido de A.

I - Ignorar el caso

S - Determinar el valor de A utilizando el método de Shapiro y asignarlo al subconjuntocorrespondiente.

C - Tratar el caso como si tuviera el valor más común de A.

P - Asignar el caso a uno de los subconjuntos con probabilidad proporcional al número de casoscon valores conocidos en cada subconjunto.

F - Asignar una fracción del caso a cada subconjunto utilizando las proporciones explicadas enel inciso anterior.

A - Incluir el caso en todos los subconjuntos

U - Desarrollar una rama separada para los casos de valores desconocidos de A.



Al clasificar un caso nuevo con un valor desconocido del atributo A que debe ser evaluado.

U - Si existe una rama especial para los valores desconocidos de A, tomarla

S - Determinar el resultado más probable de A y actuar de acuerdo con ello.

C - Tratar el caso como si fuese el del valor más común de A.

F - Explorar todas las ramas, combinando los resultados para reflejar las probabilidades de losdistintos resultados.

H - Parar en este punto y asignar el caso a la clase más frecuente.

2.4.2.1.2. Casos analizados

• Valores desconocidos al particionar: los resultados de las pruebas revelan una clara superioridad del

RFF (asignar casos fraccionales a los subconjuntos) y una clara desventaja del RIF (ignorar los casos

de entrenamiento con valores desconocidos).

• Valores desconocidos al clasificar: la estrategia de parar ante los valores desconocidos dio muy

malos resultados, mientras que todos las otras estrategias dieron resultados similares

• Valores desconocidos al seleccionar las pruebas: ignorar los valores desconocidos dio resultados

peores que reducir la ganancia o completar los valores, pero no existió un método claramente

superior entre estos dos últimos.

2.4.2.1.3. Resultados obtenidos

El estudio se concentró en dominios con altos niveles de valores desconocidos y conjuntos de

entrenamiento chicos. Este estudio proporcionó evidencia para las siguientes hipótesis:

• En la evaluación de pruebas, los enfoques que ignoran los casos con valores desconocidos (y por lo

tanto no tienen en cuenta la proporción de desconocimiento) presentan malos resultados cuando esta

proporción varía de atributo en atributo.

• Cuando el conjunto de entrenamiento se divide ignorando los casos con valores desconocidos para el

atributo probado, se obtienen resultados pobres (esta es la forma en que el ID3 realiza las

particiones). El enfoque de dividir los casos entre los subconjuntos resultó muy bueno.



Durante la clasificación, tratar de determinar el resultado más probable de una prueba, funciona bien en

algunos dominios (aquellos en los cuales la sustitución puede realizarse con confianza), pero muy mal en

otros. La combinación de todos los resultados posibles es más resilente, dando una mayor certeza en la

clasificación general.

2.4.3. Transformación a Reglas de Decisión

Los árboles de decisión demasiado grandes son difíciles de entender porque cada nodo debe ser

interpretado dentro del contexto fijado por las ramas anteriores. Cada prueba tiene sentido, solamente, si

se analiza junto con los resultados de las pruebas previas. Cada prueba en el árbol tiene un contexto único

que es crucial a la hora de entenderla y puede ser muy difícil comprender un árbol en el cual el contexto

cambia demasiado seguido al recorrerlo. Además, la estructura de árbol puede hacer que un concepto en

particular quede fragmentado, lo cual hace que el árbol sea aún más difícil de entender. Existen dos

maneras de solucionar estos problemas: definir nuevos atributos que estén relacionados con las tareas o

cambiar de método de representación, por ejemplo, a reglas de decisión.

En cualquier árbol de decisión, las condiciones que deben satisfacerse cuando un caso se clasifica por una

hoja pueden encontrarse analizando los resultados de las pruebas en el camino recorrido desde la raíz. Es

más, si el camino fuese transformado directamente en una regla de producción, dicha regla podría ser

expresada como una conjunción de todas las condiciones que deben ser satisfechas para llegar a la hoja.

Consecuentemente, todos los antecedentes de las reglas generadas de esta manera serían mutuamente

excluyentes y exhaustivos.

Al hablar de reglas de decisión o de producción nos referimos a una estructura de la forma:

Si atributo1=valorX y atributo2=valorY .... y atributon=valorZ

Entonces claseK

Diremos que una regla cubre un caso si el caso satisface todas las condiciones en el antecedente de la

misma.



2.5.EVALUACIÓN DE LOS MÉTODOS DE APRENDIZAJE

La evaluación es la clave del progreso en la Minería de Datos. Existen varias maneras de inferir

estructuras a partir de los datos; para determinar cuál es el mejor método para cada conjunto de datos,

debe existir una manera de evaluar los métodos de aprendizaje y compararlos entre sí.

Si se cuenta con una gran cantidad de datos, la evaluación no es problema: se genera un modelo a partir

de un conjunto grande de entrenamiento y, luego, se lo prueba con otro gran conjunto de datos. Sin

embargo, aunque la Minería de Datos implica por su definición trabajar con grandes cantidades de datos,

los conjuntos de datos de buena calidad son pocos. Los datos de entrenamiento deben ser cuidadosamente

generados y analizados por expertos humanos, un recurso que escasea.

Existen varios indicadores de la performance de un algoritmo de aprendizaje. Algunos de ellos se

describen a continuación [Michalski et al, 1998]:

• Precisión: cantidad de ejemplos positivos y negativos evaluados correctamente. Algunas veces, es

importante distinguir entre dos tipos de errores: los ejemplos positivos clasificados como negativos

(errores de omisión) y viceversa (errores de comisión). Estos dos tipos de errores nos ayudan a

determinar si los conceptos aprendidos son demasiado generales o demasiado específicos. Para que

un sistema sea preciso, es necesario que genere descripciones que sean consistentes (no cubran

ningún ejemplo negativo) y que sean completas (cubran todos los ejemplos positivos).

• Eficiencia: un sistema debe ser capaz de generar descripciones correctas con un número mínimo de

ejemplos. Un instructor no siempre puede dotar al sistema de una cantidad infinita de ejemplos, y la

velocidad en el aprendizaje es un indicador de inteligencia. Dentro de la eficiencia, debemos evaluar

también los requerimientos computacionales. Estos se miden en función a la cantidad de tiempo y

recursos que un sistema necesita para llegar a una buena descripción.

• Comprensibilidad: es importante que los conceptos generados sean comprensibles al usuario, ya

que el fin último de estos sistemas es que el usuario aprenda algo de ellos.

• Robustez: contra el ruido y contra los ejemplos incompletos. Cada sistema maneja estos dos

problemas de forma diferente, con lo cual debe evaluarse en cada sistema en particular.

• Requerimientos especiales: en algunos dominios, se requiere que un sistema aprenda a medida que

llegan los ejemplos. Esto se conoce como aprendizaje incremental y es, especialmente, importante en

aquellas áreas en que los conceptos evolucionan, cambian su significado a través del tiempo.



2.5.1 Evaluación en la familia TDIDT

Para los problemas de clasificación, como los de la familia TDIDT, es natural medir la performance del

clasificador con una proporción de error. El clasificador predice la clase de cada instancia: si la

predicción es correcta, estamos ante un éxito; si no lo es, estamos ante un error. La proporción de error,

entonces, es simplemente la cantidad de errores sobre la cantidad total de instancias clasificadas.

Por supuesto, lo que nos interesa es estimar la proporción de errores sobre los nuevos datos y no sobre los

datos de entrenamiento, los cuales ya están clasificados. ¿Podemos decir que la proporción de error

estimada a partir de los datos de entrenamiento es correcta para los datos futuros? No, si los datos sobre

los que se estimó el error fueron utilizados al generar el clasificador. La proporción de error sobre los

datos de entrenamiento no es un buen indicador de los errores futuros; como el clasificador se generó a

partir de estos datos, la proporción de error es subjetiva y totalmente optimista. La proporción de error

generada a partir de los datos de entrenamiento se conoce como error de sustitución, ya que se calcula al

sustituir las instancias en un clasificador que fue construido a partir de ellas. A pesar de que no es un buen

estimador para la predicción de futuros errores, es muy útil conocerlo.

Para predecir la performance del clasificador en los datos futuros, necesitamos evaluar la proporción de

error sobre datos no utilizados durante la construcción del mismo. El conjunto independiente de datos

utilizado con este propósito es el conjunto de prueba. Es esencial que el conjunto de prueba no haya sido

utilizado para nada en la generación del clasificador. Entonces, aquellos esquemas en que la construcción

se realiza en dos etapas o requieren probar el clasificador, trabajan con dos conjuntos de datos: el de

entrenamiento y el de prueba.

Podemos decir que a mayor cantidad de datos, mejor clasificador y mejor estimador de error. El problema

está cuando hay una pequeña cantidad de datos de entrenamiento. En muchas situaciones, los datos de

entrenamiento y prueba deben clasificarse manualmente. Debemos encontrar la forma de encontrar un

buen estimador de error, aún cuando los datos de prueba escasean. A continuación, se explican varios

métodos para evaluar los algoritmos de clasificación.

2.5.2. Métodos de evaluación

2.5.2.1. Evaluación Cruzada (Cross-Validation)

Cuando existe una cantidad limitada de datos de entrenamiento y prueba, puede aplicarse el método de

retención (holdout) para estimar la proporción de error [Witten y Frank, 2000]. Este método reserva una

cierta cantidad de datos al azar para prueba y utiliza el resto para el entrenamiento. En general, se reserva

un tercio para prueba y se utilizan dos tercios como datos de entrenamiento.



Por supuesto, siempre cabe la posibilidad de que los datos utilizados para entrenamiento y prueba no sean

representativos de los datos sobre los que se utilizará el modelo posteriormente. En general, no se puede

afirmar si un conjunto es representativo o no, pero existe una prueba muy simple que vale la pena

realizar: cada una de las clases del conjunto total de datos debería estar representada en la misma

proporción en los datos de entrenamiento y prueba, y esta proporción debería ser similar a la que se

presentará cuando se aplique el modelo generado al caso real. Supongamos que todos los ejemplos de una

clase determinada no entran en el conjunto de entrenamiento, el clasificador generado será incorrecto. Al

trabajar con la hipótesis del Universo Cerrado, no podemos pretender que clasifique correctamente los

miembros de una clase que no sabía que existía. Si en el conjunto de prueba hay datos de esa clase, la

proporción de error obtenida será muy grande. Entonces, al dividir al azar los datos preclasificados entre

los conjuntos de entrenamiento y prueba, debemos garantizar que cada clase esté correctamente

representada tanto en los datos de prueba como en los de entrenamiento. Este procedimiento se conoce

como estratificación (stratification), y podemos hablar de una retención estratificada.

Una manera de evitar la tendencia introducida por los datos retenidos, es repetir el proceso completo

(entrenamiento y prueba) varias veces con distintas divisiones de los datos. En cada iteración, una misma

proporción de los datos se retiene al azar para las pruebas y el resto se utiliza para el entrenamiento. Las

proporciones de error obtenidas en las múltiples iteraciones se promedian para obtener una proporción de

error general. Este método se conoce como retención repetida (repeated holdout).

En un procedimiento de retención general podríamos elegir cambiar los roles de los datos de

entrenamiento y de prueba entre sí. No obstante, esto es factible únicamente si trabajamos con una

proporción 50:50, lo cual no es ideal ya que conviene utilizar más del 50% de los datos para el

entrenamiento. Para solucionar este problema utilizamos una variación del método estadístico de

validación cruzada (cross-validation).

En la validación cruzada, se determina con anterioridad una cierta cantidad de pliegos o particiones de los

datos. Supongamos que utilizamos tres, es decir, los datos se dividen al azar en tres particiones de

aproximadamente la misma cantidad, y cada una a su turno se utiliza para prueba mientras que las otras

dos se utilizan para entrenamiento. Por lo tanto, utilizamos un tercio para prueba y dos tercios para

entrenamiento, y repetimos el procedimiento tres veces. Las tres proporciones de error obtenidas se

promedian para llegar a una proporción de error general. Este procedimiento conocido como validación

cruzada de tres pliegues (threefold cross-validation), puede trabajar con datos estratificados, en cuyo caso

sería validación cruzada de tres pliegues estratificada.

Podemos generalizar el método para llegar a una validación cruzada de n pliegues, estratificada o no. El

caso más utilizado para predecir la proporción de error de una técnica de aprendizaje es utilizar una

validación cruzada de diez pliegues. Además, las pruebas han demostrado que el uso de la estratificación

mejora los resultados levemente [Witten y Frank, 2000]. Utilizar una validación cruzada de diez pliegues

puede no ser suficiente para obtener un buen estimador de la proporción de error. Distintas validaciones



cruzadas de diez pliegues dan distintos resultados dado que la división en pliegues se realiza al azar. La

estratificación reduce la variación entre los resultados pero no la elimina. Si se quiere obtener una

estimación de la proporción de error muy precisa, generalmente, se repite la validación cruzada de diez

pliegues diez veces y se promedian los resultados. Esto implica invocar al algoritmo de aprendizaje cien

veces con conjuntos de datos del tamaño del 90% del conjunto original. Obtener una buena medida de la

performance es un método que consume grandes recursos computacionales.

2.5.2.2 Dejar-uno-afuera (Leave-one-out)

La validación cruzada de diez pliegues es una manera normalmente utilizada para estimar la proporción

de error, pero no es la única. Existen otras técnicas bastante populares como la de dejar-uno-afuera. Esta

técnica es simplemente una validación cruzada de n pliegues donde n es el número de instancias del

conjunto de datos. Por turnos, cada una de las instancias se deja afuera y se entrena el clasificador con el

resto de las instancias. Se lo evalúa según el resultado de la clasificación de la instancia que había

quedado afuera. Los resultados de las n evaluaciones luego se promedian para determinar la proporción

de error.

Este procedimiento es atractivo por dos razones [Witten y Frank, 2000]. Primero, se utiliza la mayor

cantidad de ejemplos posibles para el entrenamiento, lo cual se presume incrementa la posibilidad de que

el clasificador sea correcto. Segundo, el procedimiento es determinístico: no se parten los datos al azar.

Además, no tiene sentido repetir el procedimiento diez ni cien veces, ya que siempre se obtendrá el

mismo resultado. Debe tenerse en cuenta que dado el alto costo computacional de aplicar este método, no

es factible utilizarlo para grandes conjunto de datos. Sin embargo, este método es el mejor para pequeños

conjuntos de datos porque, en cierta medida, evalúa todas las posibilidades.

2.5.2.3. Bootstrap

Este método está basado en el procedimiento estadístico de obtener muestras con sustitución. En los

métodos anteriores, cuando se tomaba una muestra de los datos de entrenamiento o de prueba, se lo hacía

sin reemplazo. Es decir, la misma instancia, una vez seleccionada, no podía seleccionarse nuevamente. La

mayoría de las técnicas de aprendizaje pueden, no obstante, utilizar la misma instancia dos veces, y el

hecho de repetirse genera una diferencia.

La idea del bootstrap es tomar muestras del conjunto de datos con remplazo para formar un conjunto de

entrenamiento. Para ello, un conjunto de n instancias se muestrea n veces, con reemplazo, y se obtiene

otro conjunto de datos de n instancias. Como algunas instancias del segundo conjunto estarán repetidas,



deben existir algunas instancias del conjunto original que no fueron seleccionadas. Utilizaremos estas

instancias para el conjunto de prueba.

La probabilidad de que una instancia particular sea elegida para el conjunto de entrenamiento es de 1/n, y,

por lo tanto, hay un 1-1/n de probabilidad de que no sea elegida. Si multiplicamos esto según las n

oportunidades de ser elegida, obtenemos la siguiente probabilidad de que no sea escogida:

0.368 en1-1 1-

n

==

Entonces, un conjunto de datos lo suficientemente grande contendrá un 36.8% de instancias de prueba y

un 63.2% de entrenamiento. Esta es la razón por la cual este método se conoce como el 0.632 bootstrap.

El error estimado sobre el conjunto de prueba será pesimista porque el clasificador tiene en cuenta sólo el

63% de los datos del conjunto original, lo cual es poco frente al 90% de la validación cruzada de diez

pliegues. Para compensar el error del conjunto de entrenamiento se combina con el error en el conjunto de

prueba de la siguiente manera:

ntoentrenamieprueba e0.368e0.632e ×+×=

Luego, todo el proceso de bootstrap se repite varias veces, y todos los estimadores de error se promedian.

2.5.3. Estimación del costo

Hasta ahora no hemos considerado el costo de tomar malas decisiones y malas clasificaciones. La

optimización de las proporciones de clasificación sin considerar el costo de los errores, generalmente

lleva a resultados extraños. Existe un ejemplo famoso de un sistema de inducción utilizado para predecir

los períodos fértiles de las vacas en un tambo. Las vacas se controlaron con un identificador electrónico

en la oreja, y otros atributos como el volumen de leche y su composición química. En las primeras

pruebas del sistema de aprendizaje automático, los resultados afirmaban que las vacas nunca estaban en el

período fértil. El período menstrual de las vacas es similar al de los humanos, con lo cual la regla

generada era correcta el 97% de las veces, un grado de precisión impresionante para el dominio de la

agricultura. Sin embargo, lo que se buscaba eran reglas que predijeran cuando una vaca estaba fértil y no

cuando no lo estaba, con lo cual, los costos de los dos casos de error son distintos. La evaluación por

exactitud en la clasificación asume costos iguales por naturaleza.



Si los costos son conocidos, pueden incluirse en el análisis de los métodos. Restringiremos nuestro

análisis a los casos que tienen clases sí y no únicamente. Los cuatro resultados posibles de una predicción

pueden listarse en una matriz de confusión como la que se muestra a continuación.

Clase predichaSí No

Sí Verdadero positivo Falso NegativoClase verdaderaNo Falso Positivo Verdadero Negativo

Los verdaderos positivos y verdaderos negativos son los casos sin error. Los falsos positivos

corresponden a aquellas instancias negativas que fueron clasificadas como positivas, mientras que los

falsos negativos son aquellas instancias clasificadas como negativas cuando en realidad son positivas.

Estos dos casos de errores generalmente tienen distintos costos, como los casos clasificados

correctamente tienen distintos beneficios. El hecho de pensar en el costo genera mejores decisiones.

No obstante, la mayoría de los algoritmos de aprendizaje automático no tienen en cuenta el costo al

aprender. Existen, sin embargo, dos maneras de transformarlo fácilmente. La primera idea para

transformar un clasificador para que tome en cuenta el costo, es variar la cantidad de ejemplos positivos y

negativos en los datos de entrenamiento de acuerdo a la importancia de cada uno de los errores. Otra idea

es ponderar las instancias. Por ejemplo, al generar un árbol de decisión, una instancia puede dividirse en

partes con un esquema de ponderación que indique la proporción con que debe tomarse cada rama.


Descripción del Problema Magdalena Servente 43

CAPÍTULO 3

DESCRIPCIÓN DEL PROBLEMA

En este capítulo se presenta el contexto de nuestro problema de interés (Sección 3.1) y las

cuestiones que los algoritmos ID3 y C4.5 pertenecientes a la familia TDIDT deben resolver

(Sección 3.2).

3.1. CONTEXTO DEL PROBLEMA

Al haberse tornado económico el almacenamiento de datos en medios físicos y al tornarse relativamente

fácil y/o accesible la recolección de dichos datos, las bases de datos crecen en forma desmesurada. Hoy

en día se recolectan datos simplemente por estar al alcance de la mano, sin tener en cuenta su importancia

lógica o práctica, o sin siquiera saber si son importantes en algún sentido. El almacenamiento masivo de

información hace que la Minería de Datos tenga una importancia cada vez mayor. El análisis de los datos

que se recolectan actualmente para toda actividad humana y para cualquier evento o hecho del universo,

excede las capacidades de una persona.

Existen muchos tipos de análisis y muchos tipos de resultados obtenibles. Por ejemplo, podemos realizar

un análisis estadístico sobre la distribución de una población de ardillas en un bosque a lo largo de los

años; u obtener la varianza y desviación estándar de los depósitos japoneses en el mercado americano de

la última década; o realizar un análisis de componentes para un determinado experimento físico, entre

otros.

Los métodos nombrados hasta ahora son esencialmente cuantitativos. Sin embargo, ¿qué pasa cuando más

allá de los modelos matemáticos encerrados en los datos, nos interesan los modelos lógicos? ¿Cuándo

más allá de las direcciones para hacer un mailing de la base de personas, nos interesa hacer un mailing

sólo a los potenciales clientes? ¿Cómo distinguimos a los potenciales clientes del resto de la gente? ¿Qué

características tienen en común? ¿Qué datos los distinguen? Cuando el análisis de los datos que estamos

buscando excede los alcances de un modelo cuantitativo y está orientado hacia una descripción cualitativa

de los datos, debemos utilizar los algoritmos inteligentes.

Estos algoritmos del Aprendizaje Automático están orientados hacia el desarrollo de descripciones

simbólicas de los datos que puedan caracterizar a uno o más conceptos, diferenciar entre clases de


44 Magdalena Servente Descripción del Problema

conceptos y describir porqué razón un objeto pertenece a una clase y no a otra. Con este tipo de

algoritmos nuestro problema del análisis de los potenciales clientes estaría resuelto.

Existen muchos tipos de algoritmos de Aprendizaje Automático; no obstante, los más útiles para nosotros

son aquellos que no quedan encerrados en el “cerebro” de la computadora, sino que pueden adaptarse a

nuestra forma de pensar. Si el resultado de realizar Minería de Datos inteligente sobre una base es una red

neuronal, ésta puede ser muy útil para clasificar nuevos ejemplos, en la medida en que sean clasificados

por medio de un programa entrenado para ello. Una persona jamás será capaz de aplicar rápida y

efectivamente una red neuronal u otro modelo similar para clasificar distintos datos. En cambio si la

persona se encuentra ante un árbol de decisión o un conjunto de reglas de decisión que debe aplicar en

orden como resultado de la Minería, la clasificación del nuevo caso es tan fácil como la lectura del árbol

desde la raíz hasta las hojas.

Este tipo de modelo de datos que representa los conceptos inherentes y ocultos en los datos, de forma tal

que son fáciles de interpretar, utilizar e incorporar para la persona humana son los que más enriquecen

nuestro conocimiento y, como tales, aquellos sobre los cuales focalizaremos nuestra atención.

En las bases de datos, las entidades se caracterizan, generalmente, por un conjunto de atributos que las

describen. Los atributos pueden ser tanto discretos como continuos, pero lo importante es que todas las

entidades están descriptas por el mismo grupo de atributos. En los problemas de clasificación, un atributo

particular, conocido como clase, describe al tipo de concepto.

3.2. APLICACIÓN DE LOS ALGORITMOS DE LA FAMILIA

TDIDT A LA MINERÍA DE DATOS

En este contexto se plantea la siguiente cuestión:

¿En qué medida los algoritmos de la familia TDIDT pueden usarse para generar modelos válidos en los

problemas de clasificación?

Analizar la aplicación de todos los Algoritmos Inteligentes a la Minería de Datos excedería los alcances

de este trabajo; por ende, vamos a centrar nuestro análisis en aquellos algoritmos que generan árboles y

reglas de decisión que son modelos que un ser humano puede interpretar y aplicar fácilmente. Un buen

modelo de datos para clasificar fenómenos meteorológicos descriptos en función de varias medidas

ambientales tomadas en los días previos, pueden ayudar a un meteorólogo a determinar si habrá sol,

lloverá, o habrá un tornado.


Descripción del Problema Magdalena Servente 45

De esta manera la cuestión previa se reformula en las siguientes:

Cuestión 1:

¿Qué tipos de sistemas generan como resultado árboles de decisión?

Cuestión 2:

¿Qué condiciones deben cumplir los datos para que su análisis con el ID3 o el C4.5 sea útil

y válido?

Cuestión 3:

¿Qué tan fácil es para un humano trabajar con estos algoritmos?

Cuestión 4:

¿Cuáles son los resultados del sistema?

Cuestión 5:

¿Cómo podemos medir la calidad de los resultados obtenidos?


46 Magdalena Servente Descripción del Problema


Solución Propuesta Magdalena Servente 47

CAPÍTULO 4

SOLUCIÓN PROPUESTA

En este capítulo se presentan todos los aspectos de la solución propuesta. Para ello se describen

las características generales de la misma (Sección 4.1): el marco teórico (Sección 4.1.1), las

condiciones que deben cumplir los datos sobre los que se realiza la Minería de Datos (Sección

4.1.2) y los tipos de resultados obtenidos (Sección 4.1.3). En la Sección 4.2 se presenta una

descripción general de los algoritmos ID3 y C4.5 que se utilizan para estudiar el problema. Se

explica cómo realizar la división de los datos de entrada (Sección 4.2.1) y la elección del criterio

de división (Sección 4.2.1.1). Luego, se presenta una descripción detallada del algoritmo ID3

(Sección 4.3.1) y de sus limitaciones (Sección 4.3.2). A modo de ejemplo, se muestra la

utilización del ID3 para generar un árbol y reglas de decisión (Sección 4.3.1.5). También se

detalla el algoritmo C4.5 (Sección 4.4) y sus características particulares (Sección 4.4.2), las

cuales lo diferencian del ID3, resaltando la poda de los árboles de decisión (Sección 4.4.3) y la

estimación de errores en dichos árboles (Sección 4.4.4). En la sección 4.4.5 se ejemplifican los

métodos anteriores. La generalización de las reglas de decisión realizada por el C4.5 se explica

en la sección 4.4.6. A continuación, se detalla el diseño del sistema integrador utilizado para

estudiar el éxito de la solución propuesta (Sección 4.5). Para este sistema se presenta una

descripción general (Sección 4.5.1) y el diseño de las secciones del sistema para el ID3 (Sección

4.5.2.1) y para el C4.5 (Sección 4.5.2.2)

La mayoría de las aplicaciones de la Inteligencia Artificial a tareas de importancia práctica construyen un

modelo de conocimiento utilizable por un experto humano. En algunos casos, la tarea que el experto

realiza es una clasificación, es decir, asigna objetos a categorías o clases determinadas según sus

propiedades [Quinlan 1993d]. En un modelo de clasificación, la conexión entre clases y propiedades

puede definirse utilizando desde un simple diagrama de flujo hasta un manual de procedimientos

complejo y desestructurado. Si restringimos nuestra discusión a modelos ejecutables, es decir, a aquellos

que pueden ser representados como programas de computación, existen dos maneras muy diferentes en

las que se puede construir un modelo. Por un lado, el modelo puede obtenerse a partir de entrevistas

relevantes con uno o más expertos. Por otro lado, si se cuenta con clasificaciones almacenadas con

anterioridad, éstas pueden ser examinadas para construir un modelo inductivo a partir de ellas, mediante

una generalización de ejemplos específicos. Los sistemas ID3 y C4.5 pertenecen a este segundo grupo

[Blockeel y De Raedt, 1997].


48 Magdalena Servente Manual del usuario

4.1. CARACTERÍSTICAS GENERALES

4.1.1. Marco teórico

Si intentamos plantear el problema de aprendizaje de un modelo de datos a partir de ejemplos desde un

marco teórico, nos encontramos ante el siguiente esquema [Blockeel y De Raedt, 1997]:

Dados:

• un conjunto C de clases,

• un conjunto E de ejemplos preclasificados

Encontrar:

Una hipótesis H (conjunto de cláusulas) tal que:

∀ e ∈ E: H ∩ e = c ∧ H ∩ e ≠ c’ (4.1)

Donde c es la clase del ejemplo e y c’ ∈ C- c

Presentar los resultados obtenidos como:

• un árbol de decisión,

• un conjunto de reglas de decisión.

El sistema generará un árbol de decisión fruto de la naturaleza en sí de los algoritmos de la familia

TDIDT. El árbol de inducción resultante será construido desde raíz hacia las hojas (top-down). El modelo

generado es muy útil para el usuario ya que permite una fácil visualización de los resultados. Además,

transformaremos el árbol a reglas de decisión que pueden ser utilizadas por otros programas de

clasificación o ser transformadas en sentencias SQL para clasificar nuevos datos rápidamente.



4.1.2. Datos de Entrada

Antes de analizar la familia TDIDT debemos tener en cuenta que no todas las tareas de clasificación son

apropiadas para este enfoque inductivo, a continuación se listan los requerimientos que deben cumplirse

[Mitchell, 1997], [Quinlan, 1986; 1993b]:

• Descripciones de atributo-valor (Attriute-value description): los datos a ser analizados deben

poder expresarse como un archivo plano, es decir, toda la información de un objeto o caso debe

poder expresarse en términos de una colección fija de propiedades o atributos2. Cada atributo puede

ser discreto o numérico, pero los atributos utilizados para describir un caso no pueden variar de un

caso a otro. Esto restringe los dominios de aplicación en los cuales los objetos tienen inherentemente

atributos variables. El hecho de que los atributos no puedan variar de un caso a otro, no restringe

aquellos casos en los cuales los valores de algunos atributos son desconocidos.

• Clases predefinidas: las categorías a las cuales se asignan los casos deben estar establecidas de

antemano. Esto significa que los algoritmos se aplican sobre un conjunto de datos de entrenamiento

previamente clasificados, del tipo valor_atributo1, valor_atributo2, ...., valor_atributon, clasek. En

la terminología del Aprendizaje Automático, esto se conoce como aprendizaje supervisado, en

contraposición al aprendizaje no supervisado en el cual la agrupación de casos se encuentra mediante

y durante el análisis.

• Clases discretas y disjuntas: las clases a las cuales se asignan los casos deben ser totalmente

disjuntas: un caso pertenece o no pertenece a una clase, pero no puede pertenecer a dos clases a la

vez. Además, deben existir muchos más casos que clases para que el modelo generado sea válido en

el dominio analizado. Por otro lado, dado la naturaleza de los árboles de decisión, las clases deben ser

discretas o discretizarse en caso de ser continuas.

• Datos suficientes: los patrones generados por la generalización inductiva no serán válidos si no se

los pueden distinguir de las casualidades. Como esta diferenciación se basa generalmente en pruebas

estadísticas, deben existir casos suficientes para que dichas pruebas sean efectivas. La cantidad de

datos requeridos está afectada por factores como la cantidad de propiedades y clases, y la

complejidad del modelo de clasificación; a medida que estos se incrementan, se necesitan más datos

para construir un modelo confiable.

2 El hecho de que los datos deben poder expresarse como un archivo plano, no restringe la aplicación del ID3 o del C4.5 a una única

tabla de una base de datos, sino que para aplicarse a múltiples tablas, éstas deben ser desnormalizadas hasta obtener una tabla con

los atributos que se desea analizar.



• Los datos de entrenamiento pueden contener errores: según Mitchell, los métodos de aprendizaje

utilizando árboles de decisión son robustos frente a los errores, tanto en los valores de las clases

como en los valores de los atributos de los datos de entrenamiento [Mitchell 1997].

• Los datos de entrenamiento pueden contener valores de atributos faltantes: los métodos de la

familia TDIDT pueden utilizarse aún cuando no se conocen todos los valores de todos los atributos

de los datos de entrenamiento. El tratamiento de valores faltantes varía de un algoritmo a otro y será

explicado para el ID3 en la sección 4.3.1.3 y para el C4.5 en la sección 4.4.2.2.

• Modelos lógicos generados: los programas sólo construyen clasificadores que pueden ser

expresados como árboles de decisión o como un conjunto de reglas de producción. Estos modelos

restringen las descripciones de clases a una expresión lógica cuyas primitivas son afirmaciones

acerca de los valores de atributos particulares. La expresión lógica representada por un árbol de

decisión es una disyunción de conjunciones. Todos aquellos casos que requieran un modelo de otra

índole no podrán ser analizados por los algoritmos ID3 o C4.5.

4.1.3. Resultados Generados

4.1.3.1. Características de los árboles de decisión

Los árboles de decisión representan una estructura de datos que organiza eficazmente los descriptores. Se

construye un árbol de forma tal que en cada nodo se realiza una prueba sobre el valor de los descriptores

y de acuerdo con la respuesta se va descendiendo en las ramas, hasta llegar al final del camino donde se

encuentra el valor del clasificador. Se puede analizar un árbol de decisión como una caja negra en función

de cuyos parámetros (descriptores) se obtiene un cierto valor del clasificador.

Figura 4.1: Estructura de un árbol de decisión

d1(p1)

Entrada

d2(p2) c

c c

Nodosdescriptores

Hojas o Nodos declasificadores

Salida

Entrada: p1, p2

F(d1(p1),d2(p2))=c

Salida: c



Un árbol de decisión puede analizarse como una disyunción de conjunciones. Cada camino desde la raíz

hasta las hojas representa una conjunción, y todos los caminos son alternativos, es decir, son

disyunciones.

4.1.3.2. Características de las reglas de decisión

Las reglas de decisión o de producción son una alternativa a los árboles de decisión, y todo árbol de

decisión puede llevarse a reglas de este tipo [Witten y Frank, 2000], [Korab, 1997], [Blurock, 1996].

Antecedente => Consecuente

Donde el antecedente es una conjunción entre distintas pruebas de valor sobre los valores de los atributos;

y el consecuente es una clase para todos los casos que satisfagan el antecedente. Por ejemplo,

Si atributo1=”valor a” y atributo2= “valor y”, entonces ClaseK

Las reglas de decisión se presentan en orden, y deben interpretarse de esa manera. El orden determina

cuáles reglas deben ejecutarse primero. Al clasificar un nuevo caso se avanza en la lista hasta llegar a un

antecedente que sea satisfecho por el caso, entonces la clase del caso es la correspondiente al consecuente

de dicha regla. El C4.5 en particular, agregar una última regla a la lista, ésta no tiene antecedente, es la

regla con la clase por defecto, es decir, si el caso no satisfizo ninguna de las reglas anteriores, entonces es

de la clase indicada por la última regla que no tiene antecedente.

En el caso de las reglas de decisión, agregar una nueva regla implica simplemente añadirla a la lista de

reglas sin necesidad de hacer cambios de estructura, mientras que agregar una nueva regla en un árbol

implicaría rehacer la estructura del mismo.

4.1.3.3. Presentación de los resultados

Tanto el ID3 como el C4.5 generan un clasificador de la forma de un árbol de decisión, cuya estructura es

[Quinlan 1993d]:

• Una hoja, indicando una clase, o



• Un nodo de decisión que especifica alguna prueba a ser realizada sobre un único atributo, con una

rama y subárbol para cada valor posible de la prueba.

El árbol de decisión generado por el C4.5 cuenta con varias características particulares: cada hoja tiene

asociados dos números, que indican el número de casos de entrenamientos cubiertos por cada hoja y la

cantidad de ellos clasificados erróneamente por la hoja. Es en cierta manera, un estimador del éxito del

árbol sobre los casos de entrenamiento. El ID3, en cambio, no clasifica erróneamente a los datos de

entrenamiento, con lo cual no son necesarios este tipo de indicadores. Es por ello, que este algoritmo, a

diferencia del C4.5, corre el riesgo de caer en sobreajuste.

El propósito de construir modelos de clasificación no se limita al desarrollo de predictores precisos,

también es esencial que el modelo construido sea comprensible para los seres humanos. Michie critica al

ID3 al sostener que los resultados recientes demuestran que los programas construidos sobre la base de

sistemas tales como el ID3 pueden ser considerados, de alguna manera, “super-programas” y al mismo

tiempo ser incomprensibles para las personas. [Michie 1986, p.233] Se han estudiado varias maneras de

simplificar los árboles de decisión. Por ejemplo, en el sistema integrado propuesto, los árboles generados

por el C4.5 como por el ID3 se transforman en un conjunto de reglas de producción o decisión, un

formato que parece más comprensible que los árboles, cuando estos últimos son demasiado extensos o

frondosos.

4.2. DESCRIPCIÓN GENERAL DE LOS ALGORITMOS

El algoritmo principal de los sistemas de la familia TDIDT, a la cual pertenecen el ID3 y su descendiente

el C4.5, es el proceso de generación de un árbol de decisión inicial a partir de un conjunto de datos de

entrenamiento. La idea original está basada en un trabajo de Hoveland y Hunt de los años 50, culminado

en el libro Experiments in Induction [Hunt et al, 1966] que describe varios experimentos con varias

implementaciones de sistemas de aprendizaje de conceptos (concept learning systems - CLS).

4.2.1. División de los datos

Recordemos que el método “divide y reinarás” realiza en cada paso una partición de los datos del nodo

según una prueba realizada sobre el “mejor” atributo. Cualquier prueba que divida a T en una manera no

trivial, tal que al menos dos subconjuntos distintos Ti no estén vacíos, eventualmente resultará en una

partición de subconjuntos de una única clase, aún cuando la mayoría de los subconjuntos contengan un

solo ejemplo. Sin embargo, el proceso de construcción del árbol no apunta meramente a encontrar

cualquier partición de este tipo, sino a encontrar un árbol que revele una estructura del dominio y, por lo



tanto, tenga poder predictivo. Para ello, necesitamos un número importante de casos en cada hoja o, dicho

de otra manera, la partición debe tener la menor cantidad de clases posibles. En el caso ideal, nos gustaría

elegir en cada paso la prueba que genere el árbol más pequeño.

Entonces, estamos buscando un árbol de decisión compacto que sea consistente con los datos de

entrenamiento. Podríamos explorar todos los árboles posibles y elegir el más simple.

Desafortunadamente, un número exponencial de árboles debería ser analizado. El problema de encontrar

el árbol de decisión más pequeño consistente con un conjunto de entrenamiento es de complejidad NP-

completa.

La mayoría de los métodos de construcción de árboles de decisión, incluyendo el C4.5 y el ID3, no

permiten volver a estados anteriores, es decir, son algoritmos golosos sin vuelta atrás. Una vez que se ha

escogido una prueba para particionar el conjunto actual, típicamente basándose en la maximización de

alguna medida local de progreso, la partición se concreta y las consecuencias de una elección alternativa

no se exploran. Por este motivo, la elección debe ser bien realizada.

4.2.1.1. Elección del criterio de división

Para realizar la división de los datos en cada paso, Quinlan propone la utilización de los métodos de la

Teoría de la Información. En un principio, el ID3 utilizaba la ganancia como criterio de división. Sin

embargo, a partir de numerosas pruebas se descubrió que este criterio no era efectivo en todos los casos y

se obtenían mejores resultados si se normalizaba el criterio en cada paso. Por lo tanto, comenzó a

utilizarse la ganancia de información, con mayor éxito. El C4.5 también utiliza este último criterio para

realizar la división de los casos. Quinlan afirma que en su opinión el criterio de proporción de ganancia

es robusto y generalmente da resultados más consistentes que el criterio de ganancia [Quinlan 1988b].

La solución propuesta permite la utilización de ambos criterios. Se estudiarán y compararán los resultados

obtenidos con el ID3 y con el C4.5 utilizando la ganancia y la proporción de ganancia.

4.2.1.1.1. Criterio de Ganancia

Recordemos la definición de ganancia presentada en la ecuación 2.6. Supongamos que tenemos una

prueba posible con n resultados que particionan al conjunto T de entrenamiento en los subconjuntos T1,

T2,. . ., Tn. Si la prueba se realiza sin explorar las divisiones subsiguientes de los subconjuntos Ti, la única

información disponible para evaluar la partición es la distribución de clases en T y sus subconjuntos.



Consideremos una medida similar luego de que T ha sido particionado de acuerdo a los n resultados de la

prueba X. La información esperada (entropía) puede determinarse como la suma ponderada de los

subconjuntos, de la siguiente manera

(4.2)

La cantidad

(4.3)

mide la información ganada al partir T de acuerdo a la prueba X. El criterio de ganancia, entonces,

selecciona la prueba que maximice la ganancia de información. Es decir, antes de particionar los datos en

cada nodo, se calcula la ganancia que resultaría de particionar el conjunto de datos según cada uno de los

atributos posibles. Se realiza la partición que resulta en la mayor ganancia.

4.2.1.1.2. Criterio de Proporción de Ganancia

El criterio de ganancia tiene un defecto muy serio: presenta una tendencia muy fuerte a favorecer las

pruebas con muchos resultados. Analicemos una prueba sobre un atributo que sea la clave primaria de un

conjunto de datos, en la cual, obtendremos un único subconjunto para cada caso, y para cada subconjunto

tendremos I (T,X) = 0, entonces la ganancia de información será máxima. Desde el punto de vista de la

predicción, este tipo de división no es útil.

Esta tendencia inherente al criterio de ganancia puede corregirse mediante una suerte de normalización,

en la cual se ajusta la ganancia aparente, atribuible a pruebas con muchos resultados. Consideremos el

contenido de información de un mensaje correspondiente a los resultados de las pruebas. Por analogía a la

definición de la I(S) tenemos:

(4.4)

Esto representa la información potencial generada al dividir T en n subconjuntos, mientras que la

ganancia de información mide la información relevante a una clasificación que nace de la misma división.

Entonces,

(4.5)

( ) ( ) ( )XTHTHXTI ,, −=

( ) ∑=

×−=

n

i

ii

TT

TT

XdivisiónI1

2log_

)(_),()(__

XdivisiónIXTIXgananciadeproporción =

( ) ( )∑=

×=n

ii

i THTT

XTH1

,



expresa la proporción útil de información generada en la partición. Si la partición es casi trivial, la

información de la división será pequeña y esta proporción se volverá inestable. Para evitar este fenómeno,

el criterio de proporción de ganancia selecciona una prueba que maximice la expresión anterior, sujeto a

la restricción de que la información de la división sea grande, al menos tan grande como la ganancia

promedio sobre todas las pruebas realizadas.

4.3. ID3El algoritmo ID3 fue diseñado en 1993 por J. Ross Quinlan [Quinlan, 93a, Quinlan, 1993b]. El ID3 toma

objetos de una clase conocida y los describe en términos de una colección fija de propiedades o de

atributos, y produce un árbol de decisión sobre estos atributos que clasifica correctamente todos los

objetos [Quinlan, 1993b]. Hay ciertas cualidades que diferencian a este algoritmo de otros sistemas

generales de inferencia. La primera se basa en la forma en que el esfuerzo requerido para realizar una

tarea de inducción crece con la dificultad de la tarea. El ID3 fue diseñado específicamente para trabajar

con masas de objetos, y el tiempo requerido para procesar los datos crece sólo linealmente con la

dificultad, como producto de:

• la cantidad de objetos presentados como ejemplos,

• la cantidad de atributos dados para describir estos objetos, y

• la complejidad del concepto a ser desarrollado (medido por la cantidad de nodos en el árbol de

decisión)

Esta linealidad se consigue a costo del poder descriptivo: los conceptos desarrollados por el ID3 sólo

toman la forma de árboles de decisión basados en los atributos dados, y este “lenguaje” es mucho más

restrictivo que la lógica de primer orden o la lógica multivaluada, en la cual otros sistemas expresan sus

conceptos [Quinlan, 1993b].

El ID3 fue presentado como descendiente del CLS creado por Hunt. El ID3, como contrapartida de su

antecesor, es un mecanismo mucho más simple para el descubrimiento de una colección de objetos

pertenecientes a dos o más clases. Cada objeto debe estar descripto en términos de un conjunto fijo de

atributos, cada uno de los cuales cuenta con su conjunto de posibles valores de atributos. Por ejemplo, el

atributo humedad puede tener los valores alta, baja, y el atributo clima, soleado, nublado, lluvioso.

Una regla de clasificación en la forma de un árbol de decisión puede construirse para cualquier conjunto

C de atributos de esa forma [Quinlan, 1993b]. Si C está vacío, entonces se lo asocia arbitrariamente a

cualquiera de las clases. Si no, C contiene los representantes de varias clases; se selecciona un atributo y

se particiona C en conjuntos disjuntos C1, C2,..., Cn, donde Ci contiene aquellos miembros de C que tienen



el valor i para el atributo seleccionado. Cada una de estos subconjuntos se maneja con la misma

estrategia. El resultado es un árbol en el cual cada hoja contiene un nombre de clase y cada nodo interior

especifica un atributo para ser testeado con una rama correspondiente al valor del atributo.

4.3.1. Descripción del ID3

El objetivo del ID3 es crear una descripción eficiente de un conjunto de datos mediante la utilización de

un árbol de decisión. Dados datos consistentes, es decir, sin contradicción entre ellos, el árbol resultante

describirá el conjunto de entrada a la perfección. Además, el árbol puede ser utilizado para predecir los

valores de nuevos datos, asumiendo siempre que el conjunto de datos sobre el cual se trabaja es

representativo de la totalidad de los datos.

Dados:

• Un conjunto de datos

• Un conjunto de descriptores de cada dato

• Un clasificador/conjunto de clasificadores para cada objeto.

Se desea obtener:

• Un árbol de decisión simple basándose en la entropía, donde los nodos pueden ser:

1. Nodos intermedios: en donde se encuentran los descriptores escogidos según el criterio de

entropía, que determinan cuál rama es la que debe tomarse.

2. Hojas: estos nodos determinan el valor del clasificador.

Este procedimiento de formación de reglas funcionará siempre dado que no existen dos objetos

pertenecientes a distintas clases pero con idéntico valor para cada uno de sus atributos; si este caso

llegara a presentarse, los atributos son inadecuados para el proceso de clasificación.

Hay dos conceptos importantes a tener en cuenta en el algoritmo ID3[Blurock, 1996]: la entropía y el

árbol de decisión. La entropía se utiliza para encontrar el parámetro más significativo en la

caracterización de un clasificador. El árbol de decisión es un medio eficiente e intuitivo para organizar los

descriptores que pueden ser utilizados con funciones predictivas.



4.3.1.1. Algoritmo ID3

A continuación se presenta el algoritmo del método ID3 para la construcción de árboles de decisión en

función de un conjunto de datos previamente clasificados.

Función ID3(R: conjunto de atributos no clasificadores, C: atributo clasificador, S: conjunto de entrenamiento) devuelve un árbol de decisión;

ComienzoSi S está vacío,

devolver un único nodo con Valor Falla;Si todos los registros de S tienen el mismo valor para el atributo clasificador,

Devolver un único nodo con dicho valor;Si R está vacío, entonces

devolver un único nodo con el valor más frecuente del atributo clasificador enlos registros de S [Nota: habrá errores, es decir, registros que no estarán bienclasificados en este caso];

Si R no está vacío, entoncesD ! atributo con mayor Ganancia(D,S) entre los atributos de R;Sean dj| j=1,2, .., m los valores del atributo D;Sean Sj| j=1,2, .., m los subconjuntos de S correspondientes a los valores dedj respectivamente;Devolver un árbol con la raíz nombrada como D y con los arcos nombrados d1, d2,.., dm que van respectivamente a los árbolesID3(R-D, C, S1), ID3(R-D, C, S2), .., ID3(R-D, C, Sm);

Fin

4.3.1.2. Poda de los árboles de decisión

La poda de los árboles de decisión se realiza con el objetivo de que éstos sean más comprensibles. Lo

cual implica que tengan menos niveles y/o sean menos frondosos. La poda aplicada en el ID3 se realiza

una vez que el árbol ha sido generado y es un mecanismo bastante simple: si de un nodo nacen muchas

ramas, las cuales terminan todas en la misma clase, entonces se reemplaza dicho nodo por una hoja con la

clase común. En caso contrario, se analizan todos los nodos hijos.

4.3.1.3. Pasaje a reglas de decisión

Para pasar a reglas de decisión, el ID3 recorre el árbol desde la raíz hasta las hojas y genera una regla por

cada camino recorrido. El antecedente de cada regla estará compuesto por la conjunción de las pruebas de

valor de cada nodo visitado, y la clase será la correspondiente a la hoja. El recorrido del árbol se basa en

el recorrido de preorden (de raíz a hojas, de izquierda a derecha). Como estamos trabajando con árboles

n-arios, este recorrido es único.



4.3.1.4. Atributos desconocidos

Es necesario que todos los casos presentados al ID3 estén descriptos por los mismos atributos. Esto limita

la aplicación del algoritmo, ya que no siempre se cuenta con toda la información necesaria. Imaginemos

una base de datos histórica en la que se fueron agregando atributos a medida que se lo consideró

necesario, para los primeros casos de la misma no se conocerán los valores de los nuevos atributos. El

ID3 puede trabajar con atributos desconocidos, los considera como si fuesen un nuevo valor, por ello, se

llega a la convención de que los valores desconocidos, deben expresarse con un “?” en los datos. El “?”

constituye un nuevo valor posible para el atributo en cuestión.

4.3.1.5. Resolución de un ejemplo utilizando el ID3

En esta sección se presentarán un árbol y un conjunto de reglas de decisión obtenidos utilizando el ID3,

para ejemplificar su aplicación. Supongamos que queremos analizar cuáles días son convenientes para

jugar al tenis basándonos en la humedad, el viento y el estado del tiempo. Los datos que se utilizarán se

presentan en la siguiente tabla:

Estado Humedad Viento JuegoTenisSoleado Alta Leve NoSoleado Alta Fuerte NoNublado Alta Leve SiLluvia Alta Leve SiLluvia Normal Leve SiLluvia Normal Fuerte NoNublado Normal Fuerte SiSoleado Alta Leve NoSoleado Normal Leve SiLluvia Normal Leve SiSoleado Normal Fuerte SiNublado Alta Fuerte SiNublado Normal Leve SiLluvia Alta Fuerte Si

En el caso de este ejemplo, los árboles y las reglas obtenidos utilizando la ganancia y la proporción de

ganancia son iguales. Se mostrarán ambos ejemplos juntos con fines prácticos.

Construcción del árbol de decisión

A partir de todos los datos disponibles, el ID3 analiza todas las divisiones posibles según los distintos

atributos y calcula la ganancia y/o la proporción de ganancia. Comecemos analizando el atributo Estado.



El atributo Estado tiene la siguiente distribución de datos:

Lluvia Nublado SoleadoNo 1 0 3Si 4 4 2Totales 5 4 5

Para calcular la ganancia y, por lo tanto, también la proporción de ganancia, es necesario calcular la

entropía del conjunto. Entonces,

bitsppppSH NoNoSiSi 86312.0144log

144

1410log

1410loglog)( 2222 =−−=−−=

Calculamos ahora la entropía que tendrían los conjuntos resultantes de la división de datos según este

atributo.

( ) ( )∑=

−−+

−−+

−−=⋅=

2

1222222 5

2log52

53log

53

145

44log

44

40log

40

144

54log

54

51log

51

145),(

iii SHSPEstadoSH

bitsEstadoSH 6046.097095.01450

1447219.0

145),( =+×+×=

Ahora calculamos la ganancia resultante de dividir al subconjunto según el atributo Estado, tendremos:

( ) ( ) ( ) bitsEstadoSHSHEstadoSGanancia 25852.0,, =−=

Para calcular la proporción de ganancia debemos conocer primero la información de la división que se

calcula como:

Finalmente, calculamos la proporción de ganancia.

De la misma manera en que calculamos la ganancia y la proporción de ganancia para el caso anterior,

calculamos para el atributo Humedad los siguientes valores:

( ) bitsSS

SS

SdivisiónIn

i

ii 577.1145log

145

144log

144

145log

145log_ 222

12 =

×−

×−

×−=

×−= ∑

=

bitsSdivisiónI

SGananciaSgananciadeproporción 491042.0)(_

)()(__ ==



Ganancia=0.0746702 bits Proporción de ganancia =0.14934 bits

Para el caso del atributo Viento obtenemos los siguientes valores:


Una vez que hemos calculado las ganancias y proporciones de ganancia para todos los atributos

disponibles, debemos elegir el atributo según el cual dividiremos a este conjunto de datos. Recordemos

que tanto en el caso de la ganancia como en el de la proporción de ganancia, el mejor atributo para la

división es aquel que la maximiza. En este ejemplo, la división según el atributo Estado es la que mayor

ganancia y proporción de ganancia ofrece. Esto significa que el nodo raíz del árbol será un nodo que

evalúa el atributo Estado.

La figura 4.2 esquematiza la construcción de un árbol de decisión utilizando el ID3 para el conjunto de

datos en cuestión. La figura 4.3 presenta el árbol de decisión obtenido.

Transformación a reglas de decisión

Como se explicó en la sección 4.3.1.3 para pasar un árbol de decisión a reglas de decisión, el ID3 lo

recorre en preorden y cada vez que llega a una hoja, escribe la regla que tiene como consecuente el valor

de la misma, y como antecedente, la conjunción de las pruebas de valor especificados en todos los nodos

recorridos desde la raíz para llegar a dicha hoja. Analicemos el pasaje del árbol de la figura 4.3 a reglas de

decisión.

El recorrido del árbol comienza por la raíz Estado, continúa por los nodos Viento y Humedad hasta llegar

a la hoja “SI”. La regla generada para este recorrido será:

Regla 0 SI Estado = Lluvia Y Viento = Fuerte Y Humedad = Alta ENTONCES JuegoTenis = Si

Si seguimos el recorrido preorden, llegamos a continuación a la hoja “NO”, obteniendo en este caso la

siguiente regla:

Regla 1 SI Estado = Lluvia Y Viento = Fuerte Y Humedad = Normal ENTONCES JuegoTenis = No



Figura 4.2: Esquema de la construcción de un árbol de decisión utilizando el ID3

HUMEDADGanancia=0.970951Proporción de ganancai=2.03632

VIENTOGanancia=0.0199731Proporción de ganancia=0.0418885

ESTADOganancia=0.258521proporción de ganancia=0.491042

HUMEDADGanancia=0.0746702Proporción de ganancia =0.14934

VIENTOGanancia=0.00597769Proporción de ganancia=0.0122457

Estado Humedad Viento JuegoTenisSoleado Alta Leve NoSoleado Alta Fuerte NoNublado Alta Leve SiLluvia Alta Leve SiLluvia Normal Leve SiLluvia Normal Fuerte NoNublado Normal Fuerte SiSoleado Alta Leve NoSoleado Normal Leve SiLluvia Normal Leve SiSoleado Normal Fuerte SiNublado Alta Fuerte SiNublado Normal Leve SiLluvia Alta Fuerte Si

Estado Humedad Viento JuegoTenisLluvia Alta Leve SiLluvia Normal Leve SiLluvia Normal Fuerte NoLluvia Normal Leve SiLluvia Alta Fuerte Si

Estado Humedad Viento JuegoTenisNublado Alta Leve SiNublado Normal Fuerte SiNublado Alta Fuerte SiNublado Normal Leve Si

Estado Humedad Viento JuegoTenisSoleado Alta Leve NoSoleado Alta Fuerte NoSoleado Alta Leve NoSoleado Normal Leve SiSoleado Normal Fuerte Si

Lluvia SoleadoNublado


VIENTOGanancia=0.321928Proporción de ganancia =0.675162

Estado

Estado Humedad Viento JuegoTenisSoleado Alta Leve NoSoleado Alta Fuerte NoSoleado Alta Leve No

Estado Humedad Viento JuegoTenisSoleado Normal Leve SiSoleado Normal Fuerte Si

SI

SI

NO

Viento

Leve

Fuerte

Estado Humedad Viento JuegoTenisLluvia Normal Fuerte NoLluvia Alta Fuerte Si

Estado Humedad Viento JuegoTenisLluvia Alta Leve SiLluvia Normal Leve SiLluvia Normal Leve Si

Estado Humedad Viento JuegoTenisLluvia Normal Fuerte No

Estado Humedad Viento JuegoTenisLluvia Alta Fuerte Si

Humedad

NormalAlta

Humedad

NormalAlta

NOSI

SI



Figura 4.3: Arbol de decisión obtenido con el ID3

Recorriendo en este sentido el árbol, el resto de las reglas obtenidas se muestran a continuación.

Regla 2 SI Estado = Lluvia Y Viento = Leve ENTONCES JuegoTenis = Si

Regla 3 SI Estado = Nublado ENTONCES JuegoTenis = Si

Regla 4 SI Estado = Soleado Y Humedad = Alta ENTONCES JuegoTenis = No

Regla 5 SI Estado = Soleado Y Humedad = Normal ENTONCES JuegoTenis = Si

4.3.2. Limitaciones al ID3

4.3.2.1. Valores continuos

El ID3 puede aplicarse a cualquier conjunto de datos, siempre y cuando los atributos sean discretos. Este

sistema no cuenta con la facilidad de trabajar con atributos continuos ya que analiza la entropía sobre

cada uno de los valores de un atributo, por lo tanto, tomaría cada valor de un atributo continuo

individualmente en el cálculo de la entropía, lo cual no es útil en muchos de los dominios. Cuando se

trabaja con atributos continuos generalmente se piensa en rangos de valores y no en valores particulares.

Lluvia SoleadoNublado

Estado

SI

SI NO

Viento

LeveFuerte

Humedad

NormalAlta

Humedad

NormalAlta

NOSI

SI



Existen varias maneras de solucionar este problema del ID3, como la agrupación de valores presentada en

[Gallion et al, 1993] o la discretización de los mismos explicada en [Blurock, 1996], [Quinlan, 1993d]. El

C4.5 resolvió el problema de los atributos continuos mediante la discretización, explicada en la Sección

2.4.1.2.

4.3.2.3. Ventanas

El proceso descripto para la construcción de árboles de decisión asume que las operaciones de cálculo,

especialmente, las de evaluación de las frecuencias relativas (en las que se deben contar elementos) del

conjunto C, pueden ser realizadas eficientemente, lo cual significa, en la práctica, que para que el proceso

sea rápido, C debe residir en memoria. ¿Qué pasa si C es tan grande que no cabe en memoria? La

solución aplicada por ID3 es una solución iterativa, que crea sucesivos árboles de decisión de precisión

cada vez mayor, hasta llegar al árbol de decisión óptimo. El método puede resumirse como [Quinlan,

1993b]:

Elegir un conjunto aleatorio de instancias (llamado ventana).Repetir:

Formar una regla para explicar la ventana actualEncontrar las excepciones a la regla en el resto de las instanciasCrear una nueva ventana a partir de la ventana actual y las excepciones a laregla generada a partir de ella

Hasta que no queden excepciones a la regla.

El proceso termina cuando se forma una regla que no tenga excepciones y sea correcta para todo C. Se

han testeado dos métodos para formar la nueva ventana. En el primero, la ventana actual crece por la

adición de excepciones hasta un número especificado. El segundo método trata de identificar los objetos

“claves” en la ventana actual y reemplaza el resto por excepciones. Ambos métodos fueron probados con

un problema de clasificación no trivial de 14 atributos y cerca de 20.000 objetos para los cuales un árbol

de decisión correcto contenía 20 nodos [Quinlan, 1993b]. Las conclusiones obtenidas de estas pruebas

fueron:

• Los métodos convergen rápidamente; generalmente, se precisaron sólo 4 iteraciones para llegar a un

árbol de decisión correcto.

• Fue posible desarrollar un árbol correcto a partir de la ventana final que contenía sólo una pequeña

fracción del total de los objetos

• El proceso no fue sensible a parámetros como el tamaño de la ventana inicial.



• El tiempo requerido para obtener un árbol de decisión correcto para el problema de clasificación

crece linealmente con la cantidad de ejemplos que están siendo analizados.

4.4. C4.5El C4.5 se basa en el ID3, por lo tanto, la estructura principal de ambos métodos es la misma. El C4.5

construye un árbol de decisión mediante el algoritmo “divide y reinarás” y evalúa la información en cada

caso utilizando los criterios de entropía y ganancia o proporción de ganancia, según sea el caso. A

continuación, se explicarán las características particulares de este método que lo diferencian de su

antecesor.

4.4.1. Algoritmo C4.5

El algoritmo del método C4.5 para la construcción de árboles de decisión a grandes rasgos muy similar al

del ID3. Varía en la manera en que realiza las pruebas sobre los atributos, tal como se detalla en las

secciones siguientes.

Función C4.5(R: conjunto de atributos no clasificadores,C: atributo clasificador,S: conjunto de entrenamiento) devuelve un árbol de decisión;

ComienzoSi S está vacío,

devolver un único nodo con Valor Falla;Si todos los registros de S tienen el mismo valor para el atributo clasificador,

Devolver un único nodo con dicho valor;Si R está vacío, entonces

devolver un único nodo con el valor más frecuente del atributo clasificador enlos registros de S [Nota: habrá errores, es decir, registros que no estarán bienclasificados en este caso];

Si R no está vacío, entoncesD ! atributo con mayor Proporción de Ganancia(D,S) entre los atributos de R;Sean dj| j=1,2, .., m los valores del atributo D;Sean Sj| j=1,2, .., m los subconjuntos de S correspondientes a los valores dedj respectivamente;Devolver un árbol con la raíz nombrada como D y con los arcos nombrados d1, d2,.., dm que van respectivamente a los árbolesC4.5(R-D, C, S1), C4.5(R-D, C, S2), .., C4.5(R-D, C, Sm);

Fin



4.4.2. Características particulares del C4.5

4.4.2.1. Pruebas utilizadas

En cada nodo, el sistema debe decidir cuál prueba escoge para dividir los datos. Los tres tipos de pruebas

posibles propuestas por el C4.5 son [Quinlan, 1993d]:

1. La prueba “estándar” para los atributos discretos, con un resultado y una rama para cada valor

posible del atributo.

2. Una prueba más compleja, basada en un atributo discreto, en donde los valores posibles son

asignados a un número variable de grupos con un resultado posible para cada grupo, en lugar de para

cada valor.

3. Si un atributo A tiene valores numéricos continuos, se realiza una prueba binaria con resultados A ≤ Z

y A > Z, para lo cual debe determinarse el valor límite Z.

Todas estas pruebas se evalúan de la misma manera, mirando el resultado de la proporción de ganancia, o

alternativamente, el de la ganancia, resultante de la división que producen. Ha sido útil agregar una

restricción adicional: para cualquier división, al menos dos de los subconjuntos Ti deben contener un

número razonable de casos. Esta restricción, que evita las subdivisiones casi triviales es tenida en cuenta

solamente cuando el conjunto T es pequeño.

4.4.2.2. Pruebas sobre atributos continuos

Las pruebas para valores continuos trabajan con un valor límite arbitrario. El método utilizado para ello

por el C4.5 es muy simple [Quinlan, 1993d] [Quinlan, 1996a]. Primero, los casos de entrenamiento T se

ordenan según los valores del atributo A continuo que está siendo considerado. Existe un número finito de

estos valores.

Sean v1, v2,. . ., vm los valores que toma el atributo A. Cualquier valor límite entre vi y vi+1 tendrá el

mismo efecto al dividir los casos entre aquellos cuyo valor para A pertenece al subconjunto v1, v2,. . .,

vi y aquellos cuyo valor pertenece a vi+1, vi+2,. . ., vm. Entonces, existen sólo m – 1 divisiones posibles

de según el valor de A y todas son examinadas. Al estar ordenados, las sucesivas pruebas para todos los

valores, pueden realizarse en una única pasada.

Típicamente se elige el punto medio del intervalo como valor límite representativo, entonces el iésimo

valor límite sería:



(4.6)

C4.5 se diferencia de otros algoritmos en que elige el mayor valor de A en todo el conjunto de casos de

entrenamiento que no excede el punto medio presentado, en lugar del punto medio en sí mismo, como

valor límite; de esta manera se asegura que todos los valores límites que aparezcan en el árbol y/o las

reglas ocurran al menos una vez en los datos.

El método utilizado para la binarización de atributos tiene una gran desventaja. Mientras que todas las

operaciones de construcción de un árbol de decisión crecen linealmente con el número de casos de

entrenamiento, el ordenamiento de d valores continuos crece proporcionalmente a d x log(d). Entonces, el

tiempo requerido para construir un árbol a partir de un gran conjunto de datos de entrenamiento, puede

estar dominado por el ordenamiento de datos con valores continuos.

4.4.2.2. Atributos desconocidos

C4.5 asume que todos los resultados de pruebas desconocidos se distribuyen probabilísticamente según la

frecuencia relativa de los valores conocidos. Un caso (posiblemente fraccional) con un valor desconocido

se divide en fragmentos cuyos pesos son proporcionales a dichas frecuencias relativas, dando por

resultado que un caso puede seguir múltiples caminos en el árbol. Esto se aplica tanto cuando los casos de

entrenamiento se dividen durante la construcción del árbol, como cuando el árbol se utiliza para clasificar

casos.

4.4.2.2.1. Evaluación de las pruebas

La modificación del criterio de ganancia es bastante directa. La ganancia de una prueba mide la

información sobre la pertenencia a una clase que puede esperarse como resultado de partir un conjunto de

datos de entrenamiento, calculada al restar la información que se espera que sea necesaria para identificar

la clase de un objeto después de la partición a la misma cantidad antes de la partición. Es evidente que

una prueba no puede proveer información de pertenencia a una clase si no se conoce el valor de un

atributo.

Sea T el conjunto de datos de entrenamiento y X una prueba basada en un atributo A, supongamos que el

valor de A se conoce únicamente en una fracción F de casos en T. Sean I(T) e IX(T) calculadas según la

ecuación 2.4, excepto que sólo se tienen en cuenta los casos para los cuales el valor de A es conocido. La

definición de ganancia puede corregirse a:

21++ ii vv



(4.7)

o, en otras palabras, la ganancia aparente de mirar a los casos con valores conocidos, multiplicada por la

fracción de dichos casos en el conjunto de entrenamiento.

El cálculo de la proporción de ganancia se realiza de la misma manera que en la ecuación 4.5. La

definición de información de la división puede modificarse de manera similar, considerando los casos con

valores desconocidos como un grupo más, entonces, si una prueba tienen n resultados, su información de

la división se calcula como la prueba dividido n+1subconjuntos.

(4.8)

4.4.1.2.2. Partición del conjunto de entrenamiento

Una prueba puede seleccionar del conjunto de pruebas posibles, como antes, pero utilizando las versiones

modificadas de ganancia e información de la división. Si la prueba X con resultados O1, O2, ..., ON es

escogida y tiene algunos valores desconocidos para algunos de los datos de entrenamiento, el concepto de

particionamiento debe ser generalizado, según un criterio probabilístico.

Cuando un caso T con un resultado conocido Oi es asignado al subconjunto Ti, esto significa que la

probabilidad de que el caso pertenezca a Ti es 1 y de que pertenezca a todos los otros subconjuntos es 0.

Cuando el resultado es desconocido, sólo se puede realizar una afirmación estadística más débil.

Entonces, se asocia con cada caso del subconjunto Ti un peso representando la probabilidad de que el caso

pertenezca a cada subconjunto. Si el resultado para el caso es conocido, entonces el peso es 1; si el caso

tiene un resultado desconocido, entonces el peso es simplemente la probabilidad del resultado Oi en este

punto. Cada subconjunto Ti es una colección de casos fraccionales posibles, tal que |Ti| debe ser

reinterpretada como la suma de los pesos fraccionales de los casos pertenecientes al subconjunto.

Los casos de entrenamiento en T pueden tener pesos no unitarios, ya que T puede ser el resultado de una

partición previa. Entonces, en general, un caso de T con peso p cuyo resultado no se conoce, es asignado a

cada subconjunto Ti con peso:

P x probabilidad_de_resultado_Oi (4.9)

( ) ( ) ( )( )

( ) ( )( )TITIFconocidoseanoAadprobabilid

TITIconocidoseaAadprobabilidXGanancia

X

X

−×=×+

−×=0____

___

( ) ∑+

=

+

×+

−=1

12 1

log1

_n

i

ii

TT

TT

XdivisiónI



La probabilidad_de_resultado_Oi se estima como la suma de los pesos de los casos en T con valores

conocidos que tienen resultado Oi, sobre la suma de los pesos de los casos en T con resultado conocidos

para la prueba.

4.4.1.2.3. Clasificación de un nuevo caso

Se toma un enfoque similar cuando el árbol de decisión es utilizado para clasificar un caso. Si en un nodo

de decisión el atributo relevante no se conoce, de manera tal que el resultado de la prueba no puede

determinarse, el sistema explora todos los resultados posibles y combina aritméticamente las

clasificaciones resultantes. Como para cada atributo pueden existir múltiples caminos desde la raíz del

árbol hasta las hojas, una “clasificación” es una distribución de clases más que una única clase. Cuando la

distribución de clases total para un caso nuevo ha sido establecida de esta manera, la clase con la

probabilidad más alta, es asignada como “la” clase predicha.

La información de la división aún se determina a partir del conjunto de entrenamiento completo y es

mayor, ya que existe una categoría extra para los valores desconocidos.

Cada hoja en el árbol de decisión resultante tiene asociados dos valores: (N/E). N es la suma de los casos

fraccionales que llegan a la hoja; y E es el número de casos cubiertos por la hoja, que no pertenecen a la

clase de la misma.

4.4.3. Poda de los Árboles de Decisión

El método recursivo de particionamiento para construir los árboles de decisión descripto anteriormente,

subdividirá el conjunto de entrenamiento hasta que la partición contenga casos de una única clase, o hasta

que la prueba no ofrezca mejora alguna. Esto da como resultado, generalmente, un árbol muy complejo

que sobreajusta los datos al inferir una estructura mayor que la requerida por los casos de entrenamiento

[Mitchell, 2000b] [Quinlan, 1995]. Además, el árbol inicial generalmente es extremadamente complejo y

tiene una proporción de errores superior a la de un árbol más simple. Mientras que el aumento en

complejidad se comprende a simple vista, la mayor proporción de errores puede ser más difícil de

visualizar.

Para entender este problema, supongamos que tenemos un conjunto de datos dos clases, donde una

proporción p ≥ 0.5 de los casos pertenecen a la clase mayoritaria. Si un clasificador asigna todos los casos

con valores indeterminados a la clase mayoritaria, la proporción esperada de error es claramente 1 – p. Si,



en cambio, el clasificador asigna un caso a la clase mayoritaria con probabilidad p y a la otra clase con

probabilidad 1 - p, su proporción esperada de error es la suma de:

• la probabilidad de que un caso perteneciente a la clase mayoritaria sea asignado a la otra clase, p x (1

– p), y

• la probabilidad de que un caso perteneciente a la otra clase sea asignado a la clase mayoritaria, (1 –

p) x p

que da como resultado 2 x p (1 – p). Como p es al menos 0.5, esto es generalmente superior a 1 – p,

entonces el segundo clasificador tendrá una mayor proporción de errores. Un árbol de decisión complejo

tiene una gran similitud con este segundo tipo de clasificador. Los casos no se relacionan a una clase,

entonces, el árbol manda cada caso al azar a alguna de las hojas.

Un árbol de decisión no se simplifica borrando todo el árbol a favor de una rama, sino que se eliminan las

partes del árbol que no contribuyen a la exactitud de la clasificación para los nuevos casos, produciendo

un árbol menos complejo, y por lo tanto, más comprensible.

4.4.3.1. ¿Cuándo debemos simplificar?

Existen, básicamente, dos maneras de modificar el método de particionamiento recursivo para producir

árboles más simples: decidir no dividir más un conjunto de casos de entrenamiento, o remover

retrospectivamente alguna parte de la estructura construida por el particionamiento recursivo.

El primer enfoque, conocido como pre-poda, tiene la ventaja de que no se pierde tiempo en construir una

estructura que luego será simplificada en el árbol final. Los sistemas que lo aplican, generalmente buscan

la mejor manera de partir el subconjunto y evalúan la partición desde el punto de vista estadístico

mediante la teoría de la ganancia de información, reducción de errores, etc. Si esta evaluación es menor

que un límite predeterminado, la división se descarta y el árbol para el subconjunto es simplemente la

hoja más apropiada. Sin embargo, este tipo de método tiene la desventaja de que no es fácil detener un

particionamiento en el momento adecuado, un límite muy alto puede terminar con la partición antes de

que los beneficios de particiones subsiguientes parezcan evidentes, mientras que un límite demasiado bajo

resulta en una simplificación demasiado leve.

El C4.5 utiliza el segundo enfoque, el método de divide y reinarás procesa los datos de entrenamiento

libremente, y el árbol sobreajustado producido es podado después. Los procesos computacionales extras

invertidos en la construcción de partes del árbol que luego serán podadas pueden ser sustanciales, pero el



costo no supera los beneficios de explorar una mayor cantidad de particiones posibles. El crecimiento y

la poda de los árboles son más lentos, pero más confiables.

La poda de los árboles de decisión llevará, sin duda, a clasificar erróneamente una mayor cantidad de los

casos de entrenamiento. Por lo tanto, las hojas de un árbol podado no contendrán necesariamente una

única clase sino una distribución de clases, como se explicó con anterioridad. Asociado a cada hoja, habrá

una distribución de clases especificando, para cada clase, la probabilidad de que un caso de entrenamiento

en la hoja pertenezca a dicha clase.

4.4.3.2. Poda en Base a Errores

Generalmente, la simplificación de los árboles de decisión se realiza descartando uno o más subárboles y

reemplazándolos por hojas. Al igual que en la construcción de árboles, las clases asociadas con cada hoja

se encuentran al examinar los casos de entrenamiento cubiertos por la hoja y eligiendo el caso más

frecuente. Además de este método, el C4.5 permite reemplazar un subárbol por alguna de sus ramas.

Supongamos que fuera posible predecir la proporción de errores de un árbol y sus subárboles. Esto

inmediatamente llevaría al siguiente método de poda: “Comenzar por las hojas y examinar cada subárbol.

Si un reemplazo del subárbol por una hoja o por su rama más frecuentemente utilizada, lleva a una

proporción de errores predicha (predicted error rate) menor, entonces podar el árbol de acuerdo a ello,

recordando que las proporciones de errores predichas para todos los subárboles que lo contienen se verán

afectadas”. Como la proporción de errores predicha para un árbol disminuye si disminuyen las

proporciones de errores predichas en cada una de sus ramas, este proceso generaría un árbol con una

proporción de errores predicha mínima.

¿Cómo podemos predecir la proporción de errores? Está claro que calcular la proporción de errores a

partir de los datos de entrenamiento para los cuales el árbol fue construido, no es un estimador útil, ya que

en lo que respecta al conjunto de entrenamiento, la poda siempre aumenta la proporción de errores.

Existen dos familias de técnicas para predecir la proporción de errores. La primer familia predice la

proporción de errores de un árbol y sus subárboles utilizando un nuevo conjunto de casos distinto del

conjunto de entrenamiento. Como estos casos no fueron examinados durante la construcción del árbol, los

estimadores obtenidos a partir de ellos son insesgados y, de existir suficientes casos, confiables. Ejemplos

de esta familia son:

• Poda según la complejidad del costo (Cost-complexity pruning) [Breinman et al, 1984] en la cual la

proporción de errores predicha para un árbol se modela como la suma ponderada de su complejidad y

sus errores en los casos de entrenamiento, con los casos extras utilizados para determinar los

coeficientes de la ponderación.



• Poda de reducción de errores (Reduced-error pruning)[Quinlan, 1987e], que evalúa la proporción de

errores de un árbol y sus componentes directamente a partir del nuevo conjunto de casos.

La desventaja de esta familia de técnicas es simplemente que una parte del conjunto de datos

preclasificados a partir de los que se construyó el árbol debe guardarse para determinar los errores,

entonces el árbol debe ser construido a partir de un conjunto de datos más pequeño. Una solución a este

problema es utilizar un enfoque de referencias cruzadas. Este consiste en dividir los casos disponibles en

bloques iguales de tamaño C y, para cada bloque, un árbol se construye con todos los otros bloques y se

miden los errores con el bloque elegido. Para valores moderados de C, se asume que el árbol construido a

partir de todos los bloques menos uno será muy similar al construido a partir de todos los datos. Por

supuesto que deben construirse C árboles y no uno solo.

El enfoque tomado por el C4.5 pertenece a la segunda familia de técnicas que utilizan únicamente el

conjunto de entrenamiento a partir del cual se construyó el árbol. La estimación de la proporción de

errores pura se ajusta para reflejar su propia tendencia. El método utilizado por el C4.5 se describe a

continuación.

Cuando una hoja cubre N casos de entrenamiento, E de ellos en forma errónea, el estimador de la

proporción de errores de resubstitución para dicha hoja es N/E. Podemos entender esto de manera naif

como E “eventos” en N pruebas. Si el conjunto de N casos de entrenamiento se tomase como una muestra

(lo cual, por supuesto, no es cierto), nos podríamos preguntar qué nos dice este resultado acerca de la

probabilidad de un evento (error) en la totalidad de la población de casos cubiertos por la hoja. La

probabilidad de error no puede determinarse de forma exacta, pero cuenta con límites de confianza. Para

un límite de confianza CF, el límite superior de esta probabilidad puede encontrarse a partir de los límites

de confianza para la distribución binomial; el límite superior se expresa como UCF(E,N). Como en la

distribución binomial los límites superior e inferior son simétricos, la probabilidad de que el promedio

real de errores exceda UCF(E,N)es CF/2. El C4.5 simplemente iguala el estimador de error predicho de la

hoja con su límite superior, bajo el argumento de que el árbol fue construido para minimizar la

proporción de error observada. Aunque los fundamentos de esta heurística son cuestionables y violan

algunos principios estadísticos, las estimaciones producidas presentan frecuentemente resultados

aceptables.

Para simplificar el cálculo, las proporciones de error para las hojas y subárboles se computan asumiendo

que fueron utilizados para clasificar un conjunto de nuevos casos del mismo tamaño del conjunto de

entrenamiento. Entonces, una hoja que cubre N casos de entrenamiento con un estimador de error

predicho de UCF(E,N) generaría N x UCF(E,N) errores predichos. Análogamente, la cantidad de errores

predichos asociados con un (sub)árbol es la suma de los errores predichos para cada una de sus ramas.



4.4.4. Estimación de la Proporción de Errores para los

Árboles de Decisión

Una vez podados, las hojas de los árboles de decisión generados por el C4.5 tendrán dos números

asociados: N y E. N es la cantidad de casos de entrenamiento cubiertos por la hoja, y E es la cantidad de

errores predichos si un conjunto de N nuevos casos fuera clasificados por el árbol.

La suma de los errores predichos en las hojas, dividido el número de casos de entrenamiento, es un

estimador inmediato del error de un árbol podado sobre nuevos casos.

4.4.5. Construcción de un árbol de decisión utilizando el

C4.5

Supongamos que queremos construir un árbol de decisión para los siguientes datos:

Estado Humedad Viento JuegoTenis? Alta Leve NoSoleado Alta Fuerte NoNublado Alta Leve SiLluvia Alta Leve SiLluvia Normal Leve SiLluvia Normal Fuerte NoNublado Normal Fuerte SiSoleado Alta Leve NoSoleado Normal Leve SiLluvia Normal Leve SiSoleado Normal Fuerte SiNublado Alta Fuerte SiNublado Normal Leve SiLluvia Alta Fuerte Si

Este es el mismo conjunto de datos que fue utilizado en la sección 4.3.1.5 para construir un árbol

utilizando el ID3 con la diferencia que es el valor del atributo Estado para el primer caso es desconocido.

En este caso, la distribución de datos para el atributo Estado es:

Desconocido Soleado Nublado LluviaNo 1 2 0 1Si 0 2 4 4Totales 1 4 4 5



Primero calculamos la entropía del conjunto. Recordemos que, como se explicó en la sección 4.4.2.2, no

debemos tener en cuenta los atributos desconocidos. Entonces, trabajamos sobre un total de 13 casos, de

los cuales 3 son positivos. Tendremos,

Calculamos ahora la entropía que tendrían los conjuntos resultantes de la división de datos según este

atributo.

Ahora calculamos la ganancia resultante de dividir al subconjunto según el atributo Estado, tendremos:

Al calcular al información de la división, debemos tener en cuenta una categoría extra para el valor

desconocido para el atributo. La información de la división se calcula como:

Finalmente, calculamos la proporción de ganancia.

De la misma manera en que calculamos la ganancia y la proporción de ganancia para el caso anterior,

calculamos para el atributo Humedad los siguientes valores:




Al igual que con el ID3, conviene dividir el conjunto según el atributo Estado tanto si trabajamos con la

ganancia como si trabajamos con la proporción de ganancia. Al dividir los 14 casos para continuar con la

construcción del árbol, los 13 casos para los que el valor de Estado es conocido, no presentan problemas y

se reparten según el valor de Estado. Mientras que el caso en que no se conoce el valor de Estado, se

bitsSdivisiónI

SGananciaSgananciadeproporción 098.0)(_

)()(__ ==

( ) bitsSdivisiónI 835.1141log

141

145log

145

144log

144

144log

144_ 2222 =

×−

×−

×−

×−=

bitsSH 7793.01310log

1310

133log

133)( 22 =−−=

bitsEstadoSH 58536.054log

54

51log

51

135

44log

44

40log

40

134

42log

42

42log

42

134),( 222222 =

−−+

−−+

−−=

( ) ( ) bitsEstadoSGanancia 180.058536.07793.01413, =−=



reparte entre los conjuntos que tienen Soleado, Nublado y Lluvia con los pesos 4/13, 4/16 y 5/13

respectivamente.

Tomemos por ejemplo, la división de los datos para el valor Nublado del atributo Estado. Los datos que

se tienen en cuenta en este caso son:

Estado Humedad Viento JuegoTenis Peso? Alta Leve No 4/13Nublado Alta Leve Si 1Nublado Normal Fuerte Si 1Nublado Alta Fuerte Si 1Nublado Normal Leve Si 1

La distribución de datos para el atributo Humedad es:

Desconocido Alta NormalNo 0 0.3 0Si 0 2 2Totales 0 2.3 2

Con estos datos obtenemos para la Humedad los siguientes valores:




En este caso, vemos que la división del conjunto de datos no ofrece ninguna mejora, por lo tanto,

colapsamos el árbol a la hoja Si, que es la que mayor peso tiene. La cantidad de casos cubiertos por la

hoja, es decir, el N asociado a la misma, es 4.3. Y la cantidad de casos cubiertos incorrectamente, o el E

asociado a la hoja, por la hoja son 0.3.

La figura 4.4 muestra un esquema de todos los pasos para la construcción del árbol de decisión en este

caso. A continuación se muestra el árbol obtenido.

Estado = Nublado: Si (4.3/0.3)Estado = Lluvia: Si (5.4/1.4)Estado = Soleado: Humedad = Alta: No (2.3) Humedad = Normal: Si (2.0)



Figura 4.4: Esquema de la construcción de un árbol de decisión utilizando el C4.5

Recordemos que el C4.5 analiza los errores predichos en cada uno de los subárboles y ramas del árbol

generado para analizar si es conveniente simplificarlo. En este caso, el error total predicho para el árbol

estará dado por:

Ahora, calculamos el error total predicho de simplificar el árbol por la hoja “Si”:

El error predicho para el árbol simplificado es menor que el error predicho para el árbol generado.

Entonces, el C4.5 poda el árbol a la siguiente hoja:

( ) ( ) ( ) ( )2,023.2,03.24.5,4.14.53.4,3.03.4)(_ %25%25%25%25 UUUUArbolpredichoError ×+×+×+×=

( ) 76.514,414)_(_ %25 =×= UdosimplificaArbolpredichoError

ESTADOganancia=0.180proporción de ganancia=0.0.098



Lluvia Soleado

Nublado

Estado

SIN=4.3E=0.3

Humedad

Alta Normal

Estado Humedad Viento JuegoTenis? Alta Leve NoSoleado Alta Fuerte NoNublado Alta Leve SiLluvia Alta Leve SiLluvia Normal Leve SiLluvia Normal Fuerte NoNublado Normal Fuerte SiSoleado Alta Leve NoSoleado Normal Leve SiLluvia Normal Leve SiSoleado Normal Fuerte SiNublado Alta Fuerte SiNublado Normal Leve SiLluvia Alta Fuerte Si

Estado Humedad Viento JuegoTenis

Peso

? Alta Leve No 5/13Lluvia Alta Leve Si 1Lluvia Normal Leve Si 1Lluvia Normal Fuerte No 1Lluvia Normal Leve Si 1Lluvia Alta Fuerte Si 1


Peso

? Alta Leve No 4/13Soleado Alta Fuerte No 1Soleado Alta Leve No 1Soleado Normal Leve Si 1Soleado Normal Fuerte Si 1


Peso

? Alta Leve No 4/13Nublado Alta Leve Si 1Nublado Normal Fuerte Si 1Nublado Alta Fuerte Si 1Nublado Normal Leve Si 1

HUMEDADGanancia=0.996Proporción de ganancia =1






SIN=5.4E=1.4

SIN=2.3E=0

SIN=2E=0



Si (14.0/5.76)

4.4.6. Generalización de reglas

Si reescribimos el árbol completamente en forma de un conjunto de reglas, una por cada hoja del árbol,

no obtendremos una estructura más simple que el árbol en sí. Sin embargo, los antecedentes de las reglas

pueden contener condiciones irrelevantes, con lo cual la regla puede ser generalizada eliminando dichas

condiciones.

Para decidir cuándo una condición debe eliminarse, utilizaremos el siguiente método. Sea R una regla de

la forma:

si A entonces clase C

Y sea una regla más general R-

si A- entonces clase C,

donde A- se obtiene borrando la condición X de las condiciones de A. La evidencia para la importancia

de X debe encontrarse en los casos de entrenamiento utilizados para la construcción del árbol de decisión.

Cada caso que satisface el antecedente más corto A- pertenece o no a la clase C, y satisface o no la

condición X. Los números de casos en cada uno de estos cuatro grupos pueden organizarse en una tabla

de contingencias de 2 x 2:

Clase C Otras clasesSatisface la condición X Y1 E1No satisface la condición X Y2 E2

¿Qué significan los valores de la tabla?:

• Y1+E1: casos que satisfacen A- y también X, por lo tanto, también están cubiertos por la regla original

R, E1 de ellos erróneamente ya que pertenecen a clases distintas a C.

• Y2+E2: casos que satisfacen A- pero no X que serán cubiertos por la regla generalizada R- pero no por

la regla original. E2 de estos casos serán clasificados erróneamente.

• Y1+Y2 + E1+E2: número total de casos cubiertos por R-



De acuerdo a varios experimentos desarrollados por Quinlan [Quinlan, 1987] para medir la importancia

de la tabla de contingencia al decidir si una condición X debe ser eliminada o no, se encontró que se

obtienen mejores resultados utilizando una estimación pesimista de la precisión de las reglas R y R- sobre

nuevos casos. No es muy probable que una hoja que cubre N casos con E errores tenga una proporción de

error tan baja como E/N al clasificar nuevos casos. En lugar de utilizar el estimador E/N al estimar la

proporción real de errores de una hoja como el límite superior UCF(E,N) del intervalo de confianza para

algún nivel de confianza CF. Si reemplazamos estos valores por los de las reglas R y R- obtendremos los

siguientes estimadores pesimistas:

• UCF(E1,Y1 + E1 ) para la regla R

• UCF(E1 + E2, Y1 + Y2 + E1 + E2) para la regla R-

Si

(4.10)

Entonces

tiene sentido eliminar la condición X.

Durante el proceso de generalización será necesario eliminar más de una condición. En lugar de analizar

todos los subconjuntos posibles de condiciones que podrían eliminarse, el sistema de C4.5 realiza una

eliminación directa golosa (straightforward greedy elimination): De todas las reglas que pueden

eliminarse por el método descripto, se elimina aquella que produce la menor proporción pesimista de

error en la regla generalizada. Como en todos las búsquedas golosas el hecho de buscar el mínimo en cada

paso no nos asegura llegar al mínimo global.

4.4.6.1. Conjuntos de Reglas

El proceso de generalización de las reglas se repite para todos los caminos del árbol. Con lo cual, las

reglas derivadas de algunos caminos pueden tener una proporción de error inaceptable o pueden solaparse

con otras derivadas de distintos caminos. Por lo tanto, podemos afirmar que el proceso de generalización

produce menos reglas que el número de hojas del árbol, y además las reglas dejan de ser mutuamente

excluyentes y exhaustivas. Un caso puede satisfacer los antecedentes de más de una regla o, si se

descartan reglas por tener una alta proporción de errores, de ninguna regla. En este último caso debe

existir una condición por defecto que indique cómo proseguir. Para resolver estos conflictos el C4.5

)+ , (≤ )+ ++ ,+ ( 111212121 EYEUEEYYEEU CFCF



plantea una solución simple: ordenar las reglas y la primera regla que cubre el caso se toma como la regla

operativa. Es necesario, entonces, establecer prioridades para el ordenamiento de las reglas y decidir la

clasificación por defecto a utilizar.

Para establecer las prioridades se siguió un método propuesto por Michie que determina que todas las

reglas de una misma clase deben aparecer juntas y estos subconjuntos de clases son los que están

ordenados en lugar de las reglas en sí. Este agrupamiento hace que las reglas sean más entendibles y tiene

la ventaja que el ordenamiento de las reglas en particular no es importante.

Supongamos que del conjunto de reglas elegimos un subconjunto S de reglas que cubren la clase C. La

performance de este subconjunto puede medirse mediante el número de casos de entrenamiento cubiertos

por S que no pertenecen a la clase C (falsos positivos) y el número de casos de entrenamiento de la clase

C que no son cubiertos por ninguna regla de S (falsos negativos).El valor del subconjunto S se mide

utilizando el Principio de Longitud de Descripción Mínima [Rissanen, 1983], explicado en la sección

2.4.1.4. Recordemos que este principio puede expresarse de la siguiente manera: Un Emisor y un

Receptor cuentan con copias idénticas de un conjunto de casos de entrenamiento, pero los casos del

Emisor también especifican la clase de cada caso, mientras que los casos del Receptor no tienen

información de las clases. El Emisor debe comunicar esta información faltante al Receptor mediante la

transmisión de una teoría de clasificación junto con las excepciones a la misma. El Emisor puede elegir la

complejidad de la teoría que envía (una teoría relativamente simple con muchas excepciones, o una teoría

muy compleja con pocas excepciones). El Principio MDL afirma que la mejor teoría derivable de los

datos de entrenamiento minimizará la cantidad de bits necesarios para codificar el mensaje completo

consistente de la teoría y sus excepciones.

La información a transmitir es la identidad en los casos de entrenamiento que pertenecen a la clase C,

utilizando un esquema de codificación para la teoría (subconjunto S de reglas) y sus excepciones. El

esquema utilizado por el C4.5 es aproximado ya que en lugar de utilizar un método de codificación en

particular, trata de encontrar un límite inferior al número de bits. Podemos resumirlo de la siguiente

manera:

1. Para codificar una regla, debemos especificar cada antecedente. El consecuente no necesita ser

codificado, porque todas las reglas del subconjunto pertenecen a la misma clase C. Existe una

pequeña complicación: las condiciones deben enviarse en algún orden, pero el orden no importa

porque las condiciones pertenecen a una conjunción. Si existen x condiciones en el antecedente,

existen x! ordenamientos posibles que podrían enviarse, todos equivalentes del punto de vista de la

especificación de la regla. Por lo tanto, la cantidad de bits requerida para enviar cualquier

ordenamiento en particular debe ser reducida en un “crédito” de log2(x!).



2. La codificación de un conjunto de reglas requiere la suma de los bits para codificar cada regla, menos

un crédito similar para el ordenamiento de las reglas (ya que todos los ordenamientos de reglas para

una misma clase son equivalentes)

3. Las excepciones se codifican indicando cuáles de los casos cubiertos por las reglas S son falsos

positivos y cuáles falsos negativos. Si las reglas cubren r de los n casos de entrenamiento, con fp

falsos positivos y fn falsos negativos, la cantidad de bits necesarios para codificar la excepción es

(4.11)

El primer término indica los bits necesarios para indicar los falsos positivos entre los casos cubiertos por

las reglas y el segundo término indica los falsos negativos entre los casos no cubiertos por las reglas.

El valor de un subconjunto S en particular se mide con la suma de las longitudes de codificación para las

reglas y excepciones, a menor suma, mejor teoría.

En la práctica, los métodos de codificación tienden a sobrestimar la cantidad de bits requeridos para

codificar una teoría relativa al conjunto de excepciones. Esto se explica por el hecho de que los conjuntos

de atributos generalmente son redundantes, por lo que diferentes teorías pueden ser funcionalmente

idénticas. Como la función de una teoría para una clase es identificar un subconjunto de casos de

entrenamiento, diferentes reglas que identifiquen al mismo conjunto son intercambiables, aún cuando

hayan sido codificadas de manera distinta. Para compensar este efecto, el sistema utiliza la suma

ponderada:

Bits de excepción + W X bits de teoría (4.12)

donde W < 1.

El valor apropiado de W dependerá de la probabilidad de que dos teorías representen los mismos casos, lo

cual dependerá del grado de redundancia en los datos. C4.5 utiliza el valor 0.5 por defecto para W, pero

puede ajustarse a un valor menor si se encuentra un gran grado de redundancia en los datos. Sin embargo,

no se ha encontrado que el resultado del algoritmo dependa en gran medida del valor de W.

Entonces, para enviar las reglas debe encontrarse un subconjunto S de reglas para la clase C que minimice

esta codificación total. Esto es similar a la generalización de reglas descripta anteriormente, pero en este

caso la eliminación golosa no parece ser efectiva. En cambio, el sistema analiza todos los subconjuntos

posibles de reglas para una clase, si no son demasiados, y utiliza recocido simulado (simulated annealing)

en caso contrario. En este último caso, el sistema repetidamente elige una regla al azar y considera

incluirla en el subconjunto S (si aún no pertenece al mismo), o eliminarla de S (si ya pertenece). Esta

−+

fn

rnfpr

22 loglog



acción producirá un cambio ∆B en el total de bits necesario para codificar el subconjunto y las

excepciones y, si el caso es beneficioso, entonces se lo acepta inmediatamente. Si la acción incrementa la

longitud total de la codificación tal que ∆B es positivo, el cambio se acepta con una probabilidad de e-∆B/K

donde K es una especia de temperatura sintética. Al reducir gradualmente el valor de K al ir explorando

los cambios, el sistema tiende a converger a un conjunto de reglas con una codificación cerca del mínimo

(near-minimun encoding).

4.4.6.2. Orden de las clases y elección de la clase por defecto

Una vez que ya se ha encontrado un subconjunto de reglas para representar cada clase, queda determinar

el ordenamiento para las clases y seleccionar un valor por defecto.

Al decidir el ordenamiento de las clases es importante tener en cuenta los falsos positivos ya que

ocasionarán clasificaciones incorrectas. Entonces, a la hora de decidir sobre el ordenamiento, se elige

primero a la clase que tiene menos falsos positivos. Luego, los falsos positivos de los casos de

entrenamiento que aún no han sido seleccionados se recomputan y se vuelve a elegir la clase con menos

falsos positivos, y así sucesivamente.

Como la clase por defecto será utilizada cuando un caso no sea cubierto por ninguna de las reglas, éstas

reglas deberían tenerse en cuenta para determinar cuál será la clase por defecto. El C4.5 elige como clase

por defecto aquella clase que cubre la mayoría de los casos de entrenamiento no cubiertos por ninguna

regla, resolviendo empates a favor de la clase con la mayor frecuencia absoluta.

Una vez que se ha determinado el ordenamiento y la clase por defecto, el conjunto de reglas se examina

por última vez. Si existe alguna regla cuya eliminación reduzca el número de errores de clasificación, se

la elimina y se recomputan los errores. El conjunto vuelve a chequearse. Este paso fue diseñado para

evaluar el conjunto de reglas en la forma en que será utilizado.

4.4.6.3. Generalización de un árbol de decisión a reglas de decisión utilizando el

C4.5

Para aclarar los métodos presentados en las secciones anteriores se procederá a la resolución de un

ejemplo. Supongamos que deseamos obtener las reglas de decisión para el conjunto de datos presentado

en la sección 4.4.5. Para generar las reglas de decisión, el C4.5 parte del árbol sin simplificar y construye

una regla de decisión para cada hoja del mismo. En este caso, las reglas generadas a partir del árbol sin

simplificar serán:



Regla 1 SI Estado = Soleado Y Humedad = Alta ENTONCES JuegoTenis = No

Regla 2 SI Estado = Soleado Y Humedad = Normal ENTONCES JuegoTenis = Si

Regla 3 SI Estado = Nublado ENTONCES JuegoTenis = Si

Regla 4 SI Estado = Lluvia ENTONCES JuegoTenis = Si

A continuación, el C4.5 generaliza cada una de estas reglas, eliminando aquellas condiciones que generan

un estimador de error pesimístico mayor. Calculamos este estimador para cada una de las reglas

presentadas y para las reglas resultantes de eliminar cada una de sus condiciones.

Para la regla 1, tendremos:

Errores Cant. de casos cubiertos Estimador pesimístico del error Condición ausente0 2 50% <regla actual>4 7 75.5% Estado=Soleado2 4 77.1% Humedad=Alta

Las reglas resultantes de eliminar cualquiera de las dos condiciones del antecedente, tienen un estimador

pesimístico de error superior al de la regla actual, con lo cual no es conveniente eliminar ninguna de las

dos condiciones. Mantenemos, entonces, la regla tal como fue generada, agregándole la precisión de la

misma.

Regla 1 SI Estado = Soleado Y Humedad = Alta ENTONCES JuegoTenis = No [50%]

Repetimos estos cálculos para las reglas restantes. En el caso de la regla 2 tendremos:

Errores Cant. De casos cubiertos Estimador pesimístico del error Condición ausente0 2 50% <regla actual>1 7 33.8% Estado=Soleado2 4 77.1% Humedad=Normal

En este caso, la regla resultante de eliminar la primera condición tiene un estimador pesimístico del error

menor que el de la regla actual, entonces, eliminamos esta condición y repetimos los cálculos,

obteniendo:



Errores Cant. De casos cubiertos Estimador pesimístico del error Condición ausente1 7 33.8% <regla actual>4 14 41.3% Humedad=Normal

Regla 2 SI Estado = Soleado Y Humedad = Normal ENTONCES JuegoTenis = Si [66.2%]

En el caso de la regla 3 tendremos:

Errores Cant. De casos cubiertos Estimador pesimístico del error Condición ausente0 4 29.3% <regla actual>4 14 41.3% Estado=Nublado

Regla 3 SI Estado = Nublado ENTONCES JuegoTenis = Si [70.7%]

Finalmente, para la regla 4 los cálculos son los siguientes:

Errores Cant. De casos cubiertos Estimador pesimístico del error Condición ausente1 5 45.4% <regla actual>4 14 41.3% Estado=Lluvia

Regla 4 SI Estado = Lluvia ENTONCES JuegoTenis = Si [54.6%]

Una vez que todas las reglas han sido generalizadas, el C4.5 agrupa las reglas según la clase de su

consecuente y busca los subconjuntos de reglas que generan una codificación mínima para la clase.

Entonces, calcula para cada subconjunto de reglas la cantidad de bits necesarios para codificar las reglas,

y utiliza el método del recocido simulado para determinar cuáles reglas son convenientes utilizar para

representar cada clase. En este caso, las reglas escogidas son la regla 1 para la clase No y la regla 3 para

la clase Si.

Finalmente, el C4.5 ordena las reglas y escoge la clase por defecto. Para ello, primero debemos computar

los falsos positivos de cada una de las reglas para escoger la de menor falsos positivos como primera. En

este caso, los falsos positivos para ambas reglas son nulos. Con lo cual, mantenemos el orden en que

fueron generadas.



Para la elección de la clase por defecto, computamos la cantidad de casos de cada clase no cubiertos por

las reglas escogidas. A continuación se presentan la cantidad de casos de cada clase, especificándose la

cantidad de casos de cada clase no cubiertos por ninguna de las reglas escogidas.

Casos No cubiertos Clase4 2 No10 6 Si

Como la mayoría de los casos no cubiertos, pertenecen a la clase Si, ésta es escogida como clase por

defecto. Las reglas finales para este ejemplo se presentan a continuación.

Regla 1 SI Estado = Soleado Y Humedad = Alta ENTONCES JuegoTenis = No [50.0%]

Regla 3 SI Estado = Nublado ENTONCES JuegoTenis = Si [70.7%]

Regla 5 Clase por defecto = Si

4.5. SISTEMA INTEGRADOR

4.5.1. Descripción general

Para estudiar los algoritmos propuestos se desarrolló un sistema que integra el ID3 y el C4.5. El sistema

recibe los datos de entrenamiento como entrada y permite que el usuario elija cuál algoritmo y con qué

criterio de decisión (ganancia o proporción de ganancia) desea aplicar. Una vez generados el árbol y las

reglas de decisión, el usuario puede evaluar los resultados sobre los datos de prueba. En el caso del ID3,

esta evaluación se realiza a partir de las reglas de decisión cuya performance, como vimos en la sección

4.3.1, es idéntica a la de los árboles. La evaluación de los resultados del C4.5, en cambio, se realiza por

separado y se obtienen, por lo tanto, dos evaluaciones distintas, una para el árbol y otra para las reglas.

Esto se debe a que, como se explicó en la sección 4.4.4, el modelo de clasificación generado con el C4.5

como árbol de decisión es distinto al generado como reglas de decisión.

La figura 4.5. presenta un esquema general del funcionamiento del sistema.


84 Magdalena Servente Solución Propuesta

Figura 4.5: Esquema general del sistema integrador propuesto

DATOS DEENTRENAMIENTO

Árbol dedecisión

Reglas dedecisión

Generación delárbol de decisión

Poda del árbolde decisión

Árbol dedecisiónpodado

Transformación areglas dedecisión

Evaluación de losresultados

Evaluación delmodelo

generado

ID3

Árbol dedecisión

Reglas dedecisión

Generación delárbol de decisión

Poda del árbolde decisión

Árbol dedecisiónpodado

Transformación areglas dedecisión

Evaluación de losresultados

Evaluación delmodelo

generado

C4.5

DATOS DEPRUEBA



4.5.2. Diseño del sistema integrador

A continuación se presenta el diseño del sistema integrador desarrollado. Se explican, tanto para el ID3

como para el C4.5 los procesos realizados y resultados generados.

4.5.2.1. Diseño para el ID3

La figura 4.6 presenta el DFD general para la sección del ID3. Con una mirada rápida, vemos que el árbol

y las reglas de decisión se generan a partir de los datos de entrenamiento. A su vez, los procesos que los

generan graban el árbol, las reglas y las sentencias SQL en sus correspondientes archivos. Además, se

genera un log del proceso. Por otro lado, la evaluación de resultados se realiza a partir de las sentencias

SQL y de los datos de prueba.

Figura 4.6: DFD general para la sección del ID3


1Generación del

árbol de decisión

2Poda del árbol

de decisión

4Transformación a

reglas dedecisión

6Evaluación de los

resultados

Árbol de decisión sin podar

DATOS DEPRUEBA

Árbol de decisión podado

LOG DEL ID3

3Impresión del

árbol de decisiónen pantalla


REGLAS DEDECISIÓN

SENTENCIASSQL

5Guardado del

árbol de decisióna disco


ÁRBOL DEDECISIÓN

Matriz de confusión

DATOSTRANSFORMACION



Cada uno de los procesos mostrados en la figura 4.6 se describe en las secciones siguientes.

4.5.2.1.1. Generación del árbol de decisión

Este proceso genera el árbol de decisión según el algoritmo explicado para el ID3 en la sección 4.3.1.1. El

árbol se construye a partir de los datos de entrenamiento en formato Paradox, seleccionados por el

usuario.

Durante este proceso se genera un archivo de log que guarda todos los cálculos de ganancia y de

proporción de ganancia realizadas en cada paso; y el atributo escogido para realizar la división. El archivo

de log se encuentra en el subdirectorio Log dentro del directorio donde está instalado el programa, y su

nombre está compuesto de la siguiente manera: MétodoDD-MM-AA HH_MM_SSNombreTabla.log. Esto

permite identificar fácilmente el log correspondiente a una corrida. El formato del archivo de log se

especifica en la sección 4.5.2.1.8.

4.5.2.1.2. Poda del árbol de decisión

Este proceso realiza la poda del árbol de decisión según la metodología explicada en la sección 4.3.1.2.

4.5.2.1.3. Impresión del árbol de decisión en pantalla

Una vez podado, el árbol de decisión se muestra en pantalla, de forma tal que figure la prueba realizada

en cada nodo y el valor de la prueba en cada rama, como aparece en la figura 4.7.

4.5.2.1.4. Transformación a reglas de decisión

A partir del árbol de decisión podado, se generan las reglas de decisión de acuerdo con el método

explicado en la sección 4.3.1.3. Se guarda en disco un archivo de texto que contiene las reglas obtenidas,

y un archivo de Paradox que contiene las sentencias SQL equivalentes. También se genera otra tabla de

Paradox, “Datos Transformación”, que contiene los datos de necesarios para identificar la transformación

correspondiente a cada sentencia SQL.



Figura 4.7: Formato del árbol de decisión impreso en pantalla


A partir del árbol de decisión podado, se generan las reglas de decisión de acuerdo con el método

explicado en la sección 4.3.1.3. Se guarda en disco un archivo de texto que contiene las reglas obtenidas,

y un archivo de Paradox que contiene las sentencias SQL equivalentes. También se genera otra tabla de

Paradox, “Datos Transformación”, que contiene los datos de necesarios para identificar la transformación

correspondiente a cada sentencia SQL.

4.5.2.1.5. Guardado del árbol de decisión a disco

Una vez presentado el árbol por pantalla, se le ofrece al usuario la posibilidad de guardarlo en el disco

rígido. Si acepta, debe elegir en qué directorio y con qué nombre desea guardarlo. La extensión del

archivo resultante es “tree”.

4.5.2.1.6. Evaluación de los resultados

A partir de una lista de corridas realizadas, el usuario elige cuál corrida del ID3 desea evaluar. Los datos

de las corridas previas están almacenados en la tabla de “Datos Transformación”. Una vez realizada la

elección, se obtienen de la tabla de “Sentencias SQL” las sentencias SQL generadas durante la

transformación del árbol a reglas de decisión (Sección 4.5.2.1.4). Estas sentencias se aplican al conjunto

de datos de prueba determinado por el usuario.



Se genera una matriz de confusión que indica para cada clase la cantidad de casos correctamente

clasificados y los incorrectamente clasificados. Se calcula la probabilidad de que un caso sea clasificado

correctamente como perteneciente a esa clase. Finalmente, se obtienen los totales generales. La matriz de

confusión obtenida se muestra en pantalla. La Figura 4.8 muestra un ejemplo de dicha matriz de

confusión.

Figura 4.8: Matriz de confusión generada durante la evaluación de resultados

4.5.2.1.7. Formato de los datos de entrenamiento y de prueba

Los datos de entrenamiento y prueba deben estar en formato de Paradox 3 (.db o .dbf) para poder ser

procesados por el sistema. Se eligió este formato porque la mayoría de los programas de manejo de datos

pueden exportar sus archivos y tablas al formato de Paradox 3; lo cual permite analizar datos

alamacenados en casi cualquier formato.

4.5.2.1.8. Archivo de Log del ID3

Durante la generación del árbol de decisión, se genera un archivo de log que almacena todos los cálculos

realizados. En cada paso, se almacenan:

1. el “Nivel” en el que se está, entendiéndose por “Nivel” el numero de ciclo de procesamiento en el

que se está

2. Para cada descriptor:

• El nombre del descriptor

• Una matriz con la cantidad de instancias pertenecientes a cada clase para cada valor posible del

descriptor.

• El valor de la ganancia



• El valor de la proporción de ganancia

3. La ganancia o la proporción de ganancia máxima (según el criterio de división con el que se esté

trabajando).

A continuación se presenta una entrada del archivo de log.

Nivel=0Descriptor=Estado Lluvia Nublado SoleadoNo 1 0 3Si 4 4 2 5 4 5 14Gain=0.258521Gain Ratio=0.491042--------------------------------------Descriptor=Humedad Alta NormalNo 3 1Si 4 6 7 7 14Gain=0.0746702Gain Ratio=0.14934--------------------------------------Descriptor=Viento Fuerte LeveNo 2 2Si 4 6 6 8 14Gain=0.00597769Gain Ratio=0.0122457--------------------------------------0.258521

4.5.2.1.9. Archivo de Reglas de decisión del ID3

El archivo de reglas de decisión generado durante la transformación a reglas de decisión contiene las

reglas para el árbol analizado. Por cada regla guarda el número de regla y la regla en sí.

4.5.2.1.10. Archivo del Árbol de decisión del ID3

Cuando el usuario elige guardar el árbol de decisión a disco, este se almacena en un archivo plano,

tabulándose n veces cada renglón, siendo n el nivel del nodo de decisión. A continuación se muestra el

contenido de un archivo “.tree” a modo de ejemplo.

Estado = LluviaViento = Fuerte

Humedad = AltaSi

Humedad = NormalNo

Viento = Leve



SiEstado = Nublado

SiEstado = Soleado

Humedad = AltaNo

Humedad = NormalSi

4.5.2.2. Diseño para el C4.5

Figura 4.9: DFD general para la sección del C4.5

La figura 4.9 presenta el DFD general para la sección del C4.5. A simple vista, vemos que el diseño de

este proceso difiere ligeramente del diseño del ID3. Aunque los procesos principales (generación y poda

del árbol de decisión, generación de las reglas de decisión, evaluación de los resultados) se mantienen,

encontramos que hay dos evaluaciones de resultados, una para el árbol de decisión y otra para las reglas.


1Generación del

árbol de decisión

2Poda del árbol

de decisión

5Transformación a

reglas dedecisión

6Evaluación de las

reglas dedecisión


Reglas de decisiónDATOS DE

PRUEBA


ÁRBOL DEDECISIÓN YEVALUACIÓN

DERESULTADOS

4Impresión del

árbol de decisiónen pantalla


Árbol de decisión podadoy Resultados de la evaluación

3Evaluación del

árbol de decisión

REGLAS DEDECISIÓN YEVALUACIÓN

DERESULTADOS




Esto se debe a que, a diferencia del ID3, las reglas de decisión y el árbol generados por el C4.5 no son

modelos de clasificación equivalentes. Por otro lado, encontramos que tanto el archivo del árbol de

decisión como el de las reglas de decisión se presentan junto a la evaluación de resultados. Recordemos

que, como se explicó en la sección 4.4, el C4.5 evalúa cada rama y cada regla en particular. Por lo tanto,

la evaluación no puede separarse de los modelos generados.

Cada uno de los procesos mostrados en la figura 4.9 se describe en las secciones siguientes.

4.5.2.2.1. Generación del árbol de decisión

Este proceso genera el árbol de decisión según el algoritmo explicado para el C4.5 en las secciones 4.4.1

y 4.4.2. El árbol se construye a partir de los datos de entrenamiento en formato Paradox, seleccionados

por el usuario.

4.5.2.2.2. Poda del árbol de decisión

Este proceso realiza la poda del árbol de decisión según la metodología explicada en la sección 4.4.3.

4.5.2.2.3. Evaluación del árbol de decisión

El árbol de decisión se evalúa según el algoritmo explicado en la sección 4.4.4. Se le agrega una prueba

de valor a cada rama y se genera una matriz de confusión a partir de la performance del árbol sobre los

datos de prueba.

4.5.2.2.4. Impresión del árbol de decisión en pantalla

El árbol de decisión se muestra en pantalla para el usuario, de manera idéntica al árbol generado para el

ID3, explicado en la sección 4.5.2.1.3.




El árbol de decisión generado, se transforma a reglas de decisión según la metodología explicada en la

sección 4.4.6. Las reglas se almacenan en un archivo plano cuyo formato se explica en la sección

4.5.2.2.8.

4.5.2.2.6. Evaluación de las reglas de decisión

Una vez generadas las reglas de decisión, el sistema las evalúa contra los datos de prueba. Genera una

apreciación de exactitud para cada regla, según lo explicado en la sección 4.4.6, y una matriz de

confusión general. Almacena todos los resultados en un archivo plano.

4.5.2.2.7. Formato de los datos de entrenamiento y de prueba

Al igual que en el caso del ID3, los datos de entrenamiento y prueba deben estar en formato de Paradox 3

(.db o .dbf) para poder ser procesados por el sistema.

4.5.2.2.8. Archivo del árbol de decisión y evaluación de resultados del C4.5

Durante la generación del árbol de decisión, su correspondiente poda y su posterior evaluación se genera

un archivo de resultados obtenidos en cada paso. En este archivo se almacenan:

1. el árbol de decisión sin podar, donde cada rama tiene asociados dos números: N y E, cuyo sentido se

detalla a continuación:

• N es la sumatoria de los casos de entrenamiento fraccionales que llegan a cada hoja

• E es la cantidad de casos, cubiertos por la hoja, que no pertenecen a la clase de la misma.

2. el árbol de decisión podado, también con dos números N y E asociados, donde:

• N es la cantidad de casos de entrenamiento cubiertos por la hoja



• E es la cantidad de errores predichos, según la distribución binomial, para la hoja si una cantidad

N de nuevos casos fuese evaluada por el árbol

3. la evaluación sobre los datos de prueba con el siguiente formato:

Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación

Donde:

Tamaño = cantidad de nodos + cantidad de hojas

Errores = x (y%)

Con:

x = cantidad de casos clasificados erróneamente

y= cantidad de casos clasificados erróneamente / cantidad total de casos

donde:

t es la cantidad de hojas del árbol

Ei es el E asociado a cada hoja

N es la cantidad total de casos de entrenamiento

4. una matriz de confusión que indica para cada clase, la cantidad de casos clasificados erróneamente y

la cantidad de casos de la misma clasificados como pertenencientes a otra clase.

A continuación se presenta un archivo de muestra.

C4.5 Generador de árboles de decisión Thu Sep 27 11:18:00 2001-------------------------------------

Opciones:Datos <cardiolo>Los árboles serán evaluados sobre los datos de pruebaSe utilizará el Gain criterion

N

EEstimación

t

ii∑

== 1



95 casos (7 atributos) leídos de cardiolo.data

Árbol de decisión:

Duración del Angor = MENOS DE 30 MIN: NO (48.0/1.0)Duración del Angor = MAS DE 30 MIN:| Dolor de Pecho de Angor = TIPICO: SI (16.0/1.0)| Dolor de Pecho de Angor = AUSENTE: NO (16.0)| Dolor de Pecho de Angor = ATIPICO:| | Irradiación del Angor = SI: SI (8.0)| | Irradiación del Angor = NO:| | | Respuesta Vasodilatadora = POSITIVO: SI (4.0/1.0)| | | Respuesta Vasodilatadora = NEGATIVO: NO (3.0)

El árbol ha sido guardado

Evaluación sobre los datos de prueba (95 ítems):

Antes de podar Después de Podar---------------- ---------------------------Tamaño Errores Tamaño Errores Estimación

10 3( 3.2%) 10 3( 3.2%) (11.6%) <<


Antes de podar Después de Podar---------------- ---------------------------Tamaño Errores Tamaño Errores Estimación

10 3( 3.2%) 10 3( 3.2%) (11.6%) <<

(a) (b) <-clasificado como ---- ---- 26 1 (a): clase SI 2 66 (b): clase NO

4.5.2.2.9. Archivo de Reglas de decisión y evaluación de resultados del C4.5

El formato del archivo de reglas de decisión y evaluación de los resultados es el siguiente:

1. Reglas obtenidas, con la proporción de éxito de cada una

2. Evaluación sobre los datos de entrenamiento, con el siguiente formato:

Regla Tamaño Error Usada Errores Ventaja ClaseDonde:

• Regla es el número de regla

• Tamaño es la cantidad de pruebas de valor en el antecedente de la regla

• Error es el estimador calculado como el complemento de la proporción de éxito asociada a

cada regla



• Usada indica la cantidad de veces que se utilizo la regla durante la evaluación

• Errores indica la cantidad de errores cometidos durante la evaluación, y la proporción de

error calculada como dicha cantidad sobre la cantidad de veces en que se utilizó la regla.

• La ventaja tiene el siguiente formato a(b|c), donde

• b es la cantidad de casos que serían clasificados erróneamente si dicha regla se

omitiese.

• c es la cantidad de casos que serían clasificados correctamente si dicha regla se

omitiese por las reglas siguientes.

• a es la el beneficio neto de omitir la regla, calculado como b-c.

3. Matriz de confusión para los datos de entrenamiento, con el mismo formato que la presentada en la

sección 4.5.2.2.8 para la evaluación de los resultados del árbol de decisión.

4. Evaluación de los datos de prueba con el mismo formato que la evaluación sobre los datos de

entrenamiento.

5. Matriz de confusión para los datos de prueba con el mismo formato que la matriz presentada para los

datos de entrenamiento.

A continuación se muestra un ejemplo del archivo en cuestión.

C4.5 Generador de reglas Thu Sep 27 11:21:54 2001------------------------

Opciones:Datos <cardiolo>Conjuntos de reglas evaluados sobre casos

nuevos

95 casos (7 atributos) leídos de cardiolo

------------------Procesando el árbol 0

Reglas finales del árbol 0:

Regla 6: Dolor de Pecho de Angor = AUSENTE

-> clase NO [95.8%]

Regla 1: Duración del Angor = MENOS DE 30 MIN

-> clase NO [94.6%]

Regla 5:



Dolor de Pecho de Angor = ATIPICO Irradiación del Angor = NO Respuesta Vasodilatadora = NEGATIVO

-> clase NO [82.0%]

Regla 2: Dolor de Pecho de Angor = TIPICO Duración del Angor = MAS DE 30 MIN

-> clase SI [84.3%]

Regla 3: Dolor de Pecho de Angor = ATIPICO Irradiación del Angor = SI Duración del Angor = MAS DE 30 MIN

-> clase SI [84.1%]

Regla 4: Dolor de Pecho de Angor = ATIPICO Duración del Angor = MAS DE 30 MIN Respuesta Vasodilatadora = POSITIVO

-> clase SI [70.0%]

Clase por defecto: NO

Evaluación sobre los datos de entrenamiento (95 ítems):

Regla Tamaño Error Usada Errores Ventaja----- ------ ----- ----- ------- ------- 6 1 4.2% 32 0 (0.0%) 0 (0|0) NO 1 1 5.4% 32 1 (3.1%) 0 (0|0) NO 5 3 18.0% 3 0 (0.0%) 0 (0|0) NO 2 2 15.7% 16 1 (6.2%) 14 (15|1) SI 3 3 15.9% 8 0 (0.0%) 4 (4|0) SI 4 3 30.0% 4 1 (25.0%) 2 (3|1) SI

Probadas 95, errores 3 (3.2%) <<

(a) (b) <-clasificado como ---- ---- 26 1 (a): clase SI 2 66 (b): clase NO


Regla Tamaño Error Usada Errores Ventaja----- ------ ----- ----- ------- ------- 6 1 4.2% 32 0 (0.0%) 0 (0|0) NO 1 1 5.4% 32 1 (3.1%) 0 (0|0) NO 5 3 18.0% 3 0 (0.0%) 0 (0|0) NO 2 2 15.7% 16 1 (6.2%) 14 (15|1) SI 3 3 15.9% 8 0 (0.0%) 4 (4|0) SI 4 3 30.0% 4 1 (25.0%) 2 (3|1) SI

Probadas 95, errores 3 (3.2%) <<

(a) (b) <-clasificado como ---- ---- 26 1 (a): clase SI

2 66 (b): clase NO


Resultados Magdalena Servente 97

CAPÍTULO 5

RESULTADOS OBTENIDOS

En este capítulo se presentan los resultados obtenidos. Primero, se explica la manera en que debe

realizarse la interpretación de los mismos (Sección 5.1), se presentan los formatos de los árboles

y las reglas de decisión tanto para el ID3 (Sección 5.1.1) como para el C4.5 (Sección 5.1.2).

Luego, se describen los dominios de datos sobre los que se trabajó (Sección 5.2), y se analizan

los resultados obtenidos con el ID3 (Sección 5.3) y con el C4.5 (Sección 5.4). En cada caso se

presenta, el árbol y las reglas de decisión obtenidos, y la evaluación de resultados sobre el

conjunto de datos de prueba. En la sección 5.5 se comparan los resultados obtenidos con el ID3 y

con el C4.5 en los distintos dominios. Y en la sección 5.6 se realiza un análisis general de los

resultados.

5.1. INTERPRETACIÓN DE LOS RESULTADOS

Se realizaron múltiples pruebas tanto con el sistema ID3 como con el C4.5. A continuación se presentan

los dominios de datos sobre los cuales se trabajó. Debe recordarse que, al no tener la limitación de datos

únicamente discretos, el C4.5 pudo aplicarse a más dominios que el ID3.

Para cada dominio, se presentan dos conjuntos de resultados para cada uno de los sistemas: uno utilizando

la ganancia como medida de la ganancia de información en cada iteración del sistema, y otra utilizando la

proporción de ganancia con el mismo propósito. Entonces, para cada combinación dominio - sistema –

medidor de ganancia, se presentan el árbol y las reglas de decisión obtenidas.

5.1.1. Interpretación de resultados en el ID3

5.1.1.1. Árboles de decisión

En el caso del ID3, el árbol de decisión no presenta ninguna característica en especial; de cada nodo sale

una rama por valor del atributo que se está siendo testeado, y, así sucesivamente, hasta llegar a las hojas

que indican la clase. El árbol de decisión presentado ha sido previamente podado, y es exhaustivo, de

ramas mutuamente excluyentes.


98 Magdalena Servente Resultados

5.1.1.2. Reglas de decisión

Las reglas de decisión en el ID3 se obtienen directamente a partir del árbol. Con lo cual, los antecedentes

de las reglas son mutuamente excluyentes y exhaustivos. Por lo tanto, el orden en que se presentan las

reglas no tiene importancia para la clasificación de un nuevo caso. Si se evalúa un nuevo conjunto de

datos con las reglas de decisión, se obtienen exactamente los mismos resultados que si se lo evalúa con el

árbol de decisión.

Como estimación del éxito del modelo generado se presenta una tabla o matriz obtenida de la evaluación

de los datos de prueba tanto con el árbol como con las reglas de decisión. La tabla generada, presentada

en la sección 4.5.2.1.6, cuenta con las siguientes columnas:

• Clases: Clases existentes en los datos

• Correctos: cantidad de casos de los datos de prueba clasificados correctamente para cada clase

• Errores: cantidad de casos de los datos de prueba clasificados erróneamente para cada clase

• Probabilidad: probabilidad de que un nuevo caso sea clasificado correctamente, se obtiene como:

(5.1)

5.1.2. Interpretación de resultados en el C4.5

5.1.2.1. Árboles de decisión

El árbol de decisión en el C4.5 es distinto del árbol generado en el ID3 en la medida en que cada una de

las hojas del mismo cubre una distribución de casos. Cada hoja tiene asociados entonces, dos números N

y E, como lo indica la figura 5.1. Cabe destacar que si E es nulo, entonces, no se lo expresa en el árbol.

Prueba 1 del atributo X: clase A (N/E)Prueba 2 del atributo X:

Prueba 1 del atributo Y: Prueba 1 del atributo Z: clase A (N) Prueba 2 del atributo Z: clase B (N/E)Prueba 2 del atributo Y: clase A (N/E)

Figura 5.2 Esquema general de un árbol obtenido con el C4.5

errorescorrectoscorrectos

+



Como se explicó previamente, en la sección 4.5.2.2.8, en los árboles sin podar, N es la suma de los casos

fraccionarios que llegan a cada hoja y E es la suma de los casos que pertenecen a una clase distinta de la

correspondiente a la hoja, los falsos positivos. Es decir, que de los N casos cubiertos por la hoja, E casos

son incorrectos. En los árboles podados, N es la cantidad de casos de entrenamiento cubiertos por la hoja,

y E es la cantidad de errores predichos si una cantidad N de casos nuevos fuese clasificada por el árbol,

según la distribución binomial. Con lo cual, puede obtenerse un rápido estimador de errores sobre datos

nuevos de la siguiente manera:

(5.2)

Donde k es la cantidad de nodos, Ei es el error en la hoja i, y N es la cantidad total de casos de

entrenamiento.

Para cada uno de los árboles se obtienen dos tablas de evaluación de idéntico formato: una a partir de los

datos de entrenamiento y la otra a partir de los datos de prueba. Una tabla indica en cada caso:

• Tamaño: tamaño del árbol obtenido (cantidad de nodos + cantidad de hojas)

• Errores (porcentaje de error %): los errores indican la cantidad de casos clasificados

erróneamente; mientras que el porcentaje de error es dicha cantidad sobre la cantidad total de casos.

• Estimación: es un estimador del éxito del árbol obtenido según la ecuación 5.1.

Además, para cada uno de los árboles se presenta la matriz de confusión del tipo:

Clasificado comoClase 1

Clasificado comoClase 2

... Clasificado comoClase N

Clase 1 ...Clase 2 ...... ... ... ... ...Clase N ...

Donde se indica para cada clase, la cantidad de casos que fueron clasificados correctamente y la cantidad

de casos que no fueron clasificados correctamente. Para estos últimos se indica en particular, de qué clase

fueron clasificados.

N

Ek

ii∑

=1



5.1.2.2. Reglas de decisión

En el caso de las reglas de decisión producidas por el C4.5, cada regla tiene asociado un estimador del

éxito predicho durante su construcción. Recordemos que dicho estimador se obtiene como el valor de la

distribución binomial para un nivel de confianza especificado, a partir de la tabla de contingencia como

fue explicado en la sección 4.4.5.

Además, a continuación de las reglas obtenidas, se presenta una tabla de performance de las mismas sobre

los datos de prueba, con los siguientes datos, descriptos en la sección 4.5.2.2.9:

• Regla: número de la regla.

• Tamaño: cantidad de conjunciones en el antecedente.

• Error: estimador del error de la regla (se obtiene restándole a 100 el estimador de éxito presente en

cada regla)

• Usada: cantidad de veces que la regla fue utilizada

• Error (porcentaje de error %): el error indica la cantidad de casos que fueron clasificados

erróneamente, y el porcentaje de error es dicha cantidad sobre la cantidad de veces en que la regla fue

usada.

• Ventaja: indica la performance del conjunto de reglas, si la regla en cuestión fuese omitida. Se

expresa como: a(b|c), donde b es la cantidad de casos que serían clasificados erróneamente, si esta

regla no existiese; c es la cantidad de casos que serían clasificados correctamente por las reglas

siguientes; y a=b-c es el beneficio neto de eliminar la regla.

5.2. DESCRIPCIÓN DE LOS DOMINIOS

A continuación se presentan los dominios sobre los cuales se realizaron las pruebas. Para cada dominio se

presenta:

a) Una breve descripción

b) Los atributos con sus correspondientes valores posibles



c) Las clases con sus valores

d) La cantidad de instancias y la distribución de clases del dominio

Los datos de cada uno de los dominios se presentan en el Apéndice B. En todos los casos, se dividieron

los datos preclasificados en dos subconjuntos: uno de entrenamiento y uno de prueba, según las

proporciones 2:3 y 1:3, respectivamente.

5.2.1. Créditos

a) Descripción

Los ejemplos planteados en esta base de datos fueron provistos por el Gerente del Centro de Cómputos de

Las Malvinas [Montalvetti, 1995] para el análisis de solicitudes de créditos. Los campos de los ejemplos

provistos son los parámetros que se tienen en cuenta al analizar un riesgo crediticio.

b) Atributos

Nombre del campo Valores PosiblesIngreso ENTRE 451 Y 550, ENTRE 451 Y 550, MAS DE 551Composición Familiar SOLTERO, CASADO SIN HIJOS, CASADO Y UN HIJO, CASADO Y DOS HIJOSVivienda ALQUILA, PROPIA O IPVUServicios BASICOS, BASICOS Y TIC, BASICOS TIC Y TELOtros Créditos UN CREDITO, DOS CREDITOS, TRES CREDITOS

c) Clases:

SI, NO.

d) Cantidad de instancias y distribución de las clases::

SI NO TotalesEn el conjunto de entrenamiento 69 30 99En el conjunto de prueba 35 16 51Totales 104 46 150



5.2.2. Cardiología

a) Descripción

Los ejemplos planteados en este caso corresponden a la patología de Infarto Agudo de Miocardio,

provistos por un cardiólogo [Montalvetti, 1995]. En este caso, todos los ejemplos responden a personas de

sexo masculino, entre 40 y 50 años, fumadoras, con displidemia e hipertensión arterial presente. Pueden

obtenerse dos diagnósticos de los ejemplos planteados: Si (Infarto Agudo de Miocardio) o No (no es un

Infarto Agudo de Miocardio). Aunque en medicina es difícil realizar un diagnóstico con una cantidad de

variables reducidas, se determinó que las variables planteadas en estos ejemplos alcanzan para realizar un

diagnóstico preliminar de gran ayuda al experto

b) Atributos

Nombre del campo Valores PosiblesDolor de Pecho de Angor TIPICO, ATIPICO, AUSENTEIrradiación del Angor SI, NODuración del Angor MENOS DE 30 MIN, MAS DE 30 MINAngor en Relación CON ESFUERZO, EN REPOSOAntigüedad del Angor RECIENTE, MAS DE 1 MESRespuesta Vasodilatadora POSITIVO, NEGATIVO

c) Clases:

SI, NO

d) Cantidad de instancias y distribución de las clases:

SI NO TotalesEn el conjunto de entrenamiento 18 46 64En el conjunto de prueba 9 22 31Totales 27 68 95

5.2.3. Votaciones

a) Descripción

Estos datos fueron recolectados a partir del Almanaque Trimestral del Congreso, 2da sesión de 98º

Congreso, 1984, Volumen XL: Congressional Quarterly Inc, Washington, D.C., 1985. Los datos incluyen

los votos de cada congresista de la U.S. House of Representatives en 16 temas claves (CQA). Se

identificaron nueve tipos diferentes de votos: votado a favor, convenio a favor, y pronunciado a favor

(agrupados como “a_favor”), votado en contra, convenio en contra, y pronunciado en contra (agrupados



como “en_contra”), voto en persona, voto en persona para evitar conflictos de intereses, y abstención de

voto o no dio su voto a conocer (agrupados como “desconocido”).

b) Atributos

Nombre del campo Valores PosiblesNiños_discapacitados A_favor, en_contra, desconocidoParticipación en el costo del proyecto del agua A_favor, en_contra, desconocidoAdopción de la resolución sobre el presupuesto A_favor, en_contra, desconocidocongelamiento de los honorarios médicos A_favor, en_contra, desconocidoayuda a El Salvador A_favor, en_contra, desconocidogrupos religiosos en las escuelas A_favor, en_contra, desconocidoprohibición de las pruebas anti satélites A_favor, en_contra, desconocidoayuda a los contras de Nicaragua A_favor, en_contra, desconocidomisil mx A_favor, en_contra, desconocidoinmigración A_favor, en_contra, desconocidoreducción a la corporación Synfuels A_favor, en_contra, desconocidopresupuesto de educación A_favor, en_contra, desconocidoderecho a demandar de la Superfund A_favor, en_contra, desconocidocrimen A_favor, en_contra, desconocidoexportaciones sin impuestos A_favor, en_contra, desconocidoacta sudafricana de administración de exportaciones A_favor, en_contra, desconocido

c) Clases:

demócrata, republicano


Demócrata republicano TotalesEn el conjunto de entrenamiento 184 116 300En el conjunto de prueba 83 52 135Totales 267 168 435

5.2.4. Estudio sobre hongos

a) Descripción

Esta base de datos incluye las descripciones de muestras hipotéticas de 23 especies de hongos de las

familias Agaricus y Lepiota. Cada especie es identificada como apta para ser ingerida, absolutamente

venenosa, o de ingestión dudosa y ciertamente no recomendable. Esta última clase fue combinada con la

venenosa. La Guía de donde se obtuvieron los datos explica que no existe una regla simple para

determinar si un hongo es ingerible o no.



b) Atributos

Forma_sombrero acampanada, cónica, convexa, chata, abotonada, hundidaSuperficie_sombrero Fibrosa, ranurada, escamosa, suaveColor_sombrero marrón, piel, canela, gris, verde, rosa, violeta, rojo, blanco, amarilloMagulladuras Si, noOlor Almendra, anís, creosota, pescado, hediondo, mohoso, ninguno,

punzante, especiosoTipo_membrana Adherida, descendente, libre, muescadaEspaciado_membrana Cercano, poblado, distanteTamaño_membrana Ancha, finaColor_membrana Negro, marron, piel, chocolate, gris, verde, naranja, rosa, violeta, rojo,

blanco, amarilloForma_tronco Abultada, cónicaRaiz_tronco bulbosa, agarrotada, copa, igual, rizomorfa, arraizada, ?Superfice_tronco_arriba_anillo Fibrosa, escamosa, sedosa, suaveSuperfice_tronco_debajo_anillo Fibrosa, escamosa, sedosa, suaveColor_tronco_arriba_anillo Marron, piel, canela, gris, naranja, rosa, rojo, blanco, amarilloColor_tronco_debajo_anillo Marron, piel, canela, gris, naranja, rosa, rojo, blanco, amarilloTipo_velo Parcial, universalColor_velo Marrón, naranja, blanco, amarilloCantidad_anillos Ninguno, uno, dosTipo_anillo Tejido, evanescente, resplandeciente, grande, ninguno, pendiente,

cubierto, zonalColor_esporas Negra, marrón, piel, chocolate, verde, naranja, violeta, blanco,

amarilloPoblacion abundante, agrupada, numerosa, dispersa, varios, solitariaHabitat Pastos, hojas, praderas, caminos, urbano, basura, bosques

Cantidad de Atributos desconocidos: 2480 (denotados por un "?"), todos para el primer atributo

c) Clases:

Ingerible, Venenoso.


Ingerible Venenoso TotalesEn el conjunto de entrenamiento 2805 2611 5416En el conjunto de prueba 1403 1305 2708Totales 4208 3916 8124

5.2.5. Elita: Base de Asteroides

a) Descripción

Existen muchas teorías físicas que clasifican a los distintos asteroides en familias identificadas por un

elemento en particular. Esta base de datos, resultado de varias mediciones realizadas sobre múltiples



valores continuos, ayuda a clasificar los asteroides en familias. Según la teoría de Hirayama, que examina

la distribución de los asteroides con respecto a sus elementos orbitales, en particular su movimiento

principal, la inclinación y la excentricidad, permite identificar a las familias KORONIS, EOS, THEMIS,

FLORA, MARIA y PHOCAEA. Esta teoría ha sido comprobada por Arnold

b) Atributos

Nombre: Clave PrimariaSemieje ContinuoExcentricidad ContinuoInclinación Continuoseno_inclinacion Continuoargumento_perihelio ContinuoResonancia Continuodistancia_marte Continuodistancia_jupiter Continuo

c) Clases:

Las clases representan las familias de asteroides a las cuales cada asteroide puede pertenecer.

THEMIS, KORONIS, MARIA, EOS, PHOCAEA, FLORA.


EOS FLORA KORONIS MARIA PHOCAEA THEMIS TotalesEn el conjunto de entrenamiento 44 103 25 13 23 45 253En el conjunto de prueba 22 53 12 7 11 22 127Totales 66 156 37 20 34 67 380

5.2.6. Hipotiroidismo

a) Descripción

Estos datos fueron obtenidos de un estudio realizado sobre múltiples pacientes que presentaban síntomas

de hipotiroidismo en el Garvan Institute.

b) Atributos

Edad: continuoSexo: M, F.Toma tiroxina: f, v.Duda sobre tiroxina: f, v.Toma medicación antitiroídea: f, v.Enfermo: f, v.



Embarazada: f, v.Cirugía tiroídea: f, v.Tratamiento I131: f, v.Es hipotiroide: f, v.Es hipertiroide: f, v.Litio: f, v.bocio: f, v.tumor: f, v.Hipopituitario: f, v.Psicológico: f, v.Medición TSH: f, v.TSH: continuoMedición T3: f, v.T3: ContinuoMedición TT4: f, v.TT4: Continuo.Medición T4U: f, v.T4U: Continuo.Medición FTI: f, v.FTI: Continuo.Medición TBG: f, v.TBG: Continuo.Fuente de referencia: WEST, STMW, SVHC, SVI, SVHD, otros.

c) Clases:

hipertiroide, hipotiroide primario, hipotiroide compensado, hipotiroide secundario, negativo


Hipertiroide Hipotiroideprimario

Hipotiroidecompensado

Hipotiroidesecundario

Negativo Totales

En el conjunto de entrenamiento 0 64 129 1 2320 2514En el conjunto de prueba 0 31 65 1 1161 1258Totales 0 95 194 2 3481 3772

5.2.7. Identificación de vidrios

a) Descripción

Esta base de datos sirve para clasificar un vidrio como flotante o no. Dicha información es muy

importante para los investigadores criminológicos, ya que cualquier vidrio dejado en la escena del crimen

sirve como evidencia, si está correctamente clasificado. Los datos fueron obtenidos del Central Research

Establishment, Home Office Forensic Science Service de Aldermaston, Reading, Berkshire.



b) Atributos

Id Clave PrimariaIR (índice de refracción) continuoNa (Sodio medido como el porcentaje del peso del óxidocorrespondiente, esto se aplica para los demás minerales)

continuo

Mg (Magnesio) continuoAl (Aluminio) continuoSi (Silicio) continuoK (Potasio) continuoCa (Calcio) continuoBa (Bario) continuoFe (Hierro) continuo

c) Clases:

vidrios_float_para_construcciones, vidrios_para_construcciones_no_float, vidrios_float_para_vehículos,

vidrios_para_vehículos_no_float, contenedores, vajilla, lamparitas


Vidrios float paraconstrucciones

Vidrios paraconstruccionesno float

Vidrios floatpara vehículos

contenedores

vajilla lamparitas Totales

En el conjuntodeentrenamiento

47 51 11 9 6 19 143

En el conjuntode prueba

23 25 6 4 3 10 71

Totales 70 76 17 13 9 29 214

5.3. RESULTADOS OBTENIDOS CON EL ID3A continuación se presentan los resultados obtenidos con el ID3 en cada uno de los dominios analizados.

Cada uno de los resultados consiste en un árbol de decisión, un conjunto de reglas de decisión y una

matriz de resultados obtenida al aplicar los modelos sobre los datos de prueba. Dicha matriz informa por

cada clase, la cantidad de instancias del conjunto de prueba que fueron clasificadas correctamente, la

cantidad que fueron clasificadas erróneamente y la probabilidad de que una nueva instancia sea

clasificada correctamente.



5.3.1. Créditos

5.3.1.1. ID3 utilizando la ganancia como criterio de decisión

Árbol de decisión

Otros_Creditos = DOS CREDITOSComposición_Familiar = CASADO SIN HIJOS

SIComposición_Familiar = CASADO Y DOS HIJOS

Ingreso = ENTRE 451 Y 550Vivienda = ALQUILA

NOVivienda = PROPIA 0 IPVU

Servicios = BASICOS Y TICSI

Servicios = BASICOS, TIC Y TELNO

Ingreso = MAS DE 551SI

Composición_Familiar = CASADO Y UN HIJOSI

Composición_Familiar = SOLTEROVivienda = ALQUILA

Ingreso = ENTRE 451 Y 550SI

Ingreso = MAS DE 551NO

Vivienda = PROPIA 0 IPVUSI

Otros_Creditos = TRES CREDITOSNO

Otros_Creditos = UN CREDITOComposición_Familiar = CASADO SIN HIJOS




SIIngreso = MAS DE 551

SIComposición_Familiar = CASADO Y UN HIJO

SIComposición_Familiar = SOLTERO

SI

Reglas de decisión

Regla 0 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO SIN HIJOS ENTONCES Otorga_Creditos = SI

Regla 1 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = ALQUILA ENTONCES Otorga_Creditos = NO

Regla 2 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = PROPIA 0 IPVU Y Servicios = BASICOS Y TIC ENTONCES Otorga_Creditos = SI



Regla 3 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = PROPIA 0 IPVU Y Servicios = BASICOS, TIC Y TEL ENTONCES Otorga_Creditos = NO

Regla 4 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = MAS DE 551 ENTONCES Otorga_Creditos = SI

Regla 5 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y UN HIJO ENTONCES Otorga_Creditos = SI

Regla 6 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = SOLTERO Y Vivienda = ALQUILA Y Ingreso = ENTRE 451 Y 550 ENTONCES Otorga_Creditos = SI

Regla 7 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = SOLTERO Y Vivienda = ALQUILA Y Ingreso = MAS DE 551 ENTONCES Otorga_Creditos = NO

Regla 8 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = SOLTERO Y Vivienda = PROPIA 0 IPVU ENTONCES Otorga_Creditos = SI

Regla 9 SI Otros_Creditos = TRES CREDITOS ENTONCES Otorga_Creditos = NO

Regla 10 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO SIN HIJOS ENTONCES Otorga_Creditos = SI

Regla 11 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = ALQUILA ENTONCES Otorga_Creditos = NO

Regla 12 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = PROPIA 0 IPVU ENTONCES Otorga_Creditos = SI

Regla 13 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = MAS DE 551 ENTONCES Otorga_Creditos = SI

Regla 14 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO Y UN HIJO ENTONCES Otorga_Creditos = SI

Regla 15 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = SOLTERO



ENTONCES Otorga_Creditos = SI

Evaluación de los resultados

Clases Correctos Errores ProbabilidadNO 16 0 1SI 17 18 0,485714Totales 33 18 0,647058

5.3.1.2. ID3 utilizando la proporción ganancia como criterio de decisión

Árbol de decisión

Otros_Creditos = DOS CREDITOSComposición_Familiar = CASADO SIN HIJOS




Servicios = BASICOS Y TIC SI


Ingreso = MAS DE 551 SI

Composición_Familiar = CASADO Y UN HIJO SI

Composición_Familiar = SOLTEROVivienda = ALQUILA

Ingreso = ENTRE 451 Y 550 SI

Ingreso = MAS DE 551NO

Vivienda = PROPIA 0 IPVU SI

Otros_Creditos = TRES CREDITOSNO

Otros_Creditos = UN CREDITOComposición_Familiar = CASADO SIN HIJOS




SIIngreso = MAS DE 551

SIComposición_Familiar = CASADO Y UN HIJO

SIComposición_Familiar = SOLTERO

SI

Reglas de decisión



Regla 0 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO SIN HIJOS ENTONCES Otorga_Creditos = SI

Regla 1 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = ALQUILA ENTONCES Otorga_Creditos = NO

Regla 2 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = PROPIA 0 IPVU Y Servicios = BASICOS Y TIC ENTONCES Otorga_Creditos = SI

Regla 3 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = PROPIA 0 IPVU Y Servicios = BASICOS, TIC Y TEL ENTONCES Otorga_Creditos = NO

Regla 4 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = MAS DE 551 ENTONCES Otorga_Creditos = SI

Regla 5 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = CASADO Y UN HIJO ENTONCES Otorga_Creditos = SI

Regla 6 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = SOLTERO Y Vivienda = ALQUILA Y Ingreso = ENTRE 451 Y 550 ENTONCES Otorga_Creditos = SI

Regla 7 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = SOLTERO Y Vivienda = ALQUILA Y Ingreso = MAS DE 551 ENTONCES Otorga_Creditos = NO

Regla 8 SI Otros_Creditos = DOS CREDITOS Y Composición_Familiar = SOLTERO Y Vivienda = PROPIA 0 IPVU ENTONCES Otorga_Creditos = SI

Regla 9 SI Otros_Creditos = TRES CREDITOS ENTONCES Otorga_Creditos = NO

Regla 10 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO SIN HIJOS ENTONCES Otorga_Creditos = SI

Regla 11 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = ALQUILA ENTONCES Otorga_Creditos = NO

Regla 12 SI Otros_Creditos = UN CREDITO



Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = ENTRE 451 Y 550 Y Vivienda = PROPIA 0 IPVU ENTONCES Otorga_Creditos = SI

Regla 13 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO Y DOS HIJOS Y Ingreso = MAS DE 551 ENTONCES Otorga_Creditos = SI

Regla 14 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = CASADO Y UN HIJO ENTONCES Otorga_Creditos = SI

Regla 15 SI Otros_Creditos = UN CREDITO Y Composición_Familiar = SOLTERO ENTONCES Otorga_Creditos = SI


Clases Correctos Errores ProbabilidadNO 16 0 1SI 17 18 0,485714Totales 33 18 0,647058

5.3.1.3. Conclusiones

En este caso, tanto el árbol como las reglas obtenidas mediante el ID3 son idénticos para la ganancia y

para la proporción de ganancia. Si analizamos la tabla de evaluación de los resultados, vemos que el

clasificador3 obtenido es excelente para clasificar la clase “NO”, pero sólo es exitoso en un 50% de los

casos de la clase “SI”. Es decir, que un nuevo caso de clase “NO” tiene una probabilidad de 1 de ser

clasificado correctamente. Mientras que un nuevo caso de clase “SI”, tiene solamente una probabilidad

del 0,49 de ser clasificado como “SI”.

Creemos que este fenómeno puede deberse a una mala elección de los datos de entrenamiento y prueba.

Un clasificador exitoso sobre los datos de entrenamiento, será exitoso sobre los demás conjuntos de datos

en la medida en que los datos de entrenamiento sean representativos de los otros conjuntos. Supongamos

que tenemos para un dominio hipotético, los siguientes datos de entrenamiento:

Atributo A Atributo B Clase1 5 NO1 90 NO

3 En el caso del ID3, por clasificador nos referiremos tanto al árbol como a las reglas obtenidas, ya es indistinto utilizar uno u otro

para clasificar nuevos casos.



2 90 SI

A partir de estos datos, el ID3 generaría las siguientes reglas de decisión:

1. SI Atributo A =1 ENTONCES Clase=”NO”

2. SI Atributo A =2 ENTONCES Clase=”SI”

Si aplicamos el clasificador a la siguiente tupla de prueba: 2,3,”NO”, el resultado será erróneo. Si todos

los casos de prueba de clase “NO” tuviesen valores distintos de 1 para el atributo A, entonces la

performance de los modelos obtenidos sobre estos datos de prueba sería poco alentadora. El conjunto de

entrenamiento en ese caso no sería representativo de los conjuntos en el cual se aplicó el clasificador.

Entonces, podemos conjeturar que la performance de los clasificadores generados por el ID3 para el

dominio Créditos, puede deberse a que los datos de entrenamiento no eran representativos de los datos de

prueba. Podemos extrapolar, este problema de representatividad de los datos de aprendizaje a los

humanos: no podemos enseñarle a un niño el concepto de pájaro mostrándole sólo distintas clases de

pingüinos, ya que cuando vea cualquier otro pájaro como una golondrina, un gorrión o una paloma,

pensará que no son pájaros; para él los pájaros no vuelan, son gordos, grandes y caminan por el hielo.

5.3.2. Cardiología


Árbol de decisión

DURACION_DEL_ANGOR = MAS DE 30 MINDOLOR_DE_PECHO_DE_ANGOR = ATIPICO

IRRADIACION_DEL_ANGOR = NORESPUESTA_VASODILATADORA = NEGATIVO

NORESPUESTA_VASODILATADORA = POSITIVO

SIIRRADIACION_DEL_ANGOR = SI

SIDOLOR_DE_PECHO_DE_ANGOR = AUSENTE

NODOLOR_DE_PECHO_DE_ANGOR = TIPICO

ANGOR_EN_RELACION = CON ESFUERZORESPUESTA_VASODILATADORA = NEGATIVO

SIRESPUESTA_VASODILATADORA = POSITIVO

IRRADIACION_DEL_ANGOR = NONO

IRRADIACION_DEL_ANGOR = SISI

ANGOR_EN_RELACION = EN REPOSOSI

DURACION_DEL_ANGOR = MENOS DE 30 MINDOLOR_DE_PECHO_DE_ANGOR = ATIPICO



NODOLOR_DE_PECHO_DE_ANGOR = AUSENTE


IRRADIACION_DEL_ANGOR = NOANTIGÜEDAD_DEL_ANGOR = MAS DE 1 MES

NOANTIGÜEDAD_DEL_ANGOR = RECIENTE

ANGOR_EN_RELACION = CON ESFUERZOSI

ANGOR_EN_RELACION = EN REPOSONO

IRRADIACION_DEL_ANGOR = SINO

Reglas de decisión

Regla 0 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = ATIPICO Y IRRADIACION_DEL_ANGOR = NO Y RESPUESTA_VASODILATADORA = NEGATIVO ENTONCES DIAGNOSTICO = NO

Regla 1 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = ATIPICO Y IRRADIACION_DEL_ANGOR = NO Y RESPUESTA_VASODILATADORA = POSITIVO ENTONCES DIAGNOSTICO = SI

Regla 2 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = ATIPICO Y IRRADIACION_DEL_ANGOR = SI ENTONCES DIAGNOSTICO = SI

Regla 3 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = AUSENTE ENTONCES DIAGNOSTICO = NO

Regla 4 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y ANGOR_EN_RELACION = CON ESFUERZO Y RESPUESTA_VASODILATADORA = NEGATIVO ENTONCES DIAGNOSTICO = SI

Regla 5 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y ANGOR_EN_RELACION = CON ESFUERZO Y RESPUESTA_VASODILATADORA = POSITIVO Y IRRADIACION_DEL_ANGOR = NO ENTONCES DIAGNOSTICO = NO

Regla 6 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y ANGOR_EN_RELACION = CON ESFUERZO Y RESPUESTA_VASODILATADORA = POSITIVO Y IRRADIACION_DEL_ANGOR = SI ENTONCES DIAGNOSTICO = SI

Regla 7 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y ANGOR_EN_RELACION = EN REPOSO ENTONCES DIAGNOSTICO = SI



Regla 8 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = ATIPICO ENTONCES DIAGNOSTICO = NO

Regla 9 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = AUSENTE ENTONCES DIAGNOSTICO = NO

Regla 10 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y IRRADIACION_DEL_ANGOR = NO Y ANTIGÜEDAD_DEL_ANGOR = MAS DE 1 MES ENTONCES DIAGNOSTICO = NO

Regla 11 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y IRRADIACION_DEL_ANGOR = NO Y ANTIGÜEDAD_DEL_ANGOR = RECIENTE Y ANGOR_EN_RELACION = CON ESFUERZO ENTONCES DIAGNOSTICO = SI

Regla 12 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y IRRADIACION_DEL_ANGOR = NO Y ANTIGÜEDAD_DEL_ANGOR = RECIENTE Y ANGOR_EN_RELACION = EN REPOSO ENTONCES DIAGNOSTICO = NO

Regla 13 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y IRRADIACION_DEL_ANGOR = SI ENTONCES DIAGNOSTICO = NO


Clases Correctos Errores ProbabilidadNO 20 2 0,909090SI 9 0 1Totales 29 2 0,935483


Árbol de decisión

DURACION_DEL_ANGOR = MAS DE 30 MINDOLOR_DE_PECHO_DE_ANGOR = ATIPICO

IRRADIACION_DEL_ANGOR = NORESPUESTA_VASODILATADORA = NEGATIVO

NORESPUESTA_VASODILATADORA = POSITIVO

SIIRRADIACION_DEL_ANGOR = SI

SIDOLOR_DE_PECHO_DE_ANGOR = AUSENTE


ANGOR_EN_RELACION = CON ESFUERZORESPUESTA_VASODILATADORA = NEGATIVO

SI



RESPUESTA_VASODILATADORA = POSITIVOIRRADIACION_DEL_ANGOR = NO

NOIRRADIACION_DEL_ANGOR = SI

SIANGOR_EN_RELACION = EN REPOSO

SIDURACION_DEL_ANGOR = MENOS DE 30 MIN

DOLOR_DE_PECHO_DE_ANGOR = ATIPICONO

DOLOR_DE_PECHO_DE_ANGOR = AUSENTENO

DOLOR_DE_PECHO_DE_ANGOR = TIPICOIRRADIACION_DEL_ANGOR = NO

ANTIGÜEDAD_DEL_ANGOR = MAS DE 1 MESNO

ANTIGÜEDAD_DEL_ANGOR = RECIENTEANGOR_EN_RELACION = CON ESFUERZO

SIANGOR_EN_RELACION = EN REPOSO

NOIRRADIACION_DEL_ANGOR = SI

NO

Reglas de decisión

Regla 0 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = ATIPICO Y IRRADIACION_DEL_ANGOR = NO Y RESPUESTA_VASODILATADORA = NEGATIVO ENTONCES DIAGNOSTICO = NO

Regla 1 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = ATIPICO Y IRRADIACION_DEL_ANGOR = NO Y RESPUESTA_VASODILATADORA = POSITIVO ENTONCES DIAGNOSTICO = SI

Regla 2 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = ATIPICO Y IRRADIACION_DEL_ANGOR = SI ENTONCES DIAGNOSTICO = SI

Regla 3 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = AUSENTE ENTONCES DIAGNOSTICO = NO

Regla 4 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y ANGOR_EN_RELACION = CON ESFUERZO Y RESPUESTA_VASODILATADORA = NEGATIVO ENTONCES DIAGNOSTICO = SI

Regla 5 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y ANGOR_EN_RELACION = CON ESFUERZO Y RESPUESTA_VASODILATADORA = POSITIVO Y IRRADIACION_DEL_ANGOR = NO ENTONCES DIAGNOSTICO = NO

Regla 6 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y ANGOR_EN_RELACION = CON ESFUERZO Y RESPUESTA_VASODILATADORA = POSITIVO Y IRRADIACION_DEL_ANGOR = SI



ENTONCES DIAGNOSTICO = SI

Regla 7 SI DURACION_DEL_ANGOR = MAS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y ANGOR_EN_RELACION = EN REPOSO ENTONCES DIAGNOSTICO = SI

Regla 8 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = ATIPICO ENTONCES DIAGNOSTICO = NO

Regla 9 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = AUSENTE ENTONCES DIAGNOSTICO = NO

Regla 10 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y IRRADIACION_DEL_ANGOR = NO Y ANTIGÜEDAD_DEL_ANGOR = MAS DE 1 MES ENTONCES DIAGNOSTICO = NO

Regla 11 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y IRRADIACION_DEL_ANGOR = NO Y ANTIGÜEDAD_DEL_ANGOR = RECIENTE Y ANGOR_EN_RELACION = CON ESFUERZO ENTONCES DIAGNOSTICO = SI

Regla 12 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y IRRADIACION_DEL_ANGOR = NO Y ANTIGÜEDAD_DEL_ANGOR = RECIENTE Y ANGOR_EN_RELACION = EN REPOSO ENTONCES DIAGNOSTICO = NO

Regla 13 SI DURACION_DEL_ANGOR = MENOS DE 30 MIN Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO Y IRRADIACION_DEL_ANGOR = SI ENTONCES DIAGNOSTICO = NO


Clases Correctos Errores ProbabilidadNO 20 2 0,909090SI 9 0 1Totales 29 2 0,935483


Al igual que en el caso anterior, vemos que tanto el árbol como las reglas de decisión obtenidas son

iguales para el criterio de ganancia como para el de proporción de ganancia. En este caso, no obstante, la

performance del clasificador es notablemente mejor que en el caso anterior. El modelo generado tiene un

93% de probabilidad de clasificar correctamente un caso negativo, y un 100% de clasificar correctamente

uno positivo.



Cabe destacar que la cantidad de casos de entrenamiento es menor a la del caso anterior y no obstante la

cantidad de reglas obtenidas es 13, contra 15 obtenidas en el caso anterior. Entonces, podríamos concluir,

grosso modo, que la cantidad de datos de entrada no es proporcional al tamaño del árbol ni la cantidad de

reglas obtenidas.

5.3.3. Votaciones


Árbol de decisión

Cong_honorarios_medicos = a_favorReduccion_corp_Synfuels = a_favor

Export_sin_impuestos = a_favordemocrata

Export_sin_impuestos = desconocidorepublicano

Export_sin_impuestos = en_contraPresupuesto_de_educacion = a_favor

Der_demanda_Superfund = a_favorParticip_proy_agua = a_favor

republicanoParticip_proy_agua = en_contra

Acta_sudaf_admin_export = a_favorrepublicano

Acta_sudaf_admin_export = desconocidorepublicano

Acta_sudaf_admin_export = en_contraNiños discapacitados = a_favor

republicanoNiños discapacitados = en_contra

democrataDer_demanda_Superfund = en_contra

democrataPresupuesto_de_educacion = desconocido

democrataPresupuesto_de_educacion = en_contra

Acta_sudaf_admin_export = a_favorAdop_resolucion_presup = a_favor

republicanoAdop_resolucion_presup = en_contra

Ayuda_a_El_Salvador = a_favorrepublicano

Ayuda_a_El_Salvador = en_contrademocrata

Acta_sudaf_admin_export = desconocidodemocrata

Acta_sudaf_admin_export = en_contrademocrata

Reduccion_corp_Synfuels = desconocidorepublicano

Reduccion_corp_Synfuels = en_contraExport_sin_impuestos = a_favor

Inmigracion = a_favorrepublicano

Inmigracion = en_contraActa_sudaf_admin_export = a_favor

democrataActa_sudaf_admin_export = desconocido

Particip_proy_agua = a_favorrepublicano

Particip_proy_agua = en_contrademocrata

Acta_sudaf_admin_export = en_contrarepublicano


Export_sin_impuestos = en_contra



Adop_resolucion_presup = a_favorActa_sudaf_admin_export = a_favor

republicanoActa_sudaf_admin_export = desconocido

Niños discapacitados = a_favorrepublicano

Niños discapacitados = en_contrademocrata

Adop_resolucion_presup = en_contrarepublicano

Cong_honorarios_medicos = desconocidoMisil_mx = a_favor

Prohib_pruebas_anti_satel = a_favordemocrata

Prohib_pruebas_anti_satel = desconocidodemocrata

Prohib_pruebas_anti_satel = en_contrarepublicano

Misil_mx = desconocidorepublicano

Misil_mx = en_contrademocrata

Cong_honorarios_medicos = en_contraPresupuesto_de_educacion = a_favor


Adop_resolucion_presup = a_favordemocrata


Presupuesto_de_educacion = en_contrademocrata

Reglas de decisión

Regla 0 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = a_favor ENTONCES Clase = democrata

Regla 1 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = desconocido ENTONCES Clase = republicano

Regla 2 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = a_favor ENTONCES Clase = republicano

Regla 3 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = en_contra Y Acta_sudaf_admin_export = a_favor ENTONCES Clase = republicano

Regla 4 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor



Y Particip_proy_agua = en_contra Y Acta_sudaf_admin_export = desconocido ENTONCES Clase = republicano

Regla 5 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = en_contra Y Acta_sudaf_admin_export = en_contra Y Niños discapacitados = a_favor ENTONCES Clase = republicano

Regla 6 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = en_contra Y Acta_sudaf_admin_export = en_contra Y Niños discapacitados = en_contra ENTONCES Clase = democrata

Regla 7 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = en_contra ENTONCES Clase = democrata

Regla 8 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = desconocido ENTONCES Clase = democrata

Regla 9 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = a_favor Y Adop_resolucion_presup = a_favor ENTONCES Clase = republicano

Regla 10 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = a_favor Y Adop_resolucion_presup = en_contra Y Ayuda_a_El_Salvador = a_favor ENTONCES Clase = republicano

Regla 11 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = a_favor Y Adop_resolucion_presup = en_contra Y Ayuda_a_El_Salvador = en_contra ENTONCES Clase = democrata

Regla 12 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = desconocido ENTONCES Clase = democrata



Regla 13 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = en_contra ENTONCES Clase = democrata

Regla 14 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = desconocido ENTONCES Clase = republicano

Regla 15 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = a_favor ENTONCES Clase = republicano

Regla 16 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = en_contra Y Acta_sudaf_admin_export = a_favor ENTONCES Clase = democrata

Regla 17 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = en_contra Y Acta_sudaf_admin_export = desconocido Y Particip_proy_agua = a_favor ENTONCES Clase = republicano

Regla 18 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = en_contra Y Acta_sudaf_admin_export = desconocido Y Particip_proy_agua = en_contra ENTONCES Clase = democrata

Regla 19 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = en_contra Y Acta_sudaf_admin_export = en_contra ENTONCES Clase = republicano

Regla 20 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = desconocido ENTONCES Clase = republicano

Regla 21 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = en_contra Y Adop_resolucion_presup = a_favor Y Acta_sudaf_admin_export = a_favor ENTONCES Clase = republicano

Regla 22 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = en_contra Y Adop_resolucion_presup = a_favor Y Acta_sudaf_admin_export = desconocido Y Niños discapacitados = a_favor ENTONCES Clase = republicano



Regla 23 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = en_contra Y Adop_resolucion_presup = a_favor Y Acta_sudaf_admin_export = desconocido Y Niños discapacitados = en_contra ENTONCES Clase = democrata

Regla 24 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = en_contra Y Adop_resolucion_presup = en_contra ENTONCES Clase = republicano

Regla 25 SI Cong_honorarios_medicos = desconocido Y Misil_mx = a_favor Y Prohib_pruebas_anti_satel = a_favor ENTONCES Clase = democrata

Regla 26 SI Cong_honorarios_medicos = desconocido Y Misil_mx = a_favor Y Prohib_pruebas_anti_satel = desconocido ENTONCES Clase = democrata

Regla 27 SI Cong_honorarios_medicos = desconocido Y Misil_mx = a_favor Y Prohib_pruebas_anti_satel = en_contra ENTONCES Clase = republicano

Regla 28 SI Cong_honorarios_medicos = desconocido Y Misil_mx = desconocido ENTONCES Clase = republicano

Regla 29 SI Cong_honorarios_medicos = desconocido Y Misil_mx = en_contra ENTONCES Clase = democrata

Regla 30 SI Cong_honorarios_medicos = en_contra Y Presupuesto_de_educacion = a_favor ENTONCES Clase = democrata

Regla 31 SI Cong_honorarios_medicos = en_contra Y Presupuesto_de_educacion = desconocido Y Adop_resolucion_presup = a_favor ENTONCES Clase = democrata

Regla 32 SI Cong_honorarios_medicos = en_contra Y Presupuesto_de_educacion = desconocido Y Adop_resolucion_presup = en_contra ENTONCES Clase = republicano

Regla 33 SI Cong_honorarios_medicos = en_contra Y Presupuesto_de_educacion = en_contra ENTONCES Clase = democrata


Clases Correctos Errores Probabilidad



Demócrata 81 2 0,9759036Republicano 47 5 0,903846Totales 128 7 0,948148


Árbol de decisión



Export_sin_impuestos = desconocido republicano




Acta_sudaf_admin_export = a_favor republicano

Acta_sudaf_admin_export = desconocido republicano








Ayuda_a_El_Salvador = a_favor republicano



Acta_sudaf_admin_export = en_contrademocrata

Reduccion_corp_Synfuels = desconocido republicano


Inmigracion = a_favor republicano



Particip_proy_agua = a_favor republicano


Acta_sudaf_admin_export = en_contra republicano

Export_sin_impuestos = desconocido republicano

Export_sin_impuestos = en_contraAdop_resolucion_presup = a_favor

Acta_sudaf_admin_export = a_favor republicano

Acta_sudaf_admin_export = desconocidoNiños discapacitados = a_favor




democrataAdop_resolucion_presup = en_contra

republicanoCong_honorarios_medicos = desconocido

Misil_mx = a_favorProhib_pruebas_anti_satel = a_favor

democrataProhib_pruebas_anti_satel = desconocido

democrataProhib_pruebas_anti_satel = en_contra

republicanoMisil_mx = desconocido

republicanoMisil_mx = en_contra

democrataCong_honorarios_medicos = en_contra


Adop_resolucion_presup = desconocidodemocrata

Adop_resolucion_presup = en_contraPresupuesto_de_educacion = a_favor


republicanoPresupuesto_de_educacion = en_contra

democrata

Reglas de decisión

Regla 0 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = a_favor ENTONCES Clase = democrata

Regla 1 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = desconocido ENTONCES Clase = republicano

Regla 2 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = a_favor ENTONCES Clase = republicano

Regla 3 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = en_contra Y Acta_sudaf_admin_export = a_favor ENTONCES Clase = republicano

Regla 4 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = en_contra Y Acta_sudaf_admin_export = desconocido ENTONCES Clase = republicano



Regla 5 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = en_contra Y Acta_sudaf_admin_export = en_contra Y Niños discapacitados = a_favor ENTONCES Clase = republicano

Regla 6 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = a_favor Y Particip_proy_agua = en_contra Y Acta_sudaf_admin_export = en_contra Y Niños discapacitados = en_contra ENTONCES Clase = democrata

Regla 7 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = a_favor Y Der_demanda_Superfund = en_contra ENTONCES Clase = democrata

Regla 8 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = desconocido ENTONCES Clase = democrata

Regla 9 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = a_favor Y Adop_resolucion_presup = a_favor ENTONCES Clase = republicano

Regla 10 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = a_favor Y Adop_resolucion_presup = en_contra Y Ayuda_a_El_Salvador = a_favor ENTONCES Clase = republicano

Regla 11 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = a_favor Y Adop_resolucion_presup = en_contra Y Ayuda_a_El_Salvador = en_contra ENTONCES Clase = democrata

Regla 12 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = desconocido ENTONCES Clase = democrata

Regla 13



SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = a_favor Y Export_sin_impuestos = en_contra Y Presupuesto_de_educacion = en_contra Y Acta_sudaf_admin_export = en_contra ENTONCES Clase = democrata

Regla 14 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = desconocido ENTONCES Clase = republicano

Regla 15 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = a_favor ENTONCES Clase = republicano

Regla 16 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = en_contra Y Acta_sudaf_admin_export = a_favor ENTONCES Clase = democrata

Regla 17 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = en_contra Y Acta_sudaf_admin_export = desconocido Y Particip_proy_agua = a_favor ENTONCES Clase = republicano

Regla 18 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = en_contra Y Acta_sudaf_admin_export = desconocido Y Particip_proy_agua = en_contra ENTONCES Clase = democrata

Regla 19 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = a_favor Y Inmigracion = en_contra Y Acta_sudaf_admin_export = en_contra ENTONCES Clase = republicano

Regla 20 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = desconocido ENTONCES Clase = republicano

Regla 21 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = en_contra Y Adop_resolucion_presup = a_favor Y Acta_sudaf_admin_export = a_favor ENTONCES Clase = republicano

Regla 22 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = en_contra Y Adop_resolucion_presup = a_favor Y Acta_sudaf_admin_export = desconocido Y Niños discapacitados = a_favor ENTONCES Clase = republicano



Regla 23 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = en_contra Y Adop_resolucion_presup = a_favor Y Acta_sudaf_admin_export = desconocido Y Niños discapacitados = en_contra ENTONCES Clase = democrata

Regla 24 SI Cong_honorarios_medicos = a_favor Y Reduccion_corp_Synfuels = en_contra Y Export_sin_impuestos = en_contra Y Adop_resolucion_presup = en_contra ENTONCES Clase = republicano

Regla 25 SI Cong_honorarios_medicos = desconocido Y Misil_mx = a_favor Y Prohib_pruebas_anti_satel = a_favor ENTONCES Clase = democrata

Regla 26 SI Cong_honorarios_medicos = desconocido Y Misil_mx = a_favor Y Prohib_pruebas_anti_satel = desconocido ENTONCES Clase = democrata

Regla 27 SI Cong_honorarios_medicos = desconocido Y Misil_mx = a_favor Y Prohib_pruebas_anti_satel = en_contra ENTONCES Clase = republicano

Regla 28 SI Cong_honorarios_medicos = desconocido Y Misil_mx = desconocido ENTONCES Clase = republicano

Regla 29 SI Cong_honorarios_medicos = desconocido Y Misil_mx = en_contra ENTONCES Clase = democrata

Regla 30 SI Cong_honorarios_medicos = en_contra Y Adop_resolucion_presup = a_favor ENTONCES Clase = democrata

Regla 31 SI Cong_honorarios_medicos = en_contra Y Adop_resolucion_presup = desconocido ENTONCES Clase = democrata

Regla 32 SI Cong_honorarios_medicos = en_contra Y Adop_resolucion_presup = en_contra Y Presupuesto_de_educacion = a_favor ENTONCES Clase = democrata

Regla 33 SI Cong_honorarios_medicos = en_contra Y Adop_resolucion_presup = en_contra Y Presupuesto_de_educacion = desconocido ENTONCES Clase = republicano

Regla 34 SI Cong_honorarios_medicos = en_contra Y Adop_resolucion_presup = en_contra Y Presupuesto_de_educacion = en_contra ENTONCES Clase = democrata




Clases Correctos Errores ProbabilidadDemócrata 81 2 0,9759036Republicano 47 5 0,903846Totales 128 7 0,948148


En comparación con los dominios anteriores, los modelos obtenidos en este caso son de gran tamaño. Los

árboles de decisión tienen un tamaño de 57 y 58 para la ganancia y proporción de ganancia

respectivamente, y se obtuvieron 34 reglas con la ganancia y 35 con la proporción de ganancia. Los

modelos generados utilizando la ganancia y la proporción de ganancia son muy similares. Si analizamos

los árboles de decisión, vemos que esta diferencia en tamaño se origina en la rama

Cong_honorarios_medicos=a_favor, donde el atributo Presupuesto_de_educacion genera la mayor

ganancia, y el atributo Adop_resolucion_presup genera la mayor proporción de ganancia.

Si miramos los tamaños de los modelos obtenidos a la luz de los dominios analizados anteriormente,

podríamos decir que, en este caso, los modelos obtenidos son de mayor tamaño porque el sistema analizó

una mayor cantidad de datos de entrenamiento. Con lo cual, nuestra hipótesis acerca de que la cantidad de

datos de entrenamiento no afecta el tamaño de los modelos generados se vería afectada. Podríamos hilar

más fino, tomando la nueva hipótesis de que la cantidad de datos de entrenamiento influye en el tamaño

de los modelos generados, en la medida en que analizamos grandes diferencias en la cantidad de datos de

entrenamiento. En cambio, cuando estas diferencias son más pequeñas, la cantidad de datos de

entrenamiento no influye. Es decir, si construimos un modelo a partir de 400 datos de entrenamiento,

obtenemos árboles de decisión del orden de X; y si construimos un modelo a partir de 40 datos de

entrenamiento, obtenemos árboles de decisión del orden de Y, siendo Y menor que X. Sin embargo, si

construimos un árbol de decisión a partir de 450 datos de entrenamiento, probablemente el árbol tenga un

tamaño del orden de X; y si lo construimos a partir de 35 datos de entrenamiento, uno de orden Y.

En cuanto a la proporción de error sobre los datos de prueba, es de 5.19% en todos los casos. Además, la

probabilidad de clasificar un caso de prueba correctamente es alta para ambas clases.





Árbol de decisión

Olor = almendraingerible

Olor = anisingerible

Olor = creosotavenenoso

Olor = especiosovenenoso

Olor = hediondovenenoso

Olor = mohosovenenoso

Olor = ningunoColor_sombrero = amarillo

venenosoColor_sombrero = blanco

Magulladuras = noingerible

Magulladuras = sivenenoso

Color_sombrero = canelaingerible

Color_sombrero = grisingerible

Color_sombrero = marronSup_tronco_arriba_anillo = escamosa

ingeribleSup_tronco_arriba_anillo = fibrosa

ingeribleSup_tronco_arriba_anillo = sedosa

venenosoSup_tronco_arriba_anillo = suave

ingeribleColor_sombrero = piel

Forma_sombrero = abotonadaingerible

Forma_sombrero = acampanadavenenoso

Forma_sombrero = chataingerible

Forma_sombrero = convexaingerible

Color_sombrero = rojoingerible

Color_sombrero = rosaColor_esporas = blanca

ingeribleColor_esporas = verde

venenosoColor_sombrero = verde

ingeribleColor_sombrero = violeta

ingeribleOlor = pescado

venenosoOlor = punzante

Venenoso

Reglas de decisión

Regla 0 SI Olor = almendra ENTONCES Tipo_Hongo = ingerible



Regla 1 SI Olor = anis ENTONCES Tipo_Hongo = ingerible

Regla 2 SI Olor = creosota ENTONCES Tipo_Hongo = venenoso

Regla 3 SI Olor = especioso ENTONCES Tipo_Hongo = venenoso

Regla 4 SI Olor = hediondo ENTONCES Tipo_Hongo = venenoso

Regla 5 SI Olor = mohoso ENTONCES Tipo_Hongo = venenoso

Regla 6 SI Olor = ninguno Y Color_sombrero = amarillo ENTONCES Tipo_Hongo = venenoso

Regla 7 SI Olor = ninguno Y Color_sombrero = blanco Y Magulladuras = no ENTONCES Tipo_Hongo = ingerible

Regla 8 SI Olor = ninguno Y Color_sombrero = blanco Y Magulladuras = si ENTONCES Tipo_Hongo = venenoso

Regla 9 SI Olor = ninguno Y Color_sombrero = canela ENTONCES Tipo_Hongo = ingerible

Regla 10 SI Olor = ninguno Y Color_sombrero = gris ENTONCES Tipo_Hongo = ingerible

Regla 11 SI Olor = ninguno Y Color_sombrero = marron Y Sup_tronco_arriba_anillo = escamosa ENTONCES Tipo_Hongo = ingerible

Regla 12 SI Olor = ninguno Y Color_sombrero = marron Y Sup_tronco_arriba_anillo = fibrosa ENTONCES Tipo_Hongo = ingerible

Regla 13 SI Olor = ninguno Y Color_sombrero = marron Y Sup_tronco_arriba_anillo = sedosa ENTONCES Tipo_Hongo = venenoso

Regla 14 SI Olor = ninguno Y Color_sombrero = marron Y Sup_tronco_arriba_anillo = suave ENTONCES Tipo_Hongo = ingerible

Regla 15 SI Olor = ninguno Y Color_sombrero = piel Y Forma_sombrero = abotonada ENTONCES Tipo_Hongo = ingerible



Regla 16 SI Olor = ninguno Y Color_sombrero = piel Y Forma_sombrero = acampanada ENTONCES Tipo_Hongo = venenoso

Regla 17 SI Olor = ninguno Y Color_sombrero = piel Y Forma_sombrero = chata ENTONCES Tipo_Hongo = ingerible

Regla 18 SI Olor = ninguno Y Color_sombrero = piel Y Forma_sombrero = convexa ENTONCES Tipo_Hongo = ingerible

Regla 19 SI Olor = ninguno Y Color_sombrero = rojo ENTONCES Tipo_Hongo = ingerible

Regla 20 SI Olor = ninguno Y Color_sombrero = rosa Y Color_esporas = blanca ENTONCES Tipo_Hongo = ingerible

Regla 21 SI Olor = ninguno Y Color_sombrero = rosa Y Color_esporas = verde ENTONCES Tipo_Hongo = venenoso

Regla 22 SI Olor = ninguno Y Color_sombrero = verde ENTONCES Tipo_Hongo = ingerible

Regla 23 SI Olor = ninguno Y Color_sombrero = violeta ENTONCES Tipo_Hongo = ingerible

Regla 24 SI Olor = pescado ENTONCES Tipo_Hongo = venenoso

Regla 25 SI Olor = punzante ENTONCES Tipo_Hongo = venenoso


Clases Correctos Errores ProbabilidadIngerible 1403 0 1Venenoso 1293 12 0,990804Totales 2696 12 0,995568



5.3.4.2 ID3. utilizando la proporción ganancia como criterio de decisión

Árbol de decisión

Olor = almendraingerible

Olor = anisingerible

Olor = creosota venenoso

Olor = especioso venenoso

Olor = hediondo venenoso

Olor = mohoso venenoso

Olor = ningunoColor_velo = amarillo

venenosoColor_velo = blanco

Tamaño_membrana = anchaColor_esporas = blanca

ingeribleColor_esporas = marron

ingeribleColor_esporas = negro

ingeribleColor_esporas = verde

venenosoTamaño_membrana = fina

Magulladuras = noSup_tronco_arriba_anillo = fibrosa

ingeribleSup_tronco_arriba_anillo = sedosa

venenosoSup_tronco_arriba_anillo = suave

ingeribleMagulladuras = si

venenosoColor_velo = marron

ingeribleColor_velo = naranja

ingeribleOlor = pescado

venenosoOlor = punzante

venenoso

Reglas de decisión

Regla 0 SI Olor = almendra ENTONCES Tipo_Hongo = ingerible

Regla 1 SI Olor = anis ENTONCES Tipo_Hongo = ingerible

Regla 2 SI Olor = creosota ENTONCES Tipo_Hongo = venenoso

Regla 3 SI Olor = especioso ENTONCES Tipo_Hongo = venenoso

Regla 4 SI Olor = hediondo ENTONCES Tipo_Hongo = venenoso



Regla 5 SI Olor = mohoso ENTONCES Tipo_Hongo = venenoso

Regla 6 SI Olor = ninguno Y Color_velo = amarillo ENTONCES Tipo_Hongo = venenoso

Regla 7 SI Olor = ninguno Y Color_velo = blanco Y Tamaño_membrana = ancha Y Color_esporas = blanca ENTONCES Tipo_Hongo = ingerible

Regla 8 SI Olor = ninguno Y Color_velo = blanco Y Tamaño_membrana = ancha Y Color_esporas = marron ENTONCES Tipo_Hongo = ingerible

Regla 9 SI Olor = ninguno Y Color_velo = blanco Y Tamaño_membrana = ancha Y Color_esporas = negro ENTONCES Tipo_Hongo = ingerible

Regla 10 SI Olor = ninguno Y Color_velo = blanco Y Tamaño_membrana = ancha Y Color_esporas = verde ENTONCES Tipo_Hongo = venenoso

Regla 11 SI Olor = ninguno Y Color_velo = blanco Y Tamaño_membrana = fina Y Magulladuras = no Y Sup_tronco_arriba_anillo = fibrosa ENTONCES Tipo_Hongo = ingerible

Regla 12 SI Olor = ninguno Y Color_velo = blanco Y Tamaño_membrana = fina Y Magulladuras = no Y Sup_tronco_arriba_anillo = sedosa ENTONCES Tipo_Hongo = venenoso

Regla 13 SI Olor = ninguno Y Color_velo = blanco Y Tamaño_membrana = fina Y Magulladuras = no Y Sup_tronco_arriba_anillo = suave ENTONCES Tipo_Hongo = ingerible

Regla 14 SI Olor = ninguno Y Color_velo = blanco Y Tamaño_membrana = fina Y Magulladuras = si ENTONCES Tipo_Hongo = venenoso

Regla 15 SI Olor = ninguno Y Color_velo = marron ENTONCES Tipo_Hongo = ingerible

Regla 16 SI Olor = ninguno Y Color_velo = naranja ENTONCES Tipo_Hongo = ingerible



Regla 17 SI Olor = pescado ENTONCES Tipo_Hongo = venenoso

Regla 18 SI Olor = punzante ENTONCES Tipo_Hongo = venenoso


Clases Correctos Errores ProbabilidadIngerible 1403 0 1Venenoso 1305 0 1Totales 2708 0 1


Los resultados obtenidos en este dominio son muy interesantes. Vemos que los árboles de decisión y, a

raíz de ello las reglas, no son iguales para el caso de la ganancia y de la proporción de ganancia. Si

analizamos los árboles, vemos que en primer término, el atributo olor es el que más información brinda

tanto utilizando la ganancia como la proporción de ganancia como medidores de información. Pero una

vez en el caso de los ejemplos que tienen olor=ninguno, la ganancia considera que el atributo

color_sombrero es el que brinda más información, mientras que la proporción de ganancia considera que

el atributo color_velo brinda más información que los demás. Analizando el archivo de log generado por

el programa (sección 4.5.2.1.8) para el caso de los ejemplos que tienen olor=ninguno, tenemos:

División Según Ganancia Proporción de gananciaColor_sombrero 0,0370 0,079699Color_velo 0,02376 0,2295

He aquí la diferencia en la elección de atributos de división para ambos medidores de información. Si

analizamos las características de los datos, vemos que el atributo color_sombrero toma diez valores

distintos, mientras que el atributo Color_velo toma cuatro valores distintos. Recordemos que la ganancia

favorece a los atributos con más valores y esa es la razón por la que se comenzó a utilizar la proporción

de ganancia, que promedia o normaliza, el cálculo de la ganancia de información en un conjunto de datos.

Este es un ejemplo claro del porqué de esta tendencia.

A pesar de esta diferencia entre los modelos obtenidos en uno y otro caso, vemos que la proporción de

error en ambos casos es baja. Con lo cual, aunque la ganancia favorezca a los atributos con mayor

cantidad de valores posibles, no podemos afirmar que esto influya en gran medida en el análisis sobre los

datos de prueba. Para el clasificador obtenido mediante la proporción de ganancia no se realizaron errores

al clasificar los casos de prueba.



5.4. RESULTADOS OBTENIDOS CON EL C4.5A continuación, se presentan los resultados obtenidos con el sistema C4.5. Se realizaron pruebas sobre los

mismos dominios que para el sistema ID3 y para otros dominios que presentan atributos continuos. Al

igual que en el caso anterior, se presentan los resultados para el sistema utilizando la ganancia y la

proporción de ganancia para medir la ganancia de información en cada paso del algoritmo.

5.4.1. Créditos

5.4.1.1. Utilizando la ganancia como criterio de decisión

Árbol de decisión

Otros Creditos = TRES CREDITOS: NO (23.0)Otros Creditos = UN CREDITO: Composición Familiar = SOLTERO: SI (10.0) Composición Familiar = CASADO SIN HIJOS: SI (10.0) Composición Familiar = CASADO Y UN HIJO: SI (10.0) Composición Familiar = CASADO Y DOS HIJOS: Ingreso = ENTRE 451 Y 550: SI (0.0) Ingreso = MAS DE 551: SI (5.0) Ingreso = ENTRE 451 Y 550: Vivienda = ALQUILA: NO (2.0) Vivienda = PROPIA 0 IPVU: SI (2.0)Otros Creditos = DOS CREDITOS: Composición Familiar = CASADO SIN HIJOS: SI (9.0) Composición Familiar = CASADO Y UN HIJO: SI (9.0) Composición Familiar = SOLTERO: Vivienda = PROPIA 0 IPVU: SI (6.0) Vivienda = ALQUILA: Ingreso = ENTRE 451 Y 550: SI (2.0) Ingreso = ENTRE 451 Y 550: SI (0.0) Ingreso = MAS DE 551: NO (2.0) Composición Familiar = CASADO Y DOS HIJOS: Ingreso = ENTRE 451 Y 550: NO (4.0/1.0) Ingreso = ENTRE 451 Y 550: SI (0.0) Ingreso = MAS DE 551: SI (5.0)

Árbol de decisión simplificado

Otros Creditos = UN CREDITO: SI (39.0/3.8)Otros Creditos = DOS CREDITOS: SI (37.0/7.2)Otros Creditos = TRES CREDITOS: NO (23.0/1.3)

Evaluación de los resultados del árbol de decisión

Evaluación sobre los datos de entrenamiento:



Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación25 1 (1.0%) 4 7 (7.1%) (12.4%)

Evaluación sobre los datos de prueba:


Clasificación general en los datos de prueba:

Clasificado como SI Clasificado como NOClase SI 17 18Clase NO 4 12

Reglas de decisión

Regla 12 SI Otros Creditos = TRES CREDITOS

ENTONCES clase=NO [94.2%]

Regla 2 SI Ingreso = ENTRE 451 Y 550 Y Composición Familiar = CASADO Y DOS HIJOS Y Vivienda = ALQUILA


Regla 6 SI Ingreso = MAS DE 551 Y Composición Familiar = SOLTERO Y Vivienda = ALQUILA Y Otros Creditos = DOS CREDITOS


Regla 1 SI Otros Creditos = UN CREDITO

Y clase=SI [90.3%]

Regla 11 SI Otros Creditos = DOS CREDITOS

ENTONCES clase=SI [80.6%]

Regla 13 Clase=SI



Evaluación de los resultados de las reglas de decisión


Regla Tamaño Error Usada Errores Ventaja Clase12 1 5.8% 23 0(0.0%) 21(21|0) NO2 3 20.6% 4 0(0.0%) 4(4|0) NO6 4 50.0% 2 0(0.0%) 2(2|0) NO1 1 9.7% 37 0(0.0%) 0(0|0) SI11 1 19.4% 33 1(3.0%) 0(0|0) SIProbadas 99, errores 1 (1.0%)


Regla Tamaño Error Usada Errores Ventaja Clase12 1 5.8% 30 18(60.0%) -8(10|18) NO2 3 20.6% 2 0(0.0%) 2(2|0) NO6 4 50.0% 2 0(0.0%) 2(2|0) NO1 1 9.7% 8 0(0.0%) 0(0|0) SI11 1 19.4% 9 0(0.0%) 0(0|0) SIProbadas 51, errores 18 (35.3%)

Clasificación general de los datos de prueba:


5.4.1.2. Utilizando la proporción de ganancia como criterio de decisión

Árbol de decisión

Otros Creditos = TRES CREDITOS: NO (23.0)Otros Creditos = UN CREDITO: Composición Familiar = SOLTERO: SI (10.0) Composición Familiar = CASADO SIN HIJOS: SI (10.0) Composición Familiar = CASADO Y UN HIJO: SI (10.0) Composición Familiar = CASADO Y DOS HIJOS: Vivienda = PROPIA 0 IPVU: SI (5.0) Vivienda = ALQUILA: Ingreso = ENTRE 451 Y 550: NO (2.0) Ingreso = ENTRE 451 Y 550: SI (0.0) Ingreso = MAS DE 551: SI (2.0)Otros Creditos = DOS CREDITOS: Composición Familiar = CASADO SIN HIJOS: SI (9.0) Composición Familiar = CASADO Y UN HIJO: SI (9.0) Composición Familiar = SOLTERO: Vivienda = PROPIA 0 IPVU: SI (6.0) Vivienda = ALQUILA: Ingreso = ENTRE 451 Y 550: SI (2.0) Ingreso = ENTRE 451 Y 550: SI (0.0) Ingreso = MAS DE 551: NO (2.0)



Composición Familiar = CASADO Y DOS HIJOS: Ingreso = ENTRE 451 Y 550: NO (4.0/1.0) Ingreso = ENTRE 451 Y 550: SI (0.0) Ingreso = MAS DE 551: SI (5.0)


Otros Creditos = UN CREDITO: SI (39.0/3.8)Otros Creditos = DOS CREDITOS: SI (37.0/7.2)Otros Creditos = TRES CREDITOS: NO (23.0/1.3)








Reglas de decisión

Regla 12 SI Otros Creditos = TRES CREDITOS


Regla 2 SI Ingreso = ENTRE 451 Y 550 Y Composición Familiar = CASADO Y DOS HIJOS Y Vivienda = ALQUILA


Regla 6 SI Ingreso = MAS DE 551



Y Composición Familiar = SOLTERO Y Vivienda = ALQUILA Y Otros Creditos = DOS CREDITOS


Regla 1 SI Otros Creditos = UN CREDITO

ENTOCNES clase=SI [90.3%]

Regla 11 SI Otros Creditos = DOS CREDITOS


Regla 13clase=SI



Regla Tamaño Error Usada Errores Ventaja Clase12 1 5.8% 23 0(0.0%) 21(21|0) NO2 3 20.6% 4 0(0.0%) 4(4|0) NO6 4 50.0% 2 0(0.0%) 2(2|0) NO1 1 9.7% 37 0(0.0%) 0(0|0) SI11 1 19.4% 33 1(3.0%) 0(0|0) SI

Probadas 99, errores 1 (1.0%)


Regla Tamaño Error Usada Errores Ventaja Clase12 1 5.8% 30 18(60.0%) -8(10|18) NO2 3 20.6% 2 0(0.0%) 2(2|0) NO6 4 50.0% 2 0(0.0%) 2(2|0) NO1 1 9.7% 8 0(0.0%) 0(0|0) SI11 1 19.4% 9 0(0.0%) 0(0|0) SI





Los árboles de decisión sin simplificar obtenidos utilizando la ganancia y la proporción de ganancia se

diferencian solamente en la rama de “Otros Créditos=UN CRÉDITO y Composición Familiar=CASADO

Y DOS HIJOS”. Al llegar a este punto, se encontró que la mayor ganancia se obtenía dividiendo a los



datos según el atributo Ingreso, mientras que la mayor proporción de ganancia se obtuvo con el atributo

Vivienda. A pesar de estas diferencias encontradas en los árboles sin simplificar, los árboles

simplificados son idénticos y tienen un único nodo, lo cual los hace muy fáciles de comprender.

En cuanto a las reglas obtenidas, son idénticas en ambos casos. Cabe destacar que, como el árbol de

decisión simplificado es tan simple, el modelo de clasificación ofrecido en ese caso se entiende más

rápidamente que el conjunto de reglas de decisión.

Analicemos la columna ventaja de la tabla de resultados para las reglas de decisión. Recordemos que la

ventaja se expresa de la forma a(b|c) donde b es la cantidad de casos que serían clasificados erróneamente

por las reglas siguientes, de omitirse esa regla; c es la cantidad de casos que serían clasificados

correctamente; y a es el beneficio neto de omitir la regla. En el caso de la regla 12, tenemos un beneficio

neto negativo, con lo cual, a pesar de que con los métodos utilizados por el C4.5 se consideró que no era

conveniente eliminarla, de utilizar este modelo para clasificar nuevos casos, debería analizarse la

posibilidad de no tener esta regla en cuenta y trabajar con un modelo más simple.

En cuanto al valor E asociado, en el árbol original representa la cantidad de casos cubiertos por una hoja

que pertenece a una clase diferente de la indicada por la misma. Mientras que en el caso del árbol podado,

E es la cantidad de errores predichos, según la distribución binomial, en dicha hoja si un conjunto de N

nuevos casos fuesen evaluados por el árbol. Recordemos que los valores E tienen especial importancia, ya

que el estimador del éxito del modelo obtenido se calcula realizando la sumatoria de todos los valores E y

dividiéndola por la cantidad de casos de entrenamiento. En este caso, la estimación del éxito del modelo

es de un 12.4%.

5.4.2. Cardiología


Árbol de decisión

Duración del Angor = MENOS DE 30 MIN: NO (33.0/1.0)Duración del Angor = MAS DE 30 MIN: Dolor de Pecho de Angor = TIPICO: SI (11.0/1.0) Dolor de Pecho de Angor = AUSENTE: NO (11.0) Dolor de Pecho de Angor = ATIPICO: Irradiación del Angor = SI: SI (5.0) Irradiación del Angor = NO: Respuesta Vasodilatadora = POSITIVO: SI (2.0) Respuesta Vasodilatadora = NEGATIVO: NO (2.0)










Reglas de decisión

Regla 2 SI Dolor de Pecho de Angor = TIPICO Y Duración del Angor = MAS DE 30 MIN


Regla 3 SI Dolor de Pecho de Angor = ATIPICO Y Irradiación del Angor = SI Y Duración del Angor = MAS DE 30 MIN


Regla 4 SI Dolor de Pecho de Angor = ATIPICO Y Duración del Angor = MAS DE 30 MIN Y Respuesta Vasodilatadora = POSITIVO


Regla 6 SI Dolor de Pecho de Angor = AUSENTE


Regla 1 SI Duración del Angor = MENOS DE 30 MIN


Regla 5 SI Dolor de Pecho de Angor = ATIPICO Y Irradiación del Angor = NO Y Respuesta Vasodilatadora = NEGATIVO


Regla 7Clase=NO





Regla Tamaño Error Usada Errores Ventaja Clase2 2 22.3% 11 1(9.1%) 9(10|1) SI3 3 24.2% 5 0(0.0%) 2(2|0) SI4 3 24.2% 2 0(0.0%) 2(2|0) SI6 1 6.1% 22 0(0.0%) 0(0|0) NO1 1 7.8% 22 1(4.5%) 0(0|0) NO5 3 24.2% 2 0(0.0%) 0(0|0) NO







5.4.2.2. Utilizando la proporción ganancia como criterio de decisión

Árbol de decisión

Duración del Angor = MENOS DE 30 MIN: NO (33.0/1.0)Duración del Angor = MAS DE 30 MIN: Dolor de Pecho de Angor = TIPICO: SI (11.0/1.0) Dolor de Pecho de Angor = AUSENTE: NO (11.0) Dolor de Pecho de Angor = ATIPICO: Respuesta Vasodilatadora = POSITIVO: SI (5.0) Respuesta Vasodilatadora = NEGATIVO: Irradiación del Angor = SI: SI (2.0) Irradiación del Angor = NO: NO (2.0)










Reglas de decisión

Regla 2 SI Dolor de Pecho de Angor = TIPICO Y Duración del Angor = MAS DE 30 MIN


Regla 3 SI Dolor de Pecho de Angor = ATIPICO Y Duración del Angor = MAS DE 30 MIN Y Respuesta Vasodilatadora = POSITIVO


Regla 4 SI Dolor de Pecho de Angor = ATIPICO Y Irradiación del Angor = SI Y Duración del Angor = MAS DE 30 MIN


Regla 6 SI Dolor de Pecho de Angor = AUSENTE


Regla 1 SI Duración del Angor = MENOS DE 30 MIN


Regla 5 SI Dolor de Pecho de Angor = ATIPICO Y Irradiación del Angor = NO Y Respuesta Vasodilatadora = NEGATIVO


Regla 7Clase= NO













En este caso, tanto los árboles de decisión como las reglas que derivan de ellos, difieren entre la ganancia

y la proporción de ganancia. Esta diferencia surge del hecho de que frente a una misma situación

(Duración del Angor=MAS DE 30 MIN Y Dolor de Pecho de Angor=Atipico), la ganancia y la

proporción de ganancia son distintas. Se obtuvo mejor proporción de ganancia con el atributo Respuesta

Vasodilatadora, y mejor ganancia con el atributo Irradiación de Pecho de Angor. No obstante, al igual que

en el caso del dominio de Estudio sobre Hongos utilizando el ID3, esta diferencia no influye en las

proporciones de error de los modelos.

Podemos encontrar la misma diferencia en las reglas de decisión. Y, al igual que en el caso anterior, no

influye en gran medida en la performance de los clasificadores sobre los datos de prueba



Notemos que en este caso los árboles de decisión no han sido podados. Dada su simplicidad, esto no fue

necesario.

5.4.3. Votaciones


Árbol de decisión

cong_honorarios_medicos = en_contra: democrata (168.0/1.0)cong_honorarios_medicos = a_favor: reduccion_corp_Synfuels = en_contra: republicano (97.0/3.0) reduccion_corp_Synfuels = desconocido: republicano (4.0) reduccion_corp_Synfuels = a_favor: export_sin_impuestos = a_favor: democrata (2.0) export_sin_impuestos = desconocido: republicano (1.0) export_sin_impuestos = en_contra: presupuesto_de_educación = a_favor: republicano (13.0/2.0) presupuesto_de_educación = en_contra: democrata (5.0/2.0) presupuesto_de_educación = desconocido: democrata (1.0)cong_honorarios_medicos = desconocido: misil_mx = a_favor: democrata (4.0/1.0) misil_mx = en_contra: democrata (3.0) misil_mx = desconocido: republicano (2.0)


cong_honorarios_medicos = a_favor: republicano (123.0/13.9)cong_honorarios_medicos = en_contra: democrata (168.0/2.6)cong_honorarios_medicos = desconocido: misil_mx = a_favor: democrata (4.0/2.2) misil_mx = en_contra: democrata (3.0/1.1) misil_mx = desconocido: republicano (2.0/1.0)





Antes de podar Después de podar



Tamaño Errores Tamaño Errores Estimación16 7 (5.2%) 7 4 (3.0%) (6.9%)


Clasificado como demócrata Clasificado como republicanoClase demócrata 80 3Clase republicano 1 51

Reglas de decisión

Regla 7 SI cong_honorarios_medicos = en_contra

ENTONCES clase=democrata [98.4%]

Regla 3 SI reduccion_corp_Synfuels = a_favor Y presupuesto_de_educación = en_contra


Regla 9 SI cong_honorarios_medicos = desconocido Y misil_mx = en_contra


Regla 5 SI cong_honorarios_medicos = a_favor

ENTONCES clase=republicano [88.7%]

Regla 10 SI cong_honorarios_medicos = desconocido Y misil_mx = desconocido


Regla 11clase=democrata



Regla Tamaño Error Usada Errores Ventaja Clase7 1 1.6% 168 1(0.6%) 0(0|0) Demócrata3 2 5.7% 8 2(25.0%) 2(4|2) Demócrata9 2 37.0% 2 0(0.0%) 0(0|0) Demócrata5 1 11.3% 117 7(6.0%) 103(110|7) Republicano10 2 50.0% 2 0(0.0%) 2(2|0) Republicano





Regla Tamaño Error Usada Errores Ventaja Clase7 1 1.6% 79 1(1.3%) 0(0|0) Demócrata3 2 5.7% 3 1(33.3%) -1(0|1) Demócrata5 1 11.3% 53 3(5.7%) 47(50|3) Republicano





Árbol de decisión

cong_honorarios_medicos = a_favor: reduccion_corp_Synfuels = en_contra: republicano (97.0/3.0) reduccion_corp_Synfuels = desconocido: republicano (4.0) reduccion_corp_Synfuels = a_favor: export_sin_impuestos = a_favor: democrata (2.0) export_sin_impuestos = desconocido: republicano (1.0) export_sin_impuestos = en_contra: presupuesto_de_educación = a_favor: republicano (13.0/2.0) presupuesto_de_educación = en_contra: democrata (5.0/2.0) presupuesto_de_educación = desconocido: democrata (1.0)cong_honorarios_medicos = en_contra: adop_resolucion_presup = a_favor: democrata (151.0) adop_resolucion_presup = desconocido: democrata (1.0) adop_resolucion_presup = en_contra: presupuesto_de_educación = a_favor: democrata (9.0) presupuesto_de_educación = en_contra: democrata (6.0) presupuesto_de_educación = desconocido: republicano (1.0)cong_honorarios_medicos = desconocido: particip_proy_agua = a_favor: democrata (4.0) particip_proy_agua = en_contra: democrata (0.0) particip_proy_agua = desconocido: misil_mx = a_favor: democrata (3.0/1.0) misil_mx = en_contra: republicano (0.0) misil_mx = desconocido: republicano (2.0)


cong_honorarios_medicos = a_favor: republicano (123.0/13.9)cong_honorarios_medicos = en_contra: democrata (168.0/2.6)cong_honorarios_medicos = desconocido: misil_mx = a_favor: democrata (4.0/2.2) misil_mx = en_contra: democrata (3.0/1.1) misil_mx = desconocido: republicano (2.0/1.0)










Reglas de decisión

Regla 1 SI reduccion_corp_Synfuels = a_favor Y export_sin_impuestos = a_favor


Regla 11 SI particip_proy_agua = a_favor Y cong_honorarios_medicos = desconocido


Regla 6 SI cong_honorarios_medicos = a_favor Y reduccion_corp_Synfuels = en_contra


Regla 2 SI cong_honorarios_medicos = a_favor Y presupuesto_de_educación = a_favor Y export_sin_impuestos = en_contra


Regla 10 SI adop_resolucion_presup = en_contra Y presupuesto_de_educación = desconocido


Regla 13 SI cong_honorarios_medicos = desconocido Y misil_mx = desconocido


Regla 14clase=democrata





Regla Tamaño Error Usada Errores Ventaja Clase1 2 2.5% 54 0(0.0%) 0(0|0) Demócrata11 2 29.3% 3 0(0.0%) 0(0|0) Demócrata6 2 5.2% 97 3(3.1%) 21(23|2) Republicano2 3 6.0% 15 2(13.3%) 11(13|2) Republicano10 2 18.0% 3 0(0.0%) 3(3|0) Republicano13 2 50.0% 2 0(0.0%) 2(2|0) Republicano



Regla Tamaño Error Usada Errores Ventaja Clase1 2 2.5% 24 2(8.3%) 0(0|0) Demócrata11 2 29.3% 1 0(0.0%) 0(0|0) Demócrata6 2 5.2% 41 0(0.0%) 6(6|0) Republicano2 3 6.0% 8 3(37.5%) 2(5|3) Republicano10 2 18.0% 2 0(0.0%) 2(2|0) Republicano





Los resultados obtenidos en este dominio con el C4.5 parecen satisfactorios a simple vista, ya que la

proporción de error no supera el 6% en ninguno de los casos. En cuanto a los árboles de decisión

simplificados son iguales para la ganancia y para la proporción de ganancia. No obstante, en los árboles

sin simplificar hay una diferencia de tamaño: el árbol obtenido con la ganancia es de tamaño menor que el

obtenido con la proporción de ganancia. Esto se debe a que en la rama

cong_honorarios_medicos=desconocido en la ganancia se optó por dividir al conjunto según el atributo

misil_mx, y en la proporción de ganancia se los dividió según particip_proy_agua y luego en uno de los

casos por misil_mx. Esta diferencia de tamaño no influye en la performance de los árboles. Es decir, nos

encontramos ante dos árboles de igual porcentaje de error, pero de distinto tamaño. Con lo cual, de tener

que optar entre ambos, eligiríamos el obtenido con la ganancia.



En cuanto a las reglas de decisión, las primeras, derivadas utilizando la ganancia, tienen una proporción

de error similar a la de los árboles y son menos que las obtenidas con la proporción de ganancia. Estas

segundas, tienen una mayor proporción de error. Nuevamente, en este caso, eligiríamos las obtenidas

utilizando la ganancia.



Árbol de decisión

Olor = almendra: ingerible (168.0)Olor = anis: ingerible (178.0)Olor = creosota: venenoso (37.0)Olor = pescado: venenoso (489.0)Olor = hediondo: venenoso (1348.0)Olor = mohoso: venenoso (36.0)Olor = punzante: venenoso (164.0)Olor = especioso: venenoso (516.0)Olor = ninguno: Color_sombrero = canela: ingerible (28.0) Color_sombrero = gris: ingerible (716.0) Color_sombrero = verde: ingerible (14.0) Color_sombrero = violeta: ingerible (9.0) Color_sombrero = rojo: ingerible (483.0) Color_sombrero = amarillo: venenoso (10.0) Color_sombrero = marron: Sup_tronco_arriba_anillo = fibrosa: ingerible (87.0) Sup_tronco_arriba_anillo = escamosa: ingerible (13.0) Sup_tronco_arriba_anillo = sedosa: venenoso (3.0) Sup_tronco_arriba_anillo = suave: ingerible (744.0) Color_sombrero = piel: Tipo_anillo = tejido: ingerible (0.0) Tipo_anillo = evanescente: ingerible (41.0) Tipo_anillo = resplandescient: ingerible (0.0) Tipo_anillo = grande: ingerible (0.0) Tipo_anillo = ninguno: ingerible (0.0) Tipo_anillo = pendiente: venenoso (2.0) Tipo_anillo = cubierto: ingerible (0.0) Tipo_anillo = zonal: ingerible (0.0) Color_sombrero = rosa: Color_esporas = negro: ingerible (0.0) Color_esporas = marron: ingerible (0.0) Color_esporas = piel: ingerible (0.0) Color_esporas = chocolate: ingerible (0.0) Color_esporas = verde: venenoso (2.0) Color_esporas = naranja: ingerible (0.0) Color_esporas = violeta: ingerible (0.0) Color_esporas = blanca: ingerible (49.0) Color_esporas = amarillo: ingerible (0.0) Color_sombrero = blanco: Habitat = pastos: ingerible (259.0) Habitat = hojas: venenoso (1.0) Habitat = praderas: venenoso (3.0) Habitat = caminos: ingerible (0.0) Habitat = urbano: ingerible (0.0) Habitat = basura: ingerible (0.0) Habitat = bosque: ingerible (16.0)



Árbol de decisión simplificado:

Olor = almendra: ingerible (168.0/1.4)Olor = anis: ingerible (178.0/1.4)Olor = creosota: venenoso (37.0/1.4)Olor = pescado: venenoso (489.0/1.4)Olor = hediondo: venenoso (1348.0/1.4)Olor = mohoso: venenoso (36.0/1.4)Olor = punzante: venenoso (164.0/1.4)Olor = especioso: venenoso (516.0/1.4)Olor = ninguno: Color_sombrero = marron: ingerible (847.0/5.1) Color_sombrero = canela: ingerible (28.0/1.4) Color_sombrero = gris: ingerible (716.0/1.4) Color_sombrero = verde: ingerible (14.0/1.3) Color_sombrero = violeta: ingerible (9.0/1.3) Color_sombrero = rojo: ingerible (483.0/1.4) Color_sombrero = amarillo: venenoso (10.0/1.3) Color_sombrero = piel: Tipo_anillo = tejido: ingerible (0.0) Tipo_anillo = evanescente: ingerible (41.0/1.4) Tipo_anillo = resplandescient: ingerible (0.0) Tipo_anillo = grande: ingerible (0.0) Tipo_anillo = ninguno: ingerible (0.0) Tipo_anillo = pendiente: venenoso (2.0/1.0) Tipo_anillo = cubierto: ingerible (0.0) Tipo_anillo = zonal: ingerible (0.0) Color_sombrero = rosa: Color_esporas = negro: ingerible (0.0) Color_esporas = marron: ingerible (0.0) Color_esporas = piel: ingerible (0.0) Color_esporas = chocolate: ingerible (0.0) Color_esporas = verde: venenoso (2.0/1.0) Color_esporas = naranja: ingerible (0.0) Color_esporas = violeta: ingerible (0.0) Color_esporas = blanca: ingerible (49.0/1.4) Color_esporas = amarillo: ingerible (0.0) Color_sombrero = blanco: Habitat = pastos: ingerible (259.0/1.4) Habitat = hojas: venenoso (1.0/0.8) Habitat = praderas: venenoso (3.0/1.1) Habitat = caminos: ingerible (0.0) Habitat = urbano: ingerible (0.0) Habitat = basura: ingerible (0.0) Habitat = bosque: ingerible (16.0/1.3)



Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación48 0(0.0%) 44 3 (0.1%) (0.6%)





Evaluación general sobre los datos de prueba:

Clasificado como ingerible Clasificado como venenosoClase ingerible 1403 0Clase venenoso 25 1280

Reglas de decisión

Regla 5 SI Olor = hediondo

ENTONCES Tipo_hongo = venenoso [99.9%]

Regla 23 SI Olor = especioso


Regla 4 SI Olor = pescado


Regla 9 SI Color_sombrero = marron Y Sup_tronco_arriba_anillo = sedosa


Regla 22 SI Olor = punzante


Regla 3 SI Olor = creosota


Regla 6 SI Olor = mohoso


Regla 21 SI Color_sombrero = amarillo Y Olor = ninguno


Regla 14 SI Color_esporas = verde


Regla 2 SI Olor = anis

ENTONCES Tipo_hongo = ingerible [99.2%]

Regla 1 SI Olor = almendra


Regla 11 SI Olor = ninguno


Regla 24Tipo_hongo = ingerible





Regla Tamaño Error Usada Errores Ventaja Clase5 1 0.10% 1348 0(0.00%) 1228(1228|0) venenoso23 1 0.30% 516 0(0.00%) 400(400|0) venenoso4 1 0.30% 489 0(0.00%) 372(372|0) venenoso9 2 0.40% 15 0(0.00%) 3(3|0) venenoso22 1 0.80% 164 0(0.00%) 164(164|0) venenoso3 1 3.70% 37 0(0.00%) 37(37|0) venenoso6 1 3.80% 24 0(0.00%) 24(24|0) venenoso21 2 12.90% 10 0(0.00%) 10(10|0) venenoso14 1 18.00% 7 0(0.00%) 7(7|0) venenoso2 1 0.80% 178 0(0.00%) 0(0|0) ingerible1 1 0.80% 168 0(0.00%) 0(0|0) ingerible11 1 1.00% 2460 1(0.00%) 0(0|0) ingerible



Regla Tamaño Error Usada Errores Ventaja Clase5 1 0.10% 812 0(0.00%) 788(788|0) venenoso23 1 0.30% 60 0(0.00%) 32(32|0) venenoso4 1 0.30% 87 0(0.00%) 60(60|0) venenoso9 2 0.40% 13 0(0.00%) 13(13|0) venenoso22 1 0.80% 92 0(0.00%) 92(92|0) venenoso3 1 3.70% 155 0(0.00%) 155(155|0) venenoso21 2 12.90% 14 0(0.00%) 14(14|0) venenoso14 1 18.00% 65 0(0.00%) 65(65|0) venenoso2 1 0.80% 222 0(0.00%) 0(0|0) ingerible1 1 0.80% 232 0(0.00%) 0(0|0) ingerible11 1 1.00% 956 7(0.70%) 0(0|0) ingerible





Árbol de decisión

Olor = almendra: ingerible (168.0)



Olor = anis: ingerible (178.0)Olor = creosota: venenoso (37.0)Olor = pescado: venenoso (489.0)Olor = hediondo: venenoso (1348.0)Olor = mohoso: venenoso (36.0)Olor = punzante: venenoso (164.0)Olor = especioso: venenoso (516.0)Olor = ninguno: Tamaño_membrana = ancha: Color_esporas = negro: ingerible (847.0) Color_esporas = marron: ingerible (921.0) Color_esporas = piel: ingerible (45.0) Color_esporas = chocolate: ingerible (0.0) Color_esporas = verde: venenoso (7.0) Color_esporas = naranja: ingerible (40.0) Color_esporas = violeta: ingerible (0.0) Color_esporas = blanca: ingerible (439.0) Color_esporas = amarillo: ingerible (43.0) Tamaño_membrana = fina: ColorTronco_arriba_anillo = marron: ingerible (0.0) ColorTronco_arriba_anillo = piel: ingerible (0.0) ColorTronco_arriba_anillo = canela: ingerible (0.0) ColorTronco_arriba_anillo = gris: ingerible (0.0) ColorTronco_arriba_anillo = naranja: ingerible (0.0) ColorTronco_arriba_anillo = rosa: ingerible (0.0) ColorTronco_arriba_anillo = rojo: ingerible (0.0) ColorTronco_arriba_anillo = amarillo: venenoso (8.0) ColorTronco_arriba_anillo = blanco: Sup_tronco_arriba_anillo = fibrosa: ingerible (21.0) Sup_tronco_arriba_anillo = escamosa: ingerible (0.0) Sup_tronco_arriba_anillo = sedosa: venenoso (5.0) Sup_tronco_arriba_anillo = suave: Poblacion = abundante: ingerible (0.0) Poblacion = agrupada: venenoso (1.0) Poblacion = numerosa: ingerible (0.0) Poblacion = dispersa: ingerible (0.0) Poblacion = varios: ingerible (63.0) Poblacion = solitaria: ingerible (40.0)


Olor = almendra: ingerible (168.0/1.4)Olor = anis: ingerible (178.0/1.4)Olor = creosota: venenoso (37.0/1.4)Olor = pescado: venenoso (489.0/1.4)Olor = hediondo: venenoso (1348.0/1.4)Olor = mohoso: venenoso (36.0/1.4)Olor = punzante: venenoso (164.0/1.4)Olor = especioso: venenoso (516.0/1.4)Olor = ninguno: Tamaño_membrana = ancha: Color_esporas = negro: ingerible (847.0/1.4) Color_esporas = marron: ingerible (921.0/1.4) Color_esporas = piel: ingerible (45.0/1.4) Color_esporas = chocolate: ingerible (0.0) Color_esporas = verde: venenoso (7.0/1.3) Color_esporas = naranja: ingerible (40.0/1.4) Color_esporas = violeta: ingerible (0.0) Color_esporas = blanca: ingerible (439.0/1.4) Color_esporas = amarillo: ingerible (43.0/1.4) Tamaño_membrana = fina: Sup_tronco_arriba_anillo = fibrosa: ingerible (21.0/1.3) Sup_tronco_arriba_anillo = escamosa: venenoso (8.0/1.3) Sup_tronco_arriba_anillo = sedosa: venenoso (5.0/1.2) Sup_tronco_arriba_anillo = suave: ingerible (104.0/2.6)





Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación40 0(0.0%) 25 1 (0.0%) (0.5%)



Evaluación general sobre los datos de prueba:


Reglas de decisión

Regla 5 SI Olor = hediondo

ENTONCES Tipo_Hongo = venenoso [99.9%]

Regla 13 SI Tamaño_membrana = fina Y Sup_tronco_arriba_anillo = sedosa


Regla 19 SI Olor = especioso


Regla 4 SI Olor = pescado


Regla 18 SI Olor = punzante


Regla 3 SI Olor = creosota


Regla 6 SI Olor = mohoso


Regla 17 SI ColorTronco_arriba_anillo = amarillo




Regla 10 SI Color_esporas = verde


Regla 9 SI Olor = ninguno Y Tamaño_membrana = ancha

ENTONCES Tipo_Hongo = ingerible [99.6%]

Regla 15 SI Olor = ninguno Y Sup_tronco_arriba_anillo = suave


Regla 12 SI Olor = ninguno Y Sup_tronco_arriba_anillo = fibrosa


Regla 2 SI Olor = anis


Regla 1 SI Olor = almendra


Regla 20Tipo_Hongo = ingerible



Regla Tamaño Error Usada Errores Ventaja Clase5 1 0.10% 1348 0(0.00%) 1088(1088|0) venenoso13 2 0.20% 497 0(0.00%) 5(5|0) venenoso19 1 0.30% 261 0(0.00%) 261(261|0) venenoso4 1 0.30% 252 0(0.00%) 252(252|0) venenoso18 1 0.80% 164 0(0.00%) 164(164|0) venenoso3 1 3.70% 37 0(0.00%) 37(37|0) venenoso6 1 3.80% 36 0(0.00%) 36(36|0) venenoso17 1 15.90% 8 0(0.00%) 8(8|0) venenoso10 1 18.00% 7 0(0.00%) 7(7|0) venenoso9 2 0.40% 2335 0(0.00%) 0(0|0) ingerible15 2 0.50% 104 1(1.00%) 0(0|0) ingerible12 2 0.60% 21 0(0.00%) 0(0|0) ingerible2 1 0.80% 178 0(0.00%) 0(0|0) ingerible1 1 0.80% 168 0(0.00%) 0(0|0) ingerible



Regla Tamaño Error Usada Errores Ventaja Clase5 1 0.10% 812 0(0.00%) 784(784|0) venenoso13 2 0.20% 111 0(0.00%) 27(27|0) venenoso



19 1 0.30% 27 0(0.00%) 27(27|0) venenoso4 1 0.30% 36 0(0.00%) 36(36|0) venenoso18 1 0.80% 92 0(0.00%) 92(92|0) venenoso3 1 3.70% 155 0(0.00%) 155(155|0) venenoso10 1 18.00% 65 0(0.00%) 65(65|0) venenoso9 2 0.40% 881 0(0.00%) 0(0|0) ingerible15 2 0.50% 72 7(9.70%) 0(0|0) ingerible12 2 0.60% 3 0(0.00%) 0(0|0) ingerible2 1 0.80% 222 0(0.00%) 0(0|0) ingerible1 1 0.80% 232 0(0.00%) 0(0|0) ingerible





El árbol de decisión obtenido utilizando la ganancia como criterio de decisión es de mayor tamaño que el

obtenido utilizando la proporción de ganancia. Esta diferencia se origina por la preferencia de la ganancia

por atributos con más cantidad de valores. Veamos que en la rama Olor=ninguno, el método que utilizó la

ganancia dividió los datos según el atributo color_sombrero que toma diez valores distintos, mientras que

el método que utilizó la proporción de ganancia, dividió los datos según el atributo Tamaño_membrana

que tiene dos valores posibles. En este caso, el hecho de que un árbol sea de mayor tamaño no favorece la

performance del mismo: el segundo árbol, más pequeño, tuvo una mejor performance en los casos de

prueba, ya que clasificó solo 7 de ellos erróneamente, mientras que el árbol generado con la ganancia

clasificó 25 erróneamente. A pesar de esta diferencia, la estimación del error sobre futuros casos es muy

buena para los dos árboles: del 0.6% para el generado utilizando la ganancia y del 0.5% para el generado

utilizando la proporción de ganancia.

Cabe destacar que en el árbol de decisión generado utilizando la proporción de ganancia, el subárbol

olor=ninguno y tamaño_membrana=fina se simplificó por una rama hija, que no contiene al atributo por

el cual se realizó la primera división. Es decir, en el árbol sin simplificar la división en el nodo en

cuestión se realizó según el atributo ColorTronco_arriba_anillo; este atributo no aparece en el árbol

simplificado.

En cuanto a las reglas de decisión, a pesar de que las primeras fueron obtenidas a partir de un árbol de

mayor tamaño, son menos que la cantidad de reglas obtenidas a partir del segundo árbol. Sin embargo, la

performance sobre los datos de prueba fue igual en ambos casos.



5.4.5. Elita


Árbol de decisión

distancia_jupiter <= 0.2 : resonancia > 5.42 : EOS (45.0/1.0) resonancia <= 5.42 : distancia_jupiter <= 0.18 : THEMIS (45.0) distancia_jupiter > 0.18 : KORONIS (24.0)distancia_jupiter > 0.2 : resonancia <= 11.51 : FLORA (103.0/1.0) resonancia > 11.51 : distancia_jupiter <= 0.24 : MARIA (13.0) distancia_jupiter > 0.24 : PHOCAEA (23.0)



Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación11 2(0.8%) 11 2(0.8%) (4.2%)


Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación11 0 (0%) 11 0(0%) (4.2%)

Evaluación general:

Clasificadocomo EOS

ClasificadocomoFLORA

ClasificadocomoKORONIS

ClasificadocomoMARIA

ClasificadocomoPHOCAEA

ClasificadocomoTHEMIS

Clase EOS 22 0 0 0 0 0Clase FLORA 0 12 0 0 0 0Clase KORONIS 0 0 7 0 0 0Clase MARIA 0 0 0 22 0 0Clase PHOCAEA 0 0 0 0 11 0Clase THEMIS 0 0 0 0 0 53



Reglas de decisión

Regla 1 SI resonancia <= 5.42 Y distancia_jupiter <= 0.18

ENTONCES Familia = THEMIS [97.0%]

Regla 2 SI distancia_jupiter > 0.18 Y distancia_jupiter <= 0.2

ENTONCES Familia = KORONIS [94.4%]

Regla 5 SI resonancia > 11.51 Y distancia_jupiter <= 0.24

ENTONCES Familia = MARIA [89.9%]

Regla 6 SI resonancia > 11.51 Y distancia_jupiter > 0.24

ENTONCES Familia = PHOCAEA [94.2%]


ENTONCES Familia = EOS [94.3%]

Regla 4 SI resonancia <= 11.51 Y distancia_jupiter > 0.2

ENTONCES Familia = FLORA [97.5%]

Regla 7Familia = FLORA



Regla Tamaño Error Usada Errores Ventaja Clase1 2 3.00% 45 0(0.00%) 45(45|0) THEMIS2 2 5.60% 24 0(0.00%) 24(24|0) KORONIS5 2 10.10% 13 0(0.00%) 13(13|0) MARIA6 2 5.80% 23 0(0.00%) 23(23|0) PHOCAEA3 2 5.70% 45 1(2.20%) 43(44|1) EOS4 2 2.50% 103 1(1.00%) 0(0|0) FLORA







Clasificación general sobre los datos de prueba:

Clasificadocomo EOS





Clasificado comoTHEMIS



Árbol de decisión

distancia_jupiter <= 0.2 : resonancia > 5.42 : EOS (45.0/1.0) resonancia <= 5.42 :

distancia_jupiter <= 0.18 : THEMIS (45.0)distancia_jupiter > 0.18 : KORONIS (24.0)

distancia_jupiter > 0.2 : resonancia <= 11.51 : FLORA (103.0/1.0) resonancia > 11.51 : distancia_jupiter <= 0.24 : MARIA (13.0) distancia_jupiter > 0.24 : PHOCAEA (23.0)



Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación11 2(0.8%) 11 2(0.8%) (4.2%)


Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación11 0 (0%) 11 0(0%) (4.2%)




Clasificado comoEOS

Clasificadocomo FLORA






Reglas de decisión

Regla 1 SI resonancia <= 5.42 Y distancia_jupiter <= 0.18

ENTONCES Familia = THEMIS [97.0%]

Regla 2 SI distancia_jupiter > 0.18 Y distancia_jupiter <= 0.2

ENTONCES Familia = KORONIS [94.4%]


ENTONCES Familia = MARIA [89.9%]

Regla 6 SI resonancia > 11.51 Y distancia_jupiter > 0.24

ENTONCES Familia = PHOCAEA [94.2%]


ENTONCES Familia = EOS [94.3%]

Regla 4 SI resonancia <= 11.51 Y distancia_jupiter > 0.2

ENTONCES Familia = FLORA [97.5%]

Regla 7Familia = FLORA


Evaluación sobre los datos de entrenamiento

Regla Tamaño Error Usada Errores Ventaja Clase1 2 3.00% 45 0(0.00%) 45(45|0) THEMIS2 2 5.60% 24 0(0.00%) 24(24|0) KORONIS5 2 10.10% 13 0(0.00%) 13(13|0) MARIA6 2 5.80% 23 0(0.00%) 23(23|0) PHOCAEA



3 2 5.70% 45 1(2.20%) 43(44|1) EOS4 2 2.50% 103 1(1.00%) 0(0|0) FLORA






Clasificadocomo EOS








En este caso, tanto los árboles como las reglas obtenidas son iguales si se utiliza la ganancia o la

proporción de ganancia como criterio de decisión. Los árboles son pequeños y poco frondosos, lo cual

facilita su comprensión. Además, no clasifican ningún ejemplo erróneamente en los datos de prueba.

Las reglas de decisión generadas, también son pocas, lo cual hace que su lectura sea más comprensible. Y

clasifican sólo un caso erróneamente sobre los datos de entrenamiento. Por lo tanto, podemos decir que

tanto los árboles como las reglas obtenidas en este dominio constituyen un buen clasificador.

Analicemos la diferencia entre trabajar con atributos discretos y con atributos continuos. Cuando

trabajamos con atributos discretos y elegimos un atributo para dividir el conjunto en la raíz, este atributo

no participa en las divisiones posteriores. Es decir, como hay una rama descendiente de ese nodo para

cada uno de los valores del atributo, todos los subconjuntos posteriores tienen un único valor para ese

atriburo, con lo cual, nunca ofrecerá una mayor ganancia o proporción de ganancia que los demás

atributos. Por lo tanto, no existirá otro nodo, descendiente del anterior, que utilice a dicho atributo como

prueba de valor. En cambio, cuando un atributo continuo se utiliza como prueba de valor en un nodo, el



C4.5 divide a los datos de acuerdo al resultado de la mejor binarización, con lo cual, la prueba de valor

realizada en el nodo es una pregunta acerca de si el valor del atributo supera o no un determinado umbral.

Puede utilizarse, no obstante, el mismo atributo para dividir los datos en un nodo hijo, variará el valor

umbral por el que se realiza la binarización. Lo mismo ocurre con los antecedentes en las reglas de

decisión. Observemos que este fenómeno se presenta tanto en los árboles como en las reglas de decisión

obtenidos en este caso, ya que la prueba de valor distancia_jupiter se repite en nodos padres e hijos, y está

presente en más de un antecedente en las reglas de decisión.

5.4.6. Hipotiroidismo


Árbol de decisión

TSH <= 6 : negativo (2246.8/1.0)TSH > 6 : FTI <= 64 : Medición T4U = f: Medición TSH = f: negativo (4.1) Medición TSH = v: hipotiroide compensado (4.5/2.1) Medición T4U = v: Cirugía tiroídea = v: negativo (3.0/1.0) Cirugía tiroídea = f: Sexo = F: hipotiroide primario (41.4) Sexo = M: Fuente de referencia = WEST: hipotiroide primario (0.0) Fuente de referencia = STMW: hipotiroide primario (0.0) Fuente de referencia = SVHC: hipotiroide primario (0.0) Fuente de referencia = SVI: hipotiroide primario (7.3) Fuente de referencia = SVHD: hipotiroide primario (0.0) Fuente de referencia = otros: TT4 <= 46 : hipotiroide primario (8.3) TT4 > 46 : negativo (2.2/1.0) FTI > 64 : Toma tiroxina = v: negativo (35.2) Toma tiroxina = f: Medición TSH = f: negativo (21.2) Medición TSH = v: TT4 > 150 : negativo (6.1/0.1) TT4 <= 150 : Cirugía tiroídea = v: negativo (3.7) Cirugía tiroídea = f: Medición T4U = v: hipotiroide compensado (120.0) Medición T4U = f:[S1]

Subárbol [S1]

Fuente de referencia = WEST: hipotiroide compensado (0.0)Fuente de referencia = STMW: hipotiroide primario (1.4)Fuente de referencia = SVHC: hipotiroide compensado (0.0)Fuente de referencia = SVI: hipotiroide primario (3.6/1.5)Fuente de referencia = SVHD: hipotiroide compensado (0.0)Fuente de referencia = otros: hipotiroide compensado (5.1)



Árbol simplificado:

TSH <= 6 : negativo (2246.8/2.6)TSH > 6 : FTI <= 64 : Medición T4U = f: Medición TSH = f: negativo (4.1/1.2) Medición TSH = v: hipotiroide compensado (4.5/3.3) Medición T4U = v: Cirugía tiroídea = f: hipotiroide primario (59.2/2.9) Cirugía tiroídea = v: negativo (3.0/2.1) FTI > 64 : Toma tiroxina = v: negativo (35.2/1.4) Toma tiroxina = f: Medición TSH = f: negativo (21.2/1.3) Medición TSH = v: TT4 > 150 : negativo (6.1/1.4) TT4 <= 150 : Cirugía tiroídea = f: hipotiroide compensado (130.2/5.7) Cirugía tiroídea = v: negativo (3.7/1.2)



Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación37 5 (0.2%) 19 8(0.3%) (0.9%)




Clasificado comohipertiroide

Clasificado comohipotiroideprimario

Clasificado comohipotiroidecompensado

Clasificadocomohipotiroidesecundario

Clasificadocomonegativo

Clase hipertiroide 0 0 0 0 0Clase hipotiroideprimario

0 28 2 0 1

Clase hipotiroidecompensado

0 0 65 0 0

Clase hipotiroidesecundario

0 0 0 0 1

Clase negativo 0 1 2 0 1158



Reglas de decisión

Regla 12 SI Toma tiroxina = f Y Cirugía tiroídea = f Y TSH > 6 Y TT4 <= 150 Y FTI > 64

ENTONCES clase = hipotiroide compensado [98.9%]

Regla 1 SI TSH <= 6

ENTONCES clase = negativo [99.9%]

Regla 15 SI Toma tiroxina = v Y FTI > 64


Regla 9 SI Medición TSH = f


Regla 14 SI TT4 > 150


Regla 8 SI Cirugía tiroídea = v


Regla 4 SI Cirugía tiroídea = f Y TSH > 6 Y FTI <= 64

ENTONCES clase = hipotiroide primario [95.6%]

Regla 11 SI Medición T4U = f Y Fuente de referencia = SVI Y TSH > 6


Regla 16Clase = hipotiroide compensado



Regla Tamaño Error Usada Errores Ventaja Clase12 5 1.10% 120 0(0.00%) 0(0|0) hipotiroide compensado1 1 0.10% 2018 1(0.00%) 1620(1620|0) negativo15 2 0.50% 41 0(0.00%) 28(28|0) negativo9 1 0.50% 247 0(0.00%) 232(232|0) negativo14 1 0.60% 6 0(0.00%) 6(6|0) negativo8 1 7.30% 7 1(14.30%) 6(6|0) negativo4 3 4.40% 59 1(1.70%) 58(58|0) hipotiroide primario11 3 64.80% 5 2(40.00%) 1(3|2) hipotiroide primario





Regla Tamaño Error Usada Errores Ventaja Clase12 5 1.10% 59 2(3.40%) 0(0|0) hipotiroide compensado1 1 0.10% 1019 1(0.10%) 816(816|0) negativo15 2 0.50% 22 0(0.00%) 20(20|0) negativo9 1 0.50% 111 0(0.00%) 106(106|0) negativo14 1 0.60% 3 0(0.00%) 3(3|0) negativo8 1 7.30% 5 1(20.00%) 3(3|0) negativo4 3 4.40% 29 1(3.40%) 28(28|0) hipotiroide primario11 3 64.80% 3 1(33.33%) 1(2|1) hipotiroide primario



Clasificadocomohipertiroide





Clasehipertiroide

0 0 0 0 0

Clase hipotiroideprimario

0 30 0 0 1


0 1 64 0 0


0 0 0 0 1



Árbol de decisión

TSH <= 6 : negativo (2246.8/1.0)TSH > 6 : FTI <= 64 : Medición TSH = f: negativo (4.3) Medición TSH = v: Medición T4U = f: hipotiroide compensado (4.5/2.1) Medición T4U = v: Cirugía tiroídea = f: hipotiroide primario (59.0/1.0) Cirugía tiroídea = v: negativo (3.0/1.0) FTI > 64 : Toma tiroxina = v: negativo (35.2) Toma tiroxina = f: Medición TSH = f: negativo (21.2) Medición TSH = v: Cirugía tiroídea = v: negativo (3.7) Cirugía tiroídea = f: TT4 > 150 : negativo (6.1/0.1) TT4 <= 150 : Medición TT4 = f: hipotiroide primario (2.8/0.7) Medición TT4 = v: hipotiroide compensado (127.4/1.5)














Clasehipertiroide

0 0 0 0 0


0 28 2 0 1


0 1 64 0 0


0 0 0 0 1


Reglas de decisión

Regla 7 SI Toma tiroxina = f Y Cirugía tiroídea = f Y TSH > 6 Y TT4 <= 150 Y FTI > 64

ENTONCES clase = hipotiroide compensado [98.9%]

Regla 4 SI Cirugía tiroídea = f Y TSH > 6 Y FTI <= 64


Regla 6 SI Toma tiroxina = f Y Medición TT4 = f Y TSH > 6




Regla 1 SI TSH <= 6


Regla 10 SI Toma tiroxina = v Y FTI > 64


Regla 2 SI Medición TSH = f

Y ENTONCES clase = negativo [99.5%]

Regla 8 SI TT4 > 150


Regla 5 SI Cirugía tiroídea = v


Regla 11Clase = hipotiroide compensado



Regla Tamaño Error Usada Errores Ventaja Clase7 5 1.10% 120 0(0.00%) 0(0|0) hipotiroide compensado4 3 4.40% 59 1(1.70%) 58(58|0) hipotiroide primario6 3 54.70% 4 1(25.00%) 2(3|1) hipotiroide primario1 1 0.10% 2018 1(0.00%) 1620(1620|0) negativo10 2 0.50% 41 0(0.00%) 28(28|0) negativo2 1 0.50% 247 0(0.00%) 232(232|0) negativo8 1 0.60% 6 0(0.00%) 6(6|0) negativo5 1 7.30% 7 1(14.30%) 6(6|0) negativo



Regla Tamaño Error Usada Errores Ventaja Clase7 5 1.10% 59 2(3.40%) 0(0|0) hipotiroide compensado4 3 4.40% 29 1(3.40%) 28(28|0) hipotiroide primario6 3 54.70% 1 1(100.00%) -1(0|1) hipotiroide primario1 1 0.10% 1019 1(0.10%) 816(816|0) negativo10 2 0.50% 22 0(0.00%) 20(20|0) negativo2 1 0.50% 111 0(0.00%) 106(106|0) negativo8 1 0.60% 3 0(0.00%) 3(3|0) negativo5 1 7.30% 5 1(20.00%) 4(4|0) negativo










Clasehipertiroide

0 0 0 0 0


0 28 2 0 1


0 1 64 0 0


0 0 0 0 1



El árbol de decisión obtenido utilizando la ganancia sin simplificar tiene mayor tamaño que el obtenido

utilizando la proporción de ganancia. No obstante, al simplificar el primer árbol se obtiene un árbol más

pequeño que ambos. En cuanto a la proporción de error, es igual para el árbol generado utilizando la

ganancia y el generado utilizando la proporción de ganancia. Por lo tanto, podríamos afirmar que el

tamaño no parece estar relacionado con la performance.

En cuanto a las reglas de decisión, en ambos casos se obtuvieron nueve reglas. La proporción de error

observada en las reglas generadas utilizando la ganancia, es la menor de todas las observadas para este

dominio.

5.4.7. Identificación de vidrios


Árbol de decisión

Mg <= 1 : Ca <= 9 : Al > 2 : contenedores (2.0) Al <= 2 : Al > 1 : lamparitas (12.0/1.0) Al <= 1 : Ba > 0 : lamparitas (4.0) Ba <= 0 : Na <= 13 : lamparitas (2.0) Na > 13 : vajilla (3.0) Ca > 9 : Al <= 0 : vidrios_para_construcciones_no_float (4.0/1.0) Al > 0 : Si <= 72 : vidrios_para_construcciones_no_float (6.0/1.0) Si > 72 : contenedores (4.0)Mg > 1 : Ca <= 7 : Ca <= 6 : contenedores (2.0/1.0)



Ca > 6 : vidrios_para_construcciones_no_float (13.0/1.0) Ca > 7 : Mg <= 2 : Na <= 12 : vidrios_para_construcciones_no_float (4.0/1.0) Na > 12 : vidrios_float_para_construcciones (5.0/3.0) Mg > 2 : Si > 72 : vidrios_float_para_construcciones (21.0/6.0) Si <= 72 : Al <= 0 : vidrios_float_para_construcciones (13.0/4.0) Al > 0 : Si <= 71 : vidrios_float_para_construcciones (6.0/2.0) Si > 71 : vidrios_para_construcciones_no_float (42.0/23.0)

Árbol simplificado

Mg <= 1 : Ca <= 9 : Al > 2 : contenedores (2.0/1.0) Al <= 2 : Al > 1 : lamparitas (12.0/2.5) Al <= 1 : Ba > 0 : lamparitas (4.0/1.2) Ba <= 0 : Na <= 13 : lamparitas (2.0/1.0) Na > 13 : vajilla (3.0/1.1) Ca > 9 : Al <= 0 : vidrios_para_construcciones_no_float (4.0/2.2) Al > 0 : Si <= 72 : vidrios_para_construcciones_no_float (6.0/2.3) Si > 72 : contenedores (4.0/1.2)Mg > 1 : Ca > 7 : vidrios_float_para_construcciones (91.0/48.8) Ca <= 7 : Ca <= 6 : contenedores (2.0/1.8) Ca > 6 : vidrios_para_construcciones_no_float (13.0/2.5)



Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación31 44 (30.8%) 21 50(35%) (45.8%)






Clasificadoscomovidrios_float_para_construcciones

Clasificadoscomovidrios_para_construcciones_no_float

Clasificadoscomovidrios_float_para_vehiculos

Clasificadoscomovidrios_para_vehículos_no_float

Clasificadoscomocontenedores

Clasificadoscomovajilla

Clasificadoscomolamparitas

Clasevidrios_float_para_construcciones

22 1 0 0 0 0 0

Clasevidrios_para_construcciones_no_float

19 6 0 0 0 0 0

Clasevidrios_float_para_vehiculos

6 0 0 0 0 0 0

Clasevidrios_para_vehículos_no_float

0 0 0 0 0 0 0

Clase contenedores 0 3 0 0 1 0 0Clase vajilla 2 1 0 0 0 0 0Clase lamparitas 0 1 0 0 1 0 8

Reglas de decisión

Regla 8 SI Al > 0 Y Si > 72 Y Ca > 9

ENTONCES clase = contenedores [70.7%]

Regla 5 SI Al > 2


Regla 2 SI Na > 13 Y Mg <= 1 Y Al <= 1 Y Ca <= 9 Y Ba <= 0

ENTONCES clase = vajilla [63.0%]

Regla 3 SI Al <= 2 Y Ca <= 9 Y Ba > 0

ENTONCES clase = lamparitas [84.1%]

Regla 4 SI Mg <= 1 Y Al > 1 Y Al <= 2 Y Ca <= 9


Regla 1 SI Na <= 13 Y Mg <= 1 Y Al <= 1 Y Ca <= 9




Regla 10 SI Mg > 1 Y Ca > 6 Y Ca <= 7

ENTONCES clase = vidrios_para_construcciones_no_float [80.9%]

Regla 7 SI Mg <= 1 Y Si <= 72 Y Ca > 9


Regla 14 SI Mg > 2 Y Ca > 7

ENTONCES clase = vidrios_float_para_construcciones [48.0%]

Regla 15Clase = vidrios_para_construcciones_no_float



Regla Tamaño Error Usada Errores Ventaja Clase8 3 29.30% 4 0(0.00%) 4(4|0) contenedores5 1 37.00% 3 0(0.00%) 3(3|0) contenedores2 5 37.00% 3 0(0.00%) 3(3|0) vajilla3 3 15.90% 8 0(0.00%) 5(5|0) lamparitas4 4 20.60% 9 1(11.10%) 8(8|0) lamparitas1 4 50.00% 2 0(0.00%) 2(2|0) lamparitas10 3 19.10% 13 1(7.70%) 0(0|0) vidrios_para_construcciones_no_float7 3 33.80% 7 1(14.30%) 0(0|0) vidrios_para_construcciones_no_float14 2 52.00% 82 39(47.60%) 16(43|27) vidrios_float_para_construcciones



Regla Tamaño Error Usada Errores Ventaja Clase8 3 29.30% 1 0(0.00%) 1(1|0) contenedores3 3 15.90% 6 0(0.00%) 5(5|0) lamparitas4 4 20.60% 3 0(0.00%) 3(3|0) lamparitas10 3 19.10% 4 1(25.00%) 0(0|0) vidrios_para_construcciones_no_float7 3 33.80% 6 4(66.67%) 0(0|0) vidrios_para_construcciones_no_float14 2 52.00% 42 21(50.00%) 6(21|15) vidrios_float_para_construcciones










Clasificados comovajilla



21 2 0 0 0 0 0


15 10 0 0 0 0 0


6 0 0 0 0 0 0


0 0 0 0 0 0 0



Árbol de decisión

Mg <= 1 : Ca <= 9 : Al > 2 : contenedores (2.0) Al <= 2 : Al > 1 : lamparitas (12.0/1.0) Al <= 1 : Ba > 0 : lamparitas (4.0) Ba <= 0 : Na <= 13 : lamparitas (2.0) Na > 13 : vajilla (3.0) Ca > 9 : Al <= 0 : vidrios_para_construcciones_no_float (4.0/1.0) Al > 0 : Si <= 72 : vidrios_para_construcciones_no_float (6.0/1.0) Si > 72 : contenedores (4.0)Mg > 1 : Ba > 0 : contenedores (2.0/1.0) Ba <= 0 : Mg <= 2 : Ca <= 8 : vidrios_para_construcciones_no_float (2.0) Ca > 8 : vidrios_float_para_construcciones (7.0/4.0) Mg > 2 : Ca <= 7 : vidrios_para_construcciones_no_float (13.0/1.0) Ca > 7 : Na > 13 : vidrios_float_para_construcciones (6.0/3.0) Na <= 13 : Si > 72 : vidrios_float_para_construcciones (21.0/6.0) Si <= 72 : Al <= 0 : vidrios_float_para_construcciones (7.0/1.0) Al > 0 :[S1]

Subárbol [S1]

Si <= 71 : vidrios_float_para_construcciones (6.0/2.0)Si > 71 : vidrios_para_construcciones_no_float (42.0/23.0)



Árbol simplificado

Mg <= 1 : Ca <= 9 : Al > 2 : contenedores (2.0/1.0) Al <= 2 : Al > 1 : lamparitas (12.0/2.5) Al <= 1 : Ba > 0 : lamparitas (4.0/1.2) Ba <= 0 : Na <= 13 : lamparitas (2.0/1.0) Na > 13 : vajilla (3.0/1.1) Ca > 9 : Al <= 0 : vidrios_para_construcciones_no_float (4.0/2.2) Al > 0 : Si <= 72 : vidrios_para_construcciones_no_float (6.0/2.3) Si > 72 : contenedores (4.0/1.2)Mg > 1 : Ba > 0 : contenedores (2.0/1.8) Ba <= 0 : Ca <= 7 : vidrios_para_construcciones_no_float (13.0/2.5) Ca > 7 : vidrios_float_para_construcciones (91.0/48.8)



Antes de podar Después de podarTamaño Errores Tamaño Errores Estimación31 44 (30.8%) 21 50(35%) (45.8%)










Clasificados comolamparitas


22 1 0 0 0 0 0


19 6 0 0 0 0 0


6 0 0 0 0 0 0




0 0 0 0 0 0 0


Reglas de decisión

Regla 8 SI Al > 0 Y Si > 72 Y Ca > 9


Regla 5 SI Al > 2


Regla 2 SI Na > 13 Y Mg <= 1 Y Al <= 1 Y Ca <= 9 Y Ba <= 0

ENTONCES clase = vajilla [63.0%]

Regla 3 SI Al <= 2 Y Ca <= 9 Y Ba > 0


Regla 4 SI Mg <= 1 Y Al > 1 Y Al <= 2 Y Ca <= 9


Regla 1 SI Na <= 13 Y Mg <= 1 Y Al <= 1 Y Ca <= 9


Regla 11 SI Mg > 1 Y Ca <= 7 Y Ba <= 0


Regla 7 SI Mg <= 1 Y Si <= 72 Y Ca > 9


Regla 15 SI Mg > 2 Y Si > 72 Y Ca > 7


Regla 10 SI Mg > 1 Y Ca > 8




Regla 16Clase = vidrios_para_construcciones_no_float



Regla Tamaño Error Usada Errores Ventaja Clase8 3 29.30% 4 0(0.00%) 4(4|0) contenedores5 1 37.00% 3 0(0.00%) 3(3|0) contenedores2 5 37.00% 3 0(0.00%) 3(3|0) vajilla3 3 15.90% 8 0(0.00%) 5(5|0) lamparitas4 4 20.60% 9 1(11.10%) 8(8|0) lamparitas1 4 50.00% 2 0(0.00%) 2(2|0) lamparitas11 3 19.10% 13 1(7.70%) 0(0|0) vidrios_para_c

onstrucciones_no_float

7 3 33.80% 7 1(14.30%) 0(0|0) vidrios_para_construcciones_no_float

15 3 38.30% 21 6(28.60%) 9(15|6) vidrios_float_para_construcciones




Regla Tamaño Error Usada Errores Ventaja Clase8 3 29.30% 1 0(0.00%) 1(1|0) contenedores3 3 15.90% 6 0(0.00%) 5(5|0) lamparitas4 4 20.60% 3 0(0.00%) 3(3|0) lamparitas11 3 19.10% 4 1(25.00%) 0(0|0) vidrios_para_c

onstrucciones_no_float

7 3 33.80% 6 4(66.67%) 0(0|0) vidrios_para_construcciones_no_float















12 11 0 0 0 0 0


6 19 0 0 0 0 0


2 4 0 0 0 0 0


0 0 0 0 0 0 0



En este caso los modelos obtenidos utilizando la ganancia y la proporción de ganancia son distintos,

aunque el tamaño de los árboles de decisión sea el mismo, y la diferencia en la cantidad de reglas

obtenidas sea de una regla. Para ambos árboles de decisión el porcentaje de error sobre los datos de

prueba es del 47.9%. Mientras que para los conjuntos de reglas de decisión es del 42.3%. Aunque en este

segundo caso la performance sea mejor, no podemos afirmar que un clasificador con el 42% de error sea

confiable.

5.5. COMPARACIÓN DE LOS RESULTADOS OBTENIDOS CON EL

ID3 Y CON EL C4.5

5.5.1. Créditos

Analizando la figura 5.1 vemos que para los árboles obtenidos con el C4.5 se obtuvo una proporción de

error del 43%, mientras que para el resto de los casos, se obtuvo una proporción de error del 35%. No

obstante, en los árboles generados con el C4.5 la estimación del error sobre casos futuros es del 12.4%.



Figura 5.1: Porcentajes de error obtenidos en el dominio Créditos

Los árboles generados con el ID3 son similares a los generados con el C4.5 sin simplificar. La única

diferencia destacable es que la rama expresada en el ID3 como:

Otros_Creditos = DOS CREDITOSComposición_Familiar = CASADO Y DOS HIJOS



Servicios = BASICOS Y TICSI


Se simplificó en el C4.5 a:

Otros Creditos = DOS CREDITOS: Composición Familiar = CASADO Y DOS HIJOS: Ingreso = ENTRE 451 Y 550: NO (4.0/1.0)

Notemos que de los cuatro casos clasificados en el C4.5 por esta rama, sólo uno se clasifica

erróneamente, y el árbol es más claro.

En este caso, el modelo más simple es el presentado por los árboles de decisión simplificados generados

por el C4.5: representan en un árbol de decisión que tiene únicamente una raíz y tres hojas aquello que los

árboles generados por el ID3 representan en un árbol de tamaño 26 y con una mayor proporción de error.

El modelo más simple, ayuda a destacar los atributos importantes del problema, y, por lo tanto, a

35.25% 35.25% 35.25% 35.25%

43.10%

35.29%

43.10%

35.29%

0.00%

5.00%

10.00%

15.00%

20.00%

25.00%

30.00%

35.00%

40.00%

45.00%

50.00%

ID3-Árbol-ganancia

ID3-Reglas-ganancia

ID3-Árbol-proporción

de ganancia

ID3-Reglas-proporción

de ganancia

C4.5-Árbol-ganancia

C4.5-Reglas-

ganancia

C4.5-Árbol-proporción

de ganancia

C4.5-Reglas-

proporciónde ganancia



entenderlo más profundamente. No obstante, es el que mayor proporción de error tuvo en la práctica.

Entonces, antes de decidirnos por un modelo, debemos analizar la relación simplicidad - proporción de

error.

Analicemos los tamaños de los modelos obtenidos. La figura 5.2 compara los tamaños de los árboles de

decisión obtenidos para el dominio Créditos. La figura 5.3 compara la cantidad de reglas de decisión

obtenidas con cada algoritmo.

Figura 5.2: Tamaño de los árboles obtenidos en el dominio Créditos

Del análisis de estos dos gráficos anteriores vemos que los modelos generados para este dominio por el

C4.5 fueron más pequeños y, por lo tanto, más comprensibles que los generados por el ID3. Si tuviéramos

que elegir un modelo entre estos cuatro para representar al dominio, eligiríamos las reglas generadas por

el C4.5, ya que son más simples que las generadas por el ID3 y tienen una proporción de error similar.

Figura 5.3: Cantidad de reglas obtenidas en el dominio Créditos

02468

1012141618

ID3-Reglas-ganancia

C4.5-Reglas-ganancia

ID3-Reglas-proporción de

ganancia

C4.5-Reglas-proporción de

ganancia

0

5

10

15

20

25

30

ID3-Árbol-ganancia C4.5-Árbol-ganancia

ID3-Árbol-proporción de

ganancia

C4.5-Árbol-proporción de

ganancia



5.5.2. Cardiología

La figura 5.4 muestra los porcentajes de error obtenidos con cada uno de los métodos para el dominio

Cardiología. Vemos que todos los porcentajes se encuentran entre el 6.45% y el 6.50%. Con lo cual, no

hay ningún modelo que sea claramente superior que otro en este aspecto.

Figura 5.4: Porcentajes de error obtenidas en el dominio Cardiología

Las figuras 5.5 y 5.6 comparan los tamaños de los modelos obtenidos. Vemos que la cantidad de reglas

obtenidas con el ID3 es el doble de la cantidad de reglas obtenidas con el C4.5. En el caso de los árboles

de decisión, el tamaño de los árboles obtenidos con el C4.5 es menor que la mitad del tamaño de los

árboles obtenidos con el ID3.

Figura 5.5: Tamaños de los árboles de decisión

6.45% 6.45% 6.45% 6.45% 6.50% 6.50% 6.50% 6.50%

0.00%

1.00%

2.00%

3.00%

4.00%

5.00%

6.00%

7.00%

ID3-Árbo

l-gan

ancia

ID3-Reg

las-ga

nanc

ia

ID3-Árbo

l-prop

orción

de ga

nanc

ia

ID3-Reg

las-pr

oporc

ión de

gana

ncia

C4.5-Á

rbol-g

anan

cia

C4.5-R

eglas

-gana

ncia

C4.5-Á

rbol-p

roporc

ión de

gana

ncia

C4.5-R

eglas

-prop

orción

de ga

nanc

ia

25

10

25

10

05

1015202530

ID3-Árbol-ganancia


ID3-Árbol-proporción

de ganancia

C4.5-Árbol-proporción

de ganancia



Figura 5.6: Cantidad de reglas obtenidas en el dominio Cardiología

Analizando los árboles de decisión obtenidos para este dominio, podemos deducir que esta diferencia en

tamaños se debe a que el ID3 ajusta el árbol de decisión para cubrir todos y cada uno de los datos de

entrada, mientras que cada hoja de un árbol generado con el C4.5 cubre una distribución de casos y puede

contener errores. Veamos, por ejemplo, los árboles obtenidos utilizando la ganancia con ambos

algoritmos. En el caso de DURACION_DEL_ANGOR = MENOS DE 30 MIN, en el árbol obtenido con

el C4.5 nos encontramos con una hoja, que cubre 33 casos, 1 sólo incorrectamente. Mientras que en el

árbol obtenido con el ID3, nos encontramos con un subárbol de tamaño 10, este subárbol también cubre

33 casos, ninguno incorrectamente. Ambos árboles tienen proporciones de errores similares. Cabe

entonces preguntarnos si no es más conveniente tener hoja con un 3.03% de error en lugar de un subárbol

que cubra todos los casos, sin ningún error. Recordemos que la performance general de ambos árboles

frente a los datos de prueba fue muy similar.

5.5.3. Votaciones

La figura 5.7 presenta los porcentajes de error obtenidos para el dominio de Votaciones. Vemos que con

el ID3 el porcentaje de error ronda el 5.20%, mientras que con el C4.5, el porcentaje de error es más bajo

en el caso de ambos árboles de decisión y de las reglas utilizando la ganancia. Esto es destacable ya que si

analizamos las figuras 5.8 y 5.9, que presentan el tamaño de los modelos obtenidos, vemos que los

modelos obtenidos con el C4.5 son mucho menores que los obtenidos con el ID3. Si a esto le agregamos

el hecho de que el porcentaje de error en tres de los modelos es menor, podemos concluir que en este caso

la performance del C4.5 es mejor que la del ID3.

Podemos preguntarnos a qué se debe la diferencia en los tamaños de los modelos generados con el ID3 y

con el C4.5. Tomemos, por ejemplo, los árboles de decisión. En el caso de los árboles generados

utilizando la ganancia, los atributos elegidos por el ID3 y por el C4.5 para realizar la partición de los

datos son los mismos. Sin embargo, recordemos que cada hoja del C4.5 cubre una distribución de casos

(aún en los árboles sin simplificar), entonces el árbol resultante es más simple.

147

147

05

1015202530

ID3-Reglas-ganancia



de ganancia

C4.5-Reglas-proporción

de ganancia



Figura 5.7: Porcentajes de error obtenidas en el dominio Votaciones

Figura 5.8: Tamaño de los árboles de decisión obtenidos en el dominio Votaciones

Figura 5.9: Cantidad de reglas de decisión obtenidas en el dominio Votaciones

A continuación, en las figuras 5.10 y 5.11 se presentan ambos árboles de decisión y se pueden apreciar las

simplificaciones realizadas por el C4.5.

5.19% 5.19% 5.19% 5.19%

3.00%3.70%

3.00%

5.20%

0.00%

1.00%

2.00%

3.00%

4.00%

5.00%

6.00%

ID3-Árbo

l-gan

ancia

ID3-Reg

las-ga

nanc

ia

ID3-Árbo

l-prop

orción

de ga

nanc

ia

ID3-Reg

las-pr

oporc

ión de

gana

ncia

C4.5-Á

rbol-g

anan

cia

C4.5-R

eglas

-gana

ncia

C4.5-Á

rbol-p

roporc

ión de

gana

ncia

C4.5-R

eglas

-prop

orción

de ga

nanc

ia

57

7

58

7

010203040506070

ID3-Árbol-ganancia



ganancia


ganancia

34

6

35

7

0

10

20

30

40

ID3-Reglas-ganancia



de ganancia

C4.5-Reglas-proporción

de ganancia










Acta_sudaf_admin_export = desconocidorepublicano




Democrata (1)Presupuesto_de_educacion = desconocido




Ayuda_a_El_Salvador = a_favorrepublicano



Acta_sudaf_admin_export = en_contraDemocrata (2)

Reduccion_corp_Synfuels = desconocidorepublicano


Inmigracion = a_favorrepublicano



Particip_proy_agua = a_favorrepublicano


Acta_sudaf_admin_export = en_contrarepublicano


Export_sin_impuestos = en_contraAdop_resolucion_presup = a_favor


Acta_sudaf_admin_export = desconocidoNiños discapacitados = a_favor


democrataAdop_resolucion_presup = en_contra

Republicano (3)Cong_honorarios_medicos = desconocido

Misil_mx = a_favorProhib_pruebas_anti_satel = a_favor

democrataProhib_pruebas_anti_satel = desconocido

democrataProhib_pruebas_anti_satel = en_contra

Republicano (4)Misil_mx = desconocido

republicano



Misil_mx = en_contrademocrata

Cong_honorarios_medicos = en_contraPresupuesto_de_educacion = a_favor




Presupuesto_de_educacion = en_contraDemocrata (5)

Figura 5.10: Árbol generado por el ID3 para el dominio Votaciones utilizando la ganancia

cong_honorarios_medicos = en_contra: democrata (168.0/1.0) (5)cong_honorarios_medicos = a_favor: reduccion_corp_Synfuels = en_contra: republicano (97.0/3.0) (3) reduccion_corp_Synfuels = desconocido: republicano (4.0) reduccion_corp_Synfuels = a_favor: export_sin_impuestos = a_favor: democrata (2.0) export_sin_impuestos = desconocido: republicano (1.0) export_sin_impuestos = en_contra: presupuesto_de_educación = a_favor: republicano (13.0/2.0) (1) presupuesto_de_educación = en_contra: democrata (5.0/2.0) (2) presupuesto_de_educación = desconocido: democrata (1.0)cong_honorarios_medicos = desconocido: misil_mx = a_favor: democrata (4.0/1.0) (4) misil_mx = en_contra: democrata (3.0) misil_mx = desconocido: republicano (2.0)

Figura 5.11: Árbol generado por el C4.5 para el dominio Votaciones utilizando la ganancia

En el caso (1), podemos observar que el subárbol de tamaño 10 generado por el ID3, se representó en el

C4.5 con una hoja que cubre 13 casos, dos incorrectamente. En el caso (2), el C4.5 presenta una hoja que

cubre 5 casos, dos de ellos erróneamente, mientras que el ID3 presenta un subárbol de tamaño 8. En el

caso (3), el subárbol presentado por el ID3 es de tamaño 17 y la hoja presentada en el mismo caso por el

C4.5 clasifica 3 casos errróneamente de los 97 que cubre. La diferencia en el caso (4) no es tan notable,

ya que el C4.5 representa en una hoja con N=4 y E=2, lo que el ID3 presenta en un nodo de decisión con

tres hojas hijas. Finalmente, en el caso (5), el C4.5 se equivoca una sola vez en los 168 casos que cubre la

hoja, mientras que el ID3 los clasifica a todos correctamente con un subárbol de tamaño 6.

El ID3 no generaliza los resultados de una hoja, es decir, no permite que una hoja cubra casos de una

clase distinta a la expresada. Por lo tanto, cubre exhaustivamente todos los casos de entrenamiento.

Mientras que la generalización realizada por el C4.5 permite obtener árboles más pequeños a un precio

que parece ser no tan alto. Pensemos que, muchas veces es preferible tener una hoja con performance del

96.9%, como en el caso (3), que un árbol de tamaño 17. Este fenómeno que ocurre en los árboles

generados por el ID3 y, como consecuencia lógica, también en las reglas generadas por el mismo sistema,

se conoce como sobreajuste. Como su nombre lo indica, se origina en que el ID3 cubre absolutamente

todos los casos de entrenamiento correctamente, ajusta el modelo a todos los casos de entrenamiento.



Existen muchas maneras de solucionar el sobreajuste. Podríamos, por ejemplo, realizar una poda del árbol

cuando un subárbol tenga una performance mayor a una cota predefinida, es decir, cuando (E*100)/N sea

superior a una cota mínima de performance. Otra opción sería realizar esta simplificación y adjuntarle al

árbol las reglas de decisión con las excepciones.


Figura 5.12: Porcentajes de error obtenidas en el dominio Estudio sobre hongos

En el caso de este dominio el porcentaje de error registrado con todos los clasificadores no supera el 1%,

como lo muestra la figura 5.12. El mayor porcentaje de error se obtuvo con el árbol de decisión generado

por el C4.5 utilizando la ganancia, y el menor, y más destacable, se obtuvo utilizando el ID3 con la

proporción de ganancia. En este caso, todos los datos de entrenamiento fueron clasificados correctamente.

En caso de tener que optar entre alguno de los clasificadores generados, optaríamos por los generados con

el ID3 utilizando la proporción de ganancia, ya que además de no presentar errores, el tamaño del árbol es

aceptable, como lo muestra la figura 5.13. Mientras que la cantidad de reglas generadas en el mismo caso

es superior a las generadas con el C4.5 utilizando la ganancia (figura 5.14), que tienen un porcentaje de

error bajo.

Como se destacó en las conclusiones particulares de este dominio para el ID3 (Sección 5.3.4.3) y para el

C4.5 (Sección 5.4.4.3), vimos que la ganancia favoreció a atributos con muchos valores diferentes frente

a otros atributos que generaban una mayor ganancia neta de información pero que tenían menos valores.

0.00% 0.00% 0.00% 0.00%

0.90%

0.30% 0.30% 0.30%

0.00%0.10%0.20%0.30%0.40%0.50%0.60%0.70%0.80%0.90%1.00%

ID3-Árbo

l-gan

ancia

ID3-Reg

las-ga

nanc

ia

ID3-Árbo

l-prop

orción

de ga

nanc

ia

ID3-Reg

las-pr

oporc

ión de

gana

ncia

C4.5-Á

rbol-g

anan

cia

C4.5-R

eglas

-gana

ncia

C4.5-Á

rbol-p

roporc

ión de

gana

ncia

C4.5-R

eglas

-prop

orción

de ga

nanc

ia



Este es un problema general de la ganancia y es una de las razones por las que se comenzó a utilizar la

proporción de ganancia.

Figura 5.13: Tamaño de los árboles de decisión obtenidos en el dominio Estudio sobre hongos

Figura 5.14: Cantidad de reglas de decisión obtenidas en el dominio Estudio sobre hongos

Si comparamos los árboles obtenidos en cada caso, veremos que en los árboles generados con el C4.5

existen muchas ramas en las que N=E=0. Es decir, ramas que no cubren ningún caso, pero que existen

porque el C4.5 toma la información de dominio y tiene en cuenta esos posibles valores al analizar la

ganancia y la proporción de ganancia en todos los casos. El ID3, en cambio, no tiene en cuenta

información de dominio, entonces, trabaja con la hipótesis de que los únicos valores válidos para los

atributos son aquellos que ocurren en los datos.

26

13

1915

0

5

10

15

20

25

30

ID3-Reglas-ganancia


ID3-Reglas-proporción de

ganancia

C4.5-Reglas-proporción de

ganancia

32

44

25 25

05

101520253035404550

ID3-Árbol-ganancia



ganancia


ganancia



5.6. ANÁLISIS GENERAL DE LOS RESULTADOS OBTENIDOS

5.6.1. Porcentaje de error

La figura 5.15 muestra el porcentaje de error obtenido con cada uno de los métodos, para cada dominio. A

simple vista nos damos cuenta que en los dominios de Créditos y Análisis de Vidrios los porcentajes de

error son altos para todos los métodos.

Figura 5.15: Porcentaje de error obtenido para cada uno de los métodos en cada dominio de datos

En la figura 5.16 se han eliminado estos dos dominios para poder analizar más claramente el porcentaje

de error en el resto de los dominios. A partir de estos dos gráficos, podríamos decir que no hay un

método4 que genere un modelo claramente superior al resto para todos los dominios. Al contrario,

podríamos decir que el porcentaje de error en todos los casos no parece depender del método utilizado

sino del dominio analizado. Es decir, el rango de porcentajes de error dentro de cada uno de los dominios

parecería estar acotado.

4 En este caso, por método nos referimos a la combinación de un algoritmo (ID3 o C4.5) utilizando ganancia o proporción de

ganancia y generando un árbol o reglas de decisión (combinación algoritmo – criterio de decisión – tipo de resultado).

0.00%

10.00%

20.00%

30.00%

40.00%

50.00%

60.00%

ID3-árboles-ganancia

ID3-reglas-ganancia

ID3-árboles-proporción

de ganancia

ID3-reglas-proporción

de ganancia

C4.5-árboles-ganancia

C4.5-reglas-ganancia

C4.5-árboles-

propociónde ganancia

C4.5-reglas-proporciónde ganancia

Créditos

Cardiología

Votaciones

Hongos

Elita

Hipotiroidismo

Vidrios



Figura 5.16: Porcentaje de error obtenido para cada uno de los métodos en distintos dominios de datos

5.6.2. Cantidad de datos de entrenamiento

En la figura 5.15 se presenta el porcentaje de error en función de la cantidad de datos de entrenamiento,

con una línea de tendencia logarítmica para cada uno de los métodos. A partir de este gráfico podríamos

decir que el porcentaje de error disminuye a medida que aumenta la cantidad de datos de entrenamiento.

Esto pareciera ser una conclusión lógica e intuitiva, y es similar a la forma en que aprendemos los

humanos: cuando nos encontramos ante una situación a la que nos hemos enfrentado múltiples veces,

generalmente ya hemos aprendido cómo reaccionar.

A pesar de lo que muestra el gráfico no podemos afirmar que la relación “menor porcentaje de error a

mayor cantidad de datos de entrenamiento” sea una regla absoluta que se cumple siempre. Para ello,

habría que hacer una cantidad de pruebas que excede los alcances de este trabajo.

0.00%

1.00%

2.00%

3.00%

4.00%

5.00%

6.00%

7.00%


ID3-reglas-ganancia

ID3-árboles-proporción

de ganancia

ID3-reglas-proporción

de ganancia



C4.5-árboles-

propociónde ganancia

C4.5-reglas-proporciónde ganancia

Cardiología

Votaciones

Hongos

Elita

Hipotiroidismo



Figura 5.15: Porcentaje de error en función de la cantidad de datos de entrenamiento. Se ha

agregado una línea de tendencia logarítmica para cada uno de los métodos.

-10.00%

0.00%

10.00%

20.00%

30.00%

40.00%

50.00%

60.00%

0 1000 2000 3000 4000 5000 6000

Cantidad de datos de entrenamiento

Porc

enta

je d

e er

ror



C4.5-árboles-propoción de ganancia

C4.5-reglas-proporción de ganancia


ID3-reglas-ganancia

ID3-árboles-proporción de ganancia

ID3-reglas-proporción de ganancia


Conclusiones Magdalena Servente 191

CAPÍTULO 6

CONCLUSIONES

En este capítulo se presentan las conclusiones del trabajo realizado. Primero se destacan los

conceptos más importantes a tener en cuenta a la hora de aplicar algún método como el ID3 y el

C4.5 (Sección 6.1.1). Luego, se analiza la búsqueda que realizan estos dos métodos en el espacio

de hipótesis (Sección 6.1.2). Se extraen conclusiones a partir de los resultados obtenidos

(Sección 6.2) y se analiza la solución propuesta (Sección 6.3). Finalmente, se plantean mejoras y

temas a tener en cuenta para continuar con el desarrollo de este tipo de algoritmos de aprendizaje

aplicados a la Minería de Datos (Sección 6.4).

6.1. CONCLUSIONES GENERALES

6.1.1. Conceptos destacables

A partir del estudio realizado sobre la Minería de Datos y el Aprendizaje Automático en general, y de los

métodos de la familia TDIDT en particular, podemos concluir que hay varios puntos claves a tener en

cuenta al realizar Minería de Datos con algoritmos inteligentes. Entre ellos, podemos destacar:

• El Aprendizaje de Conceptos puede verse como una búsqueda en un gran espacio de hipótesis

predefinidas [Mitchell, 1997]. En el caso de la familia TDIDT este espacio de hipótesis, está

constituido por todos los árboles de decisión posibles para los datos que se están analizando.

• Los datos ruidosos y faltantes pueden influir en la performance del algoritmo, y depende de cada

método en particular ser robusto o no ante estas situaciones.

• Los algoritmos de aprendizaje son capaces de clasificar nuevos casos, nunca vistos para ellos, porque

tienen un sesgo inductivo implícito, es decir, realizan alguna suposición que les permite construir el

modelo. En el caso de los algoritmos de la familia TDIDT, esta suposición implícita se divide en dos:

1. Los datos sobre los que se construye el problema son representativos del dominio sobre el que se

aplicará el modelo obtenido.

2. Las hipótesis (árboles de decisión en este caso) más simples se prefieren sobre las hipótesis más

complejas, es decir, se aplica la Afeitadora de Occam.


192 Magdalena Servente Conclusiones

Si el espacio de hipótesis se extendiera hasta cubrir todos los casos posibles, se eliminaría este sesgo

inductivo. Sin embargo, trabajar con todos los árboles de decisión posibles para un conjunto de datos,

no permitiría realizar la clasificación de un caso no presente en los datos de entrenamiento, ya que no

sería clasificado por ningún árbol. Es decir, un modelo totalmente insesgado, no podría clasificar

nuevos casos [Mitchell, 1997].

Recordemos que no cualquier problema de Minería de Datos es apto para ser analizado mediante los

algoritmos de la familia TDIDT. Debe cumplirse que las instancias estén constituidas por pares atributo-

valor, y que los resultados de la función de clasificación sean discretos. Además, es conveniente que los

algoritmos sean capaces de trabajar con atributos ruidosos y con atributos faltantes.

6.1.2. Espacio de hipótesis

Como se destacó en la sección anterior, tanto el ID3 como el C4.5 realizan una búsqueda en un espacio de

hipótesis constituido por los árboles de decisión posibles. El espacio de hipótesis para estos algoritmos es

un espacio completo según los atributos disponibles. Como cualquier función de prueba de valor de

atributos puede representarse como un árbol de decisión, estos métodos evitan uno de los mayores riesgos

de los métodos inductivos que trabajan con un espacio de hipótesis reducido: que la función resultado, en

nuestro caso el árbol de decisión, no se encuentre en el espacio de hipótesis analizado.

A medida que exploran el espacio de hipótesis, los algoritmos analizados mantienen una sola hipótesis

actual y no todas aquellas consistentes con los datos analizados. Esto ocasiona que estos métodos no sean

capaces de representar todos los árboles consistentes con los datos de entrada.

Por otro lado, recordemos que estos métodos no tienen vuelta atrás. Es decir, una vez que se seleccionó

un atributo como nodo del árbol, éste nunca se cambiará; los algoritmos no vuelven atrás para

reconsiderar sus elecciones. Esto ocasiona que los algoritmos sean susceptibles de caer en un máximo

local y que converjan a una solución que no es globalmente óptima [Mitchell, 1997]. El C4.5 agrega un

cierto grado de reconsideración de sus elecciones en la postpoda que realiza.

Por último, cabe destacar que el ID3 y el C4.5 utilizan todos los datos de entrenamiento en cada paso para

elegir el “mejor” atributo; esta elección se realiza estadísticamente. Esto es favorable frente a otros

métodos de aprendizaje automático que analizan los datos de entrada en forma incremental. El hecho de

tener en cuenta todos los datos disponibles en cada paso, resulta en una búsqueda mucho menos sensible a

errores en casos individuales.



6.2. ANÁLISIS DE LOS RESULTADOS OBTENIDOS

Del análisis de los resultados obtenidos podríamos concluir que no hay ningún método que sea

predominante frente a los otros. Es decir, no podemos decir, por ejemplo, que el C4.5 que utiliza la

ganancia es claramente superior en todos los dominios. Sin embargo, podemos afirmar que los resultados

muestran que la proporción de error parecería ser función del dominio. En cada dominio, la proporción de

error para los cuatro métodos analizados es similar: si la proporción de error es grande para alguno de los

métodos en un dominio, seguramente lo sea también para el resto de los métodos. Si la proporción de

error para alguno de los cuatro métodos en un dominio es pequeña, probablemente también sea pequeña

con los otros tres métodos.

Como línea futura de trabajo, se propone analizar los datos de entrada con los cuatro métodos (ID3

utilizando ganancia, ID3 utilizando proporción de ganancia, C4.5 utilizando ganancia y C4.5 utilizando

proporción de ganancia) y elegir para el nuevo dominio, el modelo que presenta la menor proporción de

error. Teniendo en cuenta que si con el primer método la proporción de error es inaceptable,

probablemente también sea inaceptable para el resto de los métodos. En cuyo caso, convendría analizar el

problema con otros métodos de aprendizaje que enfoquen la resolución del mismo desde otro ángulo.

La cantidad de datos presentada como entrada de los algoritmos debe ser la mayor posible, ya que los

casos analizados parecen mostrar que proporción de error disminuye a medida que la cantidad de datos de

entrenamiento aumenta.

6.3. ANÁLISIS DE LA SOLUCIÓN PROPUESTA

A partir de la solución propuesta y de los resultados analizados, podemos responder a las cuestiones

planteadas en el Capítulo 3:

Cuestión 1:

¿Qué tipos de sistemas generan como resultado árboles de decisión? La familia de los Top Down

Induction Trees (TDIDT) analiza datos previamente clasificados y genera árboles de inducción para

los mismos. Nuestro análisis se enfocó en dos algoritmos de dicha familia, el ID3 creado por Quinlan

a mediados de los años 80 [Quinlan, 1986] y el C4.5 creado por Quinlan unos años más tarde

[Quinlan, 1993d]. Estos algoritmos generan como resultado árboles de decisión que pueden aplicarse

tanto por un operador humano como por una máquina para clasificar nuevos casos.



Cuestión 2:

¿Qué condiciones deben cumplir los datos para que su análisis con el ID3 o el C4.5 sea útil y

válido? Como expresamos con anterioridad, no todos los datos son aptos para ser analizados con el

ID3 y el C4.5. En líneas generales, estos algoritmos trabajan con problemas de clasificación, es decir,

problemas donde las instancias pertenecen o no a una clase. De esta manera, el árbol de decisión

generado contiene en las hojas las distintas clases a las que pueden pertenecer los datos.

Cuestión 3:

¿Qué tan fácil es para un humano trabajar con estos algoritmos? Se planteó el desarrollo de un

ambiente integrado, en el que un usuario puede fácilmente aplicar estos dos algoritmos a bases de

datos existentes. El usuario debe lidiar con una interface gráfica mucho más amigable de por sí que la

línea de comandos, en donde, con una simple marca puede aplicar el ID3 o el C4.5 a la base de datos

que seleccionó previamente.

Cuestión 4:

¿Cuáles son los resultados del sistema? Además, de producir los árboles de decisión, el sistema

genera un conjunto de reglas de producción que pueden aplicarse para clasificar nuevos casos. La

interpretación de este conjunto de reglas debe hacerse en orden: se leen hasta que el antecedente de

alguna de las reglas satisfaga el caso en cuestión, entonces se lee el consecuente para obtener la clase.

El sistema también presenta como resultado, la evaluación de los modelos generados sobre un nuevo

conjunto de datos de prueba.

Cuestión 5:

¿Cómo podemos medir la calidad de los resultados obtenidos? Una vez generado el modelo de

decisión, el usuario puede elegir la opción de evaluarlo contra un conjunto de datos de prueba,

inéditos para el sistema. Básicamente, el sistema clasifica estos datos de prueba y compara las clases

obtenidas contra las que debería haber obtenido, generando una matriz de clasificación. De esta

manera, se obtiene una medida de la calidad del sistema de información generado, bajo el supuesto

que tanto los datos de entrenamiento como los de prueba sean representativos de la realidad a la cual

el modelo de clasificación generado se verá enfrentado una vez que entre en funcionamiento.



6.4. UNA MIRADA AL FUTURO

Los algoritmos analizados no clasifican perfectamente a todos los nuevos casos, a pesar de que los

modelos de clasificación presentados son entendibles y aceptables. Quedan cuestiones sin resolver,

posibles mejoras y futuras líneas de trabajo que se plantean a continuación

6.4.1. Atributos multivaluados en el ID3 y el C4.5

Cuando alguno de los algoritmos realiza la partición de los casos de entrenamiento según los valores de

los atributos siguiendo el método de divide y reinarás, los resultados son útiles en la medida en que los

valores del atributo según el cual se particiona no sean demasiados. Si existen demasiados valores para el

atributo se presentan básicamente dos inconvenientes:

1. Una de las consecuencias de particionar un conjunto de entrenamiento en numerosos subconjuntos es

que cada subconjunto es pequeño. Por lo tanto, aquellos patrones útiles del subconjunto pueden

tornarse indetectables por insuficiencia de datos.

2. Si los atributos discretos varían en forma notable en sus valores, ¿podemos estar seguros de que un

criterio como la proporción de ganancia los está evaluando de la mejor manera? La proporción de

ganancia mide la proporción de información relevante a la clasificación, que provee la división sobre

la información producida por la división en sí. El denominador crece rápidamente a medida que la

cantidad de subconjuntos se incrementa, por lo cual, el estimador deja de ser efectivo al existir

muchos valores para un atributo. Recordemos el ejemplo del cálculo de la información de la división

sobre la clave primaria de un conjunto de datos (Sección 4.2.1.1.2)

Si deseamos reducir el número de resultados de un atributo multivaluado, debemos asociar uno o más de

sus valores en una colección de valores de atributos o grupo de valores. En los primeros trabajos sobre el

tema [Hunt et al., 1966] la única forma de agrupar valores era mediante la división binaria o binarización,

como la realizada por el C4.5.

En lugar de realizar este tipo de división, los algoritmos podrían asociar cada grupo de valores con una de

las ramas en cantidad variable. En algunos dominios, la agrupación de valores podría determinarse de

acuerdo a los conocimientos sobre el dominio. De esta manera, además de mejorar el manejo de atributos

multivaluados, estaríamos incorporando información previa al sistema. De no existir agrupaciones

determinables de acuerdo al dominio, debería seguirse otro método. Si un atributo tiene n valores, existen

2n-1-1 divisiones binarias no triviales de estos valores, entonces para un valor de n grande se hace

imposible explorar todas estas combinaciones.



En cuanto al ID3, que no maneja atributos continuos, podría incorporársele la binarización utilizada por el

C4.5, o un método similar, para que pueda trabajar con atributos de este tipo. El ID3 tal como fue

presentado, no puede aplicarse a todos los dominios, además de descartarse los dominios con clases

continuas, como en el C4.5, se descartan los dominios con cualquier atributo continuo. El agregado de

una mejora de este tipo lo liberaría de esta restricción y no es demasiado cara.

6.4.2. El futuro de la Minería de Datos Inteligente

¿En qué medida podemos afirmar que la Minería de Datos Inteligente es efectiva? Más aún, ¿cómo

podemos estar seguros de que es útil realizar Minería de Datos Inteligente frente a cualquier problema de

Minería de Datos? ¿Podemos afirmar que siempre será efectivo aplicar, por ejemplo, la familia TDIDT

cuando se busca obtener un modelo a partir de una gran cantidad de datos?

La Ley de Conservación sostiene que ningún algoritmo puede superar a otro cuando la medida de

performance es la precisión de generalización esperada, sobre la suposición de que todos los resultados

posibles son igualmente probables. El hecho de promediar la performance de un algoritmo sobre todos los

casos posibles, asumiendo que todos son igualmente probables, sería como evaluar la performance de un

auto en todos los terrenos posibles, asumiendo que todos son igualmente probables. Esta afirmación es

falsa para la práctica, ya que en un dominio en particular, es claro que no todos los casos son igualmente

probables.

Quinlan, quien ha identificado familias de dominios paralelos y secuenciales, sostiene que las redes

neuronales son más eficientes en los dominios paralelos, mientras que los algoritmos que construyen

árboles de decisión obtienen mejores resultados en los dominios secuenciales. Por lo tanto, aunque un

único algoritmo de inducción puede no ser óptimo en todas las situaciones posibles, debe analizarse el

mejor algoritmo para cada situación en particular.

El campo de la Minería de Datos es un campo en pleno desarrollo, donde la mayoría de las herramientas

utilizadas provienen de otros campos relacionados como el reconocimiento de patrones, la Estadística o la

teoría de complejidad. Dada la novedad de las investigaciones en esta área quedan todavía varios

problemas por afrontar, como ser el tamaño de los datos y el ruido en los mismos.

En los últimos años se han desarrollado muchos sistemas de Minería de Datos y se espera que este

desarrollo continúe floreciendo dada la enorme cantidad de datos que son almacenados día a día, que

requiere algún tipo de análisis, entendimiento o clasificación. La diversidad de los datos, y de las técnicas

y enfoques de la minería de datos, son un desafío para el crecimiento de este área de la tecnología.


Manual del usuario Magdalena Servente 197

ANEXO A

MANUAL DEL USUARIO

En este Anexo se describen las características generales del sistema (Sección A.1) y las

funciones de cada uno de los menúes (Sección A.2), detallando las acciones que pueden

realizarse con cada una de las opciones disponibles.

A.1. CARACTERÍSTICAS GENERALES

El objetivo del sistema desarrollado es permitir que el usuario realice una minería de datos sobre las

tablas de su elección. La minería se lleva a cabo mediante dos algoritmos inteligentes de la familia de los

árboles inductivos construidos de raíz hacia las hojas (Top Down Induction Trees – TDIDT): el ID3 y, su

sucesor, el C4.5.

Cuando el usuario ingresa al sistema debe seleccionar la tabla sobre la cual desea trabajar y la columna de

la tabla que servirá como clasificador. Dicha tabla debe estar en formato de Paradox 4. Una vez

seleccionada la tabla de trabajo, el usuario podrá elegir el método con el cual desea realizar la minería.

Los métodos disponibles son el ID3 utilizando la ganancia como criterio de decisión, el ID3 utilizando la

proporción de ganancia como criterio de decisión, el C4.5 utilizando la ganancia como criterio de

decisión y el C4.5 utilizando la proporción de ganancia con el mismo propósito.

Una vez finalizada la minería, el sistema mostrará en pantalla el árbol de decisión generado. El usuario

tendrá la opción de guardar dicho árbol en disco. Además, el sistema genera un conjunto de reglas de

decisión. El formato de estas reglas es lo suficientemente general como para que puedan aplicarse y

utilizarse a posteriori para clasificar datos cuya clase no se conoce. Es decir, tanto el árbol como las reglas

nos sirven para comprender el modelo de clasificación presente en los datos, y las reglas nos sirven para

clasificar nuevos datos de la misma base de datos que no fueron utilizados por el sistema.



A.2. FUNCIONALIDAD

A.2.1. Pantalla principal

Cuando el usuario ingresa al sistema se encontrará con la pantalla mostrada en la Figura A.1, donde podrá

ver un menú de acceso rápido que detalla la tabla que el usuario eligió como predeterminada para

trabajar, y el atributo clasificador de la misma. Si el usuario desea realizar una minería según sus

opciones por defecto puede hacerlo rápidamente, presionando los botones de ID3 o de C4.5, dependiendo

en el tipo de método que desee utilizar.

Figura A.1: Pantalla principal del sistema

A.2.2. Descripción del menú

A continuación se detalla cada una de las funciones que se pueden realizar mediante las opciones del

menú del sistema.



A.2.2.1. Menú Resolución

A.2.2.1.1. ID3

Con la opción ID3 del menú Resolución, se aplica el ID3 a la tabla elegida en la pantalla de Cambio de

Tabla (Menú Opciones/Cambio de Tabla). El ID3 puede aplicarse utilizando la ganancia o la proporción

de ganancia como criterio de decisión, el criterio de decisión se escoge según la subopción del menú que

el usuario elija.

A.2.2.1.2. C4.5

Al igual que con la opción anterior, con la opción C4.5 del menú Resolución, se aplica el C4.5 a la tabla

elegida en la sección de Cambio de Tabla (Menú Opciones/Cambio de Tabla). Nuevamente, se utilizará la

ganancia o la proporción de ganancia de acuerdo a la opción del menú desplegable en que el usuario haya

marcado.

A.2.2.1.3. Salir

La opción Salir del menú Resolución, cierra el programa.

A.2.2.2. Menú Evaluación

A.2.2.2.1. ID3

Cuando el usuario elige esta opción se encuentra con la pantalla de la figura A.2 donde puede elegir una

tabla y una corrida sobre la cual desea obtener una evaluación de los resultados obtenidos. Por corrida, se

entiende, una fecha y hora determinadas en las cuales se aplicó el ID3 sobre la tabla. De esta manera,

cuando el usuario hace clic sobre el botón “Aceptar” de esta pantalla, se realiza una evaluación sobre los

datos de la tabla de prueba predefinida por el usuario y se muestran la cantidad de casos clasificados

correcta e incorrectamente para cada una de las clases de la tabla.

A.2.2.2.1. C4.5

Al hacer clic sobre esta opción de menú, el usuario podrá evaluar de manera similar a la explicada en la

sección anterior, las corridas realizadas con el C4.5.



Figura A.2: Elección de la tabla y la corrida que se desean evaluar

A.2.2.3. Menú Opciones

A.2.2.3.1. Ver Tabla

Esta función muestra los datos de la tabla sobre la que se está trabajando.

A.2.2.3.2. Cambiar Tabla

Esta opción despliega la pantalla mostrada en la figura A.3 donde el usuario puede cambiar la tabla de

trabajo y la columna del clasificador (clase) de la misma. Si el usuario hace clic en “Aceptar” esta tabla se

utilizará para todas las corridas hasta que se cierre el sistema. Si el usuario hace clic en “Aplicar” esta

tabla quedará predeterminada, con lo cual se utilizará para todas las corridas posteriores y para las

corridas realizadas cuando se utilice el sistema por próxima vez; queda determinada como tabla por

defecto.

A.2.2.3.3. Parámetros del sistema

Esta pantalla, permite cambiar los parámetros generales de trabajo que utiliza el sistema por defecto. Los

parámetros que se pueden cambiar son el sistema de minería por defecto: ID3 o C4.5; el criterio de

decisión por defecto: ganancia o proporción de ganancia; y si se realiza o no la poda del árbol de decisión

obtenido.



Figura A.3: Pantalla de cambio de tabla y elección de la clase

A.2.2.4. Menú Ayuda

Este menú despliega una ayuda para el usuario del sistema.


Conjuntos de datos Magdalena Servente 203

ANEXO B

CONJUNTOS DE DATOS

En este Anexo se detallan los conjuntos de datos utilizados para realizar las pruebas descriptas en

el Capítulo 5. Para cada uno de los dominios, se muestran los conjuntos de datos de

entrenamiento y prueba. Los datos presentados corresponden a los siguientes dominios: Créditos

(Sección B.1), Cardiología (Sección B.2), Votaciones (Sección B.3), Estudio sobre hongos

(Sección B.4), Elita: Base de Asteroides (Sección B.5), Hipotiroidismo (Sección B.6),

Identificación de vidrios (Sección B.7).

Los datos del anexo B se encuentran en el CD que acompaña este trabajo. Están divididos en archivos

según los dominios a los que pertenecen:

• Créditos: AnexoB-Creditos.doc

• Cardiología: AnexoB-Cardiologia.doc

• Votaciones: AnexoB-Votaciones.doc

• Estudio sobre hongos: AnexoB-Hongos.doc

• Elita: Base de Asteroides: AnexoB-Asteroides.doc

• Hipotiroidismo: AnexoB-Hipotiroidismo.doc

• Identificación de vidrios: AnexoB-Vidrios.doc.


204 Magdalena Servente Conjuntos de datos


Documentación del sistema Magdalena Servente 205

ANEXO C

DOCUMENTACIÓN DEL SISTEMA

Este anexo es un complemento a la explicación de la funcionalidad del sistema de la Sección 4.5.

En la sección C.1 se detalla la interacción entre los módulos del sistema. Las principales

funciones de cada uno de estos módulos se presentan en la sección C.2. En la sección C.3 se

detallan las principales estructuras de datos utilizadas por el sistema.

C.1. INTERACCIÓN DE LOS MÓDULOS

El sistema está compuesto básicamente por diez módulos o formularios (archivos de extensión cpp),

complementados por cuatro archivos de definiciones de tipos (archivos de extensión h y cpp) y un archivo

de arranque del sistema (Archivo de extensión cpp). Este último es el primero que corre al iniciar el

programa y es quien inicializa los demás módulos.

Existe un módulo principal, el Uprincipal, desde donde se realizan los llamados a los demás módulos.

Este módulo es el formulario principal con el cual interactúa el usuario. El corazón del sistema reside en

los módulos UDMID3 y UDMC45, quienes aplican el ID3 y el C4.5 respectivamente.

La figura C.1 detalla la interacción entre los módulos del sistema. Las flechas representan los mensajes

entre ellos. Hemos divididos los módulos en cuatro grupos: módulos de pantallas principales, módulos de

opciones generales, módulos de Minería de Datos y módulos de clases de datos. Los módulos de pantallas

principales son aquellos que representan la pantalla principal y el menú de acceso rápido. Su objetivo es

llamar a los otros módulos para llevar a cabo las acciones que el usuario indica en los menúes. Los

módulos de opciones generales son aquellos módulos que realizan todas las operaciones comunes al ID3

y al C4.5, como el cambio de la tabla de datos, el cambio del criterio de decisión utilizado por defecto, o

la elección de la tabla sobre la cual se desea evaluar el rendimiento, entre otros. Por otro lado, los

módulos de Minería de Datos son aquellos que construyen los árboles y las reglas de decisión a partir de

las tablas, para ello utilizan las estructuras de datos definidas en los módulos de clases de datos.

El módulo TDIDT no pertenece a ninguno de estos grupos ya es el módulo de inicio del programa.

Las funciones principales de cada uno de estos módulos se detallan en la Sección C.2.


206 Magdalena Servente Documentación del sistema

Figura C.1:Esquema de la interacción de los módulos del sistema

C.2. DESCRIPCIÓN DE LOS ARCHIVOS FUENTE

C.2.1. TDIDT.cpp

Es el módulo inicial del sistema. Inicializa las variables de entorno Windows, las librerías estándar y el

módulo de la Uprincipal, el módulo UinfoGral y el módulo DMID3.

Módulos de pantallas principales

Módulos de Minería de Datos

Módulos de Opciones Generales

frmOpcionesSist

TDIDT.cpp

UArbolUBD UCambioTabla

UDMC45

UElegirRendimiento

UDMID3

UInfoGral

UPrincipal

URendimiento

Módulos de clases de datos

defns.h Rulex.h Types.hUTipos

Inicializar

Inicializar

Utilización Utilización

Mostrar Tabla

Inicializar

Aplicarmétodo

Cambiar Tabla

DeterminarPreferencias

EvaluarRendimiento

EvaluarRendimiento

EvaluarRendimiento

Aplicar ID3 Aplicar C4.5

Mostrar árbol Mostrar ÁrbolMostrarrendimiento

Mostrarrendimiento



C.2.2. Módulos de pantallas principales

C.2.2.1. UPrincipal

Este módulo administra el menú del sistema y transforma los clics del usuario en llamados a los

procedimientos correspondientes.

C.2.2.2. UInfoGral

Este es un menú de acceso rápido que aparece apenas se inicia el programa. El usuario puede elegir

aplicar el ID3 o el C4.5 en las opciones previamente elegidas por defecto.

C.2.3. Módulos de opciones generales

C.2.3.1. UBD

Lista por pantalla todos los casos de la tabla sobre la cual se está trabajando. Es un módulo de consulta

para el usuario.

C.2.3.2. UCambioTabla

Lista todos los datos de la tabla sobre la cual se está trabajando por pantalla. Permite que el usuario

seleccione otra tabla sobre la cual trabajar, y permite determinar la clase de los datos, es decir, el campo

de tabla que cumple la función de clasificador.

Si el usuario aplica los cambios, la elección de la tabla y del campo clasificador serán guardadas como

elecciones por defecto. En cambio, si el usuario acepta los cambios, la tabla y el campo escogidos serán

utilizados hasta que se cierre el programa o hasta que el usuario modifique su elección.

C.2.3.3. frmOpcionesSist

En esta pantalla el usuario puede modificar las opciones por defecto del sistema. Estas opciones son el

método (ID3 o C4.5) aplicado con mayor preferencia, el criterio de decisión (ganancia o proporción de



ganancia) utilizado y la poda o no por defecto. Estas opciones se utilizan cuando el usuario realiza la

Minería de Datos a través del menú de acceso rápido detallado en la Sección C.2.2.2.

C.2.3.4. UElegirRendimiento

Cuando el usuario desea evaluar el rendimiento de alguno de los modelos generados con el sistema,

deberá entrar en este módulo para elegir la tabla sobre la que desea trabajar y la fecha y hora en que se

generó el modelo que está tratando de evaluar. Una vez que el usuario ha determinado todos estos datos,

se realiza la evaluación del rendimiento del modelo escogido.

C.2.3.5. URendimiento

Muestra por pantalla la matriz de evaluación del rendimiento del modelo escogido por el usuario en la

pantalla descripta en la sección C.2.3.4. La matriz de evaluación muestra, para cada clase, la cantidad de

casos que fueron evaluados correctamente y la cantidad de casos que fueron evaluados incorrectamente,

según lo descripto en el Capítulo 5.

C.2.3.6. UArbol

Este módulo muestra el árbol obtenido por pantalla. El usuario puede guardar este árbol en el archivo de

texto de su preferencia.

C.2.4. Módulos de minería de datos

C.2.4.1. UDMID3

Este módulo agrupa todas las funciones necesarias para aplicar el ID3 a una tabla. Se utiliza tanto para

generar el árbol de decisión como para construir las reglas de decisión y evaluar los modelos obtenidos.



C.2.4.2. UDMC45

Al igual que el módulo anterior, este módulo agrupa todas las funciones necesarias para aplicar el C4.5 a

una tabla. Genera el árbol y las reglas de decisión, y evalúa los modelos generados.

C.2.5. Módulos de clases de datos

C.2.5.1. UTipos

En este modulo se definen todos los tipos de datos propios del sistema, principalmente aquellos utilizados

por el ID3.

C.2.5.2. Types.h

En este modulo se definen todos los principales tipos de datos utilizados en el C4.5.

C.2.5.3. Defns.h

Este módulo complementa al anterior, y define aún más tipos de datos utilizados por el C4.5.

C.2.5.4. Rulex.h

En este modulo se definen los tipos de datos necesarios para aplicar el C4.5

C.3. ESTRUCTURAS DE DATOS

C.3.1. Estructuras de datos generales

La clase Tparams es una clase general que guarda todos los parámetros necesarios para aplicar el C4.5 y

el ID3. Su estructura se detalla a continuación:



class TParametros public: AnsiString ArchivoIni; AnsiString NombreBD; AnsiString TablaBD; AnsiString TablaReglas; AnsiString ColClasificador; AnsiString ExtensionFileReglas; TStringList *LClasificadores; int iFormatoReglas; /* 0: Insight2+ 1: KappaPC 2: ambos 3: ninguno*/ int iSistema; /* 0: ID3 1: C4.5 */ int iCriterio; /* 0: Ganancia 1: Proporción de ganancia */ int iPoda; /* 0: Si 1: No */ int iConjuntos; /* indica si las pruebas en el C4.5 se realizan sobre grupos de atributos discretos 0: Si 1: No */ int iMinObjs; /* Cantidad mínima de objetos que debe tener una rama en el C4.5 */ int iCF; /* Nivel de confianza para la poda en el C4.5 */

TParametros(AnsiString ArchIni); //constructor //Toma los parámetros del archivo .ini ~TParametros(); //destructor

//Refresca los parámetros a partir del archivo .ini /*Devuelve 0 si no hubo problemas, -1 en caso contrario*/ int RefrescarParams(); //Guardar los parámetros en el .ini /*Devuelve 0 si no hubo problemas, -1 en caso contrario*/ int GrabarParams(); ;

C.3.2. Estructuras de datos del ID3

La estructura principal utilizada por el ID3 es el árbol de decisión, implementado mediante el uso de

punteros. Cada nodo del árbol de decisión contiene un indicador para determinar si es una hoja o un nodo,

indica el descriptor que está evaluando, con sus valores válidos, y tiene un vector de punteros a sus nodos

hijos. La declaración de este tipo de datos se muestra a continuación.

typedef struct tree_node *tree_ptr;

struct tree_node short int flag_hoja; /* 0 si es hoja y todos los valores son "Yes" 1 si es hoja y todos los valores son "No" 2 si es hoja y sus valores son mixtos 3 si no es hoja*/ int desc;

tree_ptr pHijos[MAX_HIJOS]; //hijo derecho short int D[MAX_CANT_DESCRIPTORES];/*Descriptores válidos para el nodo*/ ;

typedef tree_ptr DECISION_TREE;



C.3.4. Estructuras de datos del C4.5

La estructura del árbol utilizada en el C4.5 es similar a la detallada para el ID3 aunque tiene una mayor

cantidad de objetos, necesarios para trabajar con atributos continuos. La definición de esta estructura de

datos se encuentra a continuación.

typedef struct tree_record *Tree;struct tree_record

short NodeType; /* 0=hoja 1=rama 2=corte 3=subconj */ ClassNo Leaf; /* clase más frecuente del nodo */ ItemCount Items, /* nro de items en el nodo */

*ClassDist, /* distrib de clase de los items */ Errors; /* nro de errores en el nodo */ Attribute Tested; /* atribute referenciado en la prueba */ short Forks; /* nro de ramas en el nodo */ float Cut, /* límite para los atrib continuos */

Lower, /* límite inferior del valor límite */ Upper; /* límite superior del valor límite */

Conjunto *Subset; /* subconj de valores discretos */ Tree *Branch; /* Branch[x] = (sub)árbol para el resultado x */ ;

typedef Tree DECISION_TREE_C45;


Código Fuente Magdalena Servente 213

ANEXO D

CÓDIGO FUENTE

En este anexo se presenta el código fuente del sistema desarrollado. En la sección D.1 se

presenta el código fuente del archivo TDIDT.cpp que es el archivo inicial del proyecto y es quien

inicializa al resto de los formularios requeridos. En la sección D.2 se presenta el código fuente de

las pantallas principales. A continuación, se detallan los códigos fuentes de los módulos de

opciones generales (Sección D:3), de los módulos de minería de datos (Sección D.4) y de los

módulos de clases o estructuras de datos (Sección D.5)

D.1. TDIDT.CPP

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstopUSERES("TDIDT.res");USEFORM("UPrincipal.cpp", FormPrincipal);USEFORM("UArbol.cpp", frm_Arbol);USEFORM("UDMID3.cpp", DMID3); /* TDataModule: DesignClass */USEUNIT("UTipos.cpp");USEFORM("UBD.cpp", frmBD);USEFORM("frmOpcionesSist.cpp", frmOpciones);USEFORM("UInfoGral.cpp", frmInfoGral);USEFORM("URendimiento.cpp", FrmRendimiento);USEFORM("UElegirRendimiento.cpp", frmElegirRendimiento);USEFORM("UCambioTabla.cpp", frmCambioTabla);USEFILE("C45\defns.h");USEFILE("C45\TYPES.h");USEFORM("C45\UDMC45.cpp", DMC45); /* TDataModule: DesignClass */USEFILE("C45\Rulex.h");//---------------------------------------------------------------------------WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int) try Application->Initialize(); Application->CreateForm(__classid(TDMID3), &DMID3); Application->CreateForm(__classid(TFormPrincipal), &FormPrincipal); Application->CreateForm(__classid(TfrmInfoGral), &frmInfoGral); Application->Run(); catch (Exception &exception) Application->ShowException(&exception); return 0;


214 Magdalena Servente Código Fuente

D.2. MÓDULOS DE PANTALLAS PRINCIPALES

D.2.1. UPrincipal

D.2.1.1. UPrincipal.h

//---------------------------------------------------------------------------#ifndef UPrincipalH#define UPrincipalH//---------------------------------------------------------------------------#include <Classes.hpp>#include <Menus.hpp>

#include "frmOpcionesSist.h"#include "UDMID3.h"#include "UArbol.h"#include "UBD.h"#include "UInfoGral.h"#include "UElegirRendimiento.h"#include "URendimiento.h"#include "UCambioTabla.h"#include "UDMC45.h"

//---------------------------------------------------------------------------class TFormPrincipal : public TForm__published: // IDE-managed Components TMainMenu *MenuPpal; TMenuItem *mnuGral; TMenuItem *mnuSep; TMenuItem *mnu_Salir; TMenuItem *mnuID3; TMenuItem *mnuC45; TMenuItem *mnuID3G; TMenuItem *mnuID3GR; TMenuItem *mnuC45G; TMenuItem *mnuC45GR; TMenuItem *mnuAyuda; TMenuItem *mnuHelpIndex; TMenuItem *mnuSep3; TMenuItem *mnuAcercaDe; TMenuItem *mnuEvaluacion; TMenuItem *mnuEvalID3; TMenuItem *mnuEvalC45; TMenuItem *mnuOpciones; TMenuItem *mnuTabla; TMenuItem *mnuCambiarTabla; TMenuItem *mnuParametros; void __fastcall FormCreate(TObject *Sender); void __fastcall FormClose(TObject *Sender, TCloseAction &Action); void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose); void __fastcall mnu_ID3GainClick(TObject *Sender); void __fastcall mnu_ID3GainRatioClick(TObject *Sender); void __fastcall mnu_SalirClick(TObject *Sender); void __fastcall mnuID3GClick(TObject *Sender); void __fastcall mnuID3GRClick(TObject *Sender); void __fastcall FormShow(TObject *Sender); void __fastcall mnuEvalID3Click(TObject *Sender); void __fastcall mnuTablaClick(TObject *Sender); void __fastcall mnuParametrosClick(TObject *Sender); void __fastcall mnuCambiarTablaClick(TObject *Sender); void __fastcall mnuEvalC45Click(TObject *Sender); void __fastcall mnuC45GClick(TObject *Sender); void __fastcall mnuC45GRClick(TObject *Sender);private: TParametros *Params;public: __fastcall TFormPrincipal(TComponent* Owner);// void ActualizarParametros(TStringList *ListaParam); /* Esta función actualiza los parámetros del formulario La lista de parámetros debe tener el siguiente orden: ExtensionArchivoReglas; AliasBD; TablaBD ColClasificador; Lista de Clasificadores*/



void ID3(short int MedidorGanancia); //llama al algoritmo ID3 sobre la tablaactual int EvalRendimiento; //indica si el usuario desea evaluar el rendimiento de unacorrida o no;

//---------------------------------------------------------------------------

extern PACKAGE TFormPrincipal *FormPrincipal;//---------------------------------------------------------------------------#endif

D.2.1.1. UPrincipal.cpp

//---------------------------------------------------------------------------#pragma hdrstop

#include "UPrincipal.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TFormPrincipal *FormPrincipal;Tfrm_Arbol *frm_Arbol;TfrmOpciones *frmOpciones;TfrmElegirRendimiento *frmElegirRendimiento;TFrmRendimiento *FrmRendimiento;TfrmBD *frmBD;TfrmCambioTabla *frmCambioTabla;//-----------------------------------------------------------------------------//-----------------------------------------------------------------------------// IMPLEMENTACION//-----------------------------------------------------------------------------//-----------------------------------------------------------------------------

__fastcall TFormPrincipal::TFormPrincipal(TComponent* Owner) : TForm(Owner) Params=new TParametros("Gap.ini");

//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::FormCreate(TObject *Sender) DMID3->RecibirParametros(Params);//---------------------------------------------------------------------------void __fastcall TFormPrincipal::FormClose(TObject *Sender, TCloseAction &Action) delete Params;//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::FormCloseQuery(TObject *Sender, bool &CanClose)int rta;

rta=MessageBox(FormPrincipal->Handle, "¿Está seguro de que desea salir de laaplicación?", "Tesis", MB_ICONQUESTION|MB_YESNO|MB_DEFBUTTON1|MB_SYSTEMMODAL); if (rta==IDNO) //el usuario no desea salir de la aplicación CanClose=false;//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnu_ID3GainClick(TObject *Sender) ID3(0);



//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnu_ID3GainRatioClick(TObject *Sender) ID3(1);//---------------------------------------------------------------------------void TFormPrincipal::ID3(short int MedidorGanancia)tree_ptr pRoot;TVecValores VecVal, VecDesc;int i;

Cursor=crHourGlass; DMID3->RecibirParametros(Params); pRoot=DMID3->Principal(MedidorGanancia); DMID3->PruneTree(pRoot); DMID3->InformarValores(VecVal); DMID3->InformarDescrip(VecDesc);

frm_Arbol= new Tfrm_Arbol(this); frm_Arbol->Cursor=crHourGlass; frm_Arbol->RecibirParametros(Params->LClasificadores,VecVal,VecDesc); frm_Arbol->PrintTree(pRoot); DMID3->ArmarReglas(pRoot); DMID3->EliminarTree(pRoot); free(pRoot);

frm_Arbol->Cursor=crArrow; FormPrincipal->Cursor=crArrow;

for (i=0;i<MAX_NIVELES;i++) VecVal[i].~AnsiString(); VecDesc[i].~AnsiString();

//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnu_SalirClick(TObject *Sender) FormPrincipal->Close();//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuID3GClick(TObject *Sender) ID3(0);//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuID3GRClick(TObject *Sender) ID3(1);

void __fastcall TFormPrincipal::FormShow(TObject *Sender) frmInfoGral->RecibirParametros(Params->TablaBD,Params->ColClasificador,Params->iCriterio);//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuEvalID3Click(TObject *Sender) EvalRendimiento=0; frmElegirRendimiento= new TfrmElegirRendimiento(this); frmElegirRendimiento->ActualizarDatos(0,Params->NombreBD); frmElegirRendimiento->ShowModal();

if (EvalRendimiento==0) FrmRendimiento= new TFrmRendimiento(this); FrmRendimiento->Cursor=crHourGlass;



DMID3->EvaluarReglas(frmElegirRendimiento->CodigoReglas);

FrmRendimiento->Cursor=crArrow; //---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuTablaClick(TObject *Sender) frmBD=new TfrmBD(this); frmBD->RecibirParametros(Params);//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuParametrosClick(TObject *Sender) frmOpciones=new TfrmOpciones(this); frmOpciones->RecibirParametros(Params); frmOpciones->Show();//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuCambiarTablaClick(TObject *Sender) frmCambioTabla=new TfrmCambioTabla(this); frmCambioTabla->RecibirParametros(Params); frmCambioTabla->Show();//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuEvalC45Click(TObject *Sender) EvalRendimiento=0; frmElegirRendimiento= new TfrmElegirRendimiento(this); frmElegirRendimiento->ActualizarDatos(0,Params->NombreBD); frmElegirRendimiento->ShowModal();

if (EvalRendimiento==0) FrmRendimiento= new TFrmRendimiento(this); FrmRendimiento->Cursor=crHourGlass;

DMC45->EvaluacionRendimiento();

FrmRendimiento->Cursor=crArrow; //---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuC45GClick(TObject *Sender) Params->iCriterio=0; DMC45->RecibirParametros(Params); DMC45->C45();//---------------------------------------------------------------------------

void __fastcall TFormPrincipal::mnuC45GRClick(TObject *Sender) Params->iCriterio=1; DMC45->RecibirParametros(Params); DMC45->C45();//---------------------------------------------------------------------------

D.2.2. UInfoGral

D.2.2.1. UInfoGral.h

//---------------------------------------------------------------------------#ifndef UInfoGralH#define UInfoGralH



//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <Buttons.hpp>#include "UPrincipal.h"

//---------------------------------------------------------------------------class TfrmInfoGral : public TForm__published: // IDE-managed Components TLabel *lblTabla; TLabel *lblClase; TEdit *txtClase; TEdit *txtTabla; TBitBtn *BtnC45; TBitBtn *BtnID3; void __fastcall FormClose(TObject *Sender, TCloseAction &Action); void __fastcall BtnID3Click(TObject *Sender);private: short MedidorGanancia;public: __fastcall TfrmInfoGral(TComponent* Owner); void RecibirParametros(AnsiString tabla, AnsiString clase, short Ganancia);;//---------------------------------------------------------------------------extern PACKAGE TfrmInfoGral *frmInfoGral;//---------------------------------------------------------------------------#endif

D.2.2.2. UInfoGral.cpp

//---------------------------------------------------------------------------#pragma hdrstop

#include "UInfoGral.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TfrmInfoGral *frmInfoGral;//---------------------------------------------------------------------------__fastcall TfrmInfoGral::TfrmInfoGral(TComponent* Owner) : TForm(Owner)//---------------------------------------------------------------------------void __fastcall TfrmInfoGral::FormClose(TObject *Sender, TCloseAction &Action) Action = caFree;//---------------------------------------------------------------------------

void TfrmInfoGral::RecibirParametros(AnsiString tabla, AnsiString clase, short Ganancia) txtTabla->Text=tabla; txtClase->Text=clase; MedidorGanancia=Ganancia; void __fastcall TfrmInfoGral::BtnID3Click(TObject *Sender) TFormPrincipal *pForm;

pForm=FormPrincipal; pForm->Cursor=crHourGlass; pForm->ID3(MedidorGanancia); pForm->Cursor=crArrow;//---------------------------------------------------------------------------



D.3. MÓDULOS DE OPCIONES GENERALES

D.3.1. UBD

D.3.1.1. UBD.h

//---------------------------------------------------------------------------#ifndef UBDH#define UBDH//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <Db.hpp>#include <DBGrids.hpp>#include <DBTables.hpp>#include <Grids.hpp>

#include "UDMID3.h"//---------------------------------------------------------------------------class TfrmBD : public TForm__published: // IDE-managed Components TDBGrid *DBGrid; TDataSource *DSTabla; TTable *Tabla; void __fastcall FormClose(TObject *Sender, TCloseAction &Action);private: /*Parámetros de la base sobre la que trabajaremos*/ TParametros *Params;public: __fastcall TfrmBD(TComponent* Owner); void RecibirParametros(TParametros *Parametros);;//---------------------------------------------------------------------------extern PACKAGE TfrmBD *frmBD;//---------------------------------------------------------------------------#endif

D.3.1.2. UBD.cpp

//---------------------------------------------------------------------------#pragma hdrstop

#include "UBD.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TfrmBD *frmBD;//---------------------------------------------------------------------------__fastcall TfrmBD::TfrmBD(TComponent* Owner) : TForm(Owner)//---------------------------------------------------------------------------void __fastcall TfrmBD::FormClose(TObject *Sender, TCloseAction &Action) Action = caFree;//---------------------------------------------------------------------------

void TfrmBD::RecibirParametros(TParametros *Parametros) Params=Parametros;

Tabla->DatabaseName=Params->NombreBD; Tabla->TableName=Params->TablaBD; Tabla->Active=true;



D.3.2. UCambioTabla

D.3.2.1. UCambioTabla.h

//---------------------------------------------------------------------------#ifndef UCambioTablaH#define UCambioTablaH//---------------------------------------------------------------------------#include <Buttons.hpp>#include <Classes.hpp>#include <Controls.hpp>#include <Db.hpp>#include <DBGrids.hpp>#include <DBTables.hpp>#include <Dialogs.hpp>#include <Grids.hpp>#include <StdCtrls.hpp>

#include "UTipos.h"#include "UDMID3.h"#include "UInfoGral.h"

//---------------------------------------------------------------------------class TfrmCambioTabla : public TForm__published: // IDE-managed Components TDBGrid *DBGrid; TDataSource *DSTabla; TTable *Tabla; TEdit *txt_Tabla; TBitBtn *Btn_fod; TOpenDialog *fod_TablaBD; TLabel *lbl_TablaBD; TLabel *lbl_nbeColClasif; TComboBox *cbo_ColClasif; TBitBtn *btn_Aceptar; TBitBtn *btn_Cancelar; TBitBtn *btn_Aplicar; void __fastcall FormClose(TObject *Sender, TCloseAction &Action); void __fastcall Btn_fodClick(TObject *Sender); void __fastcall btn_CancelarClick(TObject *Sender); void __fastcall btn_AceptarClick(TObject *Sender); void __fastcall btn_AplicarClick(TObject *Sender); void __fastcall txt_TablaChange(TObject *Sender); void __fastcall cbo_ColClasifChange(TObject *Sender);private: /*Parámetros de la base sobre la que trabajaremos*/ TParametros *Params; void CargarCombo(); int ActualizarCambios(); /*Devuelve: 0: si los cambios fueron exitosos 1: si hubo problemas*/public: __fastcall TfrmCambioTabla(TComponent* Owner); void RecibirParametros(TParametros *Parametros);;//---------------------------------------------------------------------------extern PACKAGE TfrmCambioTabla *frmCambioTabla;//---------------------------------------------------------------------------#endif

D.3.2.2. UCambioTabla.cpp

//---------------------------------------------------------------------------#pragma hdrstop

#include "UCambioTabla.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"



TfrmCambioTabla *frmCambioTabla;//---------------------------------------------------------------------------__fastcall TfrmCambioTabla::TfrmCambioTabla(TComponent* Owner) : TForm(Owner)//---------------------------------------------------------------------------void __fastcall TfrmCambioTabla::FormClose(TObject *Sender, TCloseAction &Action) Action = caFree;//---------------------------------------------------------------------------void TfrmCambioTabla::RecibirParametros(TParametros *Parametros) Params=Parametros;

//Cargamos los datos relacionados con la Base de Datos fod_TablaBD->FileName=Params->TablaBD; txt_Tabla->Text=Params->TablaBD; Tabla->TableName=Params->TablaBD; Tabla->DatabaseName=Params->NombreBD; Tabla->Active=true; CargarCombo(); btn_Aplicar->Enabled=false;

//---------------------------------------------------------------------------void __fastcall TfrmCambioTabla::Btn_fodClick(TObject *Sender)bool res;int index;AnsiString TablaBD;

res=fod_TablaBD->Execute(); if (res) TablaBD=fod_TablaBD->FileName; index=TablaBD.LastDelimiter("\\"); TablaBD=TablaBD.SubString(index+1,TablaBD.Length()-index); txt_Tabla->Text=TablaBD; Tabla->Active=false; Tabla->TableName=TablaBD; Tabla->Active=true; cbo_ColClasif->Clear(); CargarCombo(); TablaBD.~AnsiString();//---------------------------------------------------------------------------void __fastcall TfrmCambioTabla::btn_CancelarClick(TObject *Sender) Close();//---------------------------------------------------------------------------

void __fastcall TfrmCambioTabla::btn_AceptarClick(TObject *Sender) if (ActualizarCambios()==0) Close();//---------------------------------------------------------------------------void TfrmCambioTabla::CargarCombo()TStringList *listaCpos = new TStringList();int i;bool fin; Tabla->GetFieldNames(listaCpos); cbo_ColClasif->Items->AddStrings(listaCpos); i=0; while (i<=cbo_ColClasif->Items->Count) if (AnsiCompareText(cbo_ColClasif->Items->Strings[i].Trim(),"NIVEL")==0) cbo_ColClasif->Items->Delete(i); else



i++;

fin=false; i=0; while (i<=cbo_ColClasif->Items->Count && !fin) if (AnsiCompareText(cbo_ColClasif->Items->Strings[i].Trim(),Params->ColClasificador.Trim())==0) cbo_ColClasif->ItemIndex=i; fin=true; i++; delete(listaCpos);

//---------------------------------------------------------------------------int TfrmCambioTabla::ActualizarCambios() /*Devuelve: 0: si los cambios fueron exitosos 1: si hubo problemas*/AnsiString TablaAnterior;AnsiString sqlstring;TQuery *QValoresClasif=new TQuery(frmCambioTabla);int res;

try res=0; if (Params->TablaBD!=txt_Tabla->Text) //actualizamos los datos de la tabla Params->TablaBD=txt_Tabla->Text; TablaAnterior=DMID3->TTennis->TableName; DMID3->TTennis->Active=false; DMID3->TTennis->DatabaseName=Params->NombreBD; DMID3->TTennis->TableName=Params->TablaBD; DMID3->TTennis->Active=true;

//Inicializamos los queries que harán sus consultas sobre la base //especificada DMID3->QGral->DatabaseName=Params->NombreBD;

//Inicializamos el campo Nivel en la Tabla sqlstring="Update "; AppendStr(sqlstring, Params->TablaBD); AppendStr(sqlstring," SET Nivel = 0 "); DMID3->QGral->SQL->Clear(); DMID3->QGral->SQL->Add(sqlstring); DMID3->QGral->ExecSQL(); DMID3->QGral->SQL->Clear(); DMID3->TTennis->Close(); DMID3->TTennis->Open();

if (Params->ColClasificador!=cbo_ColClasif->Text) //Cambiamos la columna del clasificador if (cbo_ColClasif->Text.Trim()=="") ShowMessage("El nombre de la Columna del Clasificador no puedequedar en blanco"); cbo_ColClasif->SetFocus(); res=1; else Params->ColClasificador=cbo_ColClasif->Text; //Actualizamos la lista de Clasificadores sqlstring="SELECT DISTINCT(" + Params->ColClasificador + ") asClasif FROM " + Params->TablaBD; QValoresClasif->DatabaseName=Params->NombreBD; QValoresClasif->SQL->Clear(); QValoresClasif->SQL->Add(sqlstring); QValoresClasif->Open();



QValoresClasif->Last(); QValoresClasif->First(); Params->LClasificadores->Clear(); while (!QValoresClasif->Eof) Params->LClasificadores->Add(QValoresClasif->FieldByName("Clasif")->AsString); QValoresClasif->Next(); res=0; frmInfoGral->RecibirParametros(Params->TablaBD,Params->ColClasificador,Params->iCriterio); catch(...) ShowMessage("Problemas con la Base de Datos, no podrá cambiar de tabla");

//Restauramos los valores anteriores DMID3->TTennis->Active=false; DMID3->TTennis->DatabaseName=Params->NombreBD; Params->TablaBD=TablaAnterior; DMID3->TTennis->TableName=Params->TablaBD; DMID3->TTennis->Active=true;

//Inicializamos los queries que harán sus consultas sobre la base //especificada DMID3->QGral->DatabaseName=Params->NombreBD;

cbo_ColClasif->Clear(); CargarCombo(); res=1; sqlstring.~AnsiString(); TablaAnterior.~AnsiString(); delete(QValoresClasif); return(res);

//---------------------------------------------------------------------------void __fastcall TfrmCambioTabla::btn_AplicarClick(TObject *Sender) ActualizarCambios(); Params->GrabarParams(); btn_Aplicar->Enabled=false;

void __fastcall TfrmCambioTabla::txt_TablaChange(TObject *Sender) btn_Aplicar->Enabled=true;//---------------------------------------------------------------------------

void __fastcall TfrmCambioTabla::cbo_ColClasifChange(TObject *Sender) btn_Aplicar->Enabled=true;//---------------------------------------------------------------------------

D.3.3. frmOpcionesSist

D.3.3.1. frmOpcionesSist.h

//---------------------------------------------------------------------------#ifndef frmOpcionesSistH#define frmOpcionesSistH//---------------------------------------------------------------------------#include <Buttons.hpp>#include <Classes.hpp>



#include <Controls.hpp>#include <ExtCtrls.hpp>#include <StdCtrls.hpp>

#include "UPrincipal.h"#include "UTipos.h"//--------------------------------------------------------------------------class TfrmOpciones : public TForm__published: // IDE-managed Components TRadioGroup *rgSistema; TRadioGroup *rgCriterio; TRadioGroup *rgPoda; TBitBtn *btn_Aplicar; TBitBtn *btn_Cancelar; TBitBtn *btn_Aceptar; void __fastcall FormClose(TObject *Sender, TCloseAction &Action); void __fastcall btn_CancelarClick(TObject *Sender); void __fastcall btn_AceptarClick(TObject *Sender); void __fastcall btn_AplicarClick(TObject *Sender);private: // User declarations TParametros *Params;public: // User declarations __fastcall TfrmOpciones(TComponent* Owner); void RecibirParametros(TParametros *Parametros);;//---------------------------------------------------------------------------extern PACKAGE TfrmOpciones *frmOpciones;//---------------------------------------------------------------------------#endif

D.3.3.2. frmOpcionesSist.cpp

//---------------------------------------------------------------------------#pragma hdrstop

#include "frmOpcionesSist.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TfrmOpciones *frmOpciones;

//---------------------------------------------------------------------------__fastcall TfrmOpciones::TfrmOpciones(TComponent* Owner) : TForm(Owner)//---------------------------------------------------------------------------

void __fastcall TfrmOpciones::FormClose(TObject *Sender, TCloseAction &Action) Action = caFree;//---------------------------------------------------------------------------void TfrmOpciones::RecibirParametros(TParametros *Parametros) Params=Parametros;

//Cargamos los datos del sistema rgSistema->ItemIndex=Params->iSistema;

//Cargamos los datos del Criterio de Evaluación rgCriterio->ItemIndex=Params->iCriterio;

//Cargamos los datos de la poda rgPoda->ItemIndex=Params->iPoda;

void __fastcall TfrmOpciones::btn_CancelarClick(TObject *Sender)



Close();//---------------------------------------------------------------------------

void __fastcall TfrmOpciones::btn_AceptarClick(TObject *Sender) int cerrar; int rta;

cerrar=0; Params->iSistema=rgSistema->ItemIndex; Params->iCriterio=rgCriterio->ItemIndex; Params->iPoda=rgPoda->ItemIndex; Params->iFormatoReglas=1; if (cerrar==0) Close();

//---------------------------------------------------------------------------

void __fastcall TfrmOpciones::btn_AplicarClick(TObject *Sender) Params->iSistema=rgSistema->ItemIndex; Params->iCriterio=rgCriterio->ItemIndex; Params->iPoda=rgPoda->ItemIndex; Params->iFormatoReglas=1; Params->GrabarParams();

//---------------------------------------------------------------------------

D.3.4. UElegirRendimiento

D.3.4.1. UElegirRendimiento.h

//---------------------------------------------------------------------------#ifndef UElegirRendimientoH#define UElegirRendimientoH//---------------------------------------------------------------------------#include <Classes.hpp>#include <Controls.hpp>#include <StdCtrls.hpp>#include <ExtCtrls.hpp>#include <Buttons.hpp>#include <DBTables.hpp>#include <Dialogs.hpp>

#include "UPrincipal.h"//---------------------------------------------------------------------------class TfrmElegirRendimiento : public TForm__published: // IDE-managed Components TRadioGroup *rgCorrida; TGroupBox *gbSeleccionar; TLabel *lblTabla; TLabel *lblFecha; TComboBox *cbTabla; TComboBox *cbFecha; TBitBtn *btn_Cancelar; TBitBtn *btn_Aceptar; void __fastcall FormClose(TObject *Sender, TCloseAction &Action); void __fastcall btn_CancelarClick(TObject *Sender); void __fastcall rgCorridaClick(TObject *Sender); void __fastcall btn_AceptarClick(TObject *Sender); void __fastcall cbTablaChange(TObject *Sender);private: AnsiString Base; int Tipo; void CargarCboFechora();public: int CodigoReglas; __fastcall TfrmElegirRendimiento(TComponent* Owner);



void ActualizarDatos(int iTipo, AnsiString NombreBD); /* iTipo 0: ID3 1:C4.5*/;//---------------------------------------------------------------------------extern PACKAGE TfrmElegirRendimiento *frmElegirRendimiento;//---------------------------------------------------------------------------#endif

D.3.4.2. UElegirRendmiento.cpp

//---------------------------------------------------------------------------#pragma hdrstop#include "UElegirRendimiento.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TfrmElegirRendimiento *frmElegirRendimiento;

//---------------------------------------------------------------------------__fastcall TfrmElegirRendimiento::TfrmElegirRendimiento(TComponent* Owner) : TForm(Owner)//---------------------------------------------------------------------------void __fastcall TfrmElegirRendimiento::FormClose(TObject *Sender, TCloseAction &Action) Action = caFree;//---------------------------------------------------------------------------void __fastcall TfrmElegirRendimiento::btn_CancelarClick(TObject *Sender) FormPrincipal->EvalRendimiento=1; Close();//---------------------------------------------------------------------------void __fastcall TfrmElegirRendimiento::rgCorridaClick(TObject *Sender) if (rgCorrida->ItemIndex==1) gbSeleccionar->Enabled=true; else gbSeleccionar->Enabled=false;//---------------------------------------------------------------------------

void TfrmElegirRendimiento::ActualizarDatos(int iTipo, AnsiString NombreBD)TQuery *QTabla=new TQuery(frmElegirRendimiento);AnsiString sqlstring;

try Base=NombreBD; Tipo=iTipo;

QTabla->DatabaseName=NombreBD;

sqlstring="SELECT distinct(Nombre_Tabla) FROM UpdatesHeader.db WHERE Metodo='"; if (iTipo==0) AppendStr(sqlstring,"ID3'"); else AppendStr(sqlstring,"C45'"); AppendStr(sqlstring,"ORDER BY Nombre_Tabla");

QTabla->SQL->Clear(); QTabla->SQL->Add(sqlstring); QTabla->Open();

QTabla->First(); while (!QTabla->Eof) cbTabla->Items->Add(QTabla->FieldByName("Nombre_Tabla")->AsString);



QTabla->Next();

cbTabla->ItemIndex=0; CargarCboFechora();

sqlstring.~AnsiString(); delete(QTabla); catch(...) ShowMessage("No se pudieron obtener los datos de la tabla de evaluación"); sqlstring.~AnsiString(); delete(QTabla);//---------------------------------------------------------------------------void __fastcall TfrmElegirRendimiento::btn_AceptarClick(TObject *Sender)TQuery *QTabla=new TQuery(frmElegirRendimiento);AnsiString sqlstring;

try QTabla->DatabaseName=Base; if (rgCorrida->ItemIndex==0) /* sqlstring="SELECT Max(Codigo)as Codigo FROM UpdatesHeader.db WHERENombre_Tabla='" + cbTabla->Text +"' AND Metodo='"; */ sqlstring="SELECT Max(Codigo) as Codigo FROM UpdatesHeader.db WHEREMetodo='";

if (Tipo==0) AppendStr(sqlstring,"ID3'"); else AppendStr(sqlstring,"C45'"); else sqlstring="SELECT Codigo FROM UpdatesHeader.db WHERE Nombre_Tabla='" + cbTabla->Text +"' AND Metodo='"; if (Tipo==0) AppendStr(sqlstring,"ID3'"); else AppendStr(sqlstring,"C45'"); AppendStr(sqlstring,"AND Fecha='"); AppendStr(sqlstring,cbFecha->Text.SubString(0,8)); AppendStr(sqlstring,"' AND Hora='"); AppendStr(sqlstring,Trim(cbFecha->Text.SubString(9,cbFecha->Text.Length()-8))); AppendStr(sqlstring,"'"); QTabla->SQL->Clear(); QTabla->SQL->Add(sqlstring); QTabla->Open(); CodigoReglas=QTabla->FieldByName("Codigo")->AsInteger; QTabla->First();

sqlstring.~AnsiString(); delete(QTabla); catch(...) ShowMessage("Problemas con la Base de Datos, no se pudo recuperar la tabla aprocesar."); sqlstring.~AnsiString(); delete(QTabla);

//---------------------------------------------------------------------------

void __fastcall TfrmElegirRendimiento::cbTablaChange(TObject *Sender) CargarCboFechora();

void TfrmElegirRendimiento::CargarCboFechora()TQuery *QTabla=new TQuery(frmElegirRendimiento);AnsiString sqlstring;



if (cbTabla->Text!="")try QTabla->DatabaseName=Base;

sqlstring="SELECT Fecha, Hora FROM UpdatesHeader.db WHERE Metodo='"; if (Tipo==0) AppendStr(sqlstring,"ID3'"); else AppendStr(sqlstring,"C45'"); AppendStr(sqlstring, " AND Nombre_Tabla='"); AppendStr(sqlstring,cbTabla->Text); AppendStr(sqlstring,"' ORDER BY Fecha DESC");

QTabla->SQL->Clear(); QTabla->SQL->Add(sqlstring); QTabla->Open();

QTabla->First(); cbFecha->Clear(); while (!QTabla->Eof) sqlstring=QTabla->FieldByName("Fecha")->AsString + " " + QTabla->FieldByName("Hora")->AsString; cbFecha->Items->Add(sqlstring); QTabla->Next(); cbFecha->ItemIndex=0; catch(...) ShowMessage("No se pudieron obtener los datos de la tabla de evaluación");sqlstring.~AnsiString();delete(QTabla);//---------------------------------------------------------------------------

D.3.5. URendimiento

D.3.5.1. URendimiento.h

//---------------------------------------------------------------------------#ifndef URendimientoH#define URendimientoH#include <Classes.hpp>#include <Controls.hpp>#include <Grids.hpp>//---------------------------------------------------------------------------class TFrmRendimiento : public TForm__published: // IDE-managed Components TStringGrid *GridResultados; void __fastcall FormClose(TObject *Sender, TCloseAction &Action);private: // User declarationspublic: // User declarations __fastcall TFrmRendimiento(TComponent* Owner);;//---------------------------------------------------------------------------extern PACKAGE TFrmRendimiento *FrmRendimiento;//---------------------------------------------------------------------------#endif

D.3.5.2. URendmiento.cpp

//---------------------------------------------------------------------------#pragma hdrstop



#include "URendimiento.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TFrmRendimiento *FrmRendimiento;//---------------------------------------------------------------------------__fastcall TFrmRendimiento::TFrmRendimiento(TComponent* Owner) : TForm(Owner)//---------------------------------------------------------------------------void __fastcall TFrmRendimiento::FormClose(TObject *Sender, TCloseAction &Action) Action = caFree;//---------------------------------------------------------------------------

D.3.6. Uarbol

D.3.6.1. UArbol.h

//---------------------------------------------------------------------------#ifndef UArbolH#define UArbolH//---------------------------------------------------------------------------#include <Classes.hpp>#include <ComCtrls.hpp>#include <Controls.hpp>#include <Dialogs.hpp>

#include "UPrincipal.h"#include "UTipos.h"

//--------------------------------------------------------------------------class Tfrm_Arbol : public TForm__published: // IDE-managed Components TTreeView *ArbolRes; TOpenDialog *fod_Archivo; void __fastcall FormClose(TObject *Sender, TCloseAction &Action); void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose);private: /*String que tendrá los valores posibles para el clasificador*/ TStringList *LClasificadores; TVecValores VecValores; TVecValores VecDescriptores;

void PrintSubtree(tree_ptr Tree, int nivel); int ObtenerNuevoValor(); /*numeración de valores del VecValores para la impresión del árbol*/public: __fastcall Tfrm_Arbol(TComponent* Owner); void PrintTree(tree_ptr Tree); void RecibirParametros(TStringList *LClasif,TVecValores VecVal, TVecValores VecDescrip);

;//---------------------------------------------------------------------------extern PACKAGE Tfrm_Arbol *frm_Arbol;//---------------------------------------------------------------------------#endif

D.3.6.2. UArbol.cpp

//---------------------------------------------------------------------------#pragma hdrstop



#include "UArbol.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"Tfrm_Arbol *frm_Arbol;TTreeNode *pNivel[MAX_CANT_DESCRIPTORES]; //para la visualización

//---------------------------------------------------------------------------__fastcall Tfrm_Arbol::Tfrm_Arbol(TComponent* Owner) : TForm(Owner)//---------------------------------------------------------------------------

void __fastcall Tfrm_Arbol::FormClose(TObject *Sender, TCloseAction &Action)int i; for (i=0;i<MAX_NIVELES;i++) VecValores[i].~AnsiString(); VecDescriptores[i].~AnsiString(); delete(ArbolRes); delete(LClasificadores); Action = caFree;//---------------------------------------------------------------------------

void __fastcall Tfrm_Arbol::FormCloseQuery(TObject *Sender, bool &CanClose)int rta;bool res;

rta=MessageBox(NULL, "¿Desea guardar el árbol en un archivo?", "TDIDT",MB_ICONQUESTION|MB_YESNOCANCEL|MB_DEFBUTTON1|MB_SYSTEMMODAL); if (rta==IDCANCEL) //el usuario no desea salir de la aplicación CanClose=false; else if (rta==IDYES) res=fod_Archivo->Execute(); if (res) ArbolRes->SaveToFile(fod_Archivo->FileName);

//---------------------------------------------------------------------------int Tfrm_Arbol::ObtenerNuevoValor() /*numeración de valores del VecValores para la impresión del árbol*/ static int i=0; i++; return(i);

//---------------------------------------------------------------------------//-------------------- IMPRESIÓN DEL ÁRBOL EN PANTALLA ----------------------//---------------------------------------------------------------------------/************************************************************************************************************************************************************/void Tfrm_Arbol::PrintTree(tree_ptr Tree) int nivel; TTreeNode *pNivel[MAX_CANT_DESCRIPTORES]; //para la visualización

nivel=0;//nivel de la raíz pNivel[nivel]= new TTreeNode(ArbolRes->Items); PrintSubtree(Tree, nivel);

// frm_Arbol->ArbolRes->Width=Width-60; ArbolRes->Left=Left+30; ArbolRes->Top=Top+50; // frm_Arbol->ArbolRes->Height=Height-100; ArbolRes->FullExpand();



ArbolRes->Visible=true;

void Tfrm_Arbol::PrintSubtree(tree_ptr Tree, int nivel) int i; int val; AnsiString nodo;

if (nivel!=0) val=ObtenerNuevoValor(); nodo=VecDescriptores[val]; AppendStr(nodo, " = "); AppendStr(nodo, VecValores[val]); pNivel[nivel]=ArbolRes->Items->AddChild(pNivel[nivel-1],nodo); if (Tree->flag_hoja!=3) //es hoja ArbolRes->Items->AddChild(pNivel[nivel], LClasificadores->Strings[Tree->flag_hoja]); else //no es hoja i=0; nivel++; while ((Tree->pHijos[i]!=NULL)&&(i<MAX_HIJOS)) PrintSubtree(Tree->pHijos[i],nivel); i++; //end else nodo.~AnsiString(); return; //---------------------------------------------------------------------------//---------------------------------------------------------------------------//---------------------------------------------------------------------------//---------------------------------------------------------------------------void Tfrm_Arbol::RecibirParametros(TStringList *LClasif,TVecValores VecVal, TVecValores VecDescrip) int i;

LClasificadores=LClasif; for (i=0;i<MAX_NIVELES;i++) VecValores[i]=VecVal[i]; VecDescriptores[i]=VecDescrip[i];

D.4. MÓDULOS DE MINERÍA DE DATOS

D.4.1. UDMID3

D.4.1.1. UDMID3.h

//---------------------------------------------------------------------------#ifndef UDMID3H#define UDMID3H//---------------------------------------------------------------------------#include <Classes.hpp>#include <Db.hpp>#include <DBTables.hpp>#include <fstream.h>#include <math.hpp>#include <Dialogs.hpp>

#include "UTipos.h"#include "URendimiento.h"



//---------------------------------------------------------------------------class TDMID3 : public TDataModule__published: // IDE-managed Components TTable *TTennis; TDataSource *DSTTennis; TQuery *QGral; TQuery *QUpdates; void __fastcall DMID3Destroy(TObject *Sender);private: TParametros *Params; short int EvaluarResultados(AnsiString NombreTabla);public: __fastcall TDMID3(TComponent* Owner);

//---------------------------------------------------------------------------- //--------------------DECLARACION DE FUNCIONES-------------------------------- //---------------------------------------------------------------------------- tree_ptr Principal ( short int MedidorGanancia); /*Módulo principal*/ void RecibirParametros(TParametros *Parametros);

short int EsUniforme(int nivelArbol); /*verifica si estamos en una hoja*/ int ObtenerCantDescr();/*Obtiene la cantidad de descriptores de la tabla*/ int BuscarPK(short int ValidDs[]); /*Busca claves promarias en la tabla*/ tree_ptr BuildTree(int nivel, short int *pD); /*Función que construye el árbol de decisión según el ID3*/ int ObtenerNuevoNivel(); /*numeración de niveles para el árbol*/ int ObtenerNuevoValor(); /*numeración de subíndices del VecValores para la impresión del árbol*/

int ArmarTabla(TTablaCorrel& Tabla, int Nivel, int desc,TStringList *valores); /*arma la tabla de correlación para el nro de descriptor indicado en el nivel del árbol indicado Si la función devuelve un 0 significa que no hubo problemas Hubo problemas en todo otro caso*/ int Particionar(int desc, int nivel, tree_ptr pNode, TStringList *valores); /*realiza la partición del conjunto de datos Si la función devuelve un 0 significa que no hubo problemas Hubo problemas en todo otro caso*/

short int PruneTree(tree_ptr Tree); /*realiza el "pruning" del árbol obtenido Devuelve 0 si todos los valores son "Yes" 1 si todos los valores son "No" 2 si los valores son mixtos -1 si los valores son distintos*/

void ArmarReglas(tree_ptr Tree); /*Arma las reglas de decisión generadas a partir del árbol de decisión "Tree"*/ void ObtenerReglas(tree_ptr Tree, TVecInt VecReglas, int nroRegla, int codigo); short int ObtenerNroRegla();/*numeración de las reglas de decisión*/ short int ObtenerSubReglas(); short int ObtenerNroUpdate();

void AplicarReglas(AnsiString Tabla, int codigoReglas);/*Aplica a Tabla lasreglas obtenidas*/ short int EvaluarReglas(int codigoReglas);/*Evalua las reglas obtenidas sobrelos datos especificados*/

//----FUNCIONES UTILIZADAS PARA EL CÁLCULO DE LA ENTROPÍA float InfoTermino(int cant, int total); /*información brindada por un término*/ float Ianterior(int cant_clasificadores, int cant_descriptores, TTablaCorreltabla); /*Esta función devuelve la información de un conjunto antes de realizar la partición*/ float Iposterior(int cant_clasificadores, int cant_descriptores, TTablaCorreltabla); /*Esta función devuelve la información de un conjunto después de realizar la partición según el atributo por el que se armó la tabla*/ float Gain(float Ianterior, float Iposterior); /*Ganancia debida a la partición del conjunto según el atributo en cuestión*/ float SplitInfo(int cant_clasificadores, int cant_descriptores, TTablaCorreltabla); /*Información debida a la partición realizada*/ float GainRatio(float Ganancia, float SplitInformation);



/*Proporción de ganancia debida a la partición del conjunto según el atributo en cuestión*/ float GananciaEntropia(int cant_clasificadores, int cant_descriptores,TTablaCorrel tabla); /*Utiliza todas las funciones anteriores para obtener el Gain Ratio de la tabla recibida como parámetro*/

tree_ptr InicializarTree(); /*inicializa el árbol, devolviendo un ptr a la raíz */ void EliminarTree(tree_ptr Tree); /*elimina todos los elementos del árbol, liberando la memoria*/

void InformarValores(TVecValores VecVal); /*Recibe los valores del arbol generado*/ void InformarDescrip(TVecValores VecDesc); /*Recibe las descripciones del arbol generado*/;//---------------------------------------------------------------------------extern PACKAGE TDMID3 *DMID3;//---------------------------------------------------------------------------#endif

D.4.1.2. UDMID3.cpp

//---------------------------------------------------------------------------#pragma hdrstop

#include "UDMID3.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"TDMID3 *DMID3;tree_ptr pRoot;

//---------------------------------------------------------------------------__fastcall TDMID3::TDMID3(TComponent* Owner) : TDataModule(Owner)//---------------------------------------------------------------------------

//==============================VARIABLES======================================/*String que tendrá los valores posibles para el clasificador*/

TVecValores VecValores;TVecValores VecDescriptores;

fstream FReglas; //guarda las reglas generadas en formato de Insight 2+fstream FVitacora; //guarda las tablas generadas en cada paso del ID3

int UsoGain; //vale 0 si uso gain, 1 si uso gain ratio//---------------------------------------------------------------------------//-----------------------IMPLEMENTACIÓN--------------------------------------//---------------------------------------------------------------------------/******************************************************************************Función principal que comienza con el armado del árbol de decisión según elalgoritmo ID3******************************************************************************/tree_ptr TDMID3::Principal ( short int MedidorGanancia) int cant_descr; short int ValidDs[MAX_CANT_DESCRIPTORES]; short int *pValidDs = ValidDs; int i, error; char outFile[50]="Log\\ID3"; tree_ptr pRoot;

UsoGain=MedidorGanancia;



//Obtener cantidad de descriptores cant_descr=ObtenerCantDescr(); for (i=0;i<cant_descr; i++) ValidDs[i]=1;

error=BuscarPK(ValidDs);

if (error!=1) DateSeparator='-'; TimeSeparator='_'; strcat(outFile, DateTimeToStr(Now()).c_str()); strcat(outFile, Params->TablaBD.c_str()); strcat(outFile, ".log");

FVitacora.open(outFile, ios::out); pRoot=BuildTree(ObtenerNuevoNivel(), pValidDs); FVitacora.close(); return(pRoot); else pRoot=NULL; return(pRoot);

void TDMID3::RecibirParametros(TParametros *Parametros) int i; AnsiString sqlstring;

Params=Parametros;

TTennis->DatabaseName=Params->NombreBD; TTennis->TableName=Params->TablaBD; TTennis->Active=true;

//Inicializamos los queries que harán sus consultas sobre la base //especificada QGral->DatabaseName=Params->NombreBD;

for (i=0; i<MAX_NIVELES;i++) VecValores[i]=""; VecDescriptores[i]="";

//Inicializamos el campo Nivel en la Tabla sqlstring="Update "; AppendStr(sqlstring, Params->TablaBD); AppendStr(sqlstring," SET Nivel = 0 "); QGral->SQL->Clear(); QGral->SQL->Add(sqlstring); QGral->ExecSQL(); QGral->SQL->Clear(); TTennis->Close(); TTennis->Open();

sqlstring.~AnsiString();/******************************************************************************Verifica la uniformidad de un conjunto de filas, por uniformidad nos referimosal hecho que todos los valores del clasificador para dicho conjunto sean iguales

Devuelve: 0 si todos los valores son "Yes" 1 si todos los valores son "No" 3 si los valores no son uniformes 4 si hubo un error******************************************************************************/short int TDMID3::EsUniforme(int nivelArbol) //begin EsUniforme



short int aux; AnsiString sqlstring;

try //intentamos abrir el QUniforme

sqlstring="Select Count(Distinct "; AppendStr(sqlstring, Params->ColClasificador); AppendStr(sqlstring,") AS diferentes FROM "); AppendStr(sqlstring,Params->TablaBD); AppendStr(sqlstring," WHERE Nivel= "); AppendStr(sqlstring,nivelArbol); QGral->SQL->Clear(); QGral->SQL->Add(sqlstring); sqlstring.~AnsiString(); QGral->Open(); aux=0; aux=(short int)QGral->FieldByName("diferentes")->AsInteger; if (aux!=1) //no son uniformes return(3); else QGral->Close(); sqlstring="Select "; AppendStr(sqlstring, Params->ColClasificador); AppendStr(sqlstring," AS valor FROM "); AppendStr(sqlstring,Params->TablaBD); AppendStr(sqlstring," WHERE Nivel= "); AppendStr(sqlstring,nivelArbol); QGral->SQL->Clear(); QGral->SQL->Add(sqlstring); QGral->Open(); if (QGral->FieldByName("valor")->AsString == Params->LClasificadores->Strings[0]) aux=0; else aux=1; QGral->Close(); return(aux); catch(...) sqlstring.~AnsiString(); ShowMessage("No se pudo abrir el Query"); return(4); //fin EsUniforme

/******************************************************************************Obtiene la cantidad de descriptores presentes en la tablaque será la cantidad de atributos menos 2: el clasificador y el atributo nivel******************************************************************************/int TDMID3::ObtenerCantDescr() int cant_descr;

TTennis->Open(); cant_descr=TTennis->FieldCount; cant_descr-=2; return(cant_descr); /******************************************************************************/*Busca claves primarias en la tabla, para no trabajar sobre esos campos porno ofrecer ninguna ganancia de informaciónDevuelve: 0 si no hubo problemas 1 si hubo algún error/******************************************************************************/int TDMID3::BuscarPK(short int ValidDs[]) AnsiString sqlstring; int i, cantCampos, cantReg;

cantCampos=TTennis->FieldCount; cantReg=TTennis->RecordCount;



try for (i=0; i<cantCampos-1; i++) sqlstring="SELECT COUNT(DISTINCT "; AppendStr(sqlstring,TTennis->Fields->Fields[i]->FieldName); AppendStr(sqlstring," ) as Cant FROM "); AppendStr(sqlstring, Params->TablaBD); QGral->SQL->Clear(); QGral->SQL->Add(sqlstring); sqlstring.~AnsiString(); QGral->Open();

if (QGral->FieldByName("Cant")->AsInteger==cantReg) ValidDs[i]=0; //no es un desc válido por ser PK

QGral->Close(); return(0); catch(...) sqlstring.~AnsiString(); ShowMessage("No se pudo abrir el Query"); return(1); //---------------------------------------------------------------------------/******************************************************************************Función recursiva que arma el árbol de decisión según elalgoritmo ID3******************************************************************************/

tree_ptr TDMID3::BuildTree(int nivel, short int *pD) float max_ganancia=-1000; short int desc_max_ganancia=-1; /*descriptor con la mayor ganancia*/ float ganancia; short int unif; tree_ptr pNewNode; short int i; int cant_clas, cant_valores_descr; int exito;

TTablaCorrel Tabla; TStringList *valores = new TStringList(); TStringList *MaxValores = new TStringList();

cant_clas=Params->LClasificadores->Count; /* Inicializar Nodo*/ pNewNode=(DECISION_TREE)malloc(sizeof(struct tree_node));

if (pNewNode==0) ShowMessage("No hay suficiente espacio en memoria para la operación"); else for (i=0; i<MAX_HIJOS; i++) pNewNode->pHijos[i]=0; pNewNode->desc=-1;

for (i=0; i<MAX_CANT_DESCRIPTORES; i++) pNewNode->D[i]=*(pD+i);

FVitacora<<"******************************************************"; FVitacora<<endl; FVitacora<<"Nivel="; FVitacora<<nivel<<endl;

/* EsUniforme?*/ unif=EsUniforme(nivel); if (unif!=4) /*no hubo un error*/ if (unif!=3) /*es hoja*/ /* Si es hoja, tabularla*/ pNewNode->flag_hoja=unif; /*unif valdrá 0 si todos los valores



son "Yes", y 1 si todos son "No"*/ delete valores; delete MaxValores; return pNewNode; else /*no es hoja*/ pNewNode->flag_hoja=3;

/*Si no es hoja, calcular la entropía para cada descriptror válido en el nivel que estamos analizando. Obtenemos el descriptor de mayor ganancia*/ for (i=0; i<MAX_CANT_DESCRIPTORES; i++) if (pNewNode->D[i]==1) /*es un descriptor válido*/ valores->Clear(); exito=ArmarTabla(Tabla,nivel,i, valores); if (exito==0) cant_valores_descr=valores->Count; ganancia=GananciaEntropia(cant_clas, cant_valores_descr,Tabla); if (ganancia>max_ganancia) max_ganancia=ganancia; desc_max_ganancia=i; MaxValores->Clear(); MaxValores->AddStrings(valores); delete valores; /*Partir el conjunto según el desciptor que ofrezca mayor entropía*/ if (desc_max_ganancia>=0) //es un descriptor válido pNewNode->desc=desc_max_ganancia; /*descriptor utilizado para realizar la partición*/ pNewNode->D[desc_max_ganancia]=0;

FVitacora<<desc_max_ganancia; FVitacora<<" "; FVitacora<<max_ganancia<<endl;

if (exito==0) exito=Particionar(desc_max_ganancia, nivel,pNewNode,MaxValores);

delete MaxValores; return(pNewNode); else /*se acabaron los descriptores, entonces habrá errores en el resultado*/ pNewNode->flag_hoja=2; delete valores; delete MaxValores; return pNewNode; // fin else no es hoja //fin else

//---------------------------------------------------------------------------/******************************************************************************Esta función proporciona un identificador único para cada uno de los nivelesdel árbol******************************************************************************/int TDMID3::ObtenerNuevoNivel() /*numeración de niveles para el árbol*/ static int i=-1; i++; return(i);

//------------------------------------------------------------------------------// CÁLCULO DE LA ENTROPÍA



//------------------------------------------------------------------------------

/******************************************************************************Esta función devuelve la información brindada por un términocant: cantidad de ocurrencias de ese elementototal: total de elementos en el conjuntoInfoTermino=-(cant/total)log2(cant/total)******************************************************************************/

float TDMID3::InfoTermino(int cant, int total) float temp; float temp1; float temp2;

if ((cant!=0)&&(total!=0)) temp1=float(cant)*0.1; temp2=float(total)*0.1; temp=temp1/temp2;

if (temp==0) temp=0; else temp*=Log2(temp); temp=-temp; return(temp); else return(0);

/******************************************************************************Esta función devuelve la información de un conjunto antes de realizar la particióncant_clasificadores: cantidad de valores posibles para los clasificadores, es decir, la cantidad de filas de la tabla de correlacióncant_descriptores: cantidad de descriptores válidos para el nivel del árbol que se está analizando, es decir, la cantidad de columnas de la tabla de correlaciónIanterior(T)=Sum(i=1, i<k)(-(cant/Total)log2(cant/total))******************************************************************************/float TDMID3::Ianterior(int cant_clasificadores, int cant_descriptores, TTablaCorreltabla) float auxI=0; float temp1, temp2; int i;

for (i=0; i<cant_clasificadores; i++) temp1=float(tabla[i][cant_descriptores]); temp2=float(tabla[cant_clasificadores][cant_descriptores]); if (temp2!=0) temp1=temp1/temp2; if (temp1!=0) auxI+=temp1*(-Log2(temp1));//InfoTermino(tabla[i][cant_descriptores],tabla[cant_clasificadores][cant_descriptores]);

return(auxI);

/******************************************************************************Esta función devuelve la información de un conjunto después de realizarla partición según el atributo por el que se armó la tablacant_clasificadores: cantidad de valores posibles para los clasificadores, es decir, la cantidad de filas de la tabla de correlacióncant_descriptores: cantidad de descriptores válidos para el nivel del árbol que se está analizando, es decir, la cantidad de columnas de la tabla de correlaciónIposterior(T)=Sum(i=1, i<k)(-(cant/Total)log2(cant/total))******************************************************************************/



float TDMID3::Iposterior(int cant_clasificadores, int cant_descriptores, TTablaCorreltabla) float Iaux, Itemp; int i,j;

Iaux=0; for (i=0; i<cant_descriptores; i++) Itemp=0; for (j=0; j<cant_clasificadores; j++) Itemp+=InfoTermino(tabla[j][i], tabla[cant_clasificadores][i]); if (tabla[cant_clasificadores][cant_descriptores]!=0)

Iaux+=(float(tabla[cant_clasificadores][i])/float(tabla[cant_clasificadores][cant_descriptores]))*Itemp; return(Iaux); /******************************************************************************Ganancia debida a la partición del conjunto según el atributo en cuestiónGain=Ianterior-Iposterior;******************************************************************************/float TDMID3::Gain(float Ianterior, float Iposterior) return(Ianterior-Iposterior);

/******************************************************************************Información debida a la partición realizadaSum(i=1, k)(|cant elementos según la partición i||cant total de elementos|* *InfoTermino);******************************************************************************/

float TDMID3::SplitInfo(int cant_clasificadores, int cant_descriptores, TTablaCorreltabla) float SIaux; int i;

SIaux=0; for (i=0; i<cant_descriptores; i++) if (tabla[cant_clasificadores][cant_descriptores]!=0)

SIaux+=InfoTermino(tabla[cant_clasificadores][i],tabla[cant_clasificadores][cant_descriptores])*(float(tabla[cant_clasificadores][i])/float(tabla[cant_clasificadores][cant_descriptores])); return(SIaux); /******************************************************************************Proporción de ganancia debida a la partición del conjunto según el atributo en cuestiónGain=Gain/SplitInfo;******************************************************************************/float TDMID3::GainRatio(float Ganancia, float SplitInformation) if (SplitInformation!=0) return(Ganancia/SplitInformation); else return(0);

/******************************************************************************Utiliza todas las funciones anteriores para obtener el Gain Ratio dela tabla recibida como parámetro******************************************************************************/float TDMID3::GananciaEntropia(int cant_clasificadores, int cant_descriptores,TTablaCorrel tabla)



float anterior, posterior, gano; float splitI, auxGE;

anterior=Ianterior(cant_clasificadores, cant_descriptores, tabla); posterior=Iposterior(cant_clasificadores, cant_descriptores, tabla); gano=Gain(anterior, posterior); splitI=SplitInfo(cant_clasificadores, cant_descriptores, tabla); auxGE=GainRatio(gano,splitI);

FVitacora<<"Gain="; FVitacora<<gano<<endl; FVitacora<<"Gain Ratio="; FVitacora<<auxGE<<endl; FVitacora<<"--------------------------------------"; FVitacora<<endl; if (UsoGain==0) return(gano); else return(auxGE);

//---------------------------------------------------------------------------/******************************************************************************Arma la tabla de correlaciónNivel: es el nivel del árbol que se está analizandodesc: es el descriptor según el que se quiere armar la tablaSi la función devuelve un 0 significa que no hubo problemasHubo problemas en todo otro caso******************************************************************************/int TDMID3::ArmarTabla(TTablaCorrel& Tabla, int Nivel, int desc, TStringList *valores) int c, d, maxd; int cant_clas; int CantTotal; AnsiString sqlstring1(""); AnsiString sqlstring2("");

TStringList *lista = new TStringList();

valores->Clear();

cant_clas=Params->LClasificadores->Count; /*Obtenemos el nombre del atributo "desc" de la tabla*/ TTennis->GetFieldNames(lista);

//====================================================================== //=================== MANEJO DEL QUERY PARA ============================ //===OBTENER TODOS LOS VALORES POSIBLES DE UN ATRIBUTO ================= //====================================================================== try //Intentamos abrir el Query /*Obtenemos todos los valores posibles para el atributo descriptor*/ sqlstring1="SELECT DISTINCT("; AppendStr(sqlstring1,lista->Strings[desc]); AppendStr(sqlstring1,") as descriptor FROM "); AppendStr(sqlstring1, Params->TablaBD); AppendStr(sqlstring1," WHERE Nivel="); AppendStr(sqlstring1,IntToStr(Nivel)); QGral->SQL->Clear(); QGral->SQL->Add(sqlstring1); QGral->Open(); QGral->First(); sqlstring1.~AnsiString();

FVitacora<<"Descriptor="; FVitacora<<lista->Strings[desc].c_str()<<endl;

d=0; while (!(QGral->Eof)) /*Obtenemos todos los valores posbiles para el descriptor en la lista valores*/

valores->Add(QGral->FieldByName("Descriptor")->AsString); d++; QGral->Next(); //fin del while



maxd=d-1; QGral->Close(); catch(...) //De la apertura del Query ShowMessage("No se pudo abrir el Query para obtener todos los valores de undescriptor"); delete lista; sqlstring1.~AnsiString(); sqlstring2.~AnsiString(); return(1);

//====================================================================== //=================== MANEJO DEL QUERY ============================= //===========CARGAMOS LOS VALORES INDIVIDUALES DE Tabla[c][d]=========== //==========================(NO LOS TOTALES)============================ //====================================================================== try //Intentamos abrir el QGral d=0; while (d<=maxd) FVitacora<<" "; FVitacora<<valores->Strings[d].c_str(); d++;

c=0; while (c<cant_clas) d=0; FVitacora<<endl; FVitacora<<Trim(Params->LClasificadores->Strings[c]).c_str(); FVitacora<<" "; while (d<=maxd) sqlstring2="SELECT (COUNT(*)) as Cant FROM "; AppendStr(sqlstring2, Params->TablaBD); AppendStr(sqlstring2," WHERE Nivel="); AppendStr(sqlstring2,IntToStr(Nivel)); AppendStr(sqlstring2," AND "); AppendStr(sqlstring2,lista->Strings[desc]); AppendStr(sqlstring2," = '"); AppendStr(sqlstring2,valores->Strings[d]); AppendStr(sqlstring2,"' AND "); AppendStr(sqlstring2, Params->ColClasificador); AppendStr(sqlstring2, " = '"); AppendStr(sqlstring2,Trim(Params->LClasificadores->Strings[c])); // AppendStr(sqlstring2,"Yes"); AppendStr(sqlstring2,"'"); QGral->SQL->Clear(); QGral->SQL->Add(sqlstring2); QGral->Open(); sqlstring2.~AnsiString();

Tabla[c][d]=QGral->FieldByName("Cant")->AsInteger;

FVitacora<<Tabla[c][d]; FVitacora<<" "; QGral->Close(); d++; //fin while (d<=maxd) c++; //fin while (c<=cant_clas)

catch(...) ShowMessage("No se pudo abrir el Query para obtener la cantidad de registros conun valor determinado de descriptor"); delete lista; sqlstring2.~AnsiString(); return(1); //fin del catch



/*Obtenemos los totales de la tabla de correlación*/

/* TOTALES POR FILA */ for (c=0; c<cant_clas; c++) Tabla[c][maxd+1]=0; for (d=0; d<=maxd; d++) Tabla[c][maxd+1]+=Tabla[c][d];

/* TOTALES POR COLUMNA Y CANTIDAD TOTAL*/ CantTotal=0; FVitacora<<endl; for (d=0; d<=maxd; d++) Tabla[cant_clas][d]=0; FVitacora<<" "; for (c=0; c<cant_clas; c++) Tabla[cant_clas][d]+=Tabla[c][d]; CantTotal+=Tabla[cant_clas][d];

FVitacora<<Tabla[cant_clas][d]; FVitacora<<" "; Tabla[cant_clas][maxd+1]=CantTotal;

FVitacora<<Tabla[cant_clas][maxd+1]; FVitacora<<endl;

delete lista; return(0);

//---------------------------------------------------------------------------/******************************************************************************Particiona el conjunto de datos según el descriptor indicado, en tantos conjuntoscomo valores pueda tomar el descriptor.desc: es el nro de descriptor con el que trabajamospNode: es el nodo del árbol desde el cual se está haciendo la particiónvalores: es la lista de valores posibles que puede tomar el descriptor******************************************************************************/int TDMID3::Particionar(int desc, int nivel, tree_ptr pNode, TStringList *valores) AnsiString sqlstring; AnsiString particion; TStringList *lista = new TStringList(); int i, maxValores; int nuevoNivel; short int *pDesc=pNode->D;

/*Obtenemos el nombre del atributo "desc" de la tabla*/ TTennis->GetFieldNames(lista); maxValores=valores->Count; try for (i=0; i<maxValores; i++) sqlstring="Update "; AppendStr(sqlstring, Params->TablaBD); AppendStr(sqlstring," SET Nivel = "); nuevoNivel=ObtenerNuevoNivel(); AppendStr(sqlstring, IntToStr(nuevoNivel)); AppendStr(sqlstring," WHERE Nivel="); AppendStr(sqlstring,IntToStr(nivel)); AppendStr(sqlstring, " AND "); AppendStr(sqlstring, lista->Strings[desc]); AppendStr(sqlstring, "= '"); AppendStr(sqlstring, valores->Strings[i]); AppendStr(sqlstring, "'"); QGral->SQL->Clear(); QGral->SQL->Add(sqlstring); QGral->ExecSQL(); QGral->SQL->Clear(); particion=lista->Strings[desc]; //nombre del descriptor VecDescriptores[nuevoNivel]=lista->Strings[desc]; AppendStr(particion, " = "); AppendStr(particion, valores->Strings[i]); //valor del descriptor



VecValores[nuevoNivel]=valores->Strings[i]; TTennis->Close(); TTennis->Open(); pNode->pHijos[i]=BuildTree(nuevoNivel, pDesc);

sqlstring.~AnsiString(); particion.~AnsiString(); delete lista; return(0); catch(...) ShowMessage("No se pudo realizar la actualización"); sqlstring.~AnsiString(); particion.~AnsiString(); delete lista; return(1); //---------------------------------------------------------------------------/******************************************************************************/*realiza el "pruning" del árbol obtenidoDevuelve 0 si todos los valores son "Yes" 1 si todos los valores son "No" 2 si los valores son mixtos -1 si los valores son distintos******************************************************************************/short int TDMID3::PruneTree(tree_ptr Tree) int i; short int hijo; short int iguales; /* 0 si todos los valores son "Yes" 1 si todos los valores son "No" 2 si todos los valores son mixtos -1 si no son iguales*/

if (Tree->flag_hoja!=3) //es hoja return(Tree->flag_hoja); else i=0; iguales=3; while ((Tree->pHijos[i]!=NULL)&&(i<MAX_HIJOS)&&(iguales!=-1)) hijo=PruneTree(Tree->pHijos[i]); if (iguales==3) iguales=hijo; else if (iguales!=hijo) iguales=-1; i++; if (iguales!=-1) //se puede "podar" la rama Tree->flag_hoja=iguales; i=0; while ((Tree->pHijos[i]!=NULL)&&(i<MAX_HIJOS)) EliminarTree(Tree->pHijos[i]); i++; return(iguales); //end else //end PruneTree

//---------------------------------------------------------------------------/********************************************************************************Arma las reglas de decisión generadas a partir del árbol de decisión "Tree"*********************************************************************************/void TDMID3::ArmarReglas(tree_ptr Tree) TVecInt VecReglas;



char outFile[50]="Reglas\\"; int nroRegla; int i; nroRegla=0; char* tabla=""; char* delimitador="."; AnsiString sqlstring; int cod;

//Iniciliazamos el vector de reglas for (i=0; i<MAX_NIVELES; i++) VecReglas[i]=-1;

/*Creamos el archivo de texto donde quedarán las reglas de decisión con la extensión especificada por el usuario, ".prl" por default.*/

//Abrimos la tabla de Updates QUpdates->DatabaseName=Params->NombreBD; sqlstring="SELECT * FROM UpdatesHeader.db"; QUpdates->SQL->Clear(); QUpdates->SQL->Add(sqlstring); QUpdates->Open(); QUpdates->Last(); cod=QUpdates->RecordCount; cod++; QUpdates->SQL->Clear(); //Insertamos el Header de las Consultas DateSeparator='/'; TimeSeparator=':'; sqlstring="INSERT INTO UpdatesHeader.db (CODIGO, NOMBRE_TABLA, METODO, FECHA,HORA) VALUES ("; AppendStr(sqlstring,cod); AppendStr(sqlstring,", '"); AppendStr(sqlstring, Params->TablaBD); AppendStr(sqlstring,"', 'ID3', '"); AppendStr(sqlstring, Date()); AppendStr(sqlstring,"', '"); AppendStr(sqlstring, Time()); AppendStr(sqlstring,"')"); QUpdates->SQL->Add(sqlstring); QUpdates->ExecSQL(); QUpdates->SQL->Clear();

//Concatenamos fecha y hora en los archivos DateSeparator='-'; TimeSeparator='_'; strcat(outFile, DateTimeToStr(Now()).c_str());

//Eliminamos la extensión de la tabla de la base de datos tabla=strtok(Params->TablaBD.c_str(),delimitador); strcat(outFile, tabla); //Les agregamos la extensión strcat(outFile, Params->ExtensionFileReglas.c_str());

FReglas.open(outFile, ios::out);

//Obtenemos las reglas ObtenerReglas(Tree, VecReglas, nroRegla,cod);

//Cerramos el archivo FReglas.close(); sqlstring.~AnsiString();

void TDMID3::ObtenerReglas(tree_ptr Tree, TVecInt VecReglas, int nroRegla, int codigo) char header[15]="Regla "; char then[]=" ENTONCES "; char si[]=" SI "; char is[]=" = "; char es[]=" = "; char and[]=" Y "; AnsiString sqlstring; AnsiString sqlstring2; AnsiString tabla; int i,j;



TRule rule="";

if (nroRegla!=0) /*Agregamos el el vector de reglas el subindice del par "descriptor - valor" utilizado para armar a regla, es decir, utilizado para recorrer la rama del arbol */ j=0; while (VecReglas[j]!=-1) j++; VecReglas[j]=ObtenerSubReglas(); if (Tree->flag_hoja!=3) //es hoja //Agregamos el nro de regla "RULE N°" FReglas << endl; FReglas << endl; FReglas << header; FReglas << ObtenerNroRegla() << endl; //Armamos la regla FReglas << si; //descriptor j=0; strcat(rule, VecDescriptores[VecReglas[j]].c_str()); sqlstring=VecDescriptores[VecReglas[j]]; AppendStr(sqlstring,"="); strcat(rule, es); //valor strcat(rule, VecValores[VecReglas[j]].c_str()); AppendStr(sqlstring,"'"); AppendStr(sqlstring,VecValores[VecReglas[j]]); AppendStr(sqlstring,"'"); FReglas << rule << endl; j++; while (VecReglas[j]!=-1) strcpy(rule, and); AppendStr(sqlstring," and "); //descriptor strcat(rule, VecDescriptores[VecReglas[j]].c_str()); strcat(rule, es); AppendStr(sqlstring,VecDescriptores[VecReglas[j]]); AppendStr(sqlstring," = "); //valor strcat(rule, VecValores[VecReglas[j]].c_str()); AppendStr(sqlstring,"'"); AppendStr(sqlstring,VecValores[VecReglas[j]]); AppendStr(sqlstring,"'"); j++; FReglas << rule << endl;

//Agregamos la conclusion de la regla strcpy(header, then); strcat(header,Params->ColClasificador.c_str()); strcat(header, is); strcat(header, Params->LClasificadores->Strings[Tree->flag_hoja].c_str()); FReglas << header << endl;

sqlstring.Insert("' WHERE ",0); sqlstring.Insert(Trim(Params->LClasificadores->Strings[Tree->flag_hoja]).c_str(),0); sqlstring.Insert(" = '",0); sqlstring.Insert(Params->ColClasificador,0); tabla=AnsiString(Params->TablaBD.c_str()); sqlstring.Insert(" SET ",0); sqlstring2="INSERT INTO Updates.db (CODIGO, NRO_REGLA, MODIFICACION)VALUES ("; AppendStr(sqlstring2,codigo); AppendStr(sqlstring2,", "); AppendStr(sqlstring2, ObtenerNroUpdate()); AppendStr(sqlstring2, ", "); AppendStr(sqlstring2,char(34)); //agregamos las comillas AppendStr(sqlstring2,sqlstring); AppendStr(sqlstring2,char(34)); AppendStr(sqlstring2,")");



QUpdates->SQL->Clear(); QUpdates->SQL->Add(sqlstring2); QUpdates->ExecSQL();

else //no es hoja i=0; nroRegla++; while ((Tree->pHijos[i]!=NULL)&&(i<MAX_HIJOS)) ObtenerReglas(Tree->pHijos[i], VecReglas, nroRegla,codigo); /*Eliminamos el valor de la ultima rama recorrida porque estamos cambiando de rama*/ j=0; while (VecReglas[j]!=-1) j++; VecReglas[j-1]=-1;

i++; //end else tabla.~AnsiString(); sqlstring.~AnsiString(); sqlstring2.~AnsiString(); return;

/********************************************************************************Numeración única para las reglas de decisión generadas****************************************************************************************************/short int TDMID3::ObtenerNroRegla() static short int nroRegla=-1; nroRegla++; return(nroRegla); short int TDMID3::ObtenerSubReglas() static short int subRegla=0; subRegla++; return(subRegla); short int TDMID3::ObtenerNroUpdate() static short int nroRegla=-1; nroRegla++; return(nroRegla);

//---------------------------------------------------------------------------/********************************************************************************Inicializa el árbol, creando un ptr a la raíz del mismo****************************************************************************************************/tree_ptr TDMID3::InicializarTree() tree_ptr pNewNode;

pNewNode=(DECISION_TREE)malloc(sizeof(struct tree_node)); if (pNewNode==0) ShowMessage("No hay suficiente espacio en memoria para la operación"); return(NULL); else pNewNode->pHijos[0]=0; return(pNewNode);

/******************************************************************************



**Elimina todos los elementos del árbol, liberando la memoria************************************************************************************************/void TDMID3::EliminarTree(tree_ptr Tree) int i;

i=0;

while ((Tree->pHijos[i]!=NULL)&&(i<5)) EliminarTree(Tree->pHijos[i]); free(Tree->pHijos[i]); i++; return;

void TDMID3::InformarValores(TVecValores VecVal) /*Recibe los valores del arbol generado*/int i; for (i=0;i<MAX_NIVELES;i++) VecVal[i]=VecValores[i];;void TDMID3::InformarDescrip(TVecValores VecDesc) /*Recibe las descripciones del arbol generado*/int i; for (i=0;i<MAX_NIVELES;i++) VecDesc[i]=VecDescriptores[i];;

/**********************************************************************************************Evaluamos los resultados obtenidos************************************************************************************************************/void TDMID3::AplicarReglas(AnsiString Tabla, int codigoReglas)AnsiString sqlstring; TQuery *QReglas=new TQuery(DMID3); TQuery *QAplicar=new TQuery(DMID3);

QReglas->DatabaseName=Params->NombreBD; QAplicar->DatabaseName=Params->NombreBD; sqlstring="SELECT * FROM Updates.db where codigo="; AppendStr(sqlstring, codigoReglas); QReglas->SQL->Clear(); QReglas->SQL->Add(sqlstring); QReglas->Open(); QReglas->Last(); QReglas->First();

while (!QReglas->Eof) sqlstring=QReglas->FieldByName("Modificacion")->AsString; sqlstring.Insert(Tabla,0); sqlstring.Insert("UPDATE ",0); QAplicar->SQL->Clear(); QAplicar->SQL->Add(sqlstring); QAplicar->ExecSQL();

QReglas->Next();

delete(QReglas); delete(QAplicar); sqlstring.~AnsiString();

//Evalua los resultados de las reglas aplicadas sobre la tabla de NombreTablashort int TDMID3::EvaluarResultados(AnsiString NombreTabla) /*Arma una tabla de resultados de la forma: Correcto Errores Probabilidad de acierto Clase1 x y t Clase2 m n l .... ... ... ... ClaseN z w v Totales totC totE totProb */TTablaCorrel TablaRes;int i, correctos,erroneos;



TQuery *QClases=new TQuery(DMID3);TQuery *QRes=new TQuery(DMID3);AnsiString sqlstring;TFrmRendimiento *pForm;

try pForm=FrmRendimiento; //Inicializamos los nombres de las columnas pForm->GridResultados->Cells[0][0]="Clases"; pForm->GridResultados->Cells[1][0]="Correctos"; pForm->GridResultados->Cells[2][0]="Errores"; pForm->GridResultados->Cells[3][0]="Probabilidad de Aciertos";

QClases->DatabaseName=Params->NombreBD; QRes->DatabaseName=Params->NombreBD;

//Obtenemos los nombres de todas las clases sqlstring="SELECT DISTINCT(ClaseReal) as Clase FROM "; AppendStr(sqlstring,NombreTabla); QClases->SQL->Clear(); QClases->SQL->Add(sqlstring); QClases->Open();

QClases->First(); i=0; while(!QClases->Eof) pForm->GridResultados->Cells[0][i+1]=QClases->FieldByName("Clase")->AsString;

//Correctos sqlstring=QClases->FieldByName("Clase")->AsString; sqlstring.Insert(" WHERE ClaseReal='",0); sqlstring.Insert(NombreTabla,0); sqlstring.Insert("SELECT Count(*) as Correctos FROM ",0); AppendStr(sqlstring,"' AND ClaseReal="); AppendStr(sqlstring,Params->ColClasificador); QRes->SQL->Clear(); QRes->SQL->Add(sqlstring); QRes->Open(); QRes->First(); TablaRes[i][0]=(double)QRes->FieldByName("Correctos")->AsInteger; pForm->GridResultados->Cells[1][i+1]=TablaRes[i][0];

//Errores sqlstring=QClases->FieldByName("Clase")->AsString; sqlstring.Insert(" WHERE ClaseReal='",0); sqlstring.Insert(NombreTabla,0); sqlstring.Insert("SELECT Count(*) as Erroneos FROM ",0); AppendStr(sqlstring,"' AND ClaseReal<>"); AppendStr(sqlstring,Params->ColClasificador); QRes->SQL->Clear(); QRes->SQL->Add(sqlstring); QRes->Open(); QRes->First(); TablaRes[i][1]=QRes->FieldByName("Erroneos")->AsInteger; pForm->GridResultados->Cells[2][i+1]=TablaRes[i][1];

QClases->Next(); pForm->GridResultados->RowCount++; i++;

QClases->First(); i=0; correctos=0; erroneos=0; while(!QClases->Eof) /*Calculamos la probabilidad con que un ejemplo clasificado como de clase i pertenece a dicha clase*/ TablaRes[i][2]=TablaRes[i][0]/(TablaRes[i][0]+TablaRes[i][1]); pForm->GridResultados->Cells[3][i+1]=TablaRes[i][2]; correctos+=TablaRes[i][0]; erroneos+=TablaRes[i][1]; QClases->Next();



i++; //Resultados generales TablaRes[i][0]=correctos; TablaRes[i][1]=erroneos; TablaRes[i][2]=TablaRes[i][0]/(TablaRes[i][0]+TablaRes[i][1]); pForm->GridResultados->Cells[0][i+1]="Totales"; pForm->GridResultados->Cells[1][i+1]=TablaRes[i][0]; pForm->GridResultados->Cells[2][i+1]=TablaRes[i][1]; pForm->GridResultados->Cells[3][i+1]=TablaRes[i][2];

QClases->Close(); QRes->Close(); delete(QClases); delete(QRes); sqlstring.~AnsiString(); return(0); catch(...) delete(QClases); delete(QRes); sqlstring.~AnsiString(); return(-1);

short int TDMID3::EvaluarReglas(int codigoReglas)/*Devuelve: 0: no hubo problemas -1: problema general -2: problema en la creación de la tabla de evaluación -3: problema en la inicialización de la tabla de evaluación */

boolean CrearTabla; AnsiString consulta; TStringList *listaCampos = new TStringList(); TQuery *QIni=new TQuery(DMID3); TTable *TEval=new TTable(DMID3); int i; short int errorNo;

try TEval->Active=false; TEval->DatabaseName=Params->NombreBD; TEval->TableName="Eval.db"; TEval->TableType=ttDefault; TEval->FieldDefs->Clear(); TFieldDef *NewField=TEval->FieldDefs->AddFieldDef(); NewField->DataType=ftString; NewField->Name="ClaseReal"; i=0; while ((TTennis->FieldDefs->Items[i]->Name!=Params->ColClasificador) &&(i<TTennis->FieldDefs->Count-1)) i++; if (i<TTennis->FieldDefs->Count-1) NewField->Size=TTennis->FieldDefs->Items[i]->Size; else NewField->Size=255;

for (i=0; i<TTennis->FieldDefs->Count; i++) NewField=TEval->FieldDefs->AddFieldDef(); NewField->DataType=TTennis->FieldDefs->Items[i]->DataType; NewField->Size=TTennis->FieldDefs->Items[i]->Size; NewField->Name=TTennis->FieldDefs->Items[i]->Name;

CrearTabla=false; if(TEval->Exists) if (Application->MessageBox((AnsiString("Sobreescribimos la tabla") + TEval->TableName + AnsiString("?")).c_str(), "Tabla Existente", MB_YESNO) == IDYES)



CrearTabla=true; else CrearTabla=true; if (CrearTabla) TEval->CreateTable(); TEval->Active=true; errorNo=0; catch(...) errorNo=-2;

if (errorNo==0) //no hubo problemas //Inicializamos la tabla de evaluación try QIni->DatabaseName=Params->NombreBD;

//Obtenemos los nombres de las columnas TEval->GetFieldNames(listaCampos);

//Copiamos los datos de la tabla original consulta="INSERT INTO Eval.db ("; AppendStr(consulta,listaCampos->Strings[0]); for (i=1;i<listaCampos->Count;i++) AppendStr(consulta,", "); AppendStr(consulta,listaCampos->Strings[i]); AppendStr(consulta,") select trim("); AppendStr(consulta,Params->ColClasificador); AppendStr(consulta,") "); for (i=1;i<listaCampos->Count;i++) AppendStr(consulta,", "); AppendStr(consulta,listaCampos->Strings[i]); AppendStr(consulta," from "); AppendStr(consulta,Params->TablaBD); QIni->SQL->Clear(); QIni->SQL->Add(consulta); QIni->ExecSQL();

errorNo=0; catch(...) errorNo=-3;

if (errorNo==0) //no hubo problemas AplicarReglas(TEval->TableName ,codigoReglas); errorNo=EvaluarResultados(TEval->TableName);

TEval->Close(); TEval->DeleteTable(); delete(listaCampos); delete(TEval); delete(QIni); consulta.~AnsiString(); return(errorNo);

void __fastcall TDMID3::DMID3Destroy(TObject *Sender)int i; for (i=0;i<MAX_NIVELES;i++) VecValores[i].~AnsiString(); VecDescriptores[i].~AnsiString();

//---------------------------------------------------------------------------



D.4.2. UDMC45

D.4.2.1. UDMC45.h

//---------------------------------------------------------------------------#ifndef UDMC45H#define UDMC45H//---------------------------------------------------------------------------#include <Classes.hpp>#include <Db.hpp>#include <DBTables.hpp>#include <fstream.h>#include <stdio.h>#include <string.h>

#include "UTipos.h"#include "defns.h"#include "types.h"#include "Rulex.h"

#define Inc 2048#define LocalVerbosity(x) if (Sh >= 0 && VERBOSITY >= x)#define Intab(x) Indent(x, "| ")#define Tab "| "#define TabSize 4#define Width 80 /* ancho máx aproximado de un árbol en pantalla */

//---------------------------------------------------------------------------class TDMC45 : public TDataModule__published: // IDE-managed Components TDataSource *DSTTennis; TTable *TTennis; void __fastcall DMC45Destroy(TObject *Sender);private: TParametros *Params; /* Datos externos descriptos en extern.i */ short MaxAtt, MaxClass, MaxDiscrVal; DiscrValue MaxAttVal[MAX_CANT_DESCRIPTORES]; TStringList *ClassName,

*AttName;TTablaValores AttValName;

TVecValores SpecialStatus;String FileName;

ItemNo MaxItem; Description *Item; short VERBOSITY,

TRIALS; Boolean GAINRATIO,

SUBSET, UNSEENS;

ItemNo MINOBJS; float CF; Tree *Pruned; Boolean AllKnown; ItemCount

*Weight, /* Weight[i] = fracción actual del item i */ **Freq, /* Freq[x][c] = nro de items de clase c con resultado x */

*ValFreq, /* ValFreq[x] = nro.de items con resultado x */ *ClassFreq; /* ClassFreq[c] = nro.de items de clase c */

float *Gain, /* Gain[a] = info gain al dividir según el atrib a */

*Info, /* Info[a] = info potencial de div sobre el atrib a */ *Bar, /* Bar[a] = mejor valor límite para el atrib a */

*UnknownRate; /* UnknownRate[a] = proporción desconocida actual para el atrib a */

char *Tested; /* Tested[a] seteado si el atrib a ya ha sido testeado */ bool MultiVal; /* true cuando todos los atribs tienen muchos valores */

float *SplitGain, /* SplitGain[i] = gain con el valor del atrib del item i

como límite */



*SplitInfo; /* SplitInfo[i] = split info potencial */

ItemCount *Slice1, /* Slice1[c] = valores de Freq[x][c] en subconj.c */

*Slice2; /* Slice2[c] = valores de Freq[y][c] */

Conjunto **Subset; /* Subset[a][s] = subconj s para atrib a */

short *Subsets; /* Subsets[a] = nro. subconj para atrib a */ short Subtree; /* tamaño máx de subárbol impreso */ Tree Subdef[100]; /* punteros a los subárboles */

FILE *TRf; /* archivo para i/o del árbol */ char Fn[500]; /* nombre del archivo */

//----------------------------------------------------------------------

void GetNames(); /* Lee los nombres de las clases, atributos y valores legales de */ /* atributos. */ void GetData(); //Lee los datos de la tabla Description GetDescription(); int VerificarPK(AnsiString Atrib); /* Verifica si el atributo Atrib es clave primaria de la tabla Devuelve: 0 si es PK 1 en caso contrario -1 si hubo error*/ int PosicionValor(AnsiString Valor,int nro_atrib, int pri, int ult); /* Busca la posición del Valor para el atributo especificado por el nro_atrib en el Tabla de Valores de atributos y la devuelve */ int PosicionClase(AnsiString Valor); /* Busca la posición del Valor en el vector de la clase */ void OneTree(); /* Construye y poda un árbol a partir de todos los datos */ void Evaluate(bool CMInfo,short Saved); /* Imprime los errores para cada una de las pruebas */ void InitialiseTreeData(); /* Reserva espacio para las tablas de construcción */ void InitialiseWeights(); /* Inicializa el peso de cada item */ Tree FormTree(ItemNo Fp, ItemNo Lp); /* Construye un árbol de decisión para los casos Fp hasta Lp */ ItemNo Group(DiscrValue V, ItemNo Fp, ItemNo Lp,Tree TestNode); /* Agrupa los ítems correspondiente a la rama V de una prueba y y devuelve el índice del último ítem */ void Intercambio(ItemNo a, ItemNo b); /* Intercambia los items en a y b */ ItemCount CountItems(ItemNo Fp, ItemNo Lp); /* Devuelve el peso total de los items desde Fp hasta Lp */

/*************************************************************************/ /* */ /* Calculo de la información, ganancia de información e */ /* impresión de distribuciones */ /* */ /*************************************************************************/ float Worth(float ThisInfo, float ThisGain, float MinGain); /* Determina el valor de una división particular según el criterio elegido */ void ResetFreq(DiscrValue MaxVal); /* Resetea las tablas de frecuencia Freq[][] y ValFreq[] */ float ComputeGain(float BaseInfo,float UnknFrac, DiscrValue MaxVal,ItemCountTotalItems); /* Dadas las tablas Freq[][] y ValFreq[], computa la ganancia de información */ float TotalInfo(ItemCount V[], DiscrValue MinVal, DiscrValue MaxVal); /* Computa la información total en V[ MinVal..MaxVal ] */ void PrintDistribution(Attribute Att,DiscrValue MaxVal,bool ShowNames); /* Imprime la tabla de distribución para un atributo determinado */

/*************************************************************************/ /* */ /* Rutinas de manejo de los árboles de decisión */ /* */ /*************************************************************************/



Tree Leaf(ItemCount *ClassFreq, ClassNo NodeClass,ItemCount Cases,ItemCountErrors); /* Construye una hoja en un determinado nodo */ void Sprout(Tree Node, DiscrValue Branches); /* Inserta ramas en un nodo */ Tree PrintTree(Tree T); /*Imprime el árbol de decisión T*/ void Show(Tree T,short Sh); /* Muestra el árbol T con offset Sh*/ void ShowBranch(short Sh,Tree T,DiscrValue v); /* Imprime un nodo T con offset Sh, valor de rama v */ short MaxLine(Tree St); /* Encuentra el tamaño máx de una línea nodo para el subárbol St */ void Indent(short Sh,char *Mark); /* Indenta Sh columnas */ void SaveTree(Tree T,AnsiString Extension); /*Guarda el árbol T en el archivo con la extension especificada */ void OutTree(Tree T); /*Guarda el árbol T como caracteres */ Tree GetTree(AnsiString Extension); /*Obtiene el árbol T del archivo de la extensión especificada */ Tree InTree(); /*Recupera el árbol a partir de los caracteres guardados */ void StreamOut(AnsiString s,int n); void StreamIn(AnsiString s,int n); /* Stream caracteres de/hacia el archivo TRf desde/hacia una dir */ void ReleaseTree(Tree Node); /* Libera el espacio ocupado por Node */ int TreeSize(Tree Node); /*Cuenta los nodos de un árbol */ Tree CopyTree(Tree T); /* Devuelve una copia de tree T */ void SaveDiscreteNames(); /* Guarda los valores de los atributos leídos con "discrete N" */ void RecoverDiscreteNames(); /* Recupera los valores de los atributos leídos con "discrete N" */

/*************************************************************************/ /* */ /* Evaluación del armado de subconjuntos sobre los atrib discretos */ /* */ /*************************************************************************/ void EvalSubset(Attribute Att, ItemNo Fp, ItemNo Lp,ItemCount Items); /* Evaluación del armado de subconjuntos sobre un atrib discreto. */ void Combine(DiscrValue x,DiscrValue y,DiscrValue Last); /* Combina los valores de la distribución de los atributos discretos x e y */ void Uncombine(DiscrValue x,DiscrValue y); /* Devuelve a x e y sus valores originales */ void PrintSubset(Attribute Att,Conjunto Ss); /* Imprime los valores del atributo Att que estan en el subconjunto Ss */ void SubsetTest(Tree Node,Attribute Att); /* Construye una prueba de nodo sobre un subconjunto de valores */ void EvalDiscreteAtt(Attribute Att,ItemNo Fp,ItemNo Lp,ItemCount Items); /* Setea Info[] and Gain[] para la partición discreta de items Fp hasta Lp */ void ComputeFrequencies(Attribute Att,ItemNo Fp,ItemNo Lp); /* Computa las tablas de frecuencia Freq[][] y ValFreq[] para Att */ float DiscrKnownBaseInfo(DiscrValue KnownItems,ItemCount MaxVal); /* Devuelve la información base de los items con valores conocidos de un atributo discreto, utilizando la tabla de frecuencias Freq[][] */ void DiscreteTest(Tree Node,Attribute Att); /* Construye y devuelve un nodo para una prueba sobre un atributo discreto */

/*************************************************************************/ /* */ /* Evaluación de una prueba sobre un atributo continuo */ /* */ /*************************************************************************/ void EvalContinuousAtt(Attribute Att,ItemNo Fp,ItemNo Lp); void ContinTest(Tree Node,Attribute Att); /* Transforma una hoja en una prueba sobre un atributo continuo */ float GreatestValueBelow(Attribute Att,float t); /* Devuelve el mayor valor del atributo Att por debajo del límite t */

void Quicksort(ItemNo Fp,ItemNo Lp,Attribute Att);//, void (*Exchange)()); /* Ordenamiento */



/*************************************************************************/ /* */ /* Poda un árbol de decisión y predice su proporción de error */ /* */ /*************************************************************************/ Conjunto *PossibleValues;//=Nil; bool Changed; bool Prune(Tree T); /*Poda el árbol T y devuelve true si el árbol fue modificado */ float EstimateErrors(Tree T, ItemNo Fp,ItemNo Lp,short Sh,bool UpdateTree); /*Estima los errores en un determinado subárbol */ void CheckPossibleValues(Tree T); /* Elimina pruebas de subconjuntos innecesarias sobre valores faltantes */

/* Computa los errores adicionales */ float Val[], Dev[]; float AddErrs(ItemCount N,ItemCount e);

/*************************************************************************/ /* */ /* Determina la clase de un caso a partir del árbol de decisión */ /* */ /*************************************************************************/ float *ClassSum; /* ClassSum[c]= peso total de la clase c */ ClassNo Category(Description CaseDesc,Tree DecisionTree); /* Categoriza la descripción de un caso utilizando el árbol de decisión */ void Classify(Description CaseDesc,Tree T,float Weight); /* Clasifica un caso utilizando el subárbol dado, ajustando el valor de ClassSum para cada clase */ Tree *Raw;

void PrintConfusionMatrix(ItemNo *ConfusionMat); /*Imprime matrices de confusión */

/*************************************************************************/ /* */ /* REGLAS DE DECISIÓN */ /* */ /*************************************************************************/ /* Variables usadas en la generación de reglas */ bool SIGTEST, /* uso de la prueba de significado en

la poda de reglas */ SIMANNEAL; /* uso de simulated annealing */ float SIGTHRESH,

REDUNDANCY; /* factor que estima la cantidad de de redundancia e irrelevancia

en los atributos */ PR *Rule; /* reglas actuales */ RuleNo NRules, /* nro de reglas actuales */

*RuleIndex; /* índice de reglas */ short RuleSpace; /* espacio reservado para las reglas */ ClassNo DefaultClass; /* clase por defecto */ RuleSet *PRSet; /* conjuntos de reglas */ float AttTestBits, /* bits para codificar el atrib

testeado */*BranchBits; /* idem para el valor del atrib */

fstream FReglas; //guarda los datos generados durante la generación de lasreglas con el C4.5 float *LogItemNo; double *LogFact; ItemNo *TargetClassFreq, /* [Boolean] */

*Errors, /* [Condición] */ *Total; /* [Condición] */ float *Pessimistic, /* [Condición] */

*Actual, /* [Condición] */ *CondSigLevel; /* [Condición] */ bool **CondSatisfiedBy, /* [Condición][NroItem] */ *Deleted; /* [Condición] */ DiscrValue *SingleValue; /* [Atributo] */ Condition *Stack; short MaxDisjuncts,

MaxDepth; ItemNo *Covered, /* Covered[i] = nro.de reglas que cubren el item i */ *FalsePos, /* FalsePos[c] = nro.de falsos positivos de las

reglas seleccionadas para la calse c */



*NoRule, /* NoRule[c] = nro.de items cubiertos por ninguna de las reglas selecciondas */

*Right, /* Right[r] = nro. de aciertos */ *Wrong; /* Wrong[r] = nro. de fallas */

float *Value, /* Value[r] = ventaja atribuíble a la regla r o realizable si la regla r es incluída */

SubsetValue, /* valor de la mejor clase del subconjunto */ CodeWeight; /* factor de multiplicación para la codificación de las

reglas */ bool *RuleIn, /* RuleIn[r] = true si la regla r está incluída */

**Match; /* Match[r][i] = true si el item i cumple las cond de la regla r */

RuleNo *ClassRules; /* lista de todas las reglas para la clase actual */

ClassNo FocusClass;

Test *TestVec; short NTests; float Confidence; /* factor de certeza de la regla aplicada (determinado por BestRuleIndex) */

void GenerateLogs();// Creación del vector LogItemNo void GenerateRules();/* Generación de todos los conjuntos de reglas a partir de los árboles de decisión */ void FindTestCodes(); /*Determina las longitudes de los codigos para los atributos y las ramas */ void SwapUnweighted(ItemNo a,ItemNo b);/*Intercambio de los items en a y b. */ void CompositeRuleset();/*Creación de un conjunto compuesto de reglas de todaslas pruebas */ void FormRules(Tree t);/*Creación de un conjunto de reglas del árbol de decisiónt */ void TreeParameters(Tree t,short d);/* Calcula la profundidad máx y el nro de hojas en el arbol t con profundidad inicial d*/ void Scan(Tree t,short d);/* Extrae los disjuntos del arbol t en la profundidad d y los procesa */ void ConstructRuleset();/* Construcción de un subconjunto ordenado (indexado por el RuleIndex)a partir del actual conjunto de reglas*/ void InitialiseTables();/*Inicialización de tablas*/ void CoverClass();/*Seleccionamos un subconjunto de las reglas para la FocusClass */ void AllCombinations(RuleNo NR); /* Probamos todas las combinaciones de reglas para encontrar la mejor */ void SimAnneal(RuleNo RuleCount);/*Búsqueda de un buen subconjunto mediante simulated annealing */ void SpotSearch(RuleNo RuleCount);/* Busca un buen subconjunto mediante una búsqueda golosa reiterativa*/ void HillClimb(RuleNo RuleCount);/* Mejora un subconjunto de reglas agregando o eliminando reglas */ void CalculateValue();/* Calculamos los aciertos y errores para las reglas de la FocusClass y determinamos el valor de dichas reglas. Si es el mejor hasta ahora, loguardamos.*/ void AddRule(RuleNo r);/* Agregamos la regla r al conj de relgas incluidas e incrementamos la cantidad de reglas que cubren los items que disparan la regla*/ void DeleteRule(RuleNo r);/* Eliminamos la regla r del conj de reglas incluídas y decrementamos la cant de reglas que cubren cada uno de los items cubiertos por la regla*/ void MakeIndex();/* Crea un índice de reglas incluídas en RuleIndex. Selecciona primero aquellas clases cuyas reglas tienen el menor nro de falsos positivos dentro de cada clase, pone las reglas con más aciertos primero */ void FindDefault();/* Determina la clase por defecto. Los empates se resuelven a favor de la clase más frecuente*/ float Fuerza(PR ThisRule,Description Case);/* Dados una regla y un caso, determina la fuerza con la que podemos determinar que el caso pertenece a la clase especificada en la regla */ float Biased(int N, int E, float ExpE);/* Determina el nro de bits necesarios para codificar las excepciones*/ float ExceptionBits(int Fires, int FP, int FN); void FindRuleCodes();/* Determina la longitud de codificación para todas las reglas*/ float CondBits(Condition C);/* Determina el nro de bits requerido para



codificar una condición */

void SaveRules();/* Guarda el conjunto de reglas en el archivo de reglas según el orden del índice*/ void GetRules();/* Obtiene un nuevo conj de reglas del archivo de reglas*/ Test FindTest(Test Newtest);/* Busca una prueba en el vector de pruebas, si no está allí, la agrega */ bool SameTest(Test t1,Test t2);/*Verifica si la prueba t1 es igual a la prueba t2*/ void InitialiseRules();/*Limpia las variables para un nuevo conj de reglas */ bool NewRule(Condition Cond[],short NConds,ClassNo TargetClass,float Err); /* Agrega una nueva regla, al conjunto de reglas actual. Actualiza Rule[],NRules y,en caso de ser necesario,RuleSpace*/ bool SameRule(RuleNo r,Condition Cond[],short NConds,ClassNo TargetClass); /* Decide si la regla actual duplica la regla r */ void PrintIndexedRules();/*Imprime el conjunto indexado de reglas*/ void PrintRule(RuleNo r);/*Imprime la regla r */ void PrintCondition(Condition c);/*Imprime la condición c de una regla deproducción*/

void PruneRule(Condition Cond[],short NCond,ClassNo TargetClass); /* Poda la regla dadas las condiciones Cond, y el nro de condiciones NCond, y agrega la regla resultante al actual conjunto de reglas si es lo suficientemente precisa*/ bool Redundant(short R,Condition Cond[],short NCond);/* Verifica si la condición R es redundante*/ bool IsSubset(Conjunto S1,Conjunto S2,Attribute Att); /* Decide si el subconj de valores S1 está contenido en S2 */ void FindTables(short NCond,ClassNo TargetClass);/* Busca las tablas de distribución de frecuencias para la condiciones actuales*/ void UpdateCount(ItemNo T[],ItemNo E[],short d,bool OK); /* Incrementa los valores de Total[d] y Errors[d]*/ bool Satisfies(Description CaseDesc,Condition OneCond); /*Determina si la descripción de un caso satisface la cond dada*/ double Hypergeom(int a,int r,int A,int B);/* Distribución hipergeometrica (usa los log de los factoriales tabulados)*/ float TableProb(int t11,int t12,int t21,int t22);/* TableProb examina la tabla t de contingencias de 2x2 y calcula la probabilidad de que una división al azar pueda producir una división al menos tan extrema como esta. */ void EvaluateRulesets(bool DeleteRules);/*Evalúa todos los conj de reglas*/ ItemNo Interpret(ItemNo Fp,ItemNo Lp,bool DeleteRules, bool CMInfo, boolArrow); /*Evalúa el conjunto de reglas actual*/ RuleNo BestRuleIndex(Description CaseDesc,RuleNo Start);/*Busca la mejor regla para el caso dado, dejando la probabilidad en Confidence*/

public: __fastcall TDMC45(TComponent* Owner); void RecibirParametros(TParametros *Parametros); void C45(); //dispara el proceso del C4.5 con los parámetros recibidos void GenerarReglasC45(); //dispara el proceso de generación de las reglas dedecisión;

//---------------------------------------------------------------------------extern PACKAGE TDMC45 *DMC45;//---------------------------------------------------------------------------#endif

D.4.2.2. UDMC45.cpp

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "UDMC45.h"//---------------------------------------------------------------------------#pragma package(smart_init)#pragma resource "*.dfm"

TDMC45 *DMC45;fstream FVitacora; //guarda los datos generados durante la ejecución del C4.5



//---------------------------------------------------------------------------__fastcall TDMC45::TDMC45(TComponent* Owner) : TDataModule(Owner) MaxDiscrVal = 2; FileName = "DF"; VERBOSITY = 0; TRIALS = 10; GAINRATIO = true; SUBSET = false; UNSEENS = false; MINOBJS = 2; AllKnown = true;

Val[0]=0; Val[1]=0.001; Val[2]=0.005; Val[3]=0.01; Val[4]=0.05; Val[5]=0.10; Val[6]=0.20; Val[7]=0.40; Val[8]=1.00; //Val[] = 0, 0.001, 0.005, 0.01, 0.05, 0.10, 0.20, 0.40, 1.00; Dev[0]=4.0; Dev[1]=3.09; Dev[2]=2.58; Dev[3]=2.33; Dev[4]=1.65; Dev[5]=1.28; Dev[6]=0.84; Dev[7]=0.25; Dev[8]=0.00; //Dev[] = 4.0, 3.09, 2.58, 2.33, 1.65, 1.28, 0.84, 0.25, 0.00; //*ClassSum=0;

//------------------------------------------------------------------------------void TDMC45::RecibirParametros(TParametros *Parametros)AnsiString sqlstring;TQuery *QGral=new TQuery(DMC45);

Params=Parametros;

TTennis->DatabaseName=Params->NombreBD; TTennis->TableName=Params->TablaBD; TTennis->Active=true;

//Inicializamos los queries que harán sus consultas sobre la base //especificada QGral->DatabaseName=Params->NombreBD;

//Inicializamos el campo Nivel en la Tabla sqlstring="Update "; AppendStr(sqlstring, Params->TablaBD); AppendStr(sqlstring," SET Nivel = 0 "); QGral->SQL->Clear(); QGral->SQL->Add(sqlstring); QGral->ExecSQL(); QGral->SQL->Clear(); TTennis->Close(); TTennis->Open();

sqlstring.~AnsiString(); delete(QGral);

//---------------------------------------------------------------------------void __fastcall TDMC45::DMC45Destroy(TObject *Sender)int i,j;

delete ClassName; delete AttName;



for (i=0;i<MAX_NIVELES;i++) for (j=0;j<MAX_NIVELES;j++) AttValName[i][j].~AnsiString(); SpecialStatus[i].~AnsiString();

/*************************************************************************//* *//* Principal c4.5 *//* ------------------ *//* *//* Basado en el código propuesto por Quinlan en: *//* Quinlan, "C4.5: Programs for Machine Learning" (1993) *//* Morgan Kaufman Publishers, San Mateo, California *//*************************************************************************/

void TDMC45::C45()extern int optind;short Best;char outFile[50]="Log\\C45";

DateSeparator='-'; TimeSeparator='_'; strcat(outFile, DateTimeToStr(Now()).c_str()); strcat(outFile, Params->TablaBD.c_str()); strcat(outFile, ".log"); FVitacora.open(outFile, ios::out);

FileName = Params->TablaBD; VERBOSITY = 5; //grado de explicación en el Log if (Params->iCriterio==0) GAINRATIO = false; if (Params->iConjuntos==0) SUBSET = true;

MINOBJS = Params->iMinObjs;

CF =Params->iCF; Check(CF, Epsilon, 100); CF /= 100;

/* Inicialización */

GetNames(); GetData(); FVitacora<<(MaxItem+1); FVitacora<<" casos ("; FVitacora<<MaxAtt; FVitacora<<" atributos) leídos de "; FVitacora<<Params->TablaBD.c_str();

/* Construcción de los árboles de decisión */

TRIALS = 1; OneTree(); Best = 0;

if ( TRIALS == 1 ) FVitacora<<endl;

FVitacora<<"El árbol ha sido guardado con éxito."; FVitacora<<endl;

SaveTree(Pruned[Best], ".tree");

/* Evaluamos los resultados */ FVitacora<<endl; FVitacora<<endl; FVitacora<<"Evaluación sobre los datos de prueba ("; FVitacora<<(MaxItem+1); FVitacora<<" ítems):"; FVitacora<<endl; Evaluate(false, Best);



if ( UNSEENS ) GetData(); FVitacora<<endl; FVitacora<<"Evaluación sobre los datos de prueba ("; FVitacora<<(MaxItem+1); FVitacora<<" ítems):"; FVitacora<<endl; Evaluate(true, Best);

exit(0);

FVitacora.close();

/*************************************************************************//* *//* Lee los nombres de las clases, atributos y valores legales de *//* atributos. *//* Cuando termina, los nombres se almacenan en: *//* ClassName - nombres de las clases *//* AttName - nombres de los atributos *//* AttValName - nombres de los valores de los atributos *//* con: *//* MaxAttVal - cantidad de valores para cada atributo *//* *//* Las otras variables globales que se setean son: *//* MaxAtt - número máximo de atributos *//* MaxClass - número máximo de clases *//* MaxDiscrVal - número máximo de valores discretos para *//* cualquier atributo */

/* *//*************************************************************************/void TDMC45::GetNames()int i,j;TQuery *QGral=new TQuery(DMC45);AnsiString sqlstring;

try /* Obtenemos los nombres de las clases */ ClassName = new TStringList(); ClassName->AddStrings(Params->LClasificadores); MaxClass = ClassName->Count;

/* Obtenemos los atributos y los nombres de sus valores */ MaxAtt=TTennis->FieldCount-2; //le restamos la clase y la columna Nivel del ID3 AttName=new TStringList();

QGral->DatabaseName=Params->NombreBD; sqlstring=") as Campo from "; AppendStr(sqlstring, Params->TablaBD); MaxDiscrVal=-1;

for (i=0;i<MaxAtt;i++) if (TTennis->Fields->Fields[i]->FieldName!=Params->ColClasificador) if (VerificarPK(TTennis->Fields->Fields[i]->FieldName)==0 ||TTennis->Fields->Fields[i]->FieldName=="Nivel" ) SpecialStatus[i]="IGNORAR"; else AttName->Add(TTennis->Fields->Fields[i]->FieldName);

/* Verificamos los tipos de datos */ if ( TTennis->Fields->Fields[i]->DataType!=ftString)//es contínuo

SpecialStatus[i] = "CONTINUOUS"; else //es discreto

SpecialStatus[i] = "DISCRETE";

//Cargamos los valores del atributo QGral->SQL->Clear();



QGral->SQL->Add("SELECT DISTINCT("+ TTennis->Fields->Fields[i]->FieldName + sqlstring); QGral->Open(); QGral->First(); j=0; while (!QGral->Eof) AttValName[i][j]=QGral->FieldByName("Campo")->AsString; QGral->Next(); j++; MaxAttVal[i] = (DiscrValue) j;

/* Leemos la máxima cantidad de valores, y chequeamos MaxDiscrVal */

if (j>MaxDiscrVal) MaxDiscrVal=j;

catch(...) Application->MessageBox("Error en la carga de los datos delarchivo","Error",MB_OK|MB_ICONWARNING);

delete(QGral); sqlstring.~AnsiString();

//---------------------------------------------------------------------------/*************************************************************************//* *//* Lee los casos de la tabla. *//* *//* Al terminar,los casos se almacenan en el vector Item con la forma *//* de Descriptions (i.e. vectores de valores de atributos), *//* y se le asigna a MaxItem el número de items de datos. *//* *//*************************************************************************/void TDMC45::GetData() ItemNo i=-1, ItemSpace; Description GetDescription(); TQuery *QData=new TQuery(DMC45); int Dv; float Cv; Variant Atributo; Description Dvec; Attribute Att; AnsiString AtDiscreto;

try ItemSpace=0; QData->DatabaseName=Params->NombreBD; QData->SQL->Clear(); QData->SQL->Add("SELECT * FROM " + Params->TablaBD); QData->Open(); QData->First();

do ++i;

MaxItem = i;

/* Verificamos si hay lugar para otro ítem */

if ( i >= ItemSpace ) if ( ItemSpace )

ItemSpace += Inc;Item = (Description *)



realloc(Item, ItemSpace*sizeof(Description)); else

Item = (Description *)malloc((ItemSpace=Inc)*sizeof(Description));

Dvec = (Description) calloc(MaxAtt+2, sizeof(AttValue));

for(Att=0;Att<MaxAtt;Att++) Atributo=QData->FieldValues[TTennis->Fields->Fields[Att]->FieldName];

if ( SpecialStatus[Att] == "IGNORAR" )

/* Salteamos este valor */

DVal(Dvec, Att) = 0; else if ( MaxAttVal[Att] || SpecialStatus[Att] == "DISCRETE" )

/* Valor discreto */ AtDiscreto=AnsiString(Atributo);

if ( AtDiscreto.AnsiCompareIC("?")==0) Dv = 0;

else

Dv = PosicionValor(AtDiscreto,Att, 0, MaxAttVal[Att]); DVal(Dvec, Att) = Dv; else

/* Valor Continuo */

if ( Atributo.VType==varEmpty || Atributo.VType==varNull) Cv = Unknown;

else Cv = double(Atributo);CVal(Dvec, Att) = Cv;

Class(Dvec) = PosicionClase(QData->FieldByName(Params->ColClasificador)->AsString);

Item[i] = Dvec; QData->Next();

while ( Item[i] != NULL && !(QData->Eof) ); QData->Close();

catch(...) Application->MessageBox("Error en la carga de los datos delarchivo","Error",MB_OK|MB_ICONWARNING); delete (QData); AtDiscreto.~AnsiString();

//-----------------------------------------------------------------------------int TDMC45::PosicionValor(AnsiString Valor,int nro_atrib, int pri, int ult) /* Busca la posición del Valor para el atributo especificado por el nro_atrib en el Tabla de Valores de atributos y la devuelve */int i;



i=pri; while (AttValName[nro_atrib][i].AnsiCompareIC(Valor)!=0 && i<=ult) i++; return(i<=ult ? i : pri-1);

int TDMC45::PosicionClase(AnsiString Valor) /* Busca la posición del Valor en el vector de la clase */int i; i=0; while (ClassName->Strings[i].Trim()!=Valor.Trim() && i<=MaxClass) i++; return(i<=MaxClass ? i : -1);

//-----------------------------------------------------------------------------int TDMC45::VerificarPK(AnsiString Atrib)/* Verifica si el atributo Atrib es clave primaria de la tabla Devuelve: o si es PK 1 en caso contrario -1 si hubo error */AnsiString sqlstring;int cantReg,res;TQuery *QGral=new TQuery(DMC45);

cantReg=TTennis->RecordCount;

try sqlstring="SELECT COUNT(DISTINCT "; AppendStr(sqlstring,Atrib); AppendStr(sqlstring," ) as Cant FROM "); AppendStr(sqlstring, Params->TablaBD); QGral->DatabaseName=Params->NombreBD; QGral->SQL->Clear(); QGral->SQL->Add(sqlstring); QGral->Open(); QGral->First(); if (QGral->FieldByName("Cant")->AsInteger==cantReg) res=0; //es PK else res=1; catch(...) res=-1; delete (QGral); sqlstring.~AnsiString(); return(res);

/*************************************************************************//* Construye y poda un árbol a partir de todos los datos *//* *//*************************************************************************/void TDMC45::OneTree()ItemNo *TargetClassFreq;Tree *Raw;Tree *Pruned;

InitialiseTreeData(); InitialiseWeights();

Raw = (Tree *) calloc(1, sizeof(Tree)); Pruned = (Tree *) calloc(1, sizeof(Tree));

AllKnown = true; Raw[0] = FormTree(0, MaxItem); FVitacora<<endl; PrintTree(Raw[0]);

SaveTree(Raw[0], ".unpruned");



Pruned[0] = CopyTree(Raw[0]); if ( Prune(Pruned[0]) ) FVitacora<<endl; FVitacora<<"Simplificamos el ";

PrintTree(Pruned[0]);

/*************************************************************************//* *//* Imprime los errores para cada una de las pruebas *//* *//*************************************************************************/void TDMC45::Evaluate(bool CMInfo,short Saved) char outFile[50]="Eval"; ClassNo RealClass, PrunedClass; short t; ItemNo *ConfusionMat, i, RawErrors, PrunedErrors; fstream FEvalRendimiento; //guarda los datos de la evaluación de rendimiento //para el C4.5

if ( CMInfo )

ConfusionMat = (ItemNo *) calloc((MaxClass+1)*(MaxClass+1), sizeof(ItemNo));

DateSeparator='-'; TimeSeparator='_'; strcat(outFile, DateTimeToStr(Now()).c_str()); strcat(outFile, Params->TablaBD.c_str()); strcat(outFile, ".log"); FEvalRendimiento.open(outFile, ios::out);

FVitacora<<endl;

if ( TRIALS > 1 ) FVitacora<<"Prueba Antes de Podar Después de Podar"; FVitacora<<endl; FVitacora<<"------ --------------- ------------------"; FVitacora<<endl; else FVitacora<<" Antes de Podar Después de Podar"; FVitacora<<endl; FVitacora<<" --------------- ------------------"; FVitacora<<endl; FVitacora<<" Tamaño Errores Tamaño Errores Estimación"; FVitacora<<endl; FVitacora<<endl;

ForEach(t, 0, TRIALS-1)

RawErrors = PrunedErrors = 0;

ForEach(i, 0, MaxItem) RealClass = Class(Item[i]);

if ( Category(Item[i], Raw[t]) != RealClass ) RawErrors++;

PrunedClass = Category(Item[i], Pruned[t]);

if ( PrunedClass != RealClass ) PrunedErrors++;

if ( CMInfo && t == Saved )

ConfusionMat[RealClass*(MaxClass+1)+PrunedClass]++;



if ( TRIALS > 1 )

FVitacora<<t;

FVitacora<<" "; FVitacora<<TreeSize(Raw[t]); FVitacora<<" "; FVitacora<<RawErrors; FVitacora<<"("; FVitacora<<(100.0*RawErrors / (MaxItem+1.0)); FVitacora<<") "; FVitacora<<TreeSize(Pruned[t]); FVitacora<<" "; FVitacora<<PrunedErrors; FVitacora<<"("; FVitacora<<(100.0*PrunedErrors / (MaxItem+1.0)); FVitacora<<") ("; FVitacora<<(100 * Pruned[t]->Errors / Pruned[t]->Items); FVitacora<<")"; if (t==Saved) FVitacora<<" <<"; FVitacora<<endl;

if ( CMInfo )

PrintConfusionMatrix(ConfusionMat);free(ConfusionMat);

FEvalRendimiento.close();

/*************************************************************************//* *//* Reserva espacio para las tablas de construcción *//* *//*************************************************************************/void TDMC45::InitialiseTreeData() DiscrValue v; Attribute a;

Tested = (char *) calloc(MaxAtt+1, sizeof(char));

Gain = (float *) calloc(MaxAtt+1, sizeof(float)); Info = (float *) calloc(MaxAtt+1, sizeof(float)); Bar = (float *) calloc(MaxAtt+1, sizeof(float));

Subset = (Conjunto **) calloc(MaxAtt+1, sizeof(Conjunto *)); ForEach(a, 0, MaxAtt)

if ( MaxAttVal[a] ) Subset[a] = (Conjunto *) calloc(MaxDiscrVal+1, sizeof(Conjunto)); ForEach(v, 0, MaxAttVal[a])

Subset[a][v] = (Conjunto) malloc((MaxAttVal[a]>>3) + 1);

Subsets = (short *) calloc(MaxAtt+1, sizeof(short));

SplitGain = (float *) calloc(MaxItem+1, sizeof(float)); SplitInfo = (float *) calloc(MaxItem+1, sizeof(float));

Weight = (ItemCount *) calloc(MaxItem+1, sizeof(ItemCount));

Freq = (ItemCount **) calloc(MaxDiscrVal+1, sizeof(ItemCount *)); ForEach(v, 0, MaxDiscrVal)

Freq[v] = (ItemCount *) calloc(MaxClass+1, sizeof(ItemCount));

ValFreq = (ItemCount *) calloc(MaxDiscrVal+1, sizeof(ItemCount)); ClassFreq = (ItemCount *) calloc(MaxClass+1, sizeof(ItemCount));



Slice1 = (ItemCount *) calloc(MaxClass+2, sizeof(ItemCount)); Slice2 = (ItemCount *) calloc(MaxClass+2, sizeof(ItemCount));

UnknownRate = (float *) calloc(MaxAtt+1, sizeof(float));

/* Verificamos si todos los atributos tienen muchos valores discretos */

MultiVal = true; if ( ! SUBSET )

for ( a = 0 ; MultiVal && a <= MaxAtt ; a++ ) if ( SpecialStatus[a] != "IGNORAR" )

MultiVal = MaxAttVal[a] >= 0.3 * (MaxItem + 1);

/*************************************************************************//* *//* Inicializa el peso de cada item *//* *//*************************************************************************/void TDMC45::InitialiseWeights() ItemNo i;

ForEach(i, 0, MaxItem) Weight[i] = 1.0;

/*************************************************************************//* *//* Construye un árbol de decisión para los casos Fp hasta Lp: *//* *//* - si todos los casos son de la misma clase, el árbol es una hoja, *//* y devuelve una hoja con dicha clase *//* *//* - para cada atributo, calcular la información potencial provista *//* por una prueba sobre el atributo (basada en las probabilidades *//* de que cada caso tenga un valor particular para el atributo), *//* y la ganancia en información que resultaría de una prueba *//* sobre el atributo (basada en las probabilidades de cada caso *//* con un valor particular para el atributo pertenezca a una *//* determinada clase). *//* *//* - sobre esta base, y dependiendo del criterio de selección actual, *//* encontrar el mejor atributo para crear una rama. *//* Nota: no se permitirán divisiones sobre un atributo a menos *//* que dos o más subconjuntos tengan al menos MINOBJS items. *//* *//* - intentar crear una rama y analizar si es mejor que crear una hoja *//* *//*************************************************************************/Tree TDMC45::FormTree(ItemNo Fp, ItemNo Lp) ItemNo i, Kp, Ep; ItemCount Cases, NoBestClass, KnownCases; float Factor, BestVal, Val, AvGain=0; Attribute Att, BestAtt, Possible=0; ClassNo c, BestClass; Tree Node; DiscrValue v; bool PrevAllKnown;

Cases = CountItems(Fp, Lp);

/* Generamos la distribución en frecuencias de la clase */

ForEach(c, 0, MaxClass)

ClassFreq[c] = 0;



ForEach(i, Fp, Lp)

ClassFreq[ Class(Item[i]) ] += Weight[i];

/* Buscamos la clase más frecuente */

BestClass = 0; ForEach(c, 0, MaxClass)

if ( ClassFreq[c] > ClassFreq[BestClass] ) BestClass = c;

NoBestClass = ClassFreq[BestClass];

Node = Leaf(ClassFreq, BestClass, Cases, Cases - NoBestClass);

/* Si todos los casos son de la misma clase o no hay suficientes casospara dividir, el árbol es una hoja */

if ( NoBestClass == Cases || Cases < 2 * MINOBJS )

return Node;

Verbosity(1) FVitacora<<(Lp-Fp+1); FVitacora<<" ítems, peso total "; FVitacora<<Cases; FVitacora<<endl;

/* Para cada atributo disponible, calculamos la información y la ganancia */

ForEach(Att, 0, MaxAtt-1)

Gain[Att] = -Epsilon;

if ( SpecialStatus[Att] == "IGNORAR" ) continue;

if ( MaxAttVal[Att] ) /* atributo discreto */

if ( SUBSET && MaxAttVal[Att] > 2 )

EvalSubset(Att, Fp, Lp, Cases); else if ( ! Tested[Att] ) EvalDiscreteAtt(Att, Fp, Lp, Cases); else /* atributo continuo */

EvalContinuousAtt(Att, Fp, Lp);

/* Actualizamos la ganancia promedio, excluyendo los atributos con muchos valores */

if ( Gain[Att] > -Epsilon && ( MultiVal || MaxAttVal[Att] < 0.3 * (MaxItem + 1) ) ) Possible++; AvGain += Gain[Att];

/* Buscamos el mejor atributo de acuerdo al criterio determinado */



BestVal = -Epsilon; BestAtt = None; AvGain = ( Possible ? AvGain / Possible : 1E6 );

Verbosity(2)

if ( AvGain < 1E6 ) FVitacora<<" ganancia promedio "; FVitacora<<AvGain; FVitacora<<endl;

ForEach(Att, 0, MaxAtt-1)

if ( Gain[Att] > -Epsilon ) Val = Worth(Info[Att], Gain[Att], AvGain); if ( Val > BestVal ) BestAtt = Att; BestVal = Val;

/* Decidimos crear una rama o no */

if ( BestAtt != None )

Verbosity(1)

FVitacora<<" mejor atributo "; FVitacora<<AttName->Strings[BestAtt].c_str();

if ( ! MaxAttVal[BestAtt] )

FVitacora<<" corte "; FVitacora<<Bar[BestAtt];

FVitacora<<" inf "; FVitacora<<Info[BestAtt]; FVitacora<<" ganancia "; FVitacora<<Gain[BestAtt]; FVitacora<<" val "; FVitacora<<BestVal; FVitacora<<endl;

/* Construir un nodo con la prueba seleccionada */

if ( MaxAttVal[BestAtt] ) /* Atributo discreto */

if ( SUBSET && MaxAttVal[BestAtt] > 2 ) SubsetTest(Node, BestAtt); else DiscreteTest(Node, BestAtt); else /* Atributo continuo */

ContinTest(Node, BestAtt);

/* Eliminamos los valores de atributo desconocidos */

PrevAllKnown = AllKnown;

Kp = Group(0, Fp, Lp, Node) + 1;if ( Kp != Fp ) AllKnown = false;



KnownCases = Cases - CountItems(Fp, Kp-1);UnknownRate[BestAtt] = (Cases - KnownCases) / (Cases + 0.001);

Verbosity(1) if ( UnknownRate[BestAtt] > 0 )

FVitacora<<" proporciones desconocidas para "; FVitacora<<AttName->Strings[BestAtt].c_str(); FVitacora<<" = "; FVitacora<<UnknownRate[BestAtt]; FVitacora<<endl;

/* Divide y reinarás recursivo */

++Tested[BestAtt];

Ep = Kp - 1;Node->Errors = 0;

ForEach(v, 1, Node->Forks) Ep = Group(v, Kp, Lp, Node);

if ( Kp <= Ep )

Factor = CountItems(Kp, Ep) / KnownCases;

ForEach(i, Fp, Kp-1) Weight[i] *= Factor;

Node->Branch[v] = FormTree(Fp, Ep);Node->Errors += Node->Branch[v]->Errors;

Group(0, Fp, Ep, Node);ForEach(i, Fp, Kp-1) Weight[i] /= Factor;

else

Node->Branch[v] = Leaf(Node->ClassDist, BestClass, 0.0, 0.0);

--Tested[BestAtt];AllKnown = PrevAllKnown;

/* Analizamos si con una hoja obtenemos resultados similares */

if ( Node->Errors >= Cases - NoBestClass - Epsilon ) Verbosity(1)

FVitacora<<"Colapsamos el árbol para "; FVitacora<<(Lp-Fp+1); FVitacora<<" ítems a la hoja "; FVitacora<<ClassName->Strings[BestClass].c_str(); FVitacora<<endl;

Node->NodeType = 0;

else

Verbosity(1) FVitacora<<" no hay divisiones razonables "; FVitacora<<Cases; FVitacora<<" "; FVitacora<<(Cases - NoBestClass); FVitacora<<endl;



return Node;

/*************************************************************************//* *//* Agrupa los ítems correspondiente a la rama V de una prueba y *//* y devuelve el índice del último ítem *//* *//* Nota: si V está vacía, agrupa valores desconocidos *//* *//*************************************************************************/ItemNo TDMC45::Group(DiscrValue V, ItemNo Fp, ItemNo Lp,Tree TestNode) ItemNo i; Attribute Att; float Thresh; Conjunto SS;

Att = TestNode->Tested;

if ( V )

/* Agrupar items según el valor del atributo Att, según el tipo de rama */

switch ( TestNode->NodeType ) case BrDiscr:

for(i=Fp;i<Lp;i++) if ( DVal(Item[i], Att) == V ) Intercambio(Fp++, i);break;

case ThreshContin:

Thresh = TestNode->Cut; for(i=Fp;i<Lp;i++)

if ( (CVal(Item[i], Att) <= Thresh) == (V == 1) ) Intercambio(Fp++,

i);break;

case BrSubset:

SS = TestNode->Subset[V]; for(i=Fp;i<Lp;i++)

if ( In(DVal(Item[i], Att), SS) ) Intercambio(Fp++, i);break;

else

/* Agrupar valores desconocidos */switch ( TestNode->NodeType ) case BrDiscr: case BrSubset:

for(i=Fp;i<Lp;i++) if ( ! DVal(Item[i], Att) ) Intercambio(Fp++, i);break;

case ThreshContin:

for(i=Fp;i<Lp;i++)



if ( CVal(Item[i], Att) == Unknown ) Intercambio(Fp++, i);break;

return Fp - 1;

/*************************************************************************//* *//* Intercambia los items en a y b *//* *//*************************************************************************/void TDMC45::Intercambio(ItemNo a, ItemNo b) register Description Hold; register ItemCount HoldW;

Hold = Item[a]; Item[a] = Item[b]; Item[b] = Hold;

HoldW = Weight[a]; Weight[a] = Weight[b]; Weight[b] = HoldW;

/*************************************************************************//* *//* Devuelve el peso total de los items desde Fp hasta Lp *//* *//*************************************************************************/

ItemCount TDMC45::CountItems(ItemNo Fp, ItemNo Lp) register ItemCount Sum=0.0, *Wt, *LWt;

if ( AllKnown ) return Lp - Fp + 1;

for ( Wt = Weight + Fp, LWt = Weight + Lp ; Wt <= LWt ; )

Sum += *Wt++;

return Sum;

//------------------------------------------------------------------------------/*************************************************************************//* *//* Determina el valor de una división particular según el criterio *//* elegido *//* *//* Parámetros: *//* SplitInfo: información potencial de la división *//* SplitGain: ganancia en información de la división *//* MinGain: ganancia a partir de la cual el *//* Gain Ratio puede usarse *//* *//* Si se está utilizando el criterio de Gain,se devuelve la ganancia de *//* información de la división, pero si se está utilizando el criterio *//* de GainRatio, se devuelve la proporción de la ganancia de *//* información con respecto a su información potencial. *//* *//*************************************************************************/float TDMC45::Worth(float ThisInfo, float ThisGain, float MinGain) if ( GAINRATIO )

if ( ThisGain >= MinGain - Epsilon && ThisInfo > Epsilon ) return ThisGain / ThisInfo;else



return -Epsilon;

else

return ( ThisInfo > 0 && ThisGain > -Epsilon ? ThisGain : -Epsilon );

/*************************************************************************//* *//* Resetea las tablas de frecuencia Freq[][] y ValFreq[] *//* *//*************************************************************************/void TDMC45::ResetFreq(DiscrValue MaxVal) DiscrValue v; ClassNo c;

for (v=0;v<MaxVal;v++) for (c=0;c<MaxClass;c++)

Freq[v][c] = 0;ValFreq[v] = 0;

/*************************************************************************//* *//* Dadas las tablas Freq[][] y ValFreq[], computa la ganancia *//* de información. *//* *//* Parámetros: *//* BaseInfo: información promedio para todos los *//* items con valores conocidos del *//* atributo que se está testeando *//* UnknownRate: fracción de los items con valor del *//* atributo desconocido *//* MaxVal: cantidad de divisiones *//* TotalItems: nro de items con valores conocidos para *//* el atributo que se está testeando *//* *//* donde Freq[x][y] contiene el nro de casos con valor x para un *//* atributo particular que pertenecen a la clase y, *//* y ValFreq[x] contiene el nro de casos con valor x para un *//* atributo particular *//* *//*************************************************************************/float TDMC45::ComputeGain(float BaseInfo,float UnknFrac, DiscrValue MaxVal,ItemCountTotalItems) DiscrValue v; float ThisInfo=0.0, ThisGain; short ReasonableSubsets=0;

/* Verificamos si se conocen todos los valores o si son todos iguales */

if ( ! TotalItems ) return -Epsilon;

/* Deben existir al menos dos subconjuntos con MINOBJS items */ for (v=1;v<MaxVal;v++)

if ( ValFreq[v] >= MINOBJS ) ReasonableSubsets++; if ( ReasonableSubsets < 2 ) return -Epsilon;

/* Calculamos la info total después de la división, sumando lainfo de cada uno de los subconjuntos resultantes de la división */

for(v=1;v<MaxVal;v++)

ThisInfo += TotalInfo(Freq[v], 0, MaxClass);

/* Seteamos la ganancia de información para todos los items,ajustada para los desconocidos */



ThisGain = (1 - UnknFrac) * (BaseInfo - ThisInfo / TotalItems);

Verbosity(5) FVitacora<<"CalculoEstaGanancia: items "; FVitacora<<(TotalItems + ValFreq[0]); FVitacora<<" info "; FVitacora<<ThisInfo; FVitacora<<" desc "; FVitacora<<UnknFrac; FVitacora<<" resultado "; FVitacora<<ThisGain<<endl; return ThisGain;

/*************************************************************************//* *//* Computa la información total en V[ MinVal..MaxVal ] *//* *//*************************************************************************/float TDMC45::TotalInfo(ItemCount V[], DiscrValue MinVal, DiscrValue MaxVal) DiscrValue v; float Sum=0.0; ItemCount N, TotalItems=0;

for(v=MinVal;v<MaxVal;v++)

N = V[v];

Sum += N * Log(N);TotalItems += N;

return TotalItems * Log(TotalItems) - Sum;

/*************************************************************************//* *//* Imprime la tabla de distribución para un atributo determinado *//* *//*************************************************************************/void TDMC45::PrintDistribution(Attribute Att,DiscrValue MaxVal,bool ShowNames) DiscrValue v; ClassNo c; String Val;

FVitacora<<endl; FVitacora<<" "; for(c=0;c<MaxClass;c++) FVitacora<<ClassName->Strings[c].c_str(); FVitacora<<endl;

for(v=0;v<MaxVal;v++)

if ( ShowNames )

if ( !v) Val="desconocidos"; else if (MaxAttVal[Att]) Val=AttValName[Att][v]; else if(v == 1)



Val="menores"; else Val="mayores"; FVitacora<<Val.c_str();

else

FVitacora<<v;

for(c=0;c<MaxClass;c++)

FVitacora<<Freq[v][c];

FVitacora<<endl;

/*************************************************************************//* *//* Construye una hoja en un determinado nodo *//* *//*************************************************************************/Tree TDMC45::Leaf(ItemCount *ClassFreq, ClassNo NodeClass,ItemCount Cases,ItemCountErrors) Tree Node;

Node = (Tree) calloc(1, sizeof(tree_record));

Node->ClassDist = (ItemCount *) calloc(MaxClass+1, sizeof(ItemCount)); memcpy(Node->ClassDist, ClassFreq, (MaxClass+1) * sizeof(ItemCount));

Node->NodeType = 0; Node->Leaf = NodeClass; Node->Items = Cases; Node->Errors = Errors;

return Node;

/*************************************************************************//* *//* Inserta ramas en un nodo *//* *//*************************************************************************/void TDMC45::Sprout(Tree Node, DiscrValue Branches) Node->Forks = Branches;

Node->Branch = (Tree *) calloc(Branches+1, sizeof(Tree));

/*************************************************************************//* *//* Muestra todo el árbol de decisión T *//* *//*************************************************************************/Tree TDMC45::PrintTree(Tree T) short s;

Subtree=0; FVitacora<<"Árbol de decisión"; FVitacora<<endl; Show(T, 0); FVitacora<<endl;

ForEach(s, 1, Subtree)



FVitacora<<endl; FVitacora<<endl; FVitacora<<"Subárbol "; FVitacora<<s;

Show(Subdef[s], 0);FVitacora<<endl;

FVitacora<<endl;

/*************************************************************************//* *//* Muestra el árbol T con offset Sh *//* *//*************************************************************************/void TDMC45::Show(Tree T,short Sh) DiscrValue v, MaxV;

if ( T->NodeType )

/* Verificamos si se necesita un nuevo subárbol */ if ( (T->Items!=0) && (Sh) && (Sh * TabSize + MaxLine(T) > Width) )

if ( Subtree < 99 )

Subdef[++Subtree] = T; FVitacora<<Subtree;

else

FVitacora<<"[S??]"; else MaxV = T->Forks;

/* Imprimimos los casos simples primero */ ForEach(v, 1, MaxV)

if ( ! T->Branch[v]->NodeType ) ShowBranch(Sh, T, v);

/* Imprimimos los subárboles */

ForEach(v, 1, MaxV)

if ( T->Branch[v]->NodeType ) ShowBranch(Sh, T, v);

else FVitacora<<ClassName->Strings[T->Leaf].c_str(); FVitacora<<"("; FVitacora<<T->Items;

if ( T->Errors > 0 ) FVitacora<<T->Errors;FVitacora>>")";

/*************************************************************************//* *//* Imprime un nodo T con offset Sh, valor de rama v *//* *//*************************************************************************/void TDMC45::ShowBranch(short Sh,Tree T,DiscrValue v) DiscrValue Pv, Last; Attribute Att;



bool FirstValue; short TextWidth, Skip, Values=0, i;

Att = T->Tested;

switch ( T->NodeType )

case BrDiscr: Indent(Sh, Tab);

FVitacora<<AttName->Strings[Att].c_str(); FVitacora<<" = "; FVitacora<<AttValName[Att][v].c_str();

break;

case ThreshContin: Indent(Sh, Tab);

FVitacora<<AttName->Strings[Att].c_str(); FVitacora<<" "; if (v==1) FVitacora<<"<="; else FVitacora<<">"; FVitacora<<" "; FVitacora<<T->Cut;

if ( T->Lower != T->Upper )

FVitacora<<"["; FVitacora<<T->Lower; FVitacora<<","; FVitacora<<T->Upper;

FVitacora<<":"; break;

case BrSubset: /* Contar los valores de la rama */ ForEach(Pv, 1, MaxAttVal[Att])

if ( In(Pv, T->Subset[v]) ) Last = Pv; Values++;

if ( ! Values ) return;

Indent(Sh, Tab);

if ( Values == 1 )

FVitacora<<AttName->Strings[Att].c_str(); FVitacora<<" = "; FVitacora<<AttValName[Att][Last].c_str(); FVitacora<<":";

break;

FVitacora<<AttName->Strings[Att].c_str(); FVitacora<<" en ";

FirstValue = true; Skip = TextWidth = AttName->Strings[Att].Length() + 5;

ForEach(Pv, 1, MaxAttVal[Att])

if ( In(Pv, T->Subset[v]) ) if ( ! FirstValue &&

TextWidth + AttValName[Att][Pv].Length() + 11 > Width ) Indent(Sh, Tab);

ForEach(i, 1, Skip) putchar(' ');

TextWidth = Skip;FirstValue = true;



FVitacora<<AttValName[Att][Pv].c_str(); if (Pv==Last) FVitacora<<""; else FVitacora<<",";

TextWidth += AttValName[Att][Pv].Length() + 1; FirstValue = false;

putchar(':');

Show(T->Branch[v], Sh+1);

/*************************************************************************//* *//* Encuentra el tamaño máx de una línea nodo para el subárbol St. *//* El formato de la línea es *//* <atributo> <> X.xx:[ <clase (<Items>)], o *//* <atributo> = <DVal>:[ <clase> (<Items>)] *//* *//*************************************************************************/short TDMC45::MaxLine(Tree St) Attribute a; DiscrValue v, MaxV, Next; short Ll, MaxLl=0;

a = St->Tested;

MaxV = St->Forks; ForEach(v, 1, MaxV)

Ll = ( St->NodeType == 2 ? 4 : AttValName[a][v].Length() ) + 1;

/* Buscamos la rama apropiada */

Next = v;

if ( ! St->Branch[Next]->NodeType ) Ll += ClassName->Strings[St->Branch[Next]->Leaf].Length() + 6;MaxLl = Max(MaxLl, Ll);

return AttName->Strings[a].Length() + 4 + MaxLl;

/*************************************************************************//* *//* Indenta Sh columnas *//* *//*************************************************************************/void TDMC45::Indent(short Sh,char *Mark) FVitacora<<endl; while ( Sh-- ) FVitacora<<Mark;

/*************************************************************************//* *//* Guardamos el árbol T completo en el archivo *//* de extensión Extension *//* *//*************************************************************************/void TDMC45::SaveTree(Tree T,AnsiString Extension) static char *LastExt="";

if ( strcmp(LastExt, Extension.c_str()) )

LastExt = Extension.c_str();

if ( TRf ) fclose(TRf);



strcpy(Fn, FileName.c_str());strcat(Fn, Extension.c_str());

if ( ! ( TRf = fopen(Fn, "w") ) ) FVitacora<<"Error al abrir el archivo de salida del árbol"; FVitacora<<endl;

putc('\n', TRf); OutTree(T);

SaveDiscreteNames();

/*************************************************************************//* *//* Guardamos el árbol T como caracteres *//* *//*************************************************************************/void TDMC45::OutTree(Tree T) DiscrValue v; int Bytes;

StreamOut((char *) &T->NodeType, sizeof(short)); StreamOut((char *) &T->Leaf, sizeof(ClassNo)); StreamOut((char *) &T->Items, sizeof(ItemCount)); StreamOut((char *) &T->Errors, sizeof(ItemCount)); StreamOut((char *) T->ClassDist, (MaxClass + 1) * sizeof(ItemCount));

if ( T->NodeType )

StreamOut((char *) &T->Tested, sizeof(Attribute));StreamOut((char *) &T->Forks, sizeof(short));

switch ( T->NodeType ) case BrDiscr:

break;

case ThreshContin:StreamOut((char *) &T->Cut, sizeof(float));StreamOut((char *) &T->Lower, sizeof(float));StreamOut((char *) &T->Upper, sizeof(float));break;

case BrSubset:Bytes = (MaxAttVal[T->Tested]>>3) + 1;ForEach(v, 1, T->Forks) StreamOut((char *) T->Subset[v], Bytes);break;

ForEach(v, 1, T->Forks) OutTree(T->Branch[v]);

/*************************************************************************//* *//* Obtiene el árbol de decisión con extensión Extension *//* *//*************************************************************************/Tree TDMC45::GetTree(AnsiString Extension) Tree Hold; static char *LastExt="";

if ( strcmp(LastExt, Extension.c_str()) )

LastExt = Extension.c_str();




strcpy(Fn, FileName.c_str());strcat(Fn, Extension.c_str());if ( ! ( TRf = fopen(Fn, "r") ) )

FVitacora<<"Error al leer del archivo del árbol"; FVitacora<<endl;

if ( ! TRf || getc(TRf) == EOF ) Hold->Items=0; return Hold;

Hold = InTree();

RecoverDiscreteNames();

return Hold;

/*************************************************************************//* *//* Recuperar el árbol a partir de los caracteres guardados *//* *//*************************************************************************/Tree TDMC45::InTree() Tree T; DiscrValue v; int Bytes;

T = (Tree) malloc(sizeof(tree_record));

StreamIn((char *) &T->NodeType, sizeof(short)); StreamIn((char *) &T->Leaf, sizeof(ClassNo)); StreamIn((char *) &T->Items, sizeof(ItemCount)); StreamIn((char *) &T->Errors, sizeof(ItemCount));

T->ClassDist = (ItemCount *) calloc(MaxClass+1, sizeof(ItemCount)); StreamIn((char *) T->ClassDist, (MaxClass + 1) * sizeof(ItemCount));

if ( T->NodeType )

StreamIn((char *) &T->Tested, sizeof(Attribute));StreamIn((char *) &T->Forks, sizeof(short));

switch ( T->NodeType ) case BrDiscr:

break;

case ThreshContin:StreamIn((char *) &T->Cut, sizeof(float));StreamIn((char *) &T->Lower, sizeof(float));StreamIn((char *) &T->Upper, sizeof(float));break;

case BrSubset:T->Subset = (Conjunto *) calloc(T->Forks + 1, sizeof(Conjunto));

Bytes = (MaxAttVal[T->Tested]>>3) + 1;ForEach(v, 1, T->Forks) T->Subset[v] = (Conjunto) malloc(Bytes); StreamIn((char *) T->Subset[v], Bytes);

T->Branch = (Tree *) calloc(T->Forks + 1, sizeof(Tree));ForEach(v, 1, T->Forks) T->Branch[v] = InTree();



return T;

/*************************************************************************//* *//* Stream caracteres de/hacia el archivo TRf desde/hacia una dir *//* *//*************************************************************************/void TDMC45::StreamOut(AnsiString s,int n)char *ss; ss=s.c_str(); while ( n-- ) putc(*ss++, TRf);

void TDMC45::StreamIn(AnsiString s,int n)char *ss; while ( n-- ) *ss++ = getc(TRf); s=AnsiString(ss);

/*************************************************************************//* *//* Libera el espacio ocupado por Node *//* *//*************************************************************************/void TDMC45::ReleaseTree(Tree Node) DiscrValue v;

if ( Node->NodeType )

ForEach(v, 1, Node->Forks) ReleaseTree(Node->Branch[v]);

free(Node->Branch);

if ( Node->NodeType == BrSubset )

free(Node->Subset);

free(Node->ClassDist); free(Node);

/*************************************************************************//* *//* Cuenta los nodos de un árbol *//* *//*************************************************************************/int TDMC45::TreeSize(Tree Node) int Sum=0; DiscrValue v;

if ( Node->NodeType )

ForEach(v, 1, Node->Forks) Sum += TreeSize(Node->Branch[v]);

return Sum + 1;

/*************************************************************************//* *//* Devuelve una copia de tree T */



/* *//*************************************************************************/Tree TDMC45::CopyTree(Tree T) DiscrValue v; Tree New;

New = (Tree) malloc(sizeof(tree_record)); memcpy(New, T, sizeof(tree_record));

New->ClassDist = (ItemCount *) calloc(MaxClass+1, sizeof(ItemCount)); memcpy(New->ClassDist, T->ClassDist, (MaxClass + 1) * sizeof(ItemCount));

if ( T->NodeType )

New->Branch = (Tree *) calloc(T->Forks + 1, sizeof(Tree));ForEach(v, 1, T->Forks) New->Branch[v] = CopyTree(T->Branch[v]);

return New;

/*************************************************************************//* *//* Guarda los valores de los atributos leídos con "discrete N" *//* *//*************************************************************************/void TDMC45::SaveDiscreteNames() Attribute Att; DiscrValue v; int Length;

ForEach(Att, 0, MaxAtt)

if ( SpecialStatus[Att] != "DISCRETE" ) continue;

StreamOut((char *) &MaxAttVal[Att], sizeof(int));

ForEach(v, 1, MaxAttVal[Att]) Length = AttValName[Att][v].Length() + 1;

StreamOut((char *) &Length, sizeof(int)); StreamOut((char *) AttValName[Att][v].c_str(), Length);

/*************************************************************************//* *//* Recupera los valores de los atributos leídos con "discrete N" *//* *//*************************************************************************/void TDMC45::RecoverDiscreteNames() Attribute Att; DiscrValue v; int Length;


if ( SpecialStatus[Att] != "DISCRETE" ) continue;

StreamIn(AnsiString(MaxAttVal[Att]), sizeof(int));

ForEach(v, 1, MaxAttVal[Att]) StreamIn(AnsiString(Length), sizeof(int));

AttValName[Att][v] = (char *) malloc(Length); StreamIn(AttValName[Att][v], Length);



/*************************************************************************//* *//* Evaluación del armado de subconjuntos sobre un atrib discreto. A *//* partir de los subconjuntos elegidos Subset[Att][], se asigna a *//* Subsets[Att] el nro de subconjuntos, y se calculan Info[] y Gain[] *//* de una prueba sobre el atributo of a test on the attribute. *//* *//*************************************************************************/void TDMC45::EvalSubset(Attribute Att, ItemNo Fp, ItemNo Lp,ItemCount Items) DiscrValue V1, V2, BestV1, BestV2, Barred; ItemCount KnownItems; ClassNo c; float BaseInfo, MinGain, ThisGain, ThisInfo,

Val, BestVal, BestGain, BestInfo,PrevVal, PrevGain, PrevInfo;

short Blocks=0, MissingValues=0, ReasonableSubsets, Bytes, b; bool MergedSubsets = false; int SaveMINOBJS;

SaveMINOBJS = MINOBJS; MINOBJS = 1;

/* Primero calculamos Freq[][], ValFreq[], info de base, y la gananciay la info total de una partición sobre el atrib discreto Att */

ComputeFrequencies(Att, Fp, Lp);

KnownItems = Items - ValFreq[0]; if ( KnownItems < Epsilon )

Verbosity(2) FVitacora<<AttName->Strings[Att].c_str(); FVitacora<<" no tiene valores conocidos "; FVitacora<<endl;

Gain[Att] = -Epsilon;Info[Att] = 0;return;

BaseInfo = DiscrKnownBaseInfo(KnownItems, MaxAttVal[Att]);

PrevGain = ComputeGain(BaseInfo, UnknownRate[Att], MaxAttVal[Att],KnownItems); PrevInfo = TotalInfo(ValFreq, 0, MaxAttVal[Att]) / Items; PrevVal = Worth(PrevInfo, PrevGain, Epsilon);

Verbosity(2) FVitacora<<AttName->Strings[Att].c_str();

Verbosity(3) PrintDistribution(Att, MaxAttVal[Att], true);

FVitacora<<"inf "; FVitacora<<PrevInfo; FVitacora<<" ganancia "; FVitacora<<PrevGain; FVitacora<<" val="; FVitacora<<PrevVal; FVitacora<<endl;

/* Eliminamos de Freq[] and ValFreq[] aquellos valores del atributoque no están representados, y creamos un subconjunto nuevo paracada uno de los valores representados del atributo */

Bytes = (MaxAttVal[Att]>>3) + 1; ClearBits(Bytes, Subset[Att][0]);

ForEach(V1, 1, MaxAttVal[Att])

if ( ValFreq[V1] > 0.5 )



if ( ++Blocks < V1 )

ValFreq[Blocks] = ValFreq[V1];ForEach(c, 0, MaxClass) Freq[Blocks][c] = Freq[V1][c];

ClearBits(Bytes, Subset[Att][Blocks]); SetBit(V1, Subset[Att][Blocks]);else SetBit(V1, Subset[Att][0]); MissingValues++;

/* Unimos los subconjuntos de una única clase con otrs de la misma clase */ /* Nota: ValFreq[V] > 0 para todo V */

ForEach(V1, 1, Blocks-1)

for ( c = 0 ; Freq[V1][c] < 0.1 ; c++ ) ;

if ( Freq[V1][c] < ValFreq[V1] - 0.1 ) continue;

/* Tenemos una única clase -- buscamos otras */

for ( V2 = V1+1 ; V2 <= Blocks ; ) if ( Freq[V2][c] < ValFreq[V2] - 0.1 )

V2++; else

/* Unimos estos subconjuntos */

Combine(V1, V2, Blocks);

ForEach(b, 0, Bytes-1) Subset[Att][V1][b] |= Subset[Att][V2][b]; Subset[Att][V2][b] = Subset[Att][Blocks][b];

Blocks--;MergedSubsets = true;

if ( MergedSubsets )

PrevGain = ComputeGain(BaseInfo, UnknownRate[Att], Blocks, KnownItems);PrevInfo = TotalInfo(ValFreq, 0, Blocks) / Items;PrevVal = Worth(PrevInfo, PrevGain, Epsilon);

Verbosity(2)

FVitacora<<"Luego de unir subconjuntos de una única clase:";

Verbosity(3) PrintDistribution(Att, Blocks, false);

FVitacora<<"inf "; FVitacora<<PrevInfo; FVitacora<<" ganancia "; FVitacora<<PrevGain; FVitacora<<" val="; FVitacora<<PrevVal; FVitacora<<endl;

/* Examinamos los pares posibles de uniones y aplicamos "hill-climbing" */



MinGain = PrevGain / 2;

while ( Blocks > 2 )

BestVal = BestV1 = 0;BestGain = -Epsilon;

/* Verificamos si existen subconjuntos razonables; si <3, unimos con el bloque más grande */

ReasonableSubsets = 0;Barred = 1;

ForEach(V1, 1, Blocks) if ( ValFreq[V1] >= SaveMINOBJS ) ReasonableSubsets++;

if ( ValFreq[V1] > ValFreq[Barred] ) Barred = V1;

if ( ReasonableSubsets >= 3 ) Barred = 0;

/* Para cada par de valores posibles, calculamos la ganancia y la info total de una división en la cual se tratan como una unidad. Almacenamos el par con mejor ganancia. */

ForEach(V1, 1, Blocks-1) ForEach(V2, V1+1, Blocks)

if ( V1 == Barred || V2 == Barred ) continue;

Combine(V1, V2, Blocks);

ThisGain = ComputeGain(BaseInfo, UnknownRate[Att],Blocks-1, KnownItems);

ThisInfo = TotalInfo(ValFreq, 0, Blocks-1) / Items;Val = Worth(ThisInfo, ThisGain, Epsilon);

Verbosity(4)

FVitacora<<"combinación "; FVitacora<<V1; FVitacora<<" "; FVitacora<<V2; FVitacora<<" info "; FVitacora<<ThisInfo; FVitacora<<" ganancia "; FVitacora<<ThisGain; FVitacora<<" val "; FVitacora<<Val;

PrintDistribution(Att, Blocks-1, false);

/* Forzamos una división si hay menos de dos subconj razonables o utilizamos la ganancia Elegimos esta división sobre la anterior si

gain >= MinGain (y la anterior < MinGain), oval >= mejor valor anterior */

if ( ThisGain >= MinGain && BestGain < MinGain || Val >= BestVal || ! BestV1 && ( ! GAINRATIO || ReasonableSubsets < 2 ) ) BestVal = Val; BestGain = ThisGain; BestInfo = ThisInfo; BestV1 = V1; BestV2 = V2;

Uncombine(V1, V2);

if ( GAINRATIO &&



ReasonableSubsets >= 2 && ( ! BestV1 || BestVal < PrevVal + 1E-5 || BestVal == PrevVal && BestGain < PrevGain ) ) break;

PrevGain = BestGain;PrevInfo = BestInfo;

PrevVal = BestVal;

Combine(BestV1, BestV2, Blocks);

ForEach(b, 0, Bytes-1) Subset[Att][BestV1][b] |= Subset[Att][BestV2][b]; Subset[Att][BestV2][b] = Subset[Att][Blocks][b];

Blocks--;

Verbosity(2)

FVitacora<<" formamos el subconjunto "; PrintSubset(Att, Subset[Att][BestV1]);

FVitacora<<": "; FVitacora<<Blocks; FVitacora<<" subconjuntos, inf "; FVitacora<<BestInfo; FVitacora<<" ganancia "; FVitacora<<BestGain; FVitacora<<" val "; FVitacora<<BestVal;

Verbosity(3)

FVitacora<<" combinación "; FVitacora<<BestV1; FVitacora<<" "; FVitacora<<BestV2;

PrintDistribution(Att, Blocks, false);

MINOBJS = SaveMINOBJS;

if ( PrevVal <= 0 )

Gain[Att] = -Epsilon;Info[Att] = 0;

else

Gain[Att] = ComputeGain(BaseInfo, UnknownRate[Att], Blocks, KnownItems);Info[Att] = PrevInfo;

if ( MissingValues ) Blocks++; CopyBits(Bytes, Subset[Att][0], Subset[Att][Blocks]);

Subsets[Att] = Blocks;

Verbosity(2) FVitacora<<" Subconjuntos finales: ";Verbosity(3) PrintDistribution(Att, Blocks, false);Verbosity(2)

FVitacora<<" inf "; FVitacora<< Info[Att]; FVitacora<<" ganancia "; FVitacora<<Gain[Att]; FVitacora<<" val "; FVitacora<< Worth(Info[Att], Gain[Att], Epsilon);



/*************************************************************************//* *//* Combina los valores de la distribución de los atributos discretos *//* x e y, guardando los nuevos valores en Freq[x][] y ValFreq[x][]. *//* Los valores anteriores se guardan en Slice1 y Slice2 *//* *//*************************************************************************/void TDMC45::Combine(DiscrValue x,DiscrValue y,DiscrValue Last) ClassNo c;


Slice1[c] = Freq[x][c];Slice2[c] = Freq[y][c];

Freq[x][c] += Freq[y][c];Freq[y][c] = Freq[Last][c];

Slice1[MaxClass+1] = ValFreq[x]; Slice2[MaxClass+1] = ValFreq[y];

ValFreq[x] += ValFreq[y]; ValFreq[y] = ValFreq[Last];

/*************************************************************************//* *//* Devuelve a x e y los valores de distribución originales a partir *//* de Slice1 y Slice2 *//* *//*************************************************************************/void TDMC45::Uncombine(DiscrValue x,DiscrValue y) ClassNo c;


Freq[x][c] = Slice1[c];Freq[y][c] = Slice2[c];

ValFreq[x] = Slice1[MaxClass+1]; ValFreq[y] = Slice2[MaxClass+1];

/*************************************************************************//* *//* Imprime los valores del atributo Att que estan en el subconjunto Ss *//* *//*************************************************************************/void TDMC45::PrintSubset(Attribute Att,Conjunto Ss) DiscrValue V1; bool First=true;

ForEach(V1, 1, MaxAttVal[Att])

if ( In(V1, Ss) ) if ( First )

First = false; else

FVitacora<<", ";

FVitacora<<AttValName[Att][V1].c_str();



/*************************************************************************//* *//* Construye una prueba de nodo sobre un subconjunto de valores *//* *//*************************************************************************/void TDMC45::SubsetTest(Tree Node,Attribute Att) short S, Bytes;

Sprout(Node, Subsets[Att]);

Node->NodeType = BrSubset; Node->Tested = Att; Node->Errors = 0;

Bytes = (MaxAttVal[Att]>>3) + 1; Node->Subset = (Conjunto *) calloc(Subsets[Att] + 1, sizeof(Conjunto)); ForEach(S, 1, Node->Forks)

Node->Subset[S] = (Conjunto) malloc(Bytes);CopyBits(Bytes, Subset[Att][S], Node->Subset[S]);

/*************************************************************************//* *//* Setea Info[] and Gain[] para la partición discreta de items *//* Fp hasta Lp *//* *//*************************************************************************/void TDMC45::EvalDiscreteAtt(Attribute Att,ItemNo Fp,ItemNo Lp,ItemCount Items) ItemCount KnownItems;

ComputeFrequencies(Att, Fp, Lp);

KnownItems = Items - ValFreq[0];

/* Caso especial cuando no existen valores conocidos del atributo */

if ( Items <= ValFreq[0] )

Verbosity(2) FVitacora<<AttName->Strings[Att].c_str();//AttName[Att]; FVitacora<<" no existen valores conocidos"; FVitacora<<endl;

Gain[Att] = -Epsilon;Info[Att] = 0.0;return;

Gain[Att] = ComputeGain(DiscrKnownBaseInfo(KnownItems, MaxAttVal[Att]), UnknownRate[Att], MaxAttVal[Att], KnownItems);

Info[Att] = TotalInfo(ValFreq, 0, MaxAttVal[Att]) / Items;

Verbosity(2) FVitacora<<AttName->Strings[Att].c_str(); Verbosity(3) PrintDistribution(Att, MaxAttVal[Att], true); FVitacora<<Info[Att]; FVitacora<<" ganancia "; FVitacora<<Gain[Att]; FVitacora<<endl;

/*************************************************************************//* */



/* Computa las tablas de frecuencia Freq[][] y ValFreq[] para el *//* atrib Att para los items desde Fp hasta Lp, y determina la *//* proporción de desconocidos (UnknownRate) para Att *//* *//*************************************************************************/void TDMC45::ComputeFrequencies(Attribute Att,ItemNo Fp,ItemNo Lp) Description Case; ClassNo c; DiscrValue v; ItemNo p;

ResetFreq(MaxAttVal[Att]);

/* Determinamos la frecuencia de cada clase según los casosde cada valor posible para el atributo dado */

ForEach(p, Fp, Lp)

Case = Item[p];Freq[ DVal(Case,Att) ][ Class(Case) ] += Weight[p];

/* Determinamos la frecuencia de cada valor posible para el atributo dado */

ForEach(v, 0, MaxAttVal[Att])

ForEach(c, 0, MaxClass) ValFreq[v] += Freq[v][c];

/* Determinamos la proporción de valores desconocidos para cada atributo */

UnknownRate[Att] = ValFreq[0] / CountItems(Fp, Lp);

/*************************************************************************//* *//* Devuelve la información base de los itemscon valores conocidos *//* de un atributo discreto, utilizando la tabla de frecuencias Freq[][] *//* *//*************************************************************************/float TDMC45::DiscrKnownBaseInfo(DiscrValue KnownItems,ItemCount MaxVal) ClassNo c; ItemCount ClassCount; double Sum=0; DiscrValue v;


ClassCount = 0;ForEach(v, 1, MaxVal) ClassCount += Freq[v][c];Sum += ClassCount * Log(ClassCount);

return (KnownItems * Log(KnownItems) - Sum) / KnownItems;

/*************************************************************************//* *//* Construye y devuelve un nodo para una prueba sobre un *//* atributo discreto *//* *//*************************************************************************/void TDMC45::DiscreteTest(Tree Node,Attribute Att) ItemCount CountItems();



Sprout(Node, MaxAttVal[Att]);

Node->NodeType = BrDiscr; Node->Tested = Att; Node->Errors = 0;

/*************************************************************************//* *//* Evaluación de una prueba sobre un atributo continuo *//* --------------------------------------------------- *//* *//*************************************************************************/

/*************************************************************************//* *//* Trabajamos ocmo si los atributos continuos tuviesen los siguientes *//* valores posibles: *//* 0 (desconocido), 1 (menor que el corte), 2(mayor que el corte) *//* Esta rutina busca el mejor corte para los items desde Fp hasta Lp *//* y setea Info[], Gain[] and Bar[] *//* *//*************************************************************************/void TDMC45::EvalContinuousAtt(Attribute Att,ItemNo Fp,ItemNo Lp) ItemNo i, BestI, Xp, Tries=0; ItemCount Items, KnownItems, LowItems, MinSplit; ClassNo c; float AvGain=0, Val, BestVal, BaseInfo, ThreshCost;

Verbosity(2) FVitacora<<"Atrib "; FVitacora<<AttName->Strings[Att].c_str(); Verbosity(3) FVitacora<<endl; ResetFreq(2);

/* Omitimos y contamos los valores desconocidos */

Items = CountItems(Fp, Lp); Xp = Fp; ForEach(i, Fp, Lp)

if ( CVal(Item[i],Att) == Unknown ) Freq[ 0 ][ Class(Item[i]) ] += Weight[i]; Intercambio(Xp, i); Xp++;

ValFreq[0] = 0; ForEach(c, 0, MaxClass)

ValFreq[0] += Freq[0][c];

KnownItems = Items - ValFreq[0]; UnknownRate[Att] = 1.0 - KnownItems / Items;

/* Caso especial cuando hay pocos valores conocidos */

if ( KnownItems < 2 * MINOBJS )

Verbosity(2) FVitacora<<"casos insuficientes con valores conocidos "; FVitacora<<endl;

Gain[Att] = -Epsilon;Info[Att] = 0.0;return;



Quicksort(Xp, Lp, Att);

/* Contamos los valores base y determimos la información base */

ForEach(i, Xp, Lp)

Freq[ 2 ][ Class(Item[i]) ] += Weight[i];SplitGain[i] = -Epsilon;SplitInfo[i] = 0;

BaseInfo = TotalInfo(Freq[2], 0, MaxClass) / KnownItems;

/* Probamos cortes posibles entre los items i e i+1, y determinamos lainformación y ganancia de cada corte.*/

MinSplit = 0.10 * KnownItems / (MaxClass + 1); if ( MinSplit <= MINOBJS ) MinSplit = MINOBJS; else if ( MinSplit > 25 ) MinSplit = 25;

LowItems = 0; ForEach(i, Xp, Lp - 1)

c = Class(Item[i]);LowItems += Weight[i];Freq[1][c] += Weight[i];Freq[2][c] -= Weight[i];

if ( LowItems < MinSplit ) continue;elseif ( LowItems > KnownItems - MinSplit ) break;

if ( CVal(Item[i],Att) < CVal(Item[i+1],Att) - 1E-5 ) ValFreq[1] = LowItems; ValFreq[2] = KnownItems - LowItems; SplitGain[i] = ComputeGain(BaseInfo, UnknownRate[Att], 2, KnownItems); SplitInfo[i] = TotalInfo(ValFreq, 0, 2) / Items; AvGain += SplitGain[i]; Tries++;

Verbosity(3) FVitacora<<" Corte en ";

FVitacora<<(( CVal(Item[i],Att) + CVal(Item[i+1],Att) ) / 2); FVitacora<<" (ganancia "; FVitacora<<SplitGain[i]; FVitacora<<" val "; FVitacora<<Worth(SplitInfo[i], SplitGain[i], Epsilon); FVitacora<<"):";

PrintDistribution(Att, 2, true);

/* Encontramos el mejor atributo según el criterio dado */

ThreshCost = Log(Tries) / Items;

BestVal = 0; BestI = None; ForEach(i, Xp, Lp - 1)

if ( (Val = SplitGain[i] - ThreshCost) > BestVal ) BestI = i; BestVal = Val;

/* Si una prueba sobre el atributo es capaz de lograr una ganancia,setear el mejor break point, ganancia e información */

if ( BestI == None )

Gain[Att] = -Epsilon;



Info[Att] = 0.0;

Verbosity(2) FVitacora<<" no hay ganancia "; FVitacora<<endl; else

Bar[Att] = (CVal(Item[BestI],Att) + CVal(Item[BestI+1],Att)) / 2;Gain[Att] = BestVal;Info[Att] = SplitInfo[BestI];

Verbosity(2) FVitacora<<" corte="; FVitacora<<Bar[Att]; FVitacora<<" inf "; FVitacora<<Info[Att]; FVitacora<<" ganancia "; FVitacora<<Gain[Att]; FVitacora<<endl;

/*************************************************************************//* *//* Transforma una hoja en una prueba sobre un atributo continuo *//* *//*************************************************************************/void TDMC45::ContinTest(Tree Node,Attribute Att) float Thresh;

Sprout(Node, 2);

Thresh = GreatestValueBelow(Att, Bar[Att]);

Node->NodeType = ThreshContin; Node->Tested = Att; Node->Cut = Node->Lower = Node->Upper = Thresh; Node->Errors = 0;

/*************************************************************************//* *//* Devuelve el mayor valor del atributo Att por debajo del límite t *//* *//*************************************************************************/float TDMC45::GreatestValueBelow(Attribute Att,float t) ItemNo i; float v, Best; bool NotYet=true;

ForEach(i, 0, MaxItem)

v = CVal(Item[i], Att);if ( v != Unknown && v <= t && ( NotYet || v > Best ) ) Best = v; NotYet = false;

return Best;

/*************************************************************************//* */



/* Ordena los items desde Fp hasta Lp según el atributo a *//* *//*************************************************************************///void TDMC45::Quicksort(ItemNo Fp,ItemNo Lp,Attribute Att, void (*Exchange)())void TDMC45::Quicksort(ItemNo Fp,ItemNo Lp,Attribute Att) register ItemNo Lower, Middle; register float Thresh; register ItemNo i;

if ( Fp < Lp )

Thresh = CVal(Item[Lp], Att);

/* Separamos todos los items con valores <= límite */

Middle = Fp;

for ( i = Fp ; i < Lp ; i++ ) if ( CVal(Item[i], Att) <= Thresh )

if ( i != Middle ) Intercambio(Middle,i);//(*Exchange)(Middle, i);Middle++;

/* Extraemos todos los valores iguales al límite */

Lower = Middle - 1;

for ( i = Lower ; i >= Fp ; i-- ) if ( CVal(Item[i], Att) == Thresh )

if ( i != Lower ) Intercambio(Lower,i);//(*Exchange)(Lower, i);Lower--;

/* Ordenamos los valores menores */

// Quicksort(Fp, Lower, Att, Exchange); Quicksort(Fp, Lower, Att);

/* Posicionamos el elemento del medio */

// (*Exchange)(Middle, Lp); Intercambio(Middle,Lp);

/* Ordenamos los valores mayores */

// Quicksort(Middle+1, Lp, Att, Exchange);Quicksort(Middle+1, Lp, Att);

/*************************************************************************//* *//* Poda el árbol T y devuelve true si el árbol fue modificado *//* *//*************************************************************************/bool TDMC45::Prune(Tree T) ItemNo i; Attribute a;

InitialiseWeights(); AllKnown = true;

Verbosity(1) FVitacora<<endl;

Changed = false;



EstimateErrors(T, 0, MaxItem, 0, true);

if ( SUBSET )

if ( ! PossibleValues ) PossibleValues = (Conjunto *) calloc(MaxAtt+1, sizeof(Conjunto));

ForEach(a, 0, MaxAtt) if ( MaxAttVal[a] )

PossibleValues[a] = (Conjunto) malloc((MaxAttVal[a]>>3) + 1);ClearBits((MaxAttVal[a]>>3) + 1, PossibleValues[a]);ForEach(i, 1, MaxAttVal[a]) SetBit(i, PossibleValues[a]);

CheckPossibleValues(T);

return Changed;

/*************************************************************************//* *//* Estima los errores en un determinado subárbol *//* *//*************************************************************************/float TDMC45::EstimateErrors(Tree T, ItemNo Fp,ItemNo Lp,short Sh,bool UpdateTree) ItemNo i, Kp, Ep; ItemCount Cases, KnownCases, *LocalClassDist, TreeErrors, LeafErrors,

ExtraLeafErrors, BranchErrors,Factor, MaxFactor; DiscrValue v, MaxBr; ClassNo c, BestClass; bool PrevAllKnown;

/* Generamos la distribución de clases */

Cases = CountItems(Fp, Lp); LocalClassDist = (ItemCount *) calloc(MaxClass+1, sizeof(ItemCount));

ForEach(i, Fp, Lp)

LocalClassDist[ Class(Item[i]) ] += Weight[i];

/* Buscamos la clase más frecuente y actualizamos el árbol */

BestClass = T->Leaf; ForEach(c, 0, MaxClass)

if ( LocalClassDist[c] > LocalClassDist[BestClass] ) BestClass = c;

LeafErrors = Cases - LocalClassDist[BestClass]; ExtraLeafErrors = AddErrs(Cases, LeafErrors);

if ( UpdateTree )

T->Items = Cases;T->Leaf = BestClass;memcpy(T->ClassDist, LocalClassDist, (MaxClass + 1) * sizeof(ItemCount));

if ( ! T->NodeType ) /* hoja */

TreeErrors = LeafErrors + ExtraLeafErrors;



if ( UpdateTree ) T->Errors = TreeErrors;

LocalVerbosity(1)

Intab(Sh); FVitacora<<ClassName->Strings[T->Leaf].c_str(); FVitacora<<" ( "; FVitacora<<T->Items; FVitacora<<":"; FVitacora<<LeafErrors; FVitacora<<"/"; FVitacora<<T->Errors; FVitacora<<endl;

free(LocalClassDist);

return TreeErrors;

/* Estimamos los errores para cada rama */

Kp = Group(0, Fp, Lp, T) + 1; KnownCases = CountItems(Kp, Lp);

PrevAllKnown = AllKnown; if ( Kp != Fp ) AllKnown = false;

TreeErrors = MaxFactor = 0;

ForEach(v, 1, T->Forks)

Ep = Group(v, Kp, Lp, T);

if ( Kp <= Ep ) Factor = CountItems(Kp, Ep) / KnownCases;

if ( Factor >= MaxFactor )

MaxBr = v;MaxFactor = Factor;

ForEach(i, Fp, Kp-1)

Weight[i] *= Factor;

TreeErrors += EstimateErrors(T->Branch[v], Fp, Ep, Sh+1, UpdateTree);

Group(0, Fp, Ep, T); ForEach(i, Fp, Kp-1)

Weight[i] /= Factor;

AllKnown = PrevAllKnown;

if ( ! UpdateTree )

free(LocalClassDist);

return TreeErrors;

/* Analizamos la performance de la rama más grande */

BranchErrors = EstimateErrors(T->Branch[MaxBr], Fp, Lp, -1000, false);

LocalVerbosity(1)



Intab(Sh); FVitacora<<AttName->Strings[T->Tested].c_str(); FVitacora<<": ["; FVitacora<<((int) ((TreeErrors * 100) / (T->Items + 0.001))); FVitacora<<"N="; FVitacora<<T->Items; FVitacora<<" árbol="; FVitacora<<TreeErrors; FVitacora<<" hoja="; FVitacora<<LeafErrors; FVitacora<<"+"; FVitacora<<ExtraLeafErrors; FVitacora<<" br["; FVitacora<<MaxBr; FVitacora<<"]="; FVitacora<<BranchErrors; FVitacora<<endl;

/* Analizamos si el árbol debería ser reemplazado por la hojao por la rama más grande */

if ( LeafErrors + ExtraLeafErrors <= BranchErrors + 0.1 && LeafErrors + ExtraLeafErrors <= TreeErrors + 0.1 )

LocalVerbosity(1) Intab(Sh);

FVitacora<<"Reemplazado por la hoja "; FVitacora<<ClassName->Strings[T->Leaf].c_str(); FVitacora<<endl;

T->NodeType = 0;T->Errors = LeafErrors + ExtraLeafErrors;Changed = true;

else if ( BranchErrors <= TreeErrors + 0.1 )

LocalVerbosity(1) Intab(Sh);

FVitacora<<"Reemplazado por la rama "; FVitacora<<MaxBr; FVitacora<<endl;

AllKnown = PrevAllKnown;EstimateErrors(T->Branch[MaxBr], Fp, Lp, Sh, true);memcpy((char *) T, (char *) T->Branch[MaxBr], sizeof(tree_record));Changed = true;

else

T->Errors = TreeErrors;

AllKnown = PrevAllKnown; free(LocalClassDist);

return T->Errors;

/*************************************************************************//* *//* Elimina pruebas de subconjuntos innecesarias sobre *//* valores faltantes *//* *//*************************************************************************/void TDMC45::CheckPossibleValues(Tree T) Conjunto HoldValues; int v, Bytes, b; Attribute A;



char Any=0;

if ( T->NodeType == BrSubset )

A = T->Tested;

Bytes = (MaxAttVal[A]>>3) + 1;HoldValues = (Conjunto) malloc(Bytes);

/* Analizamos si la última (default) rama puede simplificarse u omitirse */

ForEach(b, 0, Bytes-1) T->Subset[T->Forks][b] &= PossibleValues[A][b]; Any |= T->Subset[T->Forks][b];

if ( ! Any ) T->Forks--;

/* Procesamos cada subárbol, dejando únicamente valores en los subconjuntos de las ramas */

CopyBits(Bytes, PossibleValues[A], HoldValues);

ForEach(v, 1, T->Forks) CopyBits(Bytes, T->Subset[v], PossibleValues[A]);

CheckPossibleValues(T->Branch[v]);

CopyBits(Bytes, HoldValues, PossibleValues[A]);

free(HoldValues); else if ( T->NodeType )

ForEach(v, 1, T->Forks) CheckPossibleValues(T->Branch[v]);

/*************************************************************************//* *//* Computa los errores adicionales si la proporción de error llega al *//* límite superior del nivel de confianza. El coeficiente es el *//* cuadrado del nro de desviaciones estándar correspondientes al *//* nivel de confianza seleccionado. *//* (Basado en el Documenta Geigy Scientific Tables (Sixth Edition), *//* p185 (with modifications).) *//* *//*************************************************************************/float TDMC45::AddErrs(ItemCount N, ItemCount e) static float Coeff=0; float Val0, Pr;

if ( ! Coeff )

/* Computa y retiene el valor del coeficiente, interpolando los valores de Val y Dev */

int i;

i = 0;while ( CF > Val[i] ) i++;

Coeff = Dev[i-1] +



(Dev[i] - Dev[i-1]) * (CF - Val[i-1]) /(Val[i] - Val[i-1]);Coeff = Coeff * Coeff;

if ( e < 1E-6 )

return N * (1 - exp(log(CF) / N)); else if ( e < 0.9999 )

Val0 = N * (1 - exp(log(CF) / N));return Val0 + e * (AddErrs(N, 1.0) - Val0);

else if ( e + 0.5 >= N )

return 0.67 * (N - e); else

Pr = (e + 0.5 + Coeff/2 + sqrt(Coeff * ((e + 0.5) * (1 - (e + 0.5)/N) + Coeff/4)) )

/ (N + Coeff);return (N * Pr - e);

/*************************************************************************//* *//* Categoriza la descripción de un caso utilizando el árbol de decisión *//* *//*************************************************************************/ClassNo TDMC45::Category(Description CaseDesc,Tree DecisionTree) ClassNo c, BestClass;

if ( ! ClassSum )

ClassSum = (float *) malloc((MaxClass+1) * sizeof(float));


ClassSum[c] = 0;

Classify(CaseDesc, DecisionTree, 1.0);

BestClass = 0; ForEach(c, 0, MaxClass)

Verbosity(5) printf("clase %s peso %.2f\n", ClassName[c], ClassSum[c]);

if ( ClassSum[c] > ClassSum[BestClass] ) BestClass = c;

return BestClass;

/*************************************************************************//* *//* Clasifica un caso utilizando el subárbol dado, ajustando el valor *//* de ClassSum para cada clase *//* *//*************************************************************************/void TDMC45::Classify(Description CaseDesc,Tree T,float Weight) DiscrValue v, dv; float Cv; Attribute a; ClassNo c;



switch ( T->NodeType ) case 0: /* hoja */

if ( T->Items > 0 )

/* Actualizamos a partir de TODAS las clases */

ForEach(c, 0, MaxClass) if ( T->ClassDist[c] )

ClassSum[c] += Weight * T->ClassDist[c] / T->Items;

else

ClassSum[T->Leaf] += Weight;

return;

case BrDiscr: /* prueba sobre un atrib discreto */

a = T->Tested; v = DVal(CaseDesc, a);

if ( v && v <= T->Forks ) /* Nos aseguramos que no sea un nuevo valor discreto */

Classify(CaseDesc, T->Branch[v], Weight);

else

ForEach(v, 1, T->Forks) Classify(CaseDesc, T->Branch[v],

(Weight * T->Branch[v]->Items) / T->Items);

return;

case ThreshContin: /* prueba sobre un atributo contínuo */

a = T->Tested; Cv = CVal(CaseDesc, a);

if ( Cv == Unknown )

ForEach(v, 1, 2) Classify(CaseDesc, T->Branch[v],

(Weight * T->Branch[v]->Items) / T->Items);

else

v = ( Cv <= T->Cut ? 1 : 2 );Classify(CaseDesc, T->Branch[v], Weight);

return;

case BrSubset: /* prueba sobre un subconj de valores discretos */

a = T->Tested; dv = DVal(CaseDesc, a);

if ( dv )

ForEach(v, 1, T->Forks) if ( In(dv, T->Subset[v]) )

Classify(CaseDesc, T->Branch[v], Weight);



return;

/* Valor desconocido o no encontrado en ningún subconjunto */

ForEach(v, 1, T->Forks)

Classify(CaseDesc, T->Branch[v], (Weight * T->Branch[v]->Items) / T->Items);

return;

/*************************************************************************//* *//* Imprime matrices de confusión *//* *//*************************************************************************/void TDMC45::PrintConfusionMatrix(ItemNo *ConfusionMat) short Row, Col;

if ( MaxClass > 20 ) return; /* No imprimir matrices sin sentido */

/* Imprimimos el encabezado primero, y luego cada una de las filas */

FVitacora<<endl; FVitacora<<endl; FVitacora<<" "; ForEach(Col, 0, MaxClass) FVitacora<<" ("; FVitacora<<('a' + Col); FVitacora<<")";

FVitacora<<" <-clasificado como "; FVitacora<<endl; FVitacora<<" "; ForEach(Col, 0, MaxClass) FVitacora<<" ------"; FVitacora<<endl;

ForEach(Row, 0, MaxClass) FVitacora<<" ";

ForEach(Col, 0, MaxClass) if ( ConfusionMat[Row*(MaxClass+1) + Col] )

FVitacora<<ConfusionMat[Row*(MaxClass+1) + Col]; else

FVitacora<<" ";

FVitacora<<" ("; FVitacora<<('a'+Row); FVitacora<<"): clase"; FVitacora<<ClassName->Strings[Row].c_str(); FVitacora<<endl; FVitacora<<endl;

/**************************************************************************************/



/*** REGLAS DE DECISIÓN *******//**************************************************************************************/void TDMC45::GenerarReglasC45() int o; extern char *optarg; extern int optind; bool FirstTime=true; char outFile[50]="Log\\C45Reglas"; //Inicializamos las variables FileName = "DF"; VERBOSITY = 5; UNSEENS = true;

SIGTEST = false; SIMANNEAL = false; SIGTHRESH = 0.05; CF= 0.25; REDUNDANCY = 1.0; NRules = 0; RuleSpace = 0; NTests = 0;

//Inicializamos el archivo strcat(outFile, DateTimeToStr(Now()).c_str()); strcat(outFile, Params->TablaBD.c_str()); strcat(outFile, ".log"); FReglas.open(outFile, ios::out); FReglas<<"C4.5 Generador de reglas "; FReglas<<DateTimeToStr(Now()).c_str(); FReglas<<endl; FReglas<<"---------------------------"; FReglas<<endl; FReglas<<endl;

/* Inicialización */

GetNames(); GetData(); FReglas<<(MaxItem+1); FReglas<<" casos ("; FReglas<<MaxAtt; FReglas<<" atributos) leídos de "; FReglas<<Params->TablaBD.c_str();

GenerateLogs();

/* Construcción de reglas */ GenerateRules(); /* Evaluaciones */

FReglas<<endl; FReglas<<endl; FReglas<<"Evaluación sobre los datos de entrenamiento ("; FReglas<<MaxItem+1; FReglas<<" ítems):"; FReglas<<endl;

EvaluateRulesets(true);

/* Guardamos el conjunto de reglas actual */

SaveRules();

if ( UNSEENS )

GetData(); FReglas<<endl; FReglas<<endl; FReglas<<"Evaluación sobre los datos de prueba ("; FReglas<<MaxItem+1; FReglas<<" ítems):"; FReglas<<endl; EvaluateRulesets(false);

exit(0);



/*************************************************************************//* *//* Creación del vector LogItemNo para contener los logaritmos de *//* enteros, y el vector LogFact para contener los logaritmos de los *//* factoriales (todos en base 2) *//* *//*************************************************************************/void TDMC45::GenerateLogs() ItemNo i;

LogItemNo = (float *) malloc((MaxItem+100) * sizeof(float)); LogFact = (double *) malloc((MaxItem+100) * sizeof(double));

LogItemNo[0] = -1E38; LogItemNo[1] = 0; LogFact[0] = LogFact[1] = 0;

ForEach(i, 2, MaxItem+99)

LogItemNo[i] = log((float) i) / Log2;LogFact[i] = LogFact[i-1] + LogItemNo[i];

/*************************************************************************//* *//* Para cada árbol, creamos un conj de reglas y lo procesamos. Luego *//* componemos un conjunto de reglas a partir de estos conjuntos. *//* Si hay un sólo árbol, entoncesno se compone un nuevo conjunto. *//* *//* Los conj de reglas se almacenan desde PRSet[0] hasta PRSet[TRIALS], *//* donde PRSet[TRIALS] contiene el conjunto compuesto. *//* *//* Al terminar, el conjunto actual es el compuesto (si es que uno se *//* creó), sino es el conjunto de un árbol. *//* *//*************************************************************************/void TDMC45::GenerateRules() Tree DecisionTree, GetTree(); short t=0, RuleSetSpace=0, r;

/* Buscamos los bits para codificar los atributos y las ramas */

FindTestCodes();

/* Procesamos cada árbol de decisión */

while ( DecisionTree = GetTree() ) FReglas<<endl;

FReglas<<"------------------"; FReglas<<endl;

FReglas<<"Procesando el árbol "; FReglas<<t;

/* Creamos un conjunto de reglas del próximo árbol */

FormRules(DecisionTree);

/* Procesamos el conjunto de reglas */

ConstructRuleset();

FReglas<<endl;FReglas<<"Reglas finales del árbol: ";

FReglas<<t; FReglas<<endl;

PrintIndexedRules();

/* Nos aseguramos de que hay suficiente lugar para el nuevo conj de reglas */

if ( t + 1 >= RuleSetSpace )



RuleSetSpace += 10;

if ( RuleSetSpace > 10 )

PRSet = (RuleSet *) realloc(PRSet, RuleSetSpace * sizeof(RuleSet)); else

PRSet = (RuleSet *) malloc(RuleSetSpace * sizeof(RuleSet));

PRSet[t].SNRules = NRules;PRSet[t].SRule = Rule;PRSet[t].SRuleIndex = RuleIndex;PRSet[t].SDefaultClass = DefaultClass;

++t;

if ( ! t ) FReglas<<endl; FReglas<<"ERROR: no se encuentra ningun árbol de decisión"; FReglas<<endl;

exit(1);

TRIALS = t;

/* Si hay más de un árbol, creamos un conjunto compuesto de reglasa partir de las reglas de cada uno de los árboles */

if ( TRIALS > 1 )

CompositeRuleset();

/*************************************************************************//* *//* Determina las longitudes de los codigos para los atributos *//* y las ramas *//* *//*************************************************************************/void TDMC45::FindTestCodes() Attribute Att; DiscrValue v, V; ItemNo i, *ValFreq; int PossibleCuts; float Sum, SumBranches=0, p; void SwapUnweighted();

BranchBits = (float *) malloc((MaxAtt+1) * sizeof(float));


if ( (V = MaxAttVal[Att]) ) ValFreq = (ItemNo *) calloc(V+1, sizeof(ItemNo));


ValFreq[DVal(Item[i],Att)]++;

Sum = 0; ForEach(v, 1, V)

if ( ValFreq[v] ) Sum += (ValFreq[v] / (MaxItem+1.0)) *

(LogItemNo[MaxItem+1] - LogItemNo[ValFreq[v]]);



free(ValFreq);

BranchBits[Att] = Sum;else Quicksort(0, MaxItem, Att);

PossibleCuts = 1; ForEach(i, 1, MaxItem)

if ( CVal(Item[i],Att) > CVal(Item[i-1],Att) ) PossibleCuts++;

BranchBits[Att] = PossibleCuts > 1 ? 1 + LogItemNo[PossibleCuts] / 2 : 0 ;

SumBranches += BranchBits[Att];

AttTestBits = 0; ForEach(Att, 0, MaxAtt)

if ( (p = BranchBits[Att] / SumBranches) > 0 ) AttTestBits -= p * log(p) / log(2.0);

/*************************************************************************//* *//* Intercambio de los items en a y b. *//* *//*************************************************************************/void TDMC45::SwapUnweighted(ItemNo a,ItemNo b) Description Hold;

Hold = Item[a]; Item[a] = Item[b]; Item[b] = Hold;

/*************************************************************************//* *//* Creación de un conjunto compuesto de reglas de todas las pruebas *//* *//*************************************************************************/void TDMC45::CompositeRuleset() RuleNo r; short t, ri;

InitialiseRules();

/* Procesamos juntas todas las reglas de cada subconjunto */

ForEach(t, 0, TRIALS-1)

ForEach(ri, 1, PRSet[t].SNRules) r = PRSet[t].SRuleIndex[ri]; NewRule(PRSet[t].SRule[r].Lhs, PRSet[t].SRule[r].Size,

PRSet[t].SRule[r].Rhs, PRSet[t].SRule[r].Error);

/* Seleccionamos un subconjunto */

ConstructRuleset();

FReglas<<endl;



FReglas<<"Conjunto compuesto de reglas:"; FReglas<<endl; PrintIndexedRules();

PRSet[TRIALS].SNRules = NRules; PRSet[TRIALS].SRule = Rule; PRSet[TRIALS].SRuleIndex = RuleIndex; PRSet[TRIALS].SDefaultClass = DefaultClass;

/*************************************************************************//* *//* Creación de un conjunto de reglas del árbol de decisión t *//* *//*************************************************************************/void TDMC45::FormRules(Tree t) short i;

/* Buscamos los parámetros esenciales y reservamos lugar */

MaxDepth = 0; MaxDisjuncts = 0;

TreeParameters(t, 0);

Actual = (float *) calloc(MaxDepth+2, sizeof(float)); Total = (ItemNo *) calloc(MaxDepth+2, sizeof(ItemNo)); Errors = (ItemNo *) calloc(MaxDepth+2, sizeof(ItemNo)); Pessimistic = (float *) calloc(MaxDepth+2, sizeof(float));

CondSigLevel = (float *) calloc(MaxDepth+2, sizeof(float));

TargetClassFreq = (ItemNo *) calloc(2, sizeof(ItemNo));

Deleted = (Boolean *) calloc(MaxDepth+2, sizeof(Boolean)); CondSatisfiedBy = (bool **) calloc(MaxDepth+2, sizeof(char *)); Stack = (Condition *) calloc(MaxDepth+2, sizeof(Condition));

ForEach(i, 0, MaxDepth+1)

CondSatisfiedBy[i] = (bool *) calloc(MaxItem+1, sizeof(char));Stack[i] = (Condition) malloc(sizeof(struct CondRec));

SingleValue = (DiscrValue *) calloc(MaxAtt+1, sizeof(DiscrValue));

InitialiseRules();

/* Extraemos y podamos las reglas disjuntas */

Scan(t, 0);

/* Liberamos almacenamiento */

ForEach(i, 0, MaxDepth+1)

free(CondSatisfiedBy[i]);free(Stack[i]);

free(Deleted); free(CondSatisfiedBy); free(Stack);

free(Actual); free(Total); free(Errors); free(Pessimistic);

free(CondSigLevel);

free(TargetClassFreq);

/*************************************************************************//* *//* Calcula la profundidad máx y el nro de hojas en el arbol t con */



/* profundidad inicial d *//* *//*************************************************************************/void TDMC45::TreeParameters(Tree t,short d) DiscrValue v;

if ( t->NodeType )

ForEach(v, 1, t->Forks) TreeParameters(t->Branch[v], d+1);

else

/* Es una hoja */

if ( d > MaxDepth ) MaxDepth = d;MaxDisjuncts++;

/*************************************************************************//* *//* Extrae los disjuntos del arbol t en la profundidad d y los procesa *//* *//*************************************************************************/void TDMC45::Scan(Tree t,short d) DiscrValue v; short i; Condition *Term; Test x, FindTest();

if ( t->NodeType )

d++;

x = (Test) malloc(sizeof(struct TestRec));x->NodeType = t->NodeType;x->Tested = t->Tested;x->Forks = t->Forks;x->Cut = ( t->NodeType == ThreshContin ? t->Cut : 0 );if ( t->NodeType == BrSubset ) x->Subset = (Conjunto *) calloc(t->Forks + 1, sizeof(Conjunto)); ForEach(v, 1, t->Forks)

x->Subset[v] = t->Subset[v];

Stack[d]->CondTest = FindTest();

ForEach(v, 1, t->Forks) Stack[d]->TestValue = v; Scan(t->Branch[v], d);

else if ( t->Items >= 1 )

/* Hoja del árbol de decisión - construimos el conjunto de condiciones asociadas con esta hoja y las podamos */Term = (Condition *) calloc(d+1, sizeof(Condition));ForEach(i, 1, d) Term[i] = (Condition) malloc(sizeof(struct CondRec)); Term[i]->CondTest = Stack[i]->CondTest; Term[i]->TestValue = Stack[i]->TestValue;

PruneRule(Term, d, t->Leaf);

free(Term);



/*************************************************************************//* *//* Construcción de un subconjunto ordenado (indexado por el RuleIndex) *//* a partir del actual conjunto de reglas *//* *//*************************************************************************/void TDMC45::ConstructRuleset() RuleNo r, OldNRules = NRules;

/* Reservamos lugar para las tablas */

Right = (ItemNo *) calloc(NRules+1, sizeof(ItemNo)); Wrong = (ItemNo *) calloc(NRules+1, sizeof(ItemNo));

Value = (float *) calloc(NRules+1, sizeof(float));

RuleIn = (bool *) calloc(NRules+1, sizeof(Boolean)); Subset = (char ***) malloc((NRules+1) * sizeof(Boolean));

ClassRules = (RuleNo *) malloc((NRules+1) * sizeof(RuleNo));

ClassFreq = (float *) calloc(MaxClass+1, sizeof(ItemNo));

Covered = (ItemNo *) calloc(MaxItem+1, sizeof(ItemNo));

Match = (bool **) calloc(NRules+1, sizeof(Boolean *));

FalsePos = (ItemNo *) calloc(MaxClass+1, sizeof(ItemNo));

NoRule = (ItemNo *) calloc(MaxClass+1, sizeof(ItemNo));

ForEach(r, 1, NRules)

Match[r] = (Boolean *) calloc(MaxItem+1, sizeof(Boolean));

/* Cubrimos cada una de las clases, y luego las ordenamos en uníndice de reglas */

InitialiseTables();

FindRuleCodes(); CodeWeight = 0.5;

ForEach(FocusClass, 0, MaxClass)

CoverClass();

MakeIndex(); FindDefault();

/* Liberamos espacio en memoria */

free(Value); free(RuleIn); free(ClassRules); free(Subset); free(Covered); free(FalsePos); free(NoRule); ForEach(r, 1, OldNRules)

free(Match[r]); free(Match);

/*************************************************************************//* *//* Inicialización de tablas *//* *//*************************************************************************/



void TDMC45::InitialiseTables() ItemNo i; RuleNo r; ClassNo c; float Strength();


RuleIn[r] = false;Rule[r].Used = Rule[r].Incorrect = 0;


ClassFreq[c] = 0;


ClassFreq[Class(Item[i])]++;


Match[r][i] = Fuerza(Rule[r], Item[i]) > 0.1;

if ( Match[r][i] )

Rule[r].Used++;if ( Class(Item[i]) != Rule[r].Rhs ) Rule[r].Incorrect++;

/*************************************************************************//* *//* Seleccionamos un subconjunto de las reglas para la FocusClass *//* *//*************************************************************************/void TDMC45::CoverClass() RuleNo r, RuleCount=0; ItemNo i;

Verbosity(1) FReglas<<endl;

FReglas<<"Clase "; FReglas<<ClassName->Strings[FocusClass].c_str(); FReglas<<endl; FReglas<<"-----"; FReglas<<"Acción Cambio Valor";


Covered[i] = 0;


if ( Rule[r].Rhs == FocusClass ) RuleCount++; ClassRules[RuleCount] = r;

if ( ! RuleCount )

return;

SubsetValue = 1E10;

if ( RuleCount <= 10 )



AllCombinations(RuleCount);

else if ( SIMANNEAL )

SimAnneal(RuleCount); else

SpotSearch(RuleCount);

memcpy(RuleIn, Subset, NRules+1); Verbosity(1) FReglas<<endl; FReglas<<" Mejor valor "; FReglas<<SubsetValue; FReglas<<endl;

/*************************************************************************//* *//* Probamos todas las combinaciones de reglas para encontrar la mejor *//* *//*************************************************************************/void TDMC45::AllCombinations(RuleNo NR) RuleNo r;

if ( ! NR )

CalculateValue(); else

r = ClassRules[NR];

AllCombinations(NR-1);

AddRule(r);AllCombinations(NR-1);

DeleteRule(r);Verbosity(1) FReglas<<endl;

/*************************************************************************//* *//* Búsqueda de un buen subconjunto mediante simulated annealing *//* *//*************************************************************************/void TDMC45::SimAnneal(RuleNo RuleCount) RuleNo r, OutCount; short ri, Tries; float Temp, Delta; Boolean Changed;

/* Eliminamos y agregamos reglas hasta q no se pueda mejorar más */

for ( Temp = 1000 ; Temp > 0.001 ; Temp *= 0.95 )

CalculateValue();

Verbosity(2) OutCount = 0;

ForEach(ri, 1, RuleCount)

r = ClassRules[ri];

if ( ! RuleIn[r] )



if ( ! (OutCount++ % 3) ) printf("\n\t\t"); FReglas<< r;

FReglas<<" "; FReglas<<Right[r]; FReglas<<" "; FReglas<<Wrong[r]; FReglas<<" "; FReglas<<Value[r];

FReglas<<endl; FReglas<<endl;

Changed = false;

for ( Tries = 100 ; ! Changed && Tries > 0 ; Tries-- ) /* Elegimos una relga para agregar o eliminar */

ri = RuleCount * Random + 1;

r = ClassRules[ri];

Delta = ( RuleIn[r] ? -Value[r] : Value[r] );

if ( Delta > 0 || Random < exp(Delta / Temp) )

if ( RuleIn[r] ) DeleteRule(r);else AddRule(r);

Changed = true;

if ( ! Changed ) break;

/* Tratamos de mejorar el mejor subconjunto mediante hill-climbing */

Verbosity(1) FReglas<<"Pulimos: "; memcpy(RuleIn, Subset, NRules+1); HillClimb(RuleCount);

/*************************************************************************//* *//* Busca un buen subconjunto mediante una búsqueda golosa reiterativa *//* *//*************************************************************************/void TDMC45::SpotSearch(RuleNo RuleCount) RuleNo r; short ri, Trial; float ProbIn;

ForEach(Trial, 0, 10)

Verbosity(1) FReglas<<endl; FReglas<<" Prueba "; FReglas<<Trial;

/* Agregamos reglas al azar al subconj inicial */

ProbIn = Trial / 10.0;ForEach(ri, 1, RuleCount)



r = ClassRules[ri]; RuleIn[r] = Random < ProbIn;

HillClimb(RuleCount);

/*************************************************************************//* *//* Mejora un subconjunto de reglas agregando o eliminando reglas *//* *//*************************************************************************/void TDMC45::HillClimb(RuleNo RuleCount) RuleNo r, Bestr; short ri, OutCount; ItemNo i; float Delta, BestDelta; ItemNo aux;


Covered[i] = 0;


r = ClassRules[ri];if ( RuleIn[r] ) ForEach(i, 0, MaxItem)

if ( Match[r][i] ) Covered[i]++;

/* Agregamos o eliminamos la regla con la mayor reducción en el costode codificación */

while ( true )

CalculateValue();

Verbosity(2) OutCount = 0;


r = ClassRules[ri];

if ( ! RuleIn[r] ) if ( ! (OutCount++ % 3) ) printf("\n\t\t");

FReglas<<r; FReglas<<"<"; aux=Right[r]|Wrong[r]; FReglas<<aux; FReglas<<"="; FReglas<<Value[r];

FReglas<<endl; FReglas<<endl;

Bestr = BestDelta = 0;ForEach(ri, 1, RuleCount) r = ClassRules[ri]; Delta = ( RuleIn[r] ? -Value[r] : Value[r] );



if ( Delta > BestDelta )

Bestr = r;BestDelta = Delta;

if ( ! Bestr ) break;

if ( RuleIn[Bestr] ) DeleteRule(Bestr);else AddRule(Bestr);

/*************************************************************************//* *//* Calculamos los aciertos y errores para las reglas de la FocusClass *//* y determinamos el valor de dichas reglas. Si es el mejor hasta *//* ahora, lo guardamos. *//* *//*************************************************************************/void TDMC45::CalculateValue()/* -------------- */ RuleNo r, Selected=0, InCount; ItemNo i, Times, FPos=0, FNeg=0, SumCover=0,aux; float BaseBits, RuleBits=0, NewBits; ClassNo ThisClass; Boolean *RuleMatch;


ThisClass = Class(Item[i]);

if ( Covered[i] ) SumCover++; if( ThisClass != FocusClass ) FPos++;elseif ( ThisClass == FocusClass ) FNeg++;


if ( Rule[r].Rhs == FocusClass ) Right[r] = Wrong[r] = 0;

if ( RuleIn[r] )

RuleBits += Rule[r].Bits;Selected++;

RuleMatch = Match[r];


if ( RuleMatch[i] && ( ! (Times = Covered[i]) || Times == 1 && RuleIn[r] ) ) if ( Class(Item[i]) == FocusClass )

Right[r]++; else



Wrong[r]++;

RuleBits -= LogFact[Selected];

BaseBits = CodeWeight * RuleBits + ExceptionBits(SumCover, FPos, FNeg);

/* A partir de los aciertos y errores de cada regla, calculamos su valor */

Verbosity(1) FReglas<<" "; InCount = -1;


if ( Rule[r].Rhs == FocusClass ) if ( RuleIn[r] )

NewBits = ExceptionBits(SumCover-Right[r]-Wrong[r],FPos-Wrong[r], FNeg+Right[r]) +

CodeWeight * (RuleBits - Rule[r].Bits + LogItemNo[Selected]);

Value[r] = NewBits - BaseBits; else

NewBits = ExceptionBits(SumCover+Right[r]+Wrong[r],FPos+Wrong[r], FNeg-Right[r]) +

CodeWeight * (RuleBits + Rule[r].Bits - LogItemNo[Selected+1]);

Value[r] = BaseBits - NewBits;

Verbosity(1) if ( RuleIn[r] )

if ( ++InCount && ! (InCount % 3) ) printf("\n\t\t"); FReglas<<r; FReglas<<"["; aux=Right[r]|Wrong[r]; FReglas<<aux; FReglas<<"="; FReglas<<Value[r];

Verbosity(1) FReglas<<endl; FReglas<<" "; FReglas<<Selected; FReglas<<" reglas, "; FReglas<<SumCover; FReglas<<" cant de veces en que la regla se usó: "; FReglas<<"F+="; FReglas<<FPos; FReglas<<" F-="; FReglas<<FNeg; FReglas<<", "; FReglas<<BaseBits; FReglas<<"bits (reglas="; FReglas<<RuleBits; FReglas<<endl;

if ( BaseBits < SubsetValue )



SubsetValue = BaseBits;memcpy(Subset, RuleIn, NRules+1);

/*************************************************************************//* *//* Agregamos la regla r al conj de relgas incluidas e incrementamos la *//* cantidad de reglas q cubren los items q disparan la regla *//* *//*************************************************************************/void TDMC45::AddRule(RuleNo r) ItemNo i;

RuleIn[r] = true;


if ( Match[r][i] ) Covered[i]++;

Verbosity(1) FReglas<<r; FReglas<<"+ "; FReglas<<Value[r];

/*************************************************************************//* *//* Eliminamos la regla r del conj de reglas incluídas y decrementamos *//* la cant de reglas que cubren cada uno de los items cubiertos por *//* la regla *//* *//*************************************************************************/void TDMC45::DeleteRule(RuleNo r) ItemNo i;

RuleIn[r] = false;


if ( Match[r][i] ) Covered[i]--;

Verbosity(1) FReglas<<r; FReglas<<"- "; FReglas<<-Value[r];

/*************************************************************************//* *//* Crea un índice de reglas incluídas en RuleIndex. Selecciona primero *//* aquellas clases cuyas reglas tienen el menor nro de falsos positivos *//* Dentro de cada clase, pone las relgas con más aciertos primero *//* *//*************************************************************************/void TDMC45::MakeIndex() ClassNo c, BestC, Pass;



RuleNo r, BestR, NewNRules = 0; ItemNo i; Boolean *Included;

Included = (Boolean *) calloc(MaxClass+1, sizeof(Boolean)); RuleIndex = (RuleNo *) calloc(NRules+1, sizeof(RuleNo));

Verbosity(1) printf("\nFalsosPos Clase\n");


Covered[i] = 0;

/* Seleccionamos la mejor clase para poner a continuación */

ForEach(Pass, 0, MaxClass)

ForEach(c, 0, MaxClass) if ( Included[c] ) continue;

FalsePos[c] = 0;


if ( Covered[i] || Class(Item[i]) == c ) continue;

ForEach(r, 1, NRules) if ( Rule[r].Rhs == c && RuleIn[r] && Match[r][i] )

FalsePos[c]++;break;

BestC = -1;ForEach(c, 0, MaxClass) if ( ! Included[c] && ( BestC < 0 || FalsePos[c] < FalsePos[BestC] ) )

BestC = c; Included[BestC] = true;

Verbosity(1) FReglas<<FalsePos[BestC]; FReglas<<" "; FReglas<<ClassName->Strings[BestC].c_str(); FReglas<<endl;

/* Ahora analizamos las reglas para esta clase */

do BestR = 0;

/* Buscamos la mejor regla */


if ( RuleIn[r] && Rule[r].Rhs == BestC && ( ! BestR || Rule[r].Error < Rule[BestR].Error ) ) BestR = r;

if ( BestR )



RuleIndex[++NewNRules] = BestR;RuleIn[BestR] = false;

ForEach(i, 0, MaxItem) Covered[i] |= Match[BestR][i];

while ( BestR );

NRules = NewNRules; free(Included);

/*************************************************************************//* *//* Determina la clase por defecto. Los empates se resuelven a favor *//* de la clase más frecuente *//* *//*************************************************************************/void TDMC45::FindDefault() ClassNo c; ItemNo i;

/* Determinamos los items no cubiertos por ninguna regla */


NoRule[c] = 0;


if ( ! Covered[i] ) NoRule[Class(Item[i])]++;

Verbosity(1) FReglas<<endl; FReglas<<"Items: No cubiertos Clase"; FReglas<<endl;


FReglas<<ClassFreq[c]; FReglas<<" "; FReglas<<NoRule[c]; FReglas<<" "; FReglas<< ClassName->Strings[c].c_str(); FReglas<<endl;

FReglas<<endl;

DefaultClass = 0; ForEach(c, 1, MaxClass)

if ( NoRule[c] > NoRule[DefaultClass] || NoRule[c] == NoRule[DefaultClass] && ClassFreq[c] > ClassFreq[DefaultClass] ) DefaultClass = c;

/*************************************************************************//* *//* Dados una regla y un caso, determina la fuerza con la que podemos *//* determinar que el caso pertenece a la clase especificada en la regla *//* Si el caso no satisface todas las condiciones de la regla, entonces *//* la fuerza vale 0. *//* */



/*************************************************************************/float TDMC45::Fuerza(PR ThisRule,Description Case) short d;

if ( ThisRule.Error > 0.7 ) return 0.0;

ForEach(d, 1, ThisRule.Size)

if ( ! Satisfies(Case, ThisRule.Lhs[d]) ) return 0.0;

return ( 1 - ThisRule.Error );

/*************************************************************************//* *//* Determina el nro de bits necesarios para codificar las excepciones *//* *//*************************************************************************/float TDMC45::Biased(int N, int E, float ExpE) float Rate;

if ( ExpE <= 1E-6 )

return ( E == 0 ? 0.0 : 1E6 ); else if ( ExpE >= N-1E-6 )

return ( E == N ? 0.0 : 1E6 );

Rate = ExpE / N; return -E * Log(Rate) - (N-E) * Log(1-Rate);

float TDMC45::ExceptionBits(int Fires, int FP, int FN) if ( Fires > 0.5 * (MaxItem+1) )

return Log(MaxItem+1)+ Biased(Fires, FP, 0.5 * (FP+FN))+ Biased(MaxItem+1-Fires, FN, (float) FN);

else

return Log(MaxItem+1)+ Biased(Fires, FP, (float) FP)+ Biased(MaxItem+1-Fires, FN, 0.5 * (FP+FN));

/*************************************************************************//* *//* Determina la longitud de codificación para todas las reglas *//* *//*************************************************************************/void TDMC45::FindRuleCodes() RuleNo r; short d, NCond; float Bits;


NCond = Rule[r].Size;Bits = 0;

ForEach(d, 1, NCond) Bits += CondBits(Rule[r].Lhs[d]);



/* Debemos codificar el nro de condiciones, pero mejorar la codificación total mediante la forma en que las condiciones pueden reordenarse */

Rule[r].Bits = Bits + LogItemNo[NCond] - LogFact[NCond];

/*************************************************************************//* *//* Determina el nro de bits requerido para codificar una condición *//* *//*************************************************************************/float TDMC45::CondBits(Condition C) Test t; Attribute a;

t = C->CondTest; a = t->Tested;

switch ( t->NodeType )

case BrDiscr: /* prueba de un atrib discreto */case ThreshContin: /* prueba de un atrib continuo */

return AttTestBits/REDUNDANCY + BranchBits[a];

case BrSubset: /* prueba de un subconj de atrib discretos */

return AttTestBits/REDUNDANCY + MaxAttVal[a];

/*************************************************************************//* *//* Guarda el conjunto de reglas en el archivo de reglas según el orden *//* del índice *//* *//*************************************************************************/void TDMC45::SaveRules() short ri, d, v, Bytes; RuleNo r; Test Tst;

strcpy(Fn, FileName.c_str()); strcat(Fn, ".rules"); if ( ! ( TRf = fopen(Fn, "w") ) ) FReglas<<"Error al abrir el archivo de reglas"; if ( TRf ) fclose(TRf);

strcpy(Fn, FileName.c_str()); strcat(Fn, ".rules"); if ( ! ( TRf = fopen(Fn, "w") ) ) FReglas<<"Error al abrir el archivo de reglas"; StreamOut((char *) &NRules, sizeof(RuleNo)); StreamOut((char *) &DefaultClass, sizeof(ClassNo));

ForEach(ri, 1, NRules)

r = RuleIndex[ri]; StreamOut((char *) &Rule[r].Size, sizeof(short));

ForEach(d, 1, Rule[r].Size) Tst = Rule[r].Lhs[d]->CondTest;

StreamOut((char *) &Tst->NodeType, sizeof(short)); StreamOut((char *) &Tst->Tested, sizeof(Attribute)); StreamOut((char *) &Tst->Forks, sizeof(short)); StreamOut((char *) &Tst->Cut, sizeof(float)); if ( Tst->NodeType == BrSubset )

Bytes = (MaxAttVal[Tst->Tested]>>3) + 1;ForEach(v, 1, Tst->Forks)



StreamOut((char *) Tst->Subset[v], Bytes);

StreamOut((char *) &Rule[r].Lhs[d]->TestValue, sizeof(short));StreamOut((char *) &Rule[r].Rhs, sizeof(ClassNo));StreamOut((char *) &Rule[r].Error, sizeof(float));

SaveDiscreteNames();

/*************************************************************************//* *//* Obtiene un nuevo conj de reglas del archivo de reglas *//* *//*************************************************************************/void TDMC45::GetRules() RuleNo nr, r; short n, d, v, Bytes; Condition *Cond; Test Tst; ClassNo c; float e;


strcpy(Fn, FileName.c_str()); strcat(Fn, ".rules"); if ( ! ( TRf = fopen(Fn, "r") ) ) FReglas<<"Error al abrir el archivo de reglas";

StreamIn((char *) &nr, sizeof(RuleNo)); StreamIn((char *) &DefaultClass, sizeof(ClassNo));

ForEach(r, 1, nr) StreamIn((char *) &n, sizeof(short));

Cond = (Condition *) calloc(n+1, sizeof(Condition));ForEach(d, 1, n) Tst = (Test) malloc(sizeof(struct TestRec));

StreamIn((char *) &Tst->NodeType, sizeof(short)); StreamIn((char *) &Tst->Tested, sizeof(Attribute)); StreamIn((char *) &Tst->Forks, sizeof(short)); StreamIn((char *) &Tst->Cut, sizeof(float)); if ( Tst->NodeType == BrSubset )

Tst->Subset = (Conjunto *) calloc(Tst->Forks + 1, sizeof(Conjunto));

Bytes = (MaxAttVal[Tst->Tested]>>3) + 1;ForEach(v, 1, Tst->Forks) Tst->Subset[v] = (Conjunto) malloc(Bytes); StreamIn((char *) Tst->Subset[v], Bytes);

Cond[d] = (Condition) malloc(sizeof(struct CondRec)); Cond[d]->CondTest = FindTest(Tst); StreamIn((char *) &Cond[d]->TestValue, sizeof(short));StreamIn((char *) &c, sizeof(ClassNo));StreamIn((char *) &e, sizeof(float));NewRule(Cond, n, c, e);free(Cond);

RecoverDiscreteNames();

/*************************************************************************//* *//* Busca una prueba en el vector de pruebas, si no está allí, la agrega */



/* *//*************************************************************************/Test TDMC45::FindTest(Test Newtest) static short TestSpace=0; short i;

ForEach(i, 1, NTests)

if ( SameTest(Newtest, TestVec[i]) ) free(Newtest); return TestVec[i];

NTests++; if ( NTests >= TestSpace )

TestSpace += 1000;if ( TestSpace > 1000 ) TestVec = (Test *) realloc(TestVec, TestSpace * sizeof(Test));else TestVec = (Test *) malloc(TestSpace * sizeof(Test));

TestVec[NTests] = Newtest;

return TestVec[NTests];

/*************************************************************************//* *//* Verifica si la prueba t1 es igual a la prueba t2 *//* *//*************************************************************************/bool TDMC45::SameTest(Test t1,Test t2) short i;

if ( t1->NodeType != t2->NodeType ||t1->Tested != t2->Tested )

return false;

switch ( t1->NodeType )

case BrDiscr: return true;case ThreshContin: return t1->Cut == t2->Cut;case BrSubset: ForEach(i, 1, t1->Forks)

if ( t1->Subset[i] != t2->Subset[i] )

return false;

return true;

/*************************************************************************//* *//* Limpia las variables para un nuevo conj de reglas *//* *//*************************************************************************/void TDMC45::InitialiseRules()/* ---------------- */ NRules = 0; Rule = 0; RuleSpace = 0;



/*************************************************************************//* *//* Agrega una nueva regla, al conjunto de reglas actual. Actualiza *//* Rule[],NRules y,en caso de ser necesario,RuleSpace *//* *//*************************************************************************/bool TDMC45::NewRule(Condition Cond[],short NConds,ClassNo TargetClass,float Err) short d, r;

/* Verificamos si la regla ya existe */


if ( SameRule(r, Cond, NConds, TargetClass) ) Verbosity(1) printf("\tduplica la regla %d\n", r);

/* Mantenemos el estimador de error más pesismista */

if ( Err > Rule[r].Error )

Rule[r].Error = Err;

return false;

/* Verificamos que haya suficiente espacio para una nueva regla */

NRules++; if ( NRules >= RuleSpace )

RuleSpace += 100;if ( RuleSpace > 100 ) Rule = (PR *) realloc(Rule, RuleSpace * sizeof(PR));else Rule = (PR *) malloc(RuleSpace * sizeof(PR));

/* Formamos la nueva regla */

Rule[NRules].Size = NConds; Rule[NRules].Lhs = (Condition *) calloc(NConds+1, sizeof(Condition)); ForEach(d, 1, NConds)

Rule[NRules].Lhs[d] = (Condition) malloc(sizeof(struct CondRec));

Rule[NRules].Lhs[d]->CondTest = Cond[d]->CondTest;Rule[NRules].Lhs[d]->TestValue = Cond[d]->TestValue;

Rule[NRules].Rhs = TargetClass; Rule[NRules].Error = Err;

Verbosity(1) PrintRule(NRules);

return true;

/*************************************************************************//* *//* Decide si la regla actual duplica la regla r *//* *//*************************************************************************/bool TDMC45::SameRule(RuleNo r,Condition Cond[],short NConds,ClassNo TargetClass) short d, i; Test SubTest1, SubTest2;



if ( Rule[r].Size != NConds || Rule[r].Rhs != TargetClass )

return false;

ForEach(d, 1, NConds)

if ( Rule[r].Lhs[d]->CondTest->NodeType != Cond[d]->CondTest->NodeType || Rule[r].Lhs[d]->CondTest->Tested != Cond[d]->CondTest->Tested ) return false;

switch ( Cond[d]->CondTest->NodeType ) case BrDiscr:

if ( Rule[r].Lhs[d]->TestValue != Cond[d]->TestValue ) return false;break;

case ThreshContin:if ( Rule[r].Lhs[d]->CondTest->Cut != Cond[d]->CondTest->Cut ) return false;break;

case BrSubset:SubTest1 = Rule[r].Lhs[d]->CondTest;SubTest2 = Cond[d]->CondTest;ForEach(i, 1, SubTest1->Forks) if ( SubTest1->Subset[i] != SubTest2->Subset[i] )

return false;

return true;

/*************************************************************************//* *//* Imprime el conjunto indexado de reglas actual *//* *//*************************************************************************/void TDMC45::PrintIndexedRules() short ri;

ForEach(ri, 1, NRules )

PrintRule(RuleIndex[ri]); printf("\nClase por defecto: %s\n", ClassName[DefaultClass]);

/*************************************************************************//* *//* Imprime la regla r *//* *//*************************************************************************/void TDMC45::PrintRule(RuleNo r) short d;

printf("\nRegla %d:\n", r); ForEach(d, 1, Rule[r].Size) printf(" "); PrintCondition(Rule[r].Lhs[d]); printf("\t-> clase %s [%.1f%%]\n",



ClassName[Rule[r].Rhs], 100 * (1 - Rule[r].Error));

/*************************************************************************//* *//* Imprime la condición c de una regla de producción *//* *//*************************************************************************/void TDMC45::PrintCondition(Condition c) Test tp; DiscrValue v, pv, Last, Values=0; Boolean First=true; Attribute Att;

tp = c->CondTest; v = c->TestValue; Att = tp->Tested;

printf("\t%s", AttName[Att]);

if ( v < 0 )

printf(" es desconocido\n");return;

switch ( tp->NodeType )

case BrDiscr: printf(" = %s\n", AttValName[Att][v]); break;

case ThreshContin: printf(" %s %g\n", ( v == 1 ? "<=" : ">" ), tp->Cut); break;

case BrSubset: /* Contamos los valores en la rama */

for ( pv=1 ; Values <= 1 && pv <= MaxAttVal[Att] ; pv++ )

if ( In(pv, tp->Subset[v]) ) Last = pv; Values++;

if ( Values == 1 )

printf(" = %s\n", AttValName[Att][Last]);break;

printf(" en "); ForEach(pv, 1, MaxAttVal[Att])

if ( In(pv, tp->Subset[v]) ) if ( First )

printf("");First = false;

else

printf(", "); printf("%s", AttValName[Att][pv]);

printf("\n");

/*************************************************************************/



/* *//* Poda la regla dadas las condiciones Cond, y el nro de condiciones *//* NCond, y agrega la regla resultante al actual conjunto de reglas *//* si es lo suficientemente precisa *//* *//*************************************************************************/void TDMC45::PruneRule(Condition Cond[],short NCond,ClassNo TargetClass) short d, dd, id, Bestd, Bestid, Remaining=NCond; float DefaultError, Extra; Boolean Alter; Condition Hold; ItemNo i;

ForEach(d, 0, NCond)

Deleted[d] = false;

/* Evaluamos la matriz de satisfacción */

TargetClassFreq[0] = TargetClassFreq[1] = 0;


ForEach(d, 1, NCond) CondSatisfiedBy[d][i] = Satisfies(Item[i], Cond[d]);TargetClassFreq[IsTarget(Item[i])]++;

DefaultError = 1.0 - (TargetClassFreq[true] + 1.0) / (MaxItem + 3.0);

/* Buscamos las condiciones a eliminar */

Verbosity(1) FReglas<<endl; FReglas<<"Poda de la regla para "; FReglas<<ClassName->Strings[TargetClass].c_str(); do

Alter = false;

FindTables(NCond, TargetClass);

/* Buscamos la condición, eliminando aquellas que producirían la mayor mejora en la precisión de la regla. Notas: se utiliza el promedio pesimístico de error,

y no el promedio actual de error. Cuando d es 0, estamos trabajando con todas las condiciones */

Bestd = id = 0;

Verbosity(1) printf("\n Err Utilizado Pesim\tCondición ausente\n");

ForEach(d, 0, NCond) if ( Deleted[d] ) continue;

if ( Total[d] )

Actual[d] = Errors[d] / (float) Total[d];Extra = AddErrs((float) Total[d], (float) Errors[d]);Pessimistic[d] = (Errors[d] + Extra) / Total[d];

else

Actual[d] = 0;Pessimistic[d] = DefaultError;

Verbosity(1)



FReglas<<" "; FReglas<<Errors[d]; FReglas<<" "; FReglas<<Total[d]; FReglas<<100 * Pessimistic[d];

if ( ! d )

Verbosity(1) FReglas<<" <regla base>"; FReglas<<endl;

else

id++;

/* Si se está usando la opción, llamamos al test de Fisher para estimar la probabilidad de que la división sobre d sea por casualidad */

if ( SIGTEST ) CondSigLevel[d] =

TableProb(Errors[0], Errors[d]-Errors[0], Total[0]-Errors[0],

Total[d]-Total[0]-Errors[d]+Errors[0]);

Verbosity(1) FReglas<<" Sig="; FReglas<<CondSigLevel[d];

Verbosity(1) PrintCondition(Cond[d]);

/* Bestd identifica la condición con el menor error estimado */

if ( ! Bestd || Pessimistic[d] <= Pessimistic[Bestd] ) Bestd = d; Bestid = id;

/* Alter será true si vamos a eliminar una condición (tanto porque el estimador pesimístico es menor, como porque una de las condiciones no pasa la prueba de sign) */

if ( Pessimistic[d] <= Pessimistic[0] || Actual[d] <= Actual[0] || SIGTEST && CondSigLevel[d] > SIGTHRESH ) Alter = true;

if ( Alter ) Verbosity(1)

FReglas<<" Eliminamos la prueba "; FReglas<<Bestid; FReglas<<endl;

Deleted[Bestd] = true; Remaining--;

while ( Alter && Remaining );

if ( ! Remaining || ! Total[0] )



return;

if ( Pessimistic[0] >= DefaultError )

Verbosity(1) FReglas<<" Muy impreciso"; FReglas<<endl;

return;

/* Ordenamos las condiciones */

ForEach(d, 1, Remaining)

dd = 0;ForEach(id, d, NCond) if ( ! Deleted[id] &&

( ! dd || Before(Cond[id]->CondTest, Cond[dd]->CondTest) ) )

dd = id;

if ( dd != d ) Hold = Cond[d]; Cond[d] = Cond[dd]; Cond[dd] = Hold; Deleted[dd] = Deleted[d];Deleted[d] = true;

NewRule(Cond, Remaining, TargetClass, Pessimistic[0]);

/*************************************************************************//* *//* Verifica si la condición R es redundante *//* *//*************************************************************************/bool TDMC45::Redundant(short R,Condition Cond[],short NCond) short d, v, vv; Test t, Rt;

Rt = Cond[R]->CondTest; v = Cond[R]->TestValue;


if ( Deleted[d] || d == R ) continue;

t = Cond[d]->CondTest;vv = Cond[d]->TestValue;

if ( t->Tested != Rt->Tested ) continue;

switch ( t->NodeType ) case BrDiscr: /* prueba sobre un atrib discreto */

return false;

case ThreshContin: /* prueba sobre un atrib contínuo */

if ( vv == v && ( v == 1 ? t->Cut < Rt->Cut : t->Cut > Rt->Cut ) ) return true;



break;

case BrSubset: /* sprueba sobre un subconjunto de atrib discretos */

if ( IsSubset(t->Subset[vv], Rt->Subset[v], Rt->Tested) ) return true;

return false;

/*************************************************************************//* *//* Decide si el subconj de valores S1 está contenido en S2 *//* *//*************************************************************************/bool TDMC45::IsSubset(Conjunto S1,Conjunto S2,Attribute Att) DiscrValue v;

ForEach(v, 1, MaxAttVal[Att])

if ( In(v, S1) && ! In(v, S2) ) return false;

return true;

/*************************************************************************//* *//* Busca las tablas de distribución de frecuencias para la condiciones *//* actuales: *//* *//* Total[0] = items q satisfacen todas las condiciones *//* Total[d] = items q satisfacen todas las condiciones menos d *//* *//* Errors[0] = items de clase errónea q satisfacen todas las cond *//* Errors[d] = items de clase errónea q satisfacen todas las cond *//* menos d *//* *//*************************************************************************/void TDMC45::FindTables(short NCond,ClassNo TargetClass) ItemNo i; short Misses, Missed[2], d; Boolean CorrectClass;

/* Limpiamos las distribuciones */


Total[d] = Errors[d] = 0;

/* Determinamos las distribuciones */


Misses = 0;CorrectClass = IsTarget(Item[i]);

for ( d = 1 ; d <= NCond && Misses <= 1 ; d++ ) if ( ! Deleted[d] && ! CondSatisfiedBy[d][i] )

Missed[Misses++] = d;

if ( ! Misses )



UpdateCount(Total, Errors, 0, CorrectClass);elseif ( Misses == 1 ) UpdateCount(Total, Errors, Missed[0], CorrectClass);

/* Ajustamos las cuentas para reflejar todos los casos q satisfacentodas las condiciones */


if ( ! Deleted[d] ) Total[d] += Total[0]; Errors[d] += Errors[0];

/*************************************************************************//* *//* Incrementa los valores de Total[d] y Errors[d] *//* *//*************************************************************************/void TDMC45::UpdateCount(ItemNo T[],ItemNo E[],short d,bool OK) T[d]++; if ( ! OK ) E[d]++;

/*************************************************************************//* *//* Determina si la descripción de un caso satisface la cond dada *//* *//*************************************************************************/bool TDMC45::Satisfies(Description CaseDesc,Condition OneCond) DiscrValue v; float cv; Test t; short s; bool Outcome;

t = OneCond->CondTest;

/* Determina el resultado de la prueba sobre el item actual */

switch ( t->NodeType )

case BrDiscr: /* prueba sobre un atrib discreto */

v = DVal(CaseDesc, t->Tested); Outcome = ( v == 0 ? -1 : v ); break;

case ThreshContin: /* prueba sobre un atrib contínuo */

cv = CVal(CaseDesc, t->Tested); Outcome = ( cv == Unknown ? -1 : cv <= t->Cut ? 1 : 2 ); break;

case BrSubset: /* prueba sobre un subconj de atrib discretos */

v = DVal(CaseDesc, t->Tested); Outcome = -1; ForEach(s, 1, t->Forks)

if ( In(v, t->Subset[s]) ) Outcome = s; break;



return ( Outcome == OneCond->TestValue );

/*************************************************************************//* *//* Distribución hipergeometrica (usa los log de los factoriales *//* tabulados) *//* *//*************************************************************************/double TDMC45::Hypergeom(int a,int r,int A,int B) return exp( LogFact[A] + LogFact[B] + LogFact[r] + LogFact[A+B-r] -

( LogFact[a] + LogFact[r-a] + LogFact[A-a] + LogFact[B-(r-a)] + LogFact[A+B]) );

/*************************************************************************//* *//* TableProb examina la tabla t de contingencias de 2x2 y calcula la *//* probabilidad de que una división al azar pueda producir una división *//* al menos tan extrema como esta. Esto también se conoce como la *//* "Prueba Exacta de Fisher" *//* *//*************************************************************************/float TDMC45::TableProb(int t11,int t12,int t21,int t22) double Sum=0.0; int A, B, r, a, k, a0;

/* Primero, llevamos la tabla a la forma canónica */

if ( t11 + t12 > t21 + t22 )

A = t11 + t12;B = t21 + t22;

if ( t11 * (t21 + t22) > t21 * (t11 + t12) ) a0 = t11; r = t11 + t21;else a0 = t12; r = t12 + t22;

else

A = t21 + t22;B = t11 + t12;if ( t21 * (t11 + t12) > t11 * (t21 + t22) ) a0 = t21; r = t21 + t11;else a0 = t22; r = t22 + t12;

/* Ahora calculamos la probabilidad */

k = Min(r, A); ForEach(a, a0, k)

Sum += Hypergeom(a, r, A, B);

return Sum;

/*************************************************************************/



/* *//* Evalúa todos los conj de reglas *//* *//*************************************************************************/void TDMC45::EvaluateRulesets(bool DeleteRules) short t; ItemNo *Errors; float AvSize=0, AvErrs=0; Boolean Final;

if ( TRIALS == 1 )

/* Evaluamos el conj de reglas actual como si no existiera un conj compuesto de reglas */

Interpret(0, MaxItem, DeleteRules, true, true);return;

Errors = (ItemNo *) malloc((TRIALS+1) * sizeof(ItemNo));

ForEach(t, 0, TRIALS)

NRules = PRSet[t].SNRules;Rule = PRSet[t].SRule;RuleIndex = PRSet[t].SRuleIndex;DefaultClass = PRSet[t].SDefaultClass;

if ( t < TRIALS ) FReglas<<endl;

FReglas<<"Conjunto de reglas "; FReglas<<t; FReglas<<endl;

else

FReglas<<endl; FReglas<<"Conjunto compuesto de reglas:"; FReglas<<endl;

Final = (t == TRIALS);Errors[t] = Interpret(0, MaxItem, DeleteRules, Final, Final);

AvSize += NRules;AvErrs += Errors[t];

if ( DeleteRules ) PRSet[t].SNRules = NRules;

/* Imprimimos los resultados */

FReglas<<endl; FReglas<<"Prueba Tamaño Errores"; FReglas<<endl; FReglas<<"------ ------ -------"; FReglas<<endl;

ForEach(t, 0, TRIALS)

if ( t < TRIALS )

FReglas<<t;else

FReglas<<" **";

FReglas<<" "; FReglas<<PRSet[t].SNRules; FReglas<<" "; FReglas<<Errors[t];



FReglas<<"("; FReglas<<100 * Errors[t] / (MaxItem+1.0); FReglas<<"%)"; FReglas<<endl;

AvSize /= TRIALS + 1; AvErrs /= TRIALS + 1; FReglas<<" Tamaño Promedio = "; FReglas<<AvSize; FReglas<<", errores promedio = "; FReglas<<AvErrs; FReglas<<" ("; FReglas<< 100 * AvErrs / (MaxItem+1.0); FReglas<<"%)"; FReglas<<endl;

/*************************************************************************//* *//* Evalúa el conjunto de reglas actual *//* *//*************************************************************************/ItemNo TDMC45::Interpret(ItemNo Fp,ItemNo Lp,bool DeleteRules, bool CMInfo, bool Arrow) ItemNo i, Tested=0, Errors=0, *Better, *Worse, *ConfusionMat; bool FoundRule; ClassNo AssignedClass, AltClass; Attribute Att; RuleNo p, Bestr, ri, ri2, riDrop=0; float ErrorRate, BestRuleConfidence;

if ( CMInfo )

ConfusionMat = (ItemNo *) calloc((MaxClass+1)*(MaxClass+1), sizeof(ItemNo));


p = RuleIndex[ri];Rule[p].Used = Rule[p].Incorrect = 0;

Better = (ItemNo *) calloc(NRules+1, sizeof(ItemNo)); Worse = (ItemNo *) calloc(NRules+1, sizeof(ItemNo));

ForEach(i, Fp, Lp)

/* Buscamos la primera opción de la regla para este item */

ri = BestRuleIndex(Item[i], 1);Bestr = ( ri ? RuleIndex[ri] : 0 );FoundRule = Bestr > 0;

if ( FoundRule ) Rule[Bestr].Used++; AssignedClass = Rule[Bestr].Rhs; BestRuleConfidence = Confidence;

/* Ahora buscamos la segunda opción */

ri2 = BestRuleIndex(Item[i], ri+1); AltClass = ( ri2 ? Rule[RuleIndex[ri2]].Rhs : DefaultClass ); if ( AltClass != AssignedClass )

if ( AssignedClass == Class(Item[i]) ) Better[ri]++;elseif ( AltClass == Class(Item[i]) ) Worse[ri]++;



else AssignedClass = DefaultClass;

if ( CMInfo ) ConfusionMat[Class(Item[i])*(MaxClass+1)+AssignedClass]++;Tested++;

if ( AssignedClass != Class(Item[i]) ) Errors++; if ( FoundRule ) Rule[Bestr].Incorrect++;

Verbosity(3)

FReglas<<endl; ForEach(Att, 0, MaxAtt)

FReglas<<" "; FReglas <<AttName->Strings[Att].c_str(); FReglas<<": ";

if ( MaxAttVal[Att] ) if ( DVal(Item[i],Att) )

FReglas<<AttValName[Att][DVal(Item[i],Att)].c_str(); FReglas<<endl;

else

FReglas<<"?";

FReglas<<endl;

else if ( CVal(Item[i],Att) != Unknown )

FReglas<<CVal(Item[i],Att); FReglas<<endl;

else

FReglas<<"?";

FReglas<<endl;

FReglas<<" "; FReglas<<i; FReglas<<": Clase dada"; FReglas<<ClassName->Strings[Class(Item[i])].c_str();

if ( FoundRule )

FReglas<<" La regla "; FReglas<<Bestr; FReglas<<" ["; FReglas<<100 * BestRuleConfidence; FReglas<<"%] determina la clase";

else

FReglas<<" Clase por defecto ";

FReglas<<ClassName->Strings[AssignedClass].c_str(); FReglas<<endl;

FReglas<<endl; FReglas<<"Regla Tamaño Error Usada Errores Ventaja"; FReglas<<endl; FReglas<<"----- ------ ----- ----- ------- -------"; FReglas<<endl;




p = RuleIndex[ri];if ( Rule[p].Used > 0 ) ErrorRate = Rule[p].Incorrect / (float) Rule[p].Used;

FReglas<<p; FReglas<<" "; FReglas<<Rule[p].Size; FReglas<<" "; FReglas<<100 * Rule[p].Error; FReglas<<"% "; FReglas<<Rule[p].Used; FReglas<<" "; FReglas<< Rule[p].Incorrect; FReglas<<" ("; FReglas<<100 * ErrorRate; FReglas<<"%) "; FReglas<<Better[ri]-Worse[ri]; FReglas<<" ("; FReglas<<Better[ri]; FReglas<<"|"; FReglas<<Worse[ri]; FReglas<<") "; FReglas<<ClassName->Strings[Rule[p].Rhs].c_str(); FReglas<<endl;

/* Verificamos si esta regla debería ser eliminada. Nota:podemos eliminar solo una regla por vez, porqueBetter y Worse se ven afectados */

if ( DeleteRules && ! riDrop && Worse[ri] > Better[ri] )

riDrop = ri;

free(Better); free(Worse);

if ( riDrop ) FReglas<<endl; FReglas<<"Eliminamos la regla "; FReglas<<RuleIndex[riDrop]; FReglas<<endl;

ForEach(ri, riDrop+1, NRules) RuleIndex[ri-1] = RuleIndex[ri];NRules--;

if ( CMInfo ) free(ConfusionMat);return Interpret(Fp, Lp, DeleteRules, true, Arrow);

else FReglas<<endl; FReglas<<"Probadas "; FReglas<<Tested; FReglas<<", errores "; FReglas<<Errors; FReglas<<" ("; FReglas<<100 * Errors / (float) Tested; FReglas<<"%)"; FReglas<<( Arrow ? " <<" : "" ); FReglas<<endl;

if ( CMInfo )

PrintConfusionMatrix(ConfusionMat);free(ConfusionMat);



return Errors;

/*************************************************************************//* *//* Busca la mejor regla para el caso dado, dejando la probabilidad *//* en Confidence *//* *//*************************************************************************/RuleNo TDMC45::BestRuleIndex(Description CaseDesc,RuleNo Start) RuleNo r, ri;

ForEach(ri, Start, NRules)

r = RuleIndex[ri];Confidence = Fuerza(Rule[r], CaseDesc);

if ( Confidence > 0.1 ) return ri;

Confidence = 0.0; return 0;

D.5. MÓDULOS DE CLASES DE DATOS

D.5.1. UTipos

D.5.1.1. UTipos.h

//---------------------------------------------------------------------------#ifndef UTiposH#define UTiposH//---------------------------------------------------------------------------//Definición de constantes#define LONG_CLASSIFIER 3 /*Longitud del campo del clasificador*/#define MAX_CANT_DESCRIPTORES 20 /*Cantidad máxima de descriptores que puede haber en la tabla*/#define MAX_CANT_CLASIFICADORES 10 /*Cantidad máxima de valores distintos que puede haber para el clasificador*/#define MAX_HIJOS 20 /*Máxima de cantidad de hijos que puede tener un nodo del árbol*/#define MAX_NIVELES 200#define MAX_CHAR 100

//---------------------------------------------------------------------------//---------------------------------------------------------------------------// DECLARACION DE TIPOS//---------------------------------------------------------------------------//---------------------------------------------------------------------------//Tabla de correlación//*****************EL TAMAÑO DE LA TABLA DEBERÍA SER DINÁMICOtypedef double TTablaCorrel[MAX_CANT_DESCRIPTORES+1][MAX_CANT_CLASIFICADORES+1];

typedef struct tree_node *tree_ptr;

struct tree_node short int flag_hoja; /* 0 si es hoja y todos los valores son "Yes" 1 si es hoja y todos los valores son "No" 2 si es hoja y sus valores son mixtos 3 si no es hoja*/ int desc;



tree_ptr pHijos[MAX_HIJOS]; //hijo derecho short int D[MAX_CANT_DESCRIPTORES];/*Descriptores válidos para el nodo*/ ;

typedef tree_ptr DECISION_TREE;

typedef AnsiString TVecValores [MAX_NIVELES];typedef AnsiString TTablaValores [MAX_NIVELES][MAX_NIVELES];typedef char TRule [MAX_CHAR];typedef int TVecInt [MAX_NIVELES];

class TParametros public: AnsiString ArchivoIni; AnsiString NombreBD; AnsiString TablaBD; AnsiString TablaReglas; AnsiString ColClasificador; AnsiString ExtensionFileReglas; TStringList *LClasificadores; int iFormatoReglas; /* 0: Insight2+ 1: KappaPC 2: ambos 3: ninguno*/ int iSistema; /* 0: ID3 1: C4.5 */ int iCriterio; /* 0: Ganancia 1: Proporción de ganancia */ int iPoda; /* 0: Si 1: No */ int iConjuntos; /* indica si las pruebas en el C4.5 se realizan sobre grupos de atrib discretos 0: Si 1: No */ int iMinObjs; /* Cantidad mínima de objetos que debe tener una rama en el C4.5 */ int iCF; /* Nivel de confianza para la poda en el C4.5 */

TParametros(AnsiString ArchIni); //constructor //Toma los parámetros del archivo .ini ~TParametros(); //destructor

//Refresca los parámetros a partir del archivo .ini /*Devuelve 0 si no hubo problemas, -1 en caso contrario*/ int RefrescarParams(); //Guardar los parámetros en el .ini /*Devuelve 0 si no hubo problemas, -1 en caso contrario*/ int GrabarParams(); ;

//---------------------------------------------------------------------------#endif

D.5.1.2. UTipos.cpp

//---------------------------------------------------------------------------#include <vcl.h>#pragma hdrstop

#include "UTipos.h"

//---------------------------------------------------------------------------#pragma package(smart_init)

//---------------------------------------------------------------------------//---------------------------------------------------------------------------// IMPLEMENTACIÓN DE LA CLASE TParametros//---------------------------------------------------------------------------



//---------------------------------------------------------------------------

TParametros::TParametros(AnsiString ArchIni) //constructor//Toma los parámetros del archivo .iniint i;char Buffer[80];

ArchivoIni=ArchIni;

LClasificadores = new TStringList();

//Cargamos las opciones por default del archivo .ini

//Cargamos los datos asociados con los clasificadores GetPrivateProfileString("Clasificadores", "ColClasif", "???", Buffer, sizeofBuffer, ArchivoIni.c_str()); if (Buffer!="???") ColClasificador=Trim(Buffer); GetPrivateProfileString("Clasificadores", "lClasif", "???", Buffer, sizeofBuffer, ArchivoIni.c_str()); if (Buffer!="???") LClasificadores->Add(AnsiString(strtok(Buffer, ","))); i=0; while (Trim(LClasificadores->Strings[i])!="") LClasificadores->Add(AnsiString(strtok(NULL, ","))); i++; LClasificadores->Delete(i);

//Cargamos los datos relacionados con la Base de Datos GetPrivateProfileString("BaseDeDatos", "Tabla", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") TablaBD=Trim(Buffer);

GetPrivateProfileString("BaseDeDatos", "Alias", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") NombreBD=Trim(Buffer);

//Cargamos los datos asociados con las reglas de decisión GetPrivateProfileString("Reglas", "Extension", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") ExtensionFileReglas=Trim(Buffer);

GetPrivateProfileString("Reglas", "Formato", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iFormatoReglas=StrToInt(Trim(Buffer));

//Cargamos los datos asociados con el sistema de resolución y sus opciones GetPrivateProfileString("Resolucion", "Sistema", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iSistema=StrToInt(Trim(Buffer));

GetPrivateProfileString("Resolucion", "Criterio", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iCriterio=StrToInt(Trim(Buffer));

GetPrivateProfileString("Resolucion", "Poda", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iPoda=StrToInt(Trim(Buffer));

//Cargamos los datos asociados con el C4.5 GetPrivateProfileString("C45", "Conjuntos", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???")



iConjuntos=StrToInt(Trim(Buffer));

GetPrivateProfileString("C45", "MinObjs", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iMinObjs=StrToInt(Trim(Buffer));

GetPrivateProfileString("C45", "CF", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iCF=StrToInt(Trim(Buffer));

//---------------------------------------------------------------------------

TParametros::~TParametros() //destructor ArchivoIni.~AnsiString(); NombreBD.~AnsiString(); TablaBD.~AnsiString(); TablaReglas.~AnsiString(); ColClasificador.~AnsiString(); ExtensionFileReglas.~AnsiString(); delete LClasificadores;//---------------------------------------------------------------------------

int TParametros::RefrescarParams()//Refresca los parámetros a partir del archivo .ini/*Devuelve 0 si no hubo problemas,-1 en caso contrario*/int i;char Buffer[80];

try LClasificadores = new TStringList();

//Cargamos las opciones por default del archivo .ini

//Cargamos los datos asociados con los clasificadores GetPrivateProfileString("Clasificadores", "ColClasif", "???", Buffer, sizeofBuffer, ArchivoIni.c_str()); if (Buffer!="???") ColClasificador=Trim(Buffer); GetPrivateProfileString("Clasificadores", "lClasif", "???", Buffer, sizeofBuffer, ArchivoIni.c_str()); if (Buffer!="???") LClasificadores->Add(AnsiString(strtok(Buffer, ","))); i=0; while (Trim(LClasificadores->Strings[i])!="") LClasificadores->Add(AnsiString(strtok(NULL, ","))); i++; LClasificadores->Delete(i);

//Cargamos los datos relacionados con la Base de Datos GetPrivateProfileString("BaseDeDatos", "Tabla", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") TablaBD=Trim(Buffer);

GetPrivateProfileString("BaseDeDatos", "Alias", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") NombreBD=Trim(Buffer);

//Cargamos los datos asociados con las reglas de decisión GetPrivateProfileString("Reglas", "Extension", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") ExtensionFileReglas=Trim(Buffer);



GetPrivateProfileString("Reglas", "Formato", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iFormatoReglas=StrToInt(Trim(Buffer));

//Cargamos los datos asociados con el sistema de resolución y sus opciones GetPrivateProfileString("Resolucion", "Sistema", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iSistema=StrToInt(Trim(Buffer));

GetPrivateProfileString("Resolucion", "Criterio", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iCriterio=StrToInt(Trim(Buffer));

GetPrivateProfileString("Resolucion", "Poda", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iPoda=StrToInt(Trim(Buffer));

//Cargamos los datos asociados con el C4.5 GetPrivateProfileString("C45", "Conjuntos", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iConjuntos=StrToInt(Trim(Buffer));

GetPrivateProfileString("C45", "MinObjs", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iMinObjs=StrToInt(Trim(Buffer));

GetPrivateProfileString("C45", "CF", "???", Buffer, sizeof Buffer,ArchivoIni.c_str()); if (Buffer!="???") iCF=StrToInt(Trim(Buffer));

return(0); catch(...) return(-1); //---------------------------------------------------------------------------int TParametros::GrabarParams()//Guardar los parámetros en el .ini/*Devuelve 0 si no hubo problemas,-1 en caso contrario*/AnsiString lista;int index;

try

//Actualizamos el archivo de inicio WritePrivateProfileString("Clasificadores", "ColClasif",ColClasificador.c_str(), ArchivoIni.c_str()); WritePrivateProfileString("BaseDeDatos", "Alias", NombreBD.c_str(),ArchivoIni.c_str()); WritePrivateProfileString("BaseDeDatos", "Tabla", TablaBD.c_str(),ArchivoIni.c_str()); WritePrivateProfileString("Reglas", "Extension", ExtensionFileReglas.c_str(),ArchivoIni.c_str());

//Clasificadores lista= ""; index=0; while (index<LClasificadores->Count) AppendStr(lista, LClasificadores->Strings[index]); AppendStr(lista, ", "); index++;



WritePrivateProfileString("Clasificadores", "lClasif", lista.c_str(),ArchivoIni.c_str());

//Formato de las reglas lista=IntToStr(iFormatoReglas); WritePrivateProfileString("Reglas", "Formato", lista.c_str(),ArchivoIni.c_str());

//Sistema de resolución lista=IntToStr(iSistema); WritePrivateProfileString("Resolucion", "Sistema", lista.c_str(),ArchivoIni.c_str()); lista=IntToStr(iCriterio); WritePrivateProfileString("Resolucion", "Criterio", lista.c_str(),ArchivoIni.c_str()); lista=IntToStr(iPoda); WritePrivateProfileString("Resolucion", "Poda", lista.c_str(),ArchivoIni.c_str());

//C4.5 lista=IntToStr(iConjuntos); WritePrivateProfileString("C45", "Conjuntos", lista.c_str(),ArchivoIni.c_str()); lista=IntToStr(iMinObjs); WritePrivateProfileString("C45", "MinObjs", lista.c_str(), ArchivoIni.c_str()); lista=IntToStr(iCF); WritePrivateProfileString("C45", "CF", lista.c_str(), ArchivoIni.c_str());

lista.~AnsiString(); return(0); catch(...) lista.~AnsiString(); return(-1);

//---------------------------------------------------------------------------//---------------------------------------------------------------------------// FIN DE LA CLASE TParametros//---------------------------------------------------------------------------//---------------------------------------------------------------------------

D.5.2. Types.h/*************************************************************************//* *//* Definiciones de tipos para C4.5 *//* ------------------------------- *//* *//*************************************************************************/

typedef char *Conjunto;typedef int ItemNo; /* nro de data item */typedef float ItemCount; /* cant de items (parciales) */

typedef short ClassNo, /* nro de clase, 0..MaxClass */DiscrValue; /* valor discreto del atributo (0 = ?) */

typedef short Attribute; /* nro de atributo, 0..MaxAtt */

typedef union _attribute_value DiscrValue _discr_val; float _cont_val; AttValue, *Description;

#define CVal(Case,Attribute) Case[Attribute]._cont_val#define DVal(Case,Attribute) Case[Attribute]._discr_val#define Class(Case) Case[MaxAtt+1]._discr_val



#define Unknown -999 /* valor desconocido para un atrib continuo */

#define BrDiscr 1 /* tipos de nodo: rama */#define ThreshContin 2 /* límite de corte */#define BrSubset 3 /* prueba de subconjuntos*/

typedef struct tree_record *Tree;struct tree_record

short NodeType; /* 0=hoja 1=rama 2=corte 3=subconj */ ClassNo Leaf; /* clase más frecuente del nodo */ ItemCount Items, /* nro de items en el nodo */

*ClassDist, /* distrib de clase de los items */ Errors; /* nro de errores en el nodo */ Attribute Tested; /* atribute referenciado en la prueba */ short Forks; /* nro de ramas en el nodo */ float Cut, /* límite para los atrib continuos */

Lower, /* límite inferior del valor límite */ Upper; /* límite superior del valor límite */

Conjunto *Subset; /* subconj de valores discretos */ Tree *Branch; /* Branch[x] = (sub)árbol para el resultado x */ ;

typedef Tree DECISION_TREE_C45;

#define IGNORAR 1 /* estado especial de un atrib: no utilizar */#define DISCRETE 2 /* estado especial de un atrib: incorporar los

valores a medida que se leen los datos */

typedef short RuleNo; /* nro de regla */

typedef struct TestRec *Test;

struct TestRec

short NodeType; /* tipo de prueba */ Attribute Tested; /* atributo testeado */ short Forks; /* ramas posibles */ float Cut; /* valor límite (si es relevante) */ Conjunto *Subset; /* subconjunto (si es relevante) */

;

typedef struct CondRec *Condition;

struct CondRec

Test CondTest; /* antecedente de la prueba */ short TestValue; /* resultado de la prueba */

;

typedef struct ProdRuleRec PR;

struct ProdRuleRec

short Size; /* nro de condiciones */ Condition *Lhs; /* condiciones */ ClassNo Rhs; /* clase resultante de la regla */ float Error, /* proporción estimada de error */

Bits; /* bits para codificar la regla */ ItemNo Used, /* cant de veces en q se uso la regla */

Incorrect; /* cant de veces en q la regla fue incorrecta */

;

typedef struct RuleSetRec RuleSet;

struct RuleSetRec

PR *SRule; /* reglas */ RuleNo SNRules, /* cant de reglas */



*SRuleIndex; /* indice de reglas */ ClassNo SDefaultClass; /* clase por defecto */

;

D.5.3. Defns.h/*************************************************************************//* *//* Definiciones utilizadas en el C4.5 *//* ---------------------------------- *//* *//*************************************************************************/

#include <stdio.h>#include <math.h>

#define None -1#define Epsilon 1E-3

long random();#define Random ((random()&2147483647) / 2147483648.0)

#define Max(a,b) ((a)>(b) ? a : b)#define Min(a,b) ((a)<(b) ? a : b)#define Round(x) ((int) (x+0.5))#define Log2 0.69314718055994530942#define Log(x) ((x) <= 0 ? 0.0 : log((float)x) / Log2)

#define Bit(b) (1 << (b))#define In(b,s) ((s[(b) >> 3]) & Bit((b) & 07))#define ClearBits(n,s) memset(s,0,n)#define CopyBits(n,f,t) memcpy(t,f,n)#define SetBit(b,s) (s[(b) >> 3] |= Bit((b) & 07))

#define ForEach(v,f,l) for(v=f ; v<=l ; ++v)

#define Verbosity(d) if(VERBOSITY >= d)

#define Check(v,l,h) if ( v<l||v>h ) printf("\t** valor inválido **\n"); exit(1);

D.5.4. Rulex.h/*************************************************************************//* *//* Datos globales para la construcción y aplicación de las reglas *//* -------------------------------------------------------------- *//* *//*************************************************************************/

#define Before(n1,n2) (n1->Tested < n2->Tested || n1->NodeType < n2->NodeType ||n1->Tested == n2->Tested && n1->Cut < n2->Cut)

#define IsTarget(case) (Class(case) == TargetClass ? 1 : 0)

extern PR *Rule; /* reglas de producción */

extern RuleNo NRules, /* nro de relgas de producción */*RuleIndex; /* índeice de las relgas de producción */

extern short RuleSpace; /* espacio reservado para las relgas */

extern RuleSet *PRSet; /* conjuntos de reglas */

extern ClassNo DefaultClass; /* clase por defecto asociada con un conj de reglas */

extern Boolean SIGTEST, /* utilizar la prueba de Fisher en la



poda de reglas */SIMANNEAL; /* usar simulated annealing */

extern float SIGTHRESH, /* nivel de sig usado en la poda de relgas */REDUNDANCY, /* factor que regula la codificación

entre reglas y excepciones */AttTestBits, /* bits promedio necesarios para

codificar un atributo testeado */*BranchBits; /* idem para el valor del atributo */

extern float *LogItemNo; /* LogItemNo[i] = log2(i) */extern double *LogFact; /* LogFact[i] = log2(i!) */


Referencias Magdalena Servente 341

REFERENCIAS

[Babic et al, 1998] Babic, A., Mathiesen, U., Hedin, K., Bodemar, G., Wigertz, O. 1998.Assessing an AI Knowledge-Base for Asymptomatic Liver Diseases.Department of Medical Informatics, Department of Internal Diseases,Department of Infectious Diseases, Linköping University Hospital,Suecia. Faculty of Electrical and Computer Engineering, University ofLjubljana, Eslovenia. Department of Internal Diseases, OskarshamnCounty Hospital, Suecia.

[Baldwin et al, 2000] Baldwin, J.F., Lawry, J., Martin, T.P. 2000 Mass AssignmentInduction of Decision Trees on Words. A.I. Group, Departament ofEngineering Mathematics, University of Bristol, Reino Unido,jim.baldwin, j.lawry, [email protected]

[Bergadano et al, 1992] Bergadano, F., Matwin, S. Michalski, R. S., Zhang, J. (1992)Learning Two-TieredDescriptions of flexible Concepts: thePOSEIDON System. En Machine Learning, Volumen 8, páginas 5-43,DBLP, www.dblp.uni-tier.de, Dinamarca.

[Blockeel y De Raedt, 1997] Blockeel, H., De Raedt, L., 1997 Top-Down Induction of LogicalDecision Trees. Katholieke Universiteit Leuven, Departament ofComputer Science, Celestijnelaan, Bélgica

[Blum, Langley, 1997] Blum, A., Langley, P. 1997 Selection of Relevant Features andExamples in Machine Learning. School of Computer Science,Carnegie Mellon University, Pittisburgh, Pennsylvania, Institute forthe Study of Learning and Expertise, Palo Alto, California, EE.UU.

[Blurock, 1996] Edward S. Blurock, 1996 The ID3 Algorithm, Research Institute forSymbolic Computation, www.risc.uni-linz.ac.at/people/bulrock/ANALYSIS/manual/document, Austria

[Cabena et al, 2000] Cabena, P., Choi, H.H., Kim, S., Otsuka, S., Reinschmidt, J.,Saarenvirta, G. 2000. Intelligent Miner for Data Applications Guide,International Technical Support Organization, IBM,http://www.redbooks.ibm.com

[Callahan, B., Coombs, 1998] Callahan, B., Coombs, J. 1998 Training Decision Trees with ID3,http://www.css.tayloru.edu/~jcoombs/proj/ml/id3.htm

[Chen, 1994] Chen, H. 1994. Machine Learning for Information Retrieval: NeuralNetworks, Symbolic Learning, and Genetic Algorithms. JASIS,http://ai.bpa.arizona.edu/papers/mlir93/mlir93.html

[Davidsson, 1995] Davidsson, P. 1995. ID3-SD: An Algortithm for LearningCharacteristic Decision Trees by Controlling the Degree ofGeneralization. Departament of Computer Science, Lund University,Suecia

[DeJong, Mooney, 1986] DeJong, G.F., Mooney, R.J. 1986. Explanation-Based Learning. AnAlternative View, en Machine Learning, Volumen 1, páginas 145-176.Kluwer Academic Publishing

[Elomaa, 1993] Elomaa, T. 1993. In Defense of C4.5: Notes on Learning One-LevelDecision Trees. Departament of Computer Science, University ofHelsinki, Finlandia

[Espasa-Calpe, 1974] 1974 Diccionario Enciclopédico Abreviado. Espasa-Calpe S.A.,Madrid. Tomo I, Séptima Edición, España.

[Fayad et al, 1996] Fayad, U. M., Piatetsky-Shapiro, G., Smyth, P., Uhturudsamy, R.(eds). 1996 Advances in Knowledge Discovery and Data Mining, SanMateo, AAAI Press, EE.UU.

[Fjara, 2000] Fjara, 2000. A Decision Tree Algorithm.www.cs.uml.edu/~fjara/mineset/id3/id3_example/id3_algoritm.html

[Frank y Witten, 1999] Frank, E. , Witten, I.H. 1999. Making Better Use of GlobalDiscretization, Proceedings 16th International Conference on MachineLearning, páginas 115-123. Departament of Computer Science,University of Waikato, Nueva Zelanda

[Gallion et al, 1993] Gallion, R., St Clair, D., Sabharwal, C., Bond, W.E. 1993. DynamicID3: A Symbolic Learning Algorithm for Many-Valued Attribute

mailto:[email protected]

http://www.dblp.uni-tier.de/

http://www.risc.uni-linz.ac.at/people/bulrock/ANALYSIS/manual/document

http://www.risc.uni-linz.ac.at/people/bulrock/ANALYSIS/manual/document

http://www.redbooks.ibm.com/

http://ai.bpa.arizona.edu/papers/mlir93/mlir93.html

http://www.cs.uml.edu/~fjara/mineset/id3/id3_example/id3_algoritm.html


342 Magdalena Servente Referencias

Domains. Engineering Education Center, University of Missouri-Rolla, St. Luis, EE.UU.

[García Martínez et al, 1987] García Martínez, R., Frítz, W., y Blanqué, J. 1987. Un algoritmo deaprendizaje de conceptos para sistemas inteligentes. Anales del VCongreso Nacional de Informática y Teleinformática. Páginas 91-96.Buenos Aires. Junio. Argentina

[García Martínez, 1994] García Martínez, R. 1994. Adquisición de Conocimiento. EnAbecasis, S. y Heras, C. Metodología de la Investigación. Prologadopor el Dr. L. Santaló. Editorial Nueva Librería. Argentina

[García Martínez, 1997] García Martínez, R. 1997 Sistemas Autónomos: AprendizajeAutomático. Nueva Librería, Buenos Aires, Argentina

[Gestwicki, 1997] Gestwicki, P. 1997 ID3: History, Implementation, and Applications,citeseer.nj.nec.com/398697.html

[Grossman et al, 1999] Grossman, R., Kasif, S., Moore, R., Rocke, D., Ullman, J. 1999. DataMining Research: Opportunities and Challenges, A Report of threeNSF Workshops on Mining Large, Massive, and Distributed Data,January 1999, Chicago, EE.UU.

[Hall, 1998] Hall, P.W. 1998. Machine Learning – ID3 [email protected], http://junior.apk.net/~philiv/rschmlid.htm

[Holsheimer, Siebes, 1994] Holsheimer, M., Siebes, A.P.J.M. 1994. Data Mining: the search forknowledge in databases. Computer Science/Departament ofAlgorithmics and Architectire, Centrum voor Wiskunde enInformatica, CS-R9406, Amsterdam, Holanda.

[Holte, 1993] Holte, R.1993. Very Simple Classification Rules Perform Well onMost Commonly Used Datasets. Computer Science Departament,University of Ottawa, Canada.

[Hunt et al, 1966] Hunt, E.B., Marin, J., Stone, P.J. 1966. Experiments in Induction.New York: Academic Press, EE.UU.

[Hunt, 1975] Hunt, E.B. 1975. Artificial Intelligence. New York: Academic Press,EE.UU.

[Joachims et al, 1995] Joachims, T., Freitag, D., Mitchell, T. 1997 Web Watcher: A TourGuide for the World Wide Web, School of Computer Science,Carnegie Mellon University, EE.UU.

[Joachims et al, 1997] Joachims, T., Mitchell, T., Freitag, D., Armstrong, R. 1995. WebWatcher: Machine Learning and Hypertext, School of ComputerScience, Carnegie Mellon University, EE.UU.

[Joshi, 1997] Joshi, K.P. 1997. Analysis of Data Mining Algorithms,http://userpages.umbc.edu/~kjoshi1/data-mine/proj_rpt.htm

[Kerns, Mansour, 1996] Kearns, M., Mansour, Y. 1996. On the Boosting Ability of Top-DownDecision Tree Learning Algorithms, AT&T Research, Tel-AvivUniversity, Israel.

[Klemettinen et al, 1994] Klemettinen, M., Mannila, H., Ronkainen, P., Toivonen, H., Verkamo,A. 1994. Finding Interesting Rules from Large Sets of DiscoveredAssociation Rules, University of Helsinki, Department of ComputerScience, Helsinki, Finlandia.

[Korab, 1997] Korab, H. 1997. Rule Induction: Decision Trees and Rules,http://www.ncsa.uiuc.edu/News/Access/Stories/97Stories/KUFRIN.html

[Mannila et al, 1994] Mannila, H., Toivonen, H., Verkamo, A. 1994. Efficient Algorithmsfor Discovering Association Rules, University of Helsinki, Departmentof Computer Science, Helsinki, Finlandia.

[Michalski et al, 1998] Michalski, R.S., Bratko, I., Kubat M. 1998. Machine Learning andData Mining. Methods and Applications. Wiley & Sons Ltd., EE.UU.

[Michalski et al, 1982] Michalski, R. S., Baskin, A. B., Spackman, K. A. 1982. A Logic-Based Approach to Conceptual Database Analysis, Sixth AnnualSymposium on Computer Applications on Medical Care, GeorgeWashington University, Medical Center, Washington, DC, EE.UU.

[Michalski, 1983] Michalski, R. S. 1983. A Theory and Methodology of InductiveLearning. En Michalski, R. S., Carbonell, J. G., Mitchell, T. M. (eds.).(1983) Machine Learning: An Artificial Intelligence Approach, Vol. I.

mailto:[email protected]

http://www.ncsa.uiuc.edu/News/Access/Stories/97Stories/KUFRIN.html

http://www.ncsa.uiuc.edu/News/Access/Stories/97Stories/KUFRIN.html


Referencias Magdalena Servente 343

Morgan-Kauffman, EE.UU.

[Michalski, 1991] Michalski, R. S. 1991. Towards an Unified Theory of Learning: AnOutline of Basic Ideas, Proceedings of the 3rd World Conference onthe Fundamentals of Artificial Intelligence, Paris, Julio 1-5, 1991

[Michalski, Tecuci, 1994] Michalski, R. S., Tecuci, G. (eds) 1994. Machine Learning: AMultistrategy Approach, Vol.IV, Morgan Kauffinan, EE.UU.

[Michie, 1986] Michie, D. 1986. On Machine Intelligence (2nd ed), Ellis Horwood,Chichester, Reino Unido

[Michie, 1998] Michie, D. 1988 Machine Learning in the next five years, EWSL-88,3rd European Working Session on Leaming, Pitman, Glasgow,Londres, Reino Unido.

[Mitchell, 1997] Mitchell, T. 1997. Machine Learning. MCB/McGraw-Hill, CarnegieMellon University, EE.UU.

[Mitchell, 2000a] Mitchell, T. 2000 Decision Trees. Cornell University,www.cs.cornell.edu/courses/c5478/2000SP, EE.UU.

[Mitchell, 2000b] Mitchell, T. 2000 Decision Trees 2. Cornell University,www.cs.cornell.edu/courses/c5478/2000SP, EE.UU.

[Montalvetti, 1995] Montalvetti, Mario 1995. Sistemas de adquisición automática deconocimientos, Tesis de grado en Ingeniería en Computación.Universidad Católica de Santiago del Estero, Argentina.

[Monter, 2001] Monter, C. 2001. Equiparación de Marcos. Notas de Seminario.Escuela de Posgrado, Instituto Tecnológico de Buenos Aires,Argentina

[Quinlan y Cameron-Jones, 1995] Quinlan, J.R., Cameron-Jones, R.M. 1995. Oversearching andLayered Search in Empirical Learning. Basser Departament ofComputer Science, University of Science, Australia.

[Quinlan, 1986] Quinlan, J.R. 1986. Induction of Decision Trees. En MachineLearning, Capítulo 1, p.81-106. Morgan Kaufmann, 1990

[Quinlan, 1987] Quinlan, J.R. 1987. Generating Production Rules from Decision trees.Proceeding of the Tenth International Joint Conference on ArtificialIntelligence, páginas. 304-307. San Mateo, CA., Morgan Kaufmann,EE.UU.

[Quinlan, 1988b] Quinlan, J.R. 1988. Decision trees and multi-valued attributes. EnJ.E. Hayes, D. Michie, and J. Richards (eds.), Machine Intelligence,Volumen II, páginas. 305-318.Oxford University Press, Oxford, ReinoUnido

[Quinlan, 1989] Quinlan, J.R. 1989. Unknown Attribute Values in Induction. BasserDepartament of Computer Science, University of Science, Australia.

[Quinlan, 1990] Quinlan, J. R. 1990. Learning Logic Definitions from Relations. EnMachine Leaming, Vol 5, páginas 239-266. Oxford University Press,Oxford, Reino Unido

[Quinlan, 1993a] Quinlan, J.R. 1993. The Effect of Noise on Concept Learning, En R.S. Michalski, J. G. Carbonell, & T. M. Mitchells (Eds.) MachineLearning, The Artificial Intelligence Approach. Morgan Kaufmann,Vol. I, Capítulo 6, páginas149-167. San Mateo, CA: MorganKaufmann, EE.UU.

[Quinlan, 1993b] Quinlan, J.R. 1993. Learning Efficient Classification Procedures andTheir Application to Chess Games, En R. S. Michalski, J. G.Carbonell, & T. M. Mitchells (Eds.) Machine Learning, The ArtificialIntelligence Approach. Morgan Kaufmann, Vol. II, Capítulo 15,páginas 463-482, EE.UU.

[Quinlan, 1993c] Quinlan, J.R. 1993. Combining Instance-Based and Model-BasedLearning. Basser Departament of Computer Science, University ofScience, Australia.

[Quinlan, 1993d] Quinlan, J.R. 1993 C4.5: Programs for Machine Learning. MorganKaufmann Publishers, San Mateo, California, EE.UU.

[Quinlan, 1995] Quinlan, J.R. 1995 MDL and Categorical Theories. BasserDepartament of Computer Science, University of Science, Australia.

http://www.cs.cornell.edu/courses/c5478/2000Sp

http://www.cs.cornell.edu/courses/c5478/2000Sp


344 Magdalena Servente Referencias

[Quinlan, 1996a] Quinlan, J.R. 1996. Improved Use of Continuous Attributes in C4.5.Basser Departament of Computer Science, University of Science,Australia.

[Quinlan, 1996b] Quinlan, J.R.1996. Learning First-Order Definitions of Functions.Basser Departament of Computer Science, University of Science,Australia

[Riddle, 1997] Riddle, P.J. 1997. ID3 Algorithm.www.cs.auckland.ac.nz/~pat/706_99/ln/node75.html, Nueva Zelanda

[Rissanen, 1983] Rissanen, J. 1983. A universal prior for integers and estimation byminimum description length. En Annals of Statistics 11, Vol 2, p. 416-431

[S/A, 19950] S/A. 1995. Building Classification Models: ID3 and C4.5,yoda.cis.temple.edu:8080/UGAIWWW/lectures/C45, Pensilvania,EE.UU.

[S/A, 1998] S/A 1998.Confidence intervals for small sample sizes. En EngineeringStatistics Handbook, Information Technology Laboratory, NIST,http://www.itl.nist.gov/div898/handbook/prc/section2/prc242.htm,EE.UU.

[S/A, 1999] S/A. 1999. What is Data Mining?,www.citeseer.nj.nec.com/69212.html.

[Thakore, 1993] Thakore, M., St Clair, D. 1993. Effect of the X2 test on theConstruction of ID3 decision trees, Sun Microsystems, University ofMO-Rolla, Engineering Education Center, St. Louis, EE.UU.

[Thrun et al, 1991] Thrun, S., Bala, J., Bratko, I., Cestnik, B., Cheng, J., De Jong, K.,Dzeroski, S., Fahlman, S.E., Fisher, D., Hamann, R., Kaufman, K.,Keller, S., Kononenko, I., Michalski, R.S., Mitchell, T., Pachowicz,P., Reich, Y., Vafaie, H., Van de Welde, W., Wenzel, W., Wnek, J,Zhang, J. 1991 The MONK’s Problems. A Performance Comparisonof Different Learning Algorithms, Carnegie Mellon University,Pittisburgh, EE.UU.

[Thrun et al, 1998] Thrun, S., Faloustos, C., Mitchell, T., Wasserman, L. 1998 AutomatedLearning and Discovery: State-Of-The-Art and Research Topics in aRapidly Growing Field. CMU-CALD-98-100, Center for AutomatedLearning and Discovery, Carnegie Mellon University, Pittisburgh,EE.UU.

[Witten y Frank, 2000] Witten, I.H., Frank, E. 2000. Data Mining: Practical MachineLearning Tools and Techniques with Java Implementations. MorganKaufmann, San Diego, EE.UU.

http://www.cs.auckland.ac.nz/~pat/706_99/ln/node75.html

http://yoda.cis.temple.edu:8080/UGAIWWW/lectures/C45

http://www.itl.nist.gov/div898/handbook/prc/section2/prc242.htm

http://citeseer.nj.nec.com/69212.html

Ingenieria Informatica - Arboles de Decicion - ID3 C4.5

Documents

Transcript of Ingenieria Informatica - Arboles de Decicion - ID3 C4.5