Mode Lo 1

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
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
Resumen Magdalena Servente

Indice Magdalena Servente i

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
ii Magdalena Servente Indice

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
Indice Magdalena Servente iii

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
iv Magdalena Servente Indice

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
Indice Magdalena Servente v


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
vi Magdalena Servente Indice

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
Indice Magdalena Servente vii

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
viii Magdalena Servente Indice

D.5.3. Defns.h 339

D.5.4. Rulex.h 339
REFERENCIAS 341
Indice Magdalena Servente ix

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.
Introducción Magdalena Servente 1

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
2 Magdalena Servente Introducció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)
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
Introducción Magdalena Servente 3

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.
4 Magdalena Servente Introducción

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
Estado del Arte Magdalena Servente 5

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.
6 Magdalena Servente Estado del Arte

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.
ejemplos
descripción de conceptos
conocimientos previos C
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

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.
Instituciones
Educativas
Primarias Secundarias Terciarias Universitarias
Públicas Privadas
UBA UTN
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,

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_Tenis

Día 1 Sol No Poca Si
Día 2 Lluvia Ráfagas Poca No
Día 3 Nublado Ventoso Poca No
Día 4 Sol Ventoso Alta Si
Dí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].
codificación de los
ejemplos ejemplos
E C ML
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
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.
codificación de los
ejemplos ejemplos
E DM
BD
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.

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 TDIDT

La 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:
H ( S i ) = − pi+ log pi+ − pi− log pi− (2.1)
Donde pi+ es la probabilidad de que un ejemplo tomado al azar de Si sea positivo. Esta probabilidad
puede calcularse como
ni+
pi+ = (2.2)
ni+ + ni−
+
Siendo ni la cantidad de ejemplos positivos de Si, y ni− la cantidad de ejemplos negativos.
La probabilidad pi− se calcula en forma análoga a pi+ , 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
H ( S i ) = ∑ − p i log p i (2.3)
i =1

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
H ( S , at ) = ∑ P(S i ) ⋅ H (S i ) (2.4)
i =1
Donde H (S i ) es la entropía del subconjunto S i y P(S i ) es la probabilidad de que un ejemplo

pertenezca a S i . Puede calcularse, utilizando los tamaños relativos de los subconjuntos, como:
Si
P(S i ) = (2.5)
S
La ganancia en información puede calcularse como la disminución en entropía. Es decir:
I (S , at ) = H (S ) − H (S , at ) (2.6)
Donde H (S ) es el valor de la entropía a priori, antes de realizar la subdivisión, y H (S , at ) 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 con

valores desconocidos para A: si A tiene una proporción de valores desconocidos del x%, la
prueba 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 la
ganancia.
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 subconjunto

correspondiente.
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 casos
con valores conocidos en cada subconjunto.
F- Asignar una fracción del caso a cada subconjunto utilizando las proporciones explicadas en
el 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 los
distintos 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:
n
 1
1 -  = e = 0.368
-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:
e = 0.632 × e prueba + 0.368 × e entrenamiento
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 predicha
Sí No
Clase verdadera Sí Verdadero positivo Falso Negativo
No 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.


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
Descripción del Problema Magdalena Servente 43

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.
44 Magdalena Servente Descripción del Problema

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?
Descripción del Problema Magdalena Servente 45

46 Magdalena Servente Descripción del Problema

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].
Solución Propuesta Magdalena Servente 47

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.
48 Magdalena Servente Manual del usuario

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.
Entrada Entrada: p1, p2
d1(p1)
Nodos
descriptores F(d1(p1),d2(p2))=c
d2(p2) c
Salida: c
Hojas o Nodos de
c c
clasificadores
Salida
Figura 4.1: Estructura de un árbol de decisión

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
n Ti
H (T , X ) = ∑ × H (Ti ) (4.2)
i =1 T
La cantidad
I (T , X ) = H (T ) − H (T , X ) (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:
n Ti  Ti 
I _ división(X ) = −∑ × log 2  
 (4.4)
i =1 T T 
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,
I (T , X )
proporción _ de _ ganancia( X ) =
I _ división( X ) (4.5)

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. ID3
El 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;
Comienzo
Si 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 en
los registros de S [Nota: habrá errores, es decir, registros que no estarán bien
clasificados en este caso];
Si R no está vacío, entonces
D ! 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 de
dj respectivamente;
Devolver un árbol con la raíz nombrada como D y con los arcos nombrados d1, d2,
.., dm que van respectivamente a los árboles
ID3(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 JuegoTenis

Soleado Alta Leve No
Soleado Alta Fuerte No
Nublado Alta Leve Si
Lluvia Alta Leve Si
Lluvia Normal Leve Si
Lluvia Normal Fuerte No
Nublado Normal Fuerte Si
Soleado Normal Leve Si
Soleado Normal Fuerte Si
Nublado Alta Fuerte Si
Nublado Normal Leve Si
Lluvia 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 Soleado

No 1 0 3
Si 4 4 2
Totales 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,
10 10 4 4
H ( S ) = − p Si log 2 p Si − p No log 2 p No = − log 2 − log 2 = 0.86312bits
14 14 14 14
Calculamos ahora la entropía que tendrían los conjuntos resultantes de la división de datos según este
atributo.
2
5 1 4 4  0 4 5  3 2
H ( S , Estado) = ∑ P(S i ) ⋅ H (S i ) =
1 4 0 4 3 2
 − log 2 − log 2  +  − log 2 − log 2  +  − log 2 − log 2 
i =1 14  5 5 5 5  14  4 4 4 4  14  5 5 5 5
5 4 5
H ( S , Estado) = × 0.7219 + × 0 + 0.97095 = 0.6046bits
14 14 14
Ahora calculamos la ganancia resultante de dividir al subconjunto según el atributo Estado, tendremos:
Ganancia(S , Estado) = H (S ) − H (S , Estado ) = 0.25852bits
Para calcular la proporción de ganancia debemos conocer primero la información de la división que se
calcula como:
 Si 
 = − 5 × log 2  5  − 4 × log 2  4  − 5 × log 2  5  = 1.577bits
n Si
I _ división(S ) = −∑ × log 2 
S    14  14  14  14  14 
i =1  S  14
Finalmente, calculamos la proporción de ganancia.
Ganancia( S )
proporción _ de _ ganancia( S ) = = 0.491042bits
I _ división( S )
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:

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


ESTADO
Soleado Alta Fuerte No ganancia=0.258521
Nublado Alta Leve Si proporción de ganancia=0.491042
Lluvia Alta Leve Si
HUMEDAD
Lluvia Normal Leve Si Ganancia=0.0746702
Lluvia Normal Fuerte No Proporción de ganancia =0.14934
Soleado Alta Leve No VIENTO
Ganancia=0.00597769
Soleado Normal Leve Si Proporción de ganancia
Lluvia Normal Leve Si =0.0122457
Lluvia
Estado Soleado
Nublado
Estado Humedad Viento JuegoTenis Estado Humedad Viento JuegoTenis Estado Humedad Viento JuegoTenis
Lluvia Alta Leve Si Nublado Alta Leve Si Soleado Alta Leve No
Lluvia Normal Leve Si Nublado Normal Fuerte Si Soleado Alta Fuerte No
Lluvia Normal Fuerte No Nublado Alta Fuerte Si Soleado Alta Leve No
Lluvia Normal Leve Si Nublado Normal Leve Si Soleado Normal Leve Si
Lluvia Alta Fuerte Si Soleado Normal Fuerte Si
SI
Viento HUMEDAD
Ganancia=0.170951 Humedad
Proporción de ganancia =0.358525 HUMEDAD
Ganancia=0.970951
Proporción de ganancai=2.03632
VIENTO
Ganancia=0.321928
Proporción de ganancia =0.675162 Alta VIENTO
Normal
Ganancia=0.0199731
Proporción de ganancia=0.0418885
Leve
Estado Humedad Viento JuegoTenis Estado Humedad Viento JuegoTenis

Soleado Alta Leve No Soleado Normal Leve Si
Fuerte Soleado Alta Fuerte No Soleado Normal Fuerte Si
SI
NO

Lluvia Alta Leve Si
SI

Humedad
Normal
Alta
Estado Humedad Viento JuegoTenis Estado Humedad Viento JuegoTenis

Lluvia Alta Fuerte Si Lluvia Normal Fuerte No
SI NO
Figura 4.2: Esquema de la construcción de un árbol de decisión utilizando el ID3

Estado
Lluvia Soleado
Nublado
Viento Humedad
SI
Leve Alta Normal

Fuerte
SI NO SI
Humedad
Normal
Alta
SI NO
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
Regla 3
SI Estado = Nublado
Regla 4
SI Estado = Soleado
Y Humedad = Alta
Regla 5
SI Estado = Soleado
Y Humedad = Normal
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.

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 actual
Encontrar las excepciones a la regla en el resto de las instancias
Crear una nueva ventana a partir de la ventana actual y las excepciones a la
regla 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.5
El 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;
Comienzo
Si 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 en
los registros de S [Nota: habrá errores, es decir, registros que no estarán bien
clasificados en este caso];
Si R no está vacío, entonces
D ! 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 de
dj respectivamente;
Devolver un árbol con la raíz nombrada como D y con los arcos nombrados d1, d2,
.., dm que van respectivamente a los árboles
C4.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:

vi + v i +1 (4.6)
2
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:

Ganancia(X ) = probabilidad _ A _ sea _ conocido × (I (T ) − I X (T )) (4.7)

+ probabilidad _ A _ no _ sea _ conocido × 0 =
F × (I (T ) − I X (T ))
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.
n +1 Ti  Ti 
I _ división(X ) = −∑ × log 2  

i =1 T +1  T + 1 
(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)

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:

? Alta Leve No
Lluvia Alta Leve Si
Soleado Normal Leve 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 Lluvia

No 1 2 0 1
Si 0 2 4 4
Totales 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,
3 3 10 10
H (S ) = − log 2 − log 2 = 0.7793bits
13 13 13 13
Calculamos ahora la entropía que tendrían los conjuntos resultantes de la división de datos según este
atributo.
4 2 2 2 2 4  0 0 4 4 5  1 1 4 4
H ( S , Estado) =  − log 2 − log 2  +  − log 2 − log 2  +  − log 2 − log 2  = 0.58536bits
13  4 4 4 4  13  4 4 4 4  13  5 5 5 5
Ahora calculamos la ganancia resultante de dividir al subconjunto según el atributo Estado, tendremos:
Ganancia(S , Estado ) = (0.7793 − 0.58536) = 0.180bits

13
14
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:
4 4 4 5 5 1 1

I _ división(S ) = −
4
× log 2   − × log 2   − × log 2   − × log 2   = 1.835bits
14  14  14  14  14  14  14  14 
Finalmente, calculamos la proporción de ganancia.
Ganancia( S )
proporción _ de _ ganancia( S ) = = 0.098bits
I _ división( S )
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

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/13
Nublado Alta Leve Si 1
Nublado Normal Fuerte Si 1
Nublado Alta Fuerte Si 1
Nublado Normal Leve Si 1
La distribución de datos para el atributo Humedad es:
Desconocido Alta Normal

No 0 0.3 0
Si 0 2 2
Totales 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)


? Alta Leve No
ESTADO
ganancia=0.180
Lluvia Alta Leve Si proporción de ganancia=0.0.098
Lluvia Normal Fuerte No HUMEDAD
Ganancia=0.075
Nublado Normal Fuerte Si Proporción de ganancia =0.075
Soleado Normal Leve Si VIENTO
Ganancia=0.006
Lluvia Normal Leve Si Proporción de ganancia =0.00609
Estado
Lluvia Soleado
Estado Humedad Viento Juego Peso Estado Humedad Viento Juego Peso
Tenis Tenis
? Alta Leve No 5/13 ? Alta Leve No 4/13
Lluvia Alta Leve Si 1 Nublado Soleado Alta Fuerte No 1
Lluvia Normal Leve Si 1 Soleado Alta Leve No 1
Lluvia Normal Fuerte No 1 Soleado Normal Leve Si 1
Lluvia Normal Leve Si 1 Soleado Normal Fuerte Si 1
Lluvia Alta Fuerte Si 1
HUMEDAD
HUMEDAD Ganancia=0.996
SI Ganancia=0.029 Estado Humedad Viento Juego Peso Proporción de ganancia =1
N=5.4 Proporción de ganancia =0.029
Tenis
E=1.4 ? Alta Leve No 4/13
VIENTO
VIENTO Ganancia=0.003
Ganancia=0.130 Nublado Alta Leve Si 1 Proporción de ganancia =0.00301
Proporción de ganancia =0.136
Nublado Normal Fuerte Si 1
Nublado Alta Fuerte Si 1
Nublado Normal Leve Si 1 Humedad
SI HUMEDAD
N=4.3 Ganancia=0.068
E=0.3 Alta Normal
VIENTO
Ganancia=0.068
SI SI
N=2.3 N=2
E=0 E=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:
Error _ predicho( Arbol ) = 4.3 × U 25% (0.3,4.3) + 5.4 × U 25% (1.4,5.4) + 2.3 × U 25% (0,2.3) + 2 × U 25% (0,2)
Ahora, calculamos el error total predicho de simplificar el árbol por la hoja “Si”:
Error _ predicho( Arbol _ simplifica do) = 14 × U 25% (4,14 ) = 5.76
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:

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 clases

Satisface la condición X Y1 E1
No 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
U CF ( E1 + E 2 , Y1 + Y2 + E1 + E 2 ) ≤ U CF ( E1 , Y1 + E1 ) (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

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
 r   n − r 
log 2     + log 2    
  fp     fn   (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

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
Regla 2
SI Estado = Soleado
Y Humedad = Normal
Regla 3
SI Estado = Nublado
Regla 4
SI Estado = Lluvia
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 ausente
0 2 50% <regla actual>
4 7 75.5% Estado=Soleado
2 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 ausente
0 2 50% <regla actual>
1 7 33.8% Estado=Soleado
2 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:

1 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:
4 14 41.3% Estado=Nublado
Regla 3
SI Estado = Nublado
Finalmente, para la regla 4 los cálculos son los siguientes:
4 14 41.3% Estado=Lluvia
Regla 4
SI Estado = Lluvia
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 Clase

4 2 No
10 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
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.

ID3
Árbol de Transformación a Evaluación del

Generación del Árbol de Poda del árbol Reglas de Evaluación de los
decisión reglas de modelo
árbol de decisión decisión de decisión decisión resultados
podado decisión generado
DATOS DE
ENTRENAMIENTO DATOS DE
PRUEBA
C4.5
Árbol de Transformación a
Generación del Árbol de Poda del árbol Reglas de
decisión reglas de
árbol de decisión decisión de decisión decisión
podado decisión
Evaluación del
Evaluación de los
modelo
resultados
generado
Figura 4.5: Esquema general del sistema integrador propuesto
84 Magdalena Servente Solución Propuesta

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.
DATOS DE
ENTRENAMIENTO
1
Generación del
árbol de decisión
LOG DEL ID3

Árbol de decisión sin podar
2
Poda del árbol
de decisión
Árbol de decisión podado

3 4
Impresión del Transformación a
árbol de decisión reglas de
en pantalla decisión
DATOS
TRANSFORMACION
REGLAS DE SENTENCIAS DATOS DE

DECISIÓN SQL PRUEBA
5
Guardado del
árbol de decisión
a disco
6
Evaluación de los
resultados
ÁRBOL DE
DECISIÓN
Matriz de confusión
Figura 4.6: DFD general para la sección del ID3

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=0
Descriptor=Estado
Lluvia Nublado Soleado
No 1 0 3
Si 4 4 2
5 4 5 14
Gain=0.258521
Gain Ratio=0.491042
--------------------------------------
Descriptor=Humedad
Alta Normal
No 3 1
Si 4 6
7 7 14
Gain=0.0746702
Gain Ratio=0.14934
--------------------------------------
Descriptor=Viento
Fuerte Leve
No 2 2
Si 4 6
6 8 14
Gain=0.00597769
Gain 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 = Lluvia
Viento = Fuerte
Humedad = Alta
Si
Humedad = Normal
No
Viento = Leve

Si
Estado = Nublado
Si
Estado = Soleado
Humedad = Alta
No
Humedad = Normal
Si
4.5.2.2. Diseño para el C4.5
DATOS DE
ENTRENAMIENTO
1
Generación del
árbol de decisión
Árbol de decisión sin podar
2
Árbol de decisión sin podar ÁRBOL DE
Poda del árbol
DECISIÓN Y
de decisión
EVALUACIÓN
DE
RESULTADOS
5
3
Transformación a
Evaluación del
reglas de
árbol de decisión
decisión
REGLAS DE
DATOS DE
Árbol de decisión podado Reglas de decisión DECISIÓN Y
PRUEBA
y Resultados de la evaluación EVALUACIÓN
DE
RESULTADOS
6
4
Evaluación de las
Impresión del
reglas de
árbol de decisión
decisión
en pantalla
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.

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 podar

Tamañ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

t
∑E i
Estimación = i =1
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 prueba
Se utilizará el Gain criterion

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

---------------- ---------------------------
10 3( 3.2%) 10 3( 3.2%) (11.6%) <<
Antes de podar Después de Podar

---------------- ---------------------------
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 Clase

Donde:
• 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:
Irradiación del Angor = SI
-> clase SI [84.1%]
Regla 4:
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%) <<

---- ----
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%) <<

---- ----
26 1 (a): clase SI
2 66 (b): clase NO

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.
Resultados Magdalena Servente 97

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:
correctos
(5.1)
correctos + errores
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
98 Magdalena Servente Resultados

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:
∑E
i =1
i (5.2)
N
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 como Clasificado como ... Clasificado como

Clase 1 Clase 2 Clase 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.

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 Posibles

Ingreso ENTRE 451 Y 550, ENTRE 451 Y 550, MAS DE 551
Composición Familiar SOLTERO, CASADO SIN HIJOS, CASADO Y UN HIJO, CASADO Y DOS HIJOS
Vivienda ALQUILA, PROPIA O IPVU
Servicios BASICOS, BASICOS Y TIC, BASICOS TIC Y TEL
Otros Créditos UN CREDITO, DOS CREDITOS, TRES CREDITOS
c) Clases:
SI, NO.
d) Cantidad de instancias y distribución de las clases::
SI NO Totales
En el conjunto de entrenamiento 69 30 99
En el conjunto de prueba 35 16 51
Totales 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

Dolor de Pecho de Angor TIPICO, ATIPICO, AUSENTE
Irradiación del Angor SI, NO
Duración del Angor MENOS DE 30 MIN, MAS DE 30 MIN
Angor en Relación CON ESFUERZO, EN REPOSO
Antigüedad del Angor RECIENTE, MAS DE 1 MES
Respuesta Vasodilatadora POSITIVO, NEGATIVO
c) Clases:
SI, NO
d) Cantidad de instancias y distribución de las clases:
SI NO Totales
Totales 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

Niños_discapacitados A_favor, en_contra, desconocido
Participación en el costo del proyecto del agua A_favor, en_contra, desconocido
Adopción de la resolución sobre el presupuesto A_favor, en_contra, desconocido
congelamiento de los honorarios médicos A_favor, en_contra, desconocido
ayuda a El Salvador A_favor, en_contra, desconocido
grupos religiosos en las escuelas A_favor, en_contra, desconocido
prohibición de las pruebas anti satélites A_favor, en_contra, desconocido
ayuda a los contras de Nicaragua A_favor, en_contra, desconocido
misil mx A_favor, en_contra, desconocido
inmigración A_favor, en_contra, desconocido
reducción a la corporación Synfuels A_favor, en_contra, desconocido
presupuesto de educación A_favor, en_contra, desconocido
derecho a demandar de la Superfund A_favor, en_contra, desconocido
crimen A_favor, en_contra, desconocido
exportaciones sin impuestos A_favor, en_contra, desconocido
acta sudafricana de administración de exportaciones A_favor, en_contra, desconocido
c) Clases:
demócrata, republicano
Demócrata republicano Totales

Totales 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, hundida

Superficie_sombrero Fibrosa, ranurada, escamosa, suave
Color_sombrero marrón, piel, canela, gris, verde, rosa, violeta, rojo, blanco, amarillo
Magulladuras Si, no
Olor Almendra, anís, creosota, pescado, hediondo, mohoso, ninguno,
punzante, especioso
Tipo_membrana Adherida, descendente, libre, muescada
Espaciado_membrana Cercano, poblado, distante
Tamaño_membrana Ancha, fina
Color_membrana Negro, marron, piel, chocolate, gris, verde, naranja, rosa, violeta, rojo,
blanco, amarillo
Forma_tronco Abultada, cónica
Raiz_tronco bulbosa, agarrotada, copa, igual, rizomorfa, arraizada, ?
Superfice_tronco_arriba_anillo Fibrosa, escamosa, sedosa, suave
Superfice_tronco_debajo_anillo Fibrosa, escamosa, sedosa, suave
Color_tronco_arriba_anillo Marron, piel, canela, gris, naranja, rosa, rojo, blanco, amarillo
Color_tronco_debajo_anillo Marron, piel, canela, gris, naranja, rosa, rojo, blanco, amarillo
Tipo_velo Parcial, universal
Color_velo Marrón, naranja, blanco, amarillo
Cantidad_anillos Ninguno, uno, dos
Tipo_anillo Tejido, evanescente, resplandeciente, grande, ninguno, pendiente,
cubierto, zonal
Color_esporas Negra, marrón, piel, chocolate, verde, naranja, violeta, blanco,
amarillo
Poblacion abundante, agrupada, numerosa, dispersa, varios, solitaria
Habitat 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 Totales

Totales 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 Primaria

Semieje Continuo
Excentricidad Continuo
Inclinación Continuo
seno_inclinacion Continuo
argumento_perihelio Continuo
Resonancia Continuo
distancia_marte Continuo
distancia_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 Totales

En el conjunto de entrenamiento 44 103 25 13 23 45 253
En el conjunto de prueba 22 53 12 7 11 22 127
Totales 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: continuo
Sexo: 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: continuo
Medición T3: f, v.
T3: Continuo
Medició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 Hipotiroide Hipotiroide Hipotiroide Negativo Totales

primario compensado secundario
En el conjunto de entrenamiento 0 64 129 1 2320 2514
En el conjunto de prueba 0 31 65 1 1161 1258
Totales 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 Primaria
IR (índice de refracción) continuo
Na (Sodio medido como el porcentaje del peso del óxido continuo
correspondiente, esto se aplica para los demás minerales)
Mg (Magnesio) continuo
Al (Aluminio) continuo
Si (Silicio) continuo
K (Potasio) continuo
Ca (Calcio) continuo
Ba (Bario) continuo
Fe (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 para Vidrios para Vidrios float contenedo vajilla lamparitas Totales
construcciones construcciones para vehículos res
no float
En el conjunto 47 51 11 9 6 19 143
de
entrenamiento
En el conjunto 23 25 6 4 3 10 71
de prueba
Totales 70 76 17 13 9 29 214
5.3. RESULTADOS OBTENIDOS CON EL ID3

A 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 CREDITOS

Composición_Familiar = CASADO SIN HIJOS
SI
Composición_Familiar = CASADO Y DOS HIJOS
Ingreso = ENTRE 451 Y 550
Vivienda = ALQUILA
NO
Vivienda = PROPIA 0 IPVU
Servicios = BASICOS Y TIC
SI
Servicios = BASICOS, TIC Y TEL
NO
Ingreso = MAS DE 551
SI
Composición_Familiar = CASADO Y UN HIJO
SI
Composición_Familiar = SOLTERO
Vivienda = ALQUILA
SI
NO
SI
Otros_Creditos = TRES CREDITOS
NO
Otros_Creditos = UN CREDITO
SI
Vivienda = ALQUILA
NO
SI
SI
SI
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
Y Composición_Familiar = CASADO Y DOS HIJOS
Y Ingreso = ENTRE 451 Y 550
Y Vivienda = ALQUILA
ENTONCES Otorga_Creditos = NO
Regla 2
Y Vivienda = PROPIA 0 IPVU
Y Servicios = BASICOS Y TIC

Regla 3
Y Servicios = BASICOS, TIC Y TEL
Regla 4
Y Ingreso = MAS DE 551
Regla 5
Y Composición_Familiar = CASADO Y UN HIJO
Regla 6
Y Composición_Familiar = SOLTERO
Regla 7
Regla 8
Regla 9
SI Otros_Creditos = TRES CREDITOS
Regla 10
SI Otros_Creditos = UN CREDITO
Regla 11
Regla 12
Regla 13
Regla 14
Regla 15

Evaluación de los resultados
Clases Correctos Errores Probabilidad

NO 16 0 1
SI 17 18 0,485714
Totales 33 18 0,647058
5.3.1.2. ID3 utilizando la proporción ganancia como criterio de decisión

Árbol de decisión

SI
Vivienda = ALQUILA
NO
SI
NO
SI
SI
Vivienda = ALQUILA
SI
NO
SI
Otros_Creditos = TRES CREDITOS
NO
Otros_Creditos = UN CREDITO
SI
Vivienda = ALQUILA
NO
SI
SI
SI
SI
Reglas de decisión

Regla 0
Regla 1
Regla 2
Y Servicios = BASICOS Y TIC
Regla 3
Y Servicios = BASICOS, TIC Y TEL
Regla 4
Regla 5
Regla 6
Regla 7
Regla 8
Regla 9
SI Otros_Creditos = TRES CREDITOS
Regla 10
Regla 11
Regla 12


Regla 13
Regla 14
Regla 15

NO 16 0 1
SI 17 18 0,485714
Totales 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 Clase

1 5 NO
1 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 MIN

DOLOR_DE_PECHO_DE_ANGOR = ATIPICO
IRRADIACION_DEL_ANGOR = NO
RESPUESTA_VASODILATADORA = NEGATIVO
NO
RESPUESTA_VASODILATADORA = POSITIVO
SI
IRRADIACION_DEL_ANGOR = SI
SI
DOLOR_DE_PECHO_DE_ANGOR = AUSENTE
NO
DOLOR_DE_PECHO_DE_ANGOR = TIPICO
ANGOR_EN_RELACION = CON ESFUERZO
SI
NO
SI
ANGOR_EN_RELACION = EN REPOSO
SI
DURACION_DEL_ANGOR = MENOS DE 30 MIN

NO
NO
ANTIGÜEDAD_DEL_ANGOR = MAS DE 1 MES
NO
ANTIGÜEDAD_DEL_ANGOR = RECIENTE
SI
NO
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
Y RESPUESTA_VASODILATADORA = POSITIVO
ENTONCES DIAGNOSTICO = SI
Regla 2
Y IRRADIACION_DEL_ANGOR = SI
Regla 3
Y DOLOR_DE_PECHO_DE_ANGOR = AUSENTE
Regla 4
Y DOLOR_DE_PECHO_DE_ANGOR = TIPICO
Y ANGOR_EN_RELACION = CON ESFUERZO
Regla 5
Regla 6
Regla 7
Y ANGOR_EN_RELACION = EN REPOSO

Regla 8
SI DURACION_DEL_ANGOR = MENOS DE 30 MIN
Regla 9
Regla 10
Y ANTIGÜEDAD_DEL_ANGOR = MAS DE 1 MES
Regla 11
Y ANTIGÜEDAD_DEL_ANGOR = RECIENTE
Regla 12
Regla 13

NO 20 2 0,909090
SI 9 0 1
Totales 29 2 0,935483

Árbol de decisión
DURACION_DEL_ANGOR = MAS DE 30 MIN

NO
SI
SI
NO
SI

NO
SI
SI
DURACION_DEL_ANGOR = MENOS DE 30 MIN
NO
NO
ANTIGÜEDAD_DEL_ANGOR = MAS DE 1 MES
NO
ANTIGÜEDAD_DEL_ANGOR = RECIENTE
SI
NO
NO
Reglas de decisión
Regla 0
Regla 1
Regla 2
Regla 3
Regla 4
Regla 5
Regla 6

Regla 7
Regla 8
Regla 9
Regla 10
Y ANTIGÜEDAD_DEL_ANGOR = MAS DE 1 MES
Regla 11
Regla 12
Regla 13

NO 20 2 0,909090
SI 9 0 1
Totales 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_favor
Reduccion_corp_Synfuels = a_favor
Export_sin_impuestos = a_favor
democrata
Export_sin_impuestos = desconocido
republicano
Export_sin_impuestos = en_contra
Presupuesto_de_educacion = a_favor
Der_demanda_Superfund = a_favor
Particip_proy_agua = a_favor
republicano
Particip_proy_agua = en_contra
Acta_sudaf_admin_export = a_favor
republicano
Acta_sudaf_admin_export = desconocido
republicano
Acta_sudaf_admin_export = en_contra
Niños discapacitados = a_favor
republicano
Niños discapacitados = en_contra
democrata
Der_demanda_Superfund = en_contra
democrata
Presupuesto_de_educacion = desconocido
democrata
Presupuesto_de_educacion = en_contra
Adop_resolucion_presup = a_favor
republicano
Adop_resolucion_presup = en_contra
Ayuda_a_El_Salvador = a_favor
republicano
Ayuda_a_El_Salvador = en_contra
democrata
democrata
democrata
Reduccion_corp_Synfuels = desconocido
republicano
Reduccion_corp_Synfuels = en_contra
Inmigracion = a_favor
republicano
Inmigracion = en_contra
democrata
republicano
democrata
republicano
republicano

republicano
republicano
democrata
republicano
Cong_honorarios_medicos = desconocido
Misil_mx = a_favor
Prohib_pruebas_anti_satel = a_favor
democrata
Prohib_pruebas_anti_satel = desconocido
democrata
Prohib_pruebas_anti_satel = en_contra
republicano
Misil_mx = desconocido
republicano
Misil_mx = en_contra
democrata
Cong_honorarios_medicos = en_contra
democrata
democrata
republicano
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
Y Export_sin_impuestos = desconocido
ENTONCES Clase = republicano
Regla 2
Y Export_sin_impuestos = en_contra
Y Presupuesto_de_educacion = a_favor
Y Der_demanda_Superfund = a_favor
Y Particip_proy_agua = a_favor
Regla 3
Y Particip_proy_agua = en_contra
Y Acta_sudaf_admin_export = a_favor
Regla 4

Y Acta_sudaf_admin_export = desconocido
Regla 5
Y Acta_sudaf_admin_export = en_contra
Y Niños discapacitados = a_favor
Regla 6
Y Niños discapacitados = en_contra
Regla 7
Y Der_demanda_Superfund = en_contra
Regla 8
Y Presupuesto_de_educacion = desconocido
Regla 9
Y Presupuesto_de_educacion = en_contra
Y Adop_resolucion_presup = a_favor
Regla 10
Y Adop_resolucion_presup = en_contra
Y Ayuda_a_El_Salvador = a_favor
Regla 11
Y Ayuda_a_El_Salvador = en_contra
Regla 12

Regla 13
Regla 14
Y Reduccion_corp_Synfuels = desconocido
Regla 15
Y Reduccion_corp_Synfuels = en_contra
Y Inmigracion = a_favor
Regla 16
Y Inmigracion = en_contra
Regla 17
Regla 18
Regla 19
Regla 20
Regla 21
Regla 22

Regla 23
Regla 24
Regla 25
SI Cong_honorarios_medicos = desconocido
Y Misil_mx = a_favor
Y Prohib_pruebas_anti_satel = a_favor
Regla 26
Y Prohib_pruebas_anti_satel = desconocido
Regla 27
Y Prohib_pruebas_anti_satel = en_contra
Regla 28
Y Misil_mx = desconocido
Regla 29
Y Misil_mx = en_contra
Regla 30
SI Cong_honorarios_medicos = en_contra
Regla 31
Regla 32
Regla 33

Demócrata 81 2 0,9759036
Republicano 47 5 0,903846
Totales 128 7 0,948148

Árbol de decisión
democrata
republicano
republicano
republicano
republicano
republicano
democrata
democrata
democrata
republicano
republicano
democrata
democrata
democrata
republicano
republicano
democrata
republicano
democrata
republicano
republicano
republicano

republicano
democrata
republicano
Misil_mx = a_favor
democrata
democrata
republicano
republicano
democrata
democrata
Adop_resolucion_presup = desconocido
democrata
democrata
republicano
democrata
Reglas de decisión
Regla 0
Regla 1
Regla 2
Regla 3
Regla 4

Regla 5
Regla 6
Regla 7
Y Der_demanda_Superfund = en_contra
Regla 8
Regla 9
Regla 10
Y Ayuda_a_El_Salvador = a_favor
Regla 11
Y Ayuda_a_El_Salvador = en_contra
Regla 12
Regla 13

Regla 14
Y Reduccion_corp_Synfuels = desconocido
Regla 15
Y Inmigracion = a_favor
Regla 16
Regla 17
Regla 18
Regla 19
Regla 20
Regla 21
Regla 22

Regla 23
Regla 24
Regla 25
Y Prohib_pruebas_anti_satel = a_favor
Regla 26
Y Prohib_pruebas_anti_satel = desconocido
Regla 27
Y Prohib_pruebas_anti_satel = en_contra
Regla 28
Y Misil_mx = desconocido
Regla 29
Y Misil_mx = en_contra
Regla 30
Regla 31
Y Adop_resolucion_presup = desconocido
Regla 32
Regla 33
Regla 34


Demócrata 81 2 0,9759036
Republicano 47 5 0,903846
Totales 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 = almendra
ingerible
Olor = anis
ingerible
Olor = creosota
venenoso
Olor = especioso
venenoso
Olor = hediondo
venenoso
Olor = mohoso
venenoso
Olor = ninguno
Color_sombrero = amarillo
venenoso
Color_sombrero = blanco
Magulladuras = no
ingerible
Magulladuras = si
venenoso
Color_sombrero = canela
ingerible
Color_sombrero = gris
ingerible
Color_sombrero = marron
Sup_tronco_arriba_anillo = escamosa
ingerible
Sup_tronco_arriba_anillo = fibrosa
ingerible
Sup_tronco_arriba_anillo = sedosa
venenoso
Sup_tronco_arriba_anillo = suave
ingerible
Color_sombrero = piel
Forma_sombrero = abotonada
ingerible
Forma_sombrero = acampanada
venenoso
Forma_sombrero = chata
ingerible
Forma_sombrero = convexa
ingerible
Color_sombrero = rojo
ingerible
Color_sombrero = rosa
Color_esporas = blanca
ingerible
Color_esporas = verde
venenoso
Color_sombrero = verde
ingerible
Color_sombrero = violeta
ingerible
Olor = pescado
venenoso
Olor = punzante
Venenoso
Reglas de decisión
Regla 0
SI Olor = almendra
ENTONCES Tipo_Hongo = ingerible

Regla 1
SI Olor = anis
Regla 2
SI Olor = creosota
ENTONCES Tipo_Hongo = venenoso
Regla 3
SI Olor = especioso
Regla 4
SI Olor = hediondo
Regla 5
SI Olor = mohoso
Regla 6
SI Olor = ninguno
Y Color_sombrero = amarillo
Regla 7
SI Olor = ninguno
Y Color_sombrero = blanco
Y Magulladuras = no
Regla 8
SI Olor = ninguno
Y Color_sombrero = blanco
Y Magulladuras = si
Regla 9
SI Olor = ninguno
Y Color_sombrero = canela
Regla 10
SI Olor = ninguno
Y Color_sombrero = gris
Regla 11
SI Olor = ninguno
Y Color_sombrero = marron
Y Sup_tronco_arriba_anillo = escamosa
Regla 12
SI Olor = ninguno
Y Sup_tronco_arriba_anillo = fibrosa
Regla 13
SI Olor = ninguno
Y Sup_tronco_arriba_anillo = sedosa
Regla 14
SI Olor = ninguno
Y Sup_tronco_arriba_anillo = suave
Regla 15
SI Olor = ninguno
Y Color_sombrero = piel
Y Forma_sombrero = abotonada

Regla 16
SI Olor = ninguno
Y Forma_sombrero = acampanada
Regla 17
SI Olor = ninguno
Y Forma_sombrero = chata
Regla 18
SI Olor = ninguno
Y Forma_sombrero = convexa
Regla 19
SI Olor = ninguno
Y Color_sombrero = rojo
Regla 20
SI Olor = ninguno
Y Color_sombrero = rosa
Y Color_esporas = blanca
Regla 21
SI Olor = ninguno
Y Color_sombrero = rosa
Y Color_esporas = verde
Regla 22
SI Olor = ninguno
Y Color_sombrero = verde
Regla 23
SI Olor = ninguno
Y Color_sombrero = violeta
Regla 24
SI Olor = pescado
Regla 25
SI Olor = punzante

Ingerible 1403 0 1
Venenoso 1293 12 0,990804
Totales 2696 12 0,995568

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

Árbol de decisión
Olor = almendra
ingerible
Olor = anis
ingerible
Olor = creosota
venenoso
Olor = especioso
venenoso
Olor = hediondo
venenoso
Olor = mohoso
venenoso
Olor = ninguno
Color_velo = amarillo
venenoso
Color_velo = blanco
Tamaño_membrana = ancha
Color_esporas = blanca
ingerible
Color_esporas = marron
ingerible
Color_esporas = negro
ingerible
Color_esporas = verde
venenoso
Tamaño_membrana = fina
Magulladuras = no
Sup_tronco_arriba_anillo = fibrosa
ingerible
Sup_tronco_arriba_anillo = sedosa
venenoso
Sup_tronco_arriba_anillo = suave
ingerible
Magulladuras = si
venenoso
Color_velo = marron
ingerible
Color_velo = naranja
ingerible
Olor = pescado
venenoso
Olor = punzante
venenoso
Reglas de decisión
Regla 0
SI Olor = almendra
Regla 1
SI Olor = anis
Regla 2
SI Olor = creosota
Regla 3
SI Olor = especioso
Regla 4
SI Olor = hediondo

Regla 5
SI Olor = mohoso
Regla 6
SI Olor = ninguno
Y Color_velo = amarillo
Regla 7
SI Olor = ninguno
Y Color_velo = blanco
Y Tamaño_membrana = ancha
Y Color_esporas = blanca
Regla 8
SI Olor = ninguno
Y Color_esporas = marron
Regla 9
SI Olor = ninguno
Y Color_esporas = negro
Regla 10
SI Olor = ninguno
Y Color_esporas = verde
Regla 11
SI Olor = ninguno
Y Tamaño_membrana = fina
Y Magulladuras = no
Regla 12
SI Olor = ninguno
Y Magulladuras = no
Regla 13
SI Olor = ninguno
Y Magulladuras = no
Regla 14
SI Olor = ninguno
Y Magulladuras = si
Regla 15
SI Olor = ninguno
Y Color_velo = marron
Regla 16
SI Olor = ninguno
Y Color_velo = naranja

Regla 17
SI Olor = pescado
Regla 18
SI Olor = punzante

Ingerible 1403 0 1
Venenoso 1305 0 1
Totales 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 ganancia

Color_sombrero 0,0370 0,079699
Color_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.5

A 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 = SOLTERO:
Vivienda = ALQUILA:
Ingreso = MAS DE 551: NO (2.0)
Ingreso = ENTRE 451 Y 550: NO (4.0/1.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:


25 1 (1.0%) 4 7 (7.1%) (12.4%)
Evaluación sobre los datos de prueba:

25 19 (37.3%) 4 22 (43.1%) (12.4%)
Clasificación general en los datos de prueba:
Clasificado como SI Clasificado como NO

Clase SI 17 18
Clase 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
Regla 6
SI Ingreso = MAS DE 551
Y Composición Familiar = SOLTERO
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

12 1 5.8% 23 0(0.0%) 21(21|0) NO
2 3 20.6% 4 0(0.0%) 4(4|0) NO
6 4 50.0% 2 0(0.0%) 2(2|0) NO
1 1 9.7% 37 0(0.0%) 0(0|0) SI
11 1 19.4% 33 1(3.0%) 0(0|0) SI
Probadas 99, errores 1 (1.0%)

12 1 5.8% 30 18(60.0%) -8(10|18) NO
2 3 20.6% 2 0(0.0%) 2(2|0) NO
6 4 50.0% 2 0(0.0%) 2(2|0) NO
1 1 9.7% 8 0(0.0%) 0(0|0) SI
11 1 19.4% 9 0(0.0%) 0(0|0) SI
Clasificación general de los datos de prueba:

Clase SI 17 18
Clase NO 0 16
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)
Vivienda = ALQUILA:
Ingreso = ENTRE 451 Y 550: NO (2.0)
Composición Familiar = SOLTERO:
Vivienda = ALQUILA:
Ingreso = MAS DE 551: NO (2.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)

25 1 (1.0%) 4 7 (7.1%) (12.4%)

25 19 (37.3%) 4 22 (43.1%) (12.4%)

Clase SI 17 18
Clase NO 4 12
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
Regla 6
SI Ingreso = MAS DE 551

Y Composición Familiar = SOLTERO

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 13
clase=SI

12 1 5.8% 23 0(0.0%) 21(21|0) NO
2 3 20.6% 4 0(0.0%) 4(4|0) NO
6 4 50.0% 2 0(0.0%) 2(2|0) NO
1 1 9.7% 37 0(0.0%) 0(0|0) SI
11 1 19.4% 33 1(3.0%) 0(0|0) SI

12 1 5.8% 30 18(60.0%) -8(10|18) NO
2 3 20.6% 2 0(0.0%) 2(2|0) NO
6 4 50.0% 2 0(0.0%) 2(2|0) NO
1 1 9.7% 8 0(0.0%) 0(0|0) SI
11 1 19.4% 9 0(0.0%) 0(0|0) SI

Clase SI 17 18
Clase NO 0 16
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

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)


10 2 (3.1%) 10 2 (3.1%) (14.9%)

10 2 (6.5%) 10 2 (6.5%) (14.9%)

Clase SI 8 1
Clase NO 1 21
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
Regla 4
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
Y Irradiación del Angor = NO
Y Respuesta Vasodilatadora = NEGATIVO
Regla 7
Clase=NO


2 2 22.3% 11 1(9.1%) 9(10|1) SI
3 3 24.2% 5 0(0.0%) 2(2|0) SI
4 3 24.2% 2 0(0.0%) 2(2|0) SI
6 1 6.1% 22 0(0.0%) 0(0|0) NO
1 1 7.8% 22 1(4.5%) 0(0|0) NO
5 3 24.2% 2 0(0.0%) 0(0|0) NO

2 2 22.3% 3 0(0.0%) 3(3|0) SI
3 3 24.2% 3 0(0.0%) 2(2|0) SI
4 3 24.2% 3 1(33.3%) 1(2|1) SI
6 1 6.1% 10 0(0.0%) 0(0|0) NO
1 1 7.8% 11 1(9.1%) 0(0|0) NO
5 3 24.2% 1 0(0.0%) 0(0|0) NO

Clase SI 8 1
Clase NO 1 21
5.4.2.2. Utilizando la proporción ganancia como criterio de decisión

Árbol de decisión

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)


10 2 (3.1%) 10 2 (3.1%) (14.9%)

10 2 (6.5%) 10 2 (6.5%) (14.9%)

Clase SI 8 1
Clase NO 1 21
Reglas de decisión
Regla 2
SI Dolor de Pecho de Angor = TIPICO
Regla 3
Y Respuesta Vasodilatadora = POSITIVO
Regla 4
Y Irradiación del Angor = SI
Regla 6
SI Dolor de Pecho de Angor = AUSENTE
Regla 1
SI Duración del Angor = MENOS DE 30 MIN
Regla 5
Y Irradiación del Angor = NO
Y Respuesta Vasodilatadora = NEGATIVO
Regla 7
Clase= NO


2 2 22.3% 11 1(9.1%) 9(10|1) SI
3 3 24.2% 5 0(0.0%) 2(2|0) SI
4 3 24.2% 2 0(0.0%) 2(2|0) SI
6 1 6.1% 22 0(0.0%) 0(0|0) NO
1 1 7.8% 22 1(4.5%) 0(0|0) NO
5 3 24.2% 2 0(0.0%) 0(0|0) NO

2 2 22.3% 3 0(0.0%) 3(3|0) SI
3 3 24.2% 4 1(25.0%) 1(2|1) SI
4 3 24.2% 2 0(0.0%) 2(2|0) SI
6 1 6.1% 10 0(0.0%) 0(0|0) NO
1 1 7.8% 11 1(9.1%) 0(0|0) NO
5 3 24.2% 1 0(0.0%) 0(0|0) NO

Clase SI 8 1
Clase NO 1 21
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)

misil_mx = en_contra: democrata (3.0/1.1)
misil_mx = desconocido: republicano (2.0/1.0)

16 9 (3.0%) 7 13 (4.3%) (6.9%)


16 7 (5.2%) 7 4 (3.0%) (6.9%)
Clasificado como demócrata Clasificado como republicano

Clase demócrata 80 3
Clase 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
Y misil_mx = desconocido
Regla 11
clase=democrata

7 1 1.6% 168 1(0.6%) 0(0|0) Demócrata
3 2 5.7% 8 2(25.0%) 2(4|2) Demócrata
9 2 37.0% 2 0(0.0%) 0(0|0) Demócrata
5 1 11.3% 117 7(6.0%) 103(110|7) Republicano
10 2 50.0% 2 0(0.0%) 2(2|0) Republicano


7 1 1.6% 79 1(1.3%) 0(0|0) Demócrata
3 2 5.7% 3 1(33.3%) -1(0|1) Demócrata
5 1 11.3% 53 3(5.7%) 47(50|3) Republicano


Árbol de decisión
reduccion_corp_Synfuels = en_contra: republicano (97.0/3.0)
presupuesto_de_educación = a_favor: republicano (13.0/2.0)
presupuesto_de_educación = en_contra: democrata (5.0/2.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)
particip_proy_agua = a_favor: democrata (4.0)
particip_proy_agua = en_contra: democrata (0.0)
particip_proy_agua = desconocido:
misil_mx = en_contra: republicano (0.0)
cong_honorarios_medicos = a_favor: republicano (123.0/13.9)

misil_mx = en_contra: democrata (3.0/1.1)
misil_mx = desconocido: republicano (2.0/1.0)


25 8 (2.7%) 7 13 (4.3%) (6.9%)

25 7 (5.2%) 7 4 (3.0%) (6.9%)

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
Y reduccion_corp_Synfuels = en_contra
Regla 2
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
Y misil_mx = desconocido
Regla 14
clase=democrata


1 2 2.5% 54 0(0.0%) 0(0|0) Demócrata
11 2 29.3% 3 0(0.0%) 0(0|0) Demócrata
6 2 5.2% 97 3(3.1%) 21(23|2) Republicano
2 3 6.0% 15 2(13.3%) 11(13|2) Republicano
10 2 18.0% 3 0(0.0%) 3(3|0) Republicano
13 2 50.0% 2 0(0.0%) 2(2|0) Republicano

1 2 2.5% 24 2(8.3%) 0(0|0) Demócrata
11 2 29.3% 1 0(0.0%) 0(0|0) Demócrata
6 2 5.2% 41 0(0.0%) 6(6|0) Republicano
2 3 6.0% 8 3(37.5%) 2(5|3) Republicano
10 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 = verde: venenoso (2.0/1.0)
Color_esporas = blanca: ingerible (49.0/1.4)
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)

48 0(0.0%) 44 3 (0.1%) (0.6%)

48 12 (0.4%) 44 25 (0.9%) (0.6%)

Evaluación general sobre los datos de prueba:
Clasificado como ingerible Clasificado como venenoso

Clase ingerible 1403 0
Clase 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
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 24
Tipo_hongo = ingerible


5 1 0.10% 1348 0(0.00%) 1228(1228|0) venenoso
23 1 0.30% 516 0(0.00%) 400(400|0) venenoso
4 1 0.30% 489 0(0.00%) 372(372|0) venenoso
9 2 0.40% 15 0(0.00%) 3(3|0) venenoso
22 1 0.80% 164 0(0.00%) 164(164|0) venenoso
3 1 3.70% 37 0(0.00%) 37(37|0) venenoso
6 1 3.80% 24 0(0.00%) 24(24|0) venenoso
21 2 12.90% 10 0(0.00%) 10(10|0) venenoso
14 1 18.00% 7 0(0.00%) 7(7|0) venenoso
2 1 0.80% 178 0(0.00%) 0(0|0) ingerible
1 1 0.80% 168 0(0.00%) 0(0|0) ingerible
11 1 1.00% 2460 1(0.00%) 0(0|0) ingerible

5 1 0.10% 812 0(0.00%) 788(788|0) venenoso
23 1 0.30% 60 0(0.00%) 32(32|0) venenoso
4 1 0.30% 87 0(0.00%) 60(60|0) venenoso
9 2 0.40% 13 0(0.00%) 13(13|0) venenoso
22 1 0.80% 92 0(0.00%) 92(92|0) venenoso
3 1 3.70% 155 0(0.00%) 155(155|0) venenoso
21 2 12.90% 14 0(0.00%) 14(14|0) venenoso
14 1 18.00% 65 0(0.00%) 65(65|0) venenoso
2 1 0.80% 222 0(0.00%) 0(0|0) ingerible
1 1 0.80% 232 0(0.00%) 0(0|0) ingerible
11 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 = verde: venenoso (7.0)
Color_esporas = blanca: ingerible (439.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 = verde: venenoso (7.0/1.3)
Color_esporas = naranja: ingerible (40.0/1.4)
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)


40 0(0.0%) 25 1 (0.0%) (0.5%)

40 0 (0.0%) 25 7 (0.3%) (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
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
ENTONCES Tipo_Hongo = ingerible [99.6%]
Regla 15
SI Olor = ninguno
Regla 12
SI Olor = ninguno
Regla 2
SI Olor = anis
Regla 1
SI Olor = almendra
Regla 20
Tipo_Hongo = ingerible

5 1 0.10% 1348 0(0.00%) 1088(1088|0) venenoso
13 2 0.20% 497 0(0.00%) 5(5|0) venenoso
19 1 0.30% 261 0(0.00%) 261(261|0) venenoso
4 1 0.30% 252 0(0.00%) 252(252|0) venenoso
18 1 0.80% 164 0(0.00%) 164(164|0) venenoso
3 1 3.70% 37 0(0.00%) 37(37|0) venenoso
6 1 3.80% 36 0(0.00%) 36(36|0) venenoso
17 1 15.90% 8 0(0.00%) 8(8|0) venenoso
10 1 18.00% 7 0(0.00%) 7(7|0) venenoso
9 2 0.40% 2335 0(0.00%) 0(0|0) ingerible
15 2 0.50% 104 1(1.00%) 0(0|0) ingerible
12 2 0.60% 21 0(0.00%) 0(0|0) ingerible
2 1 0.80% 178 0(0.00%) 0(0|0) ingerible
1 1 0.80% 168 0(0.00%) 0(0|0) ingerible

5 1 0.10% 812 0(0.00%) 784(784|0) venenoso
13 2 0.20% 111 0(0.00%) 27(27|0) venenoso

19 1 0.30% 27 0(0.00%) 27(27|0) venenoso

4 1 0.30% 36 0(0.00%) 36(36|0) venenoso
18 1 0.80% 92 0(0.00%) 92(92|0) venenoso
3 1 3.70% 155 0(0.00%) 155(155|0) venenoso
10 1 18.00% 65 0(0.00%) 65(65|0) venenoso
9 2 0.40% 881 0(0.00%) 0(0|0) ingerible
15 2 0.50% 72 7(9.70%) 0(0|0) ingerible
12 2 0.60% 3 0(0.00%) 0(0|0) ingerible
2 1 0.80% 222 0(0.00%) 0(0|0) ingerible
1 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)

11 2(0.8%) 11 2(0.8%) (4.2%)

11 0 (0%) 11 0(0%) (4.2%)
Evaluación general:
Clasificado Clasificado Clasificado Clasificado Clasificado Clasificado

como EOS como como como como como
FLORA KORONIS MARIA PHOCAEA THEMIS
Clase EOS 22 0 0 0 0 0
Clase FLORA 0 12 0 0 0 0
Clase KORONIS 0 0 7 0 0 0
Clase MARIA 0 0 0 22 0 0
Clase PHOCAEA 0 0 0 0 11 0
Clase 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
ENTONCES Familia = KORONIS [94.4%]
Regla 5
SI resonancia > 11.51
ENTONCES Familia = MARIA [89.9%]
Regla 6
Y distancia_jupiter > 0.24
ENTONCES Familia = PHOCAEA [94.2%]
Regla 3
ENTONCES Familia = EOS [94.3%]
Regla 4
ENTONCES Familia = FLORA [97.5%]
Regla 7
Familia = FLORA

1 2 3.00% 45 0(0.00%) 45(45|0) THEMIS
2 2 5.60% 24 0(0.00%) 24(24|0) KORONIS
5 2 10.10% 13 0(0.00%) 13(13|0) MARIA
6 2 5.80% 23 0(0.00%) 23(23|0) PHOCAEA
3 2 5.70% 45 1(2.20%) 43(44|1) EOS
4 2 2.50% 103 1(1.00%) 0(0|0) FLORA

1 2 3.00% 22 0(0.00%) 22(22|0) THEMIS
2 2 5.60% 12 0(0.00%) 12(12|0) KORONIS
5 2 10.10% 8 1(12.50%) 6(7|1) MARIA
6 2 5.80% 11 0(0.00%) 11(11|0) PHOCAEA
3 2 5.70% 21 0(0.00%) 21(21|0) EOS
4 2 2.50% 53 0(0.00%) 0(0|0) FLORA

Clasificación general sobre los datos de prueba:
Clasificado Clasificado Clasificado Clasificado Clasificado Clasificad

como EOS como como como como o como
Clase EOS 22 0 0 0 0 0

Á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)

11 2(0.8%) 11 2(0.8%) (4.2%)

11 0 (0%) 11 0(0%) (4.2%)

Clasificad Clasificado Clasificado Clasificado Clasificado Clasificad

o como como FLORA como como como o como
EOS KORONIS MARIA PHOCAEA THEMIS
Clase EOS 22 0 0 0 0 0
Reglas de decisión
Regla 1
ENTONCES Familia = THEMIS [97.0%]
Regla 2
SI distancia_jupiter > 0.18
ENTONCES Familia = KORONIS [94.4%]
Regla 5
ENTONCES Familia = MARIA [89.9%]
Regla 6
ENTONCES Familia = PHOCAEA [94.2%]
Regla 3
ENTONCES Familia = EOS [94.3%]
Regla 4
ENTONCES Familia = FLORA [97.5%]
Regla 7
Familia = FLORA
Evaluación sobre los datos de entrenamiento

1 2 3.00% 45 0(0.00%) 45(45|0) THEMIS
2 2 5.60% 24 0(0.00%) 24(24|0) KORONIS
5 2 10.10% 13 0(0.00%) 13(13|0) MARIA
6 2 5.80% 23 0(0.00%) 23(23|0) PHOCAEA

3 2 5.70% 45 1(2.20%) 43(44|1) EOS

4 2 2.50% 103 1(1.00%) 0(0|0) FLORA

1 2 3.00% 22 0(0.00%) 22(22|0) THEMIS
2 2 5.60% 12 0(0.00%) 12(12|0) KORONIS
5 2 10.10% 8 1(12.50%) 6(7|1) MARIA
6 2 5.80% 11 0(0.00%) 11(11|0) PHOCAEA
3 2 5.70% 21 0(0.00%) 21(21|0) EOS
4 2 2.50% 53 0(0.00%) 0(0|0) FLORA
Clasificado Clasificado Clasificado Clasificado Clasificado Clasificad

como EOS como como como como o como
Clase EOS 22 0 0 0 0 0
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 = v:
TT4 > 150 : negativo (6.1/0.1)
TT4 <= 150 :
Cirugía tiroídea = v: negativo (3.7)
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)
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)

37 5 (0.2%) 19 8(0.3%) (0.9%)

37 6 (0.5%) 19 7(0.6%) (0.9%)
Clasificad Clasificado como Clasificado como Clasificado Clasificado

o como hipotiroide hipotiroide como como
hipertiroid primario compensado hipotiroide negativo
e secundario
Clase hipertiroide 0 0 0 0 0
Clase hipotiroide 0 28 2 0 1
primario
compensado
secundario
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 16
Clase = hipotiroide compensado

12 5 1.10% 120 0(0.00%) 0(0|0) hipotiroide compensado
1 1 0.10% 2018 1(0.00%) 1620(1620|0) negativo
15 2 0.50% 41 0(0.00%) 28(28|0) negativo
9 1 0.50% 247 0(0.00%) 232(232|0) negativo
14 1 0.60% 6 0(0.00%) 6(6|0) negativo
8 1 7.30% 7 1(14.30%) 6(6|0) negativo
4 3 4.40% 59 1(1.70%) 58(58|0) hipotiroide primario


1 1 0.10% 1019 1(0.10%) 816(816|0) negativo
15 2 0.50% 22 0(0.00%) 20(20|0) negativo
9 1 0.50% 111 0(0.00%) 106(106|0) negativo
14 1 0.60% 3 0(0.00%) 3(3|0) negativo
8 1 7.30% 5 1(20.00%) 3(3|0) negativo
Clasificado Clasificado como Clasificado como Clasificado Clasificado

como hipotiroide hipotiroide como como
hipertiroide primario compensado hipotiroide negativo
secundario
Clase 0 0 0 0 0
hipertiroide
primario
compensado
secundario

Árbol de decisión
TSH <= 6 : negativo (2246.8/1.0)

TSH > 6 :
FTI <= 64 :
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)
FTI > 64 :
Toma tiroxina = v: negativo (35.2)
Toma tiroxina = f:
Medición TSH = v:
Cirugía tiroídea = v: negativo (3.7)
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)


21 6 (0.2%) 21 6(0.2%) (0.9%)

21 8 (0.6%) 21 8(0.6%) (0.9%)

secundario
Clase 0 0 0 0 0
hipertiroide
primario
compensado
secundario
Reglas de decisión
Regla 7
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
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 11
Clase = hipotiroide compensado

1 1 0.10% 2018 1(0.00%) 1620(1620|0) negativo
10 2 0.50% 41 0(0.00%) 28(28|0) negativo
2 1 0.50% 247 0(0.00%) 232(232|0) negativo
8 1 0.60% 6 0(0.00%) 6(6|0) negativo
5 1 7.30% 7 1(14.30%) 6(6|0) negativo

6 3 54.70% 1 1(100.00%) -1(0|1) hipotiroide primario
1 1 0.10% 1019 1(0.10%) 816(816|0) negativo
10 2 0.50% 22 0(0.00%) 20(20|0) negativo
2 1 0.50% 111 0(0.00%) 106(106|0) negativo
8 1 0.60% 3 0(0.00%) 3(3|0) negativo
5 1 7.30% 5 1(20.00%) 4(4|0) negativo


secundario
Clase 0 0 0 0 0
hipertiroide
primario
compensado
secundario
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 :
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 :
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)

31 44 (30.8%) 21 50(35%) (45.8%)

31 31 (43.7%) 21 34(47.9%) (45.8%)

Clasificados Clasificados Clasificados Clasificados Clasificados Clasifica Clasifica

como como como como como dos dos
vidrios_float vidrios_para vidrios_float vidrios_para contenedores como como
_para_constr _construccio _para_vehic _vehículos_ vajilla lamparit
ucciones nes_no_float ulos no_float as
Clase 22 1 0 0 0 0 0
vidrios_float_para_
construcciones
Clase 19 6 0 0 0 0 0
vidrios_para_constr
ucciones_no_float
Clase 6 0 0 0 0 0 0
vidrios_float_para_
vehiculos
Clase 0 0 0 0 0 0 0
vidrios_para_vehíc
ulos_no_float
Clase contenedores 0 3 0 0 1 0 0
Clase vajilla 2 1 0 0 0 0 0
Clase 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 15
Clase = vidrios_para_construcciones_no_float

8 3 29.30% 4 0(0.00%) 4(4|0) contenedores
5 1 37.00% 3 0(0.00%) 3(3|0) contenedores
2 5 37.00% 3 0(0.00%) 3(3|0) vajilla
3 3 15.90% 8 0(0.00%) 5(5|0) lamparitas
4 4 20.60% 9 1(11.10%) 8(8|0) lamparitas
1 4 50.00% 2 0(0.00%) 2(2|0) lamparitas
10 3 19.10% 13 1(7.70%) 0(0|0) vidrios_para_construcciones_no_float
14 2 52.00% 82 39(47.60%) 16(43|27) vidrios_float_para_construcciones

8 3 29.30% 1 0(0.00%) 1(1|0) contenedores
3 3 15.90% 6 0(0.00%) 5(5|0) lamparitas
4 4 20.60% 3 0(0.00%) 3(3|0) lamparitas
14 2 52.00% 42 21(50.00%) 6(21|15) vidrios_float_para_construcciones

Clasificados Clasificados Clasificados Clasificados Clasificados Clasificado Clasif

como como como como como s como icados
vidrios_float vidrios_para vidrios_float vidrios_para contenedore vajilla como
_para_constr _construccio _para_vehic _vehículos_ s lampa
ucciones nes_no_float ulos no_float ritas
Clase 21 2 0 0 0 0 0
vidrios_float_para_
construcciones
Clase 15 10 0 0 0 0 0
vidrios_para_constr
ucciones_no_float
Clase 6 0 0 0 0 0 0
vidrios_float_para_
vehiculos
Clase 0 0 0 0 0 0 0
vidrios_para_vehíc
ulos_no_float

Árbol de decisión
Mg <= 1 :
Ca <= 9 :
Al > 2 : contenedores (2.0)
Al <= 2 :
Al <= 1 :
Ba > 0 : lamparitas (4.0)
Ba <= 0 :
Na <= 13 : lamparitas (2.0)
Na > 13 : vajilla (3.0)
Ca > 9 :
Al > 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)
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 :
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 :
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)

31 44 (30.8%) 21 50(35%) (45.8%)

31 31 (43.7%) 21 34(47.9%) (45.8%)
Clasificados Clasificados Clasificados Clasificados Clasificados Clasificado Clasifica

como como como como como s como dos como
vidrios_float vidrios_para vidrios_float vidrios_para contenedore vajilla lamparita
_para_constr _construccio _para_vehic _vehículos_ s s
ucciones nes_no_float ulos no_float
Clase 22 1 0 0 0 0 0
vidrios_float_para_
construcciones
Clase 19 6 0 0 0 0 0
vidrios_para_constr
ucciones_no_float
Clase 6 0 0 0 0 0 0
vidrios_float_para_
vehiculos

Clase 0 0 0 0 0 0 0
vidrios_para_vehíc
ulos_no_float
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 16
Clase = vidrios_para_construcciones_no_float

8 3 29.30% 4 0(0.00%) 4(4|0) contenedores
5 1 37.00% 3 0(0.00%) 3(3|0) contenedores
2 5 37.00% 3 0(0.00%) 3(3|0) vajilla
3 3 15.90% 8 0(0.00%) 5(5|0) lamparitas
4 4 20.60% 9 1(11.10%) 8(8|0) lamparitas
1 4 50.00% 2 0(0.00%) 2(2|0) lamparitas
11 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_c
onstrucciones_
no_float
15 3 38.30% 21 6(28.60%) 9(15|6) vidrios_float_p
ara_construccio
nes
10 2 48.50% 23 9(39.10%) 10(14|4) vidrios_float_p
ara_construccio
nes

8 3 29.30% 1 0(0.00%) 1(1|0) contenedores
3 3 15.90% 6 0(0.00%) 5(5|0) lamparitas
4 4 20.60% 3 0(0.00%) 3(3|0) lamparitas
11 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_c
onstrucciones_
no_float
15 3 38.30% 9 5(55.60%) 1(4|3) vidrios_float_p
ara_construccio
nes
10 2 48.50% 14 6(42.90%) 5(8|3) vidrios_float_p
ara_construccio
nes

Clasificados Clasificados Clasificados Clasificados Clasificados Clasificado Clasific

como como como como como s como ados
vidrios_float vidrios_para vidrios_float vidrios_para contenedore vajilla como
_para_constr _construccio _para_vehic _vehículos_ s lampari
ucciones nes_no_float ulos no_float tas
Clase 12 11 0 0 0 0 0
vidrios_float_para_
construcciones
Clase 6 19 0 0 0 0 0
vidrios_para_constr
ucciones_no_float
Clase 2 4 0 0 0 0 0
vidrios_float_para_
vehiculos
Clase 0 0 0 0 0 0 0
vidrios_para_vehíc
ulos_no_float
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%.

50.00%
45.00% 43.10% 43.10%
40.00%
35.25% 35.25% 35.25% 35.25% 35.29% 35.29%
35.00%
30.00%
25.00%
20.00%
15.00%
10.00%
5.00%
0.00%
ID3-Árbol- ID3-Reglas- ID3-Árbol- ID3-Reglas- C4.5-Árbol- C4.5- C4.5-Árbol- C4.5-
ganancia ganancia proporción proporción ganancia Reglas- proporción Reglas-
de ganancia de ganancia ganancia de ganancia proporción
de ganancia
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:

Vivienda = ALQUILA
NO
SI
NO
Se simplificó en el C4.5 a:

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

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.
30
25
20
15
10
0
ID3-Árbol-ganancia C4.5-Árbol- ID3-Árbol- C4.5-Árbol-
ganancia proporción de proporción de
ganancia ganancia
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.
18
16
14
12
10
8
6
4
2
0
ID3-Reglas- C4.5-Reglas- ID3-Reglas- C4.5-Reglas-
ganancia ganancia proporción de proporción de
ganancia ganancia
Figura 5.3: Cantidad de reglas obtenidas en el dominio Créditos

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.
7.00% 6.45% 6.45% 6.45% 6.45% 6.50% 6.50% 6.50% 6.50%
6.00%
5.00%
4.00%
3.00%
2.00%
1.00%
0.00%
ia
ia
ia
ia
a
ia
ci
ci
ci
nc
nc
nc
nc
nc
an
an
an
na
na
na
na
na
an
an
an
ga
ga
ga
ga
ga
-g
-g
-g
s-
de
de
de
ol
ol
as
d
la
rb
rb
gl
ón
g
Á
-Á
ió
ió
ió
Re
ci
-R
3-
rc
rc
c
.5
3-
or
ID
po
.5
po
po
C4
ID
op
C4
ro
ro
r o
pr
-p
-p
-p
s-
ol
ol
as
la
rb
rb
gl
eg
Á
-Á
Re
-R
3-
.5
3-
ID
.5
C4
ID
C4
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.
30 25 25
25
20
15 10 10
10
5
0
ID3-Árbol- C4.5-Árbol- ID3-Árbol- C4.5-Árbol-
ganancia ganancia proporción proporción
de ganancia de ganancia
Figura 5.5: Tamaños de los árboles de decisión

30
25
20 14 14
15
10 7 7
5
0
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.

6.00%
5.19% 5.19% 5.19% 5.19% 5.20%
5.00%
3.70%
4.00%
3.00% 3.00%
3.00%
2.00%
1.00%
0.00%
ia
ia
ia
ia
a
ia
ci
ci
ci
nc
nc
nc
nc
nc
an
an
an
na
na
na
na
na
an
an
an
ga
ga
ga
ga
ga
-g
-g
-g
s-
e
de
de
de
ol
ol
s
d
la
la
rb
rb
n
ón
g
eg
Á
-Á
ió
ió
ó
e
-R
ci
-R
3-
rc
rc
rc
.5
or
ID
.5
po
po
C4
ID
op
C4
ro
ro
r o
pr
-p
-p
-p
s-
ol
ol
as
la
rb
rb
gl
eg
Á
-Á
Re
-R
3-
.5
3-
ID
.5
C4
ID
C4
Figura 5.7: Porcentajes de error obtenidas en el dominio Votaciones
40 34 35
30
20
6 7
10
0
Figura 5.8: Tamaño de los árboles de decisión obtenidos en el dominio Votaciones
70 57 58
60
50
40
30
20 7 7
10
0
ganancia ganancia
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.

democrata
republicano
republicano
republicano
republicano
republicano
democrata
Democrata (1)
democrata
republicano
republicano
democrata
democrata
Democrata (2)
republicano
republicano
democrata
republicano
democrata
republicano
republicano
republicano
republicano
democrata
Republicano (3)
Misil_mx = a_favor
democrata
democrata
Republicano (4)
republicano

democrata
democrata
democrata
republicano
Democrata (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)

reduccion_corp_Synfuels = en_contra: republicano (97.0/3.0) (3)
presupuesto_de_educación = a_favor: republicano (13.0/2.0) (1)
presupuesto_de_educación = en_contra: democrata (5.0/2.0) (2)
misil_mx = a_favor: democrata (4.0/1.0) (4)
misil_mx = en_contra: democrata (3.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.
1.00% 0.90%
0.90%
0.80%
0.70%
0.60%
0.50%
0.40% 0.30% 0.30% 0.30%
0.30%
0.20%
0.10% 0.00% 0.00% 0.00% 0.00%
0.00%
ia
ia
ia
ia
a
a
a
ia
ci
ci
ci
nc
nc
nc
nc
nc
an
an
an
na
na
na
na
na
an
an
an
ga
ga
ga
ga
ga
-g
-g
-g
s-
e
de
de
de
ol
ol
as
la
rb
rb
gl
n
n
ón
eg
-Á
Á
ió
ó
ió
e
ci
-R
-R
ci
3-
rc
rc
.5
or
or
ID
.5
3
po
po
C4
ID
op
C4
ro
ro
ro
pr
-p
-p
-p
s-
ol
ol
as
la
rb
rb
gl
eg
-Á
Á
Re
-R
3-
.5
3-
ID
.5
C4
ID
C4
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.

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.
50 44
45
40 32
35
30 25 25
25
20
15
10
5
0
ganancia ganancia
Figura 5.13: Tamaño de los árboles de decisión obtenidos en el dominio Estudio sobre hongos
30 26
25
19
20
15
13
15
10
5
0
ganancia ganancia
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.

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.
60.00%
50.00%
40.00% Créditos
Cardiología
Votaciones
30.00% Hongos
Elita
Hipotiroidismo
20.00%
Vidrios
10.00%
0.00%
ID3-árboles- ID3-reglas- ID3-árboles- ID3-reglas- C4.5- C4.5-reglas- C4.5- C4.5-reglas-
ganancia ganancia proporción proporción árboles- ganancia árboles- proporción
de ganancia de ganancia ganancia propoción de ganancia
de ganancia
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).

7.00%
6.00%
5.00%
Cardiología
4.00% Votaciones
Hongos
3.00% Elita
Hipotiroidismo
2.00%
1.00%
0.00%
ID3-árboles- ID3-reglas- ID3-árboles- ID3-reglas- C4.5- C4.5-reglas- C4.5- C4.5-reglas-
ganancia ganancia proporción proporción árboles- ganancia árboles- proporción
de ganancia de ganancia ganancia propoción de ganancia
de ganancia
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.

60.00% C4.5-árboles-ganancia
50.00% C4.5-reglas-ganancia
40.00% C4.5-árboles-propoción de ganancia

Porcentaje de error
30.00%
C4.5-reglas-proporción de ganancia
20.00%
ID3-árboles-ganancia
10.00%
ID3-reglas-ganancia
0.00%
0 1000 2000 3000 4000 5000 6000 ID3-árboles-proporción de ganancia
-10.00%
Cantidad de datos de entrenam iento ID3-reglas-proporción de ganancia
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.


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.
Conclusiones Magdalena Servente 191

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.
192 Magdalena Servente Conclusiones

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.

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.
Manual del usuario Magdalena Servente 197

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.


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.
Conjuntos de datos Magdalena Servente 203

204 Magdalena Servente Conjuntos de datos

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.
Documentación del sistema Magdalena Servente 205

Módulos de clases de datos
UTipos defns.h Rulex.h Types.h
Utilización
TDIDT.cpp Utilización
Inicializar
Inicializar Módulos de Minería de Datos
Módulos de pantallas principales UDMID3 UDMC45

Inicializar
UInfoGral
Aplicar
método
Aplicar ID3 Aplicar C4.5
UPrincipal Evaluar
Evaluar Rendimiento
Mostrar árbol
RendimientoMostrar Mostrar Mostrar Árbol
rendimiento rendimiento
Determinar Evaluar
Mostrar Tabla PreferenciasRendimiento
Cambiar Tabla
UBD UCambioTabla frmOpcionesSist UElegirRendimiento URendimiento UArbol
Módulos de Opciones Generales
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.
206 Magdalena Servente Documentación del sistema

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
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;


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 hdrstop
USERES("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;
}
Código Fuente Magdalena Servente 213

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*/
214 Magdalena Servente Código Fuente

void ID3(short int MedidorGanancia); //llama al algoritmo ID3 sobre la tabla

actual
int EvalRendimiento; //indica si el usuario desea evaluar el rendimiento de una
corrida 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 la

aplicació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 <Controls.hpp>
#include <StdCtrls.hpp>
#include <Buttons.hpp>
//---------------------------------------------------------------------------
class TfrmInfoGral : public TForm
{
TLabel *lblTabla;
TLabel *lblClase;
TEdit *txtClase;
TEdit *txtTabla;
TBitBtn *BtnC45;
TBitBtn *BtnID3;
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
//---------------------------------------------------------------------------
TfrmInfoGral *frmInfoGral;
//---------------------------------------------------------------------------
__fastcall TfrmInfoGral::TfrmInfoGral(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TfrmInfoGral::FormClose(TObject *Sender,
{
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 <Db.hpp>
#include <DBGrids.hpp>
#include <DBTables.hpp>
#include <Grids.hpp>
#include "UDMID3.h"
//---------------------------------------------------------------------------
class TfrmBD : public TForm
{
TDBGrid *DBGrid;
TDataSource *DSTabla;
TTable *Tabla;
private:
/*Parámetros de la base sobre la que trabajaremos*/
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"
//---------------------------------------------------------------------------
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 <Db.hpp>
#include <DBGrids.hpp>
#include <Dialogs.hpp>
#include "UTipos.h"
#include "UDMID3.h"
//---------------------------------------------------------------------------
class TfrmCambioTabla : public TForm
{
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 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*/
void CargarCombo();
int ActualizarCambios(); /*Devuelve:
0: si los cambios fueron exitosos
1: si hubo problemas*/
public:
__fastcall TfrmCambioTabla(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TfrmCambioTabla *frmCambioTabla;
//---------------------------------------------------------------------------
#endif
D.3.2.2. UCambioTabla.cpp
//---------------------------------------------------------------------------
#pragma hdrstop
#include "UCambioTabla.h"
//---------------------------------------------------------------------------

TfrmCambioTabla *frmCambioTabla;
//---------------------------------------------------------------------------
__fastcall TfrmCambioTabla::TfrmCambioTabla(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TfrmCambioTabla::FormClose(TObject *Sender,
{
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 puede
quedar en blanco");
cbo_ColClasif->SetFocus();
res=1;
}
else
{
Params->ColClasificador=cbo_ColClasif->Text;
//Actualizamos la lista de Clasificadores
sqlstring="SELECT DISTINCT(" + Params->ColClasificador + ") as
Clasif 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;

//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 <ExtCtrls.hpp>
#include "UTipos.h"
//--------------------------------------------------------------------------
class TfrmOpciones : public TForm
{
TRadioGroup *rgSistema;
TRadioGroup *rgCriterio;
TRadioGroup *rgPoda;
TBitBtn *btn_Aplicar;
void __fastcall btn_AplicarClick(TObject *Sender);
private: // User declarations
public: // User declarations
__fastcall TfrmOpciones(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TfrmOpciones *frmOpciones;
//---------------------------------------------------------------------------
#endif
D.3.3.2. frmOpcionesSist.cpp
//---------------------------------------------------------------------------
#pragma hdrstop
#include "frmOpcionesSist.h"
//---------------------------------------------------------------------------
TfrmOpciones *frmOpciones;
//---------------------------------------------------------------------------
__fastcall TfrmOpciones::TfrmOpciones(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TfrmOpciones::FormClose(TObject *Sender,

{
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 <ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TfrmElegirRendimiento : public TForm
{
TRadioGroup *rgCorrida;
TGroupBox *gbSeleccionar;
TLabel *lblTabla;
TLabel *lblFecha;
TComboBox *cbTabla;
TComboBox *cbFecha;
void __fastcall rgCorridaClick(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"
//---------------------------------------------------------------------------
TfrmElegirRendimiento *frmElegirRendimiento;
//---------------------------------------------------------------------------
__fastcall TfrmElegirRendimiento::TfrmElegirRendimiento(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TfrmElegirRendimiento::FormClose(TObject *Sender,
{
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);
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();
delete(QTabla);
}
catch(...)
{ShowMessage("No se pudieron obtener los datos de la tabla de evaluación");
delete(QTabla);}
}
//---------------------------------------------------------------------------
void __fastcall TfrmElegirRendimiento::btn_AceptarClick(TObject *Sender)
{
TQuery *QTabla=new TQuery(frmElegirRendimiento);
try {
QTabla->DatabaseName=Base;
if (rgCorrida->ItemIndex==0)
{
/* sqlstring="SELECT Max(Codigo)as Codigo FROM UpdatesHeader.db WHERE
Nombre_Tabla='" +
cbTabla->Text +"' AND Metodo='";
*/ sqlstring="SELECT Max(Codigo) as Codigo FROM UpdatesHeader.db WHERE
Metodo='";
if (Tipo==0)
else
}
else
{
sqlstring="SELECT Codigo FROM UpdatesHeader.db WHERE Nombre_Tabla='" +
cbTabla->Text +"' AND Metodo='";
if (Tipo==0)
else
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->Open();
CodigoReglas=QTabla->FieldByName("Codigo")->AsInteger;
QTabla->First();
delete(QTabla);
}
catch(...)
{ShowMessage("Problemas con la Base de Datos, no se pudo recuperar la tabla a
procesar.");
delete(QTabla);}
}
//---------------------------------------------------------------------------
void __fastcall TfrmElegirRendimiento::cbTablaChange(TObject *Sender)

{
CargarCboFechora();
}
void TfrmElegirRendimiento::CargarCboFechora()
{TQuery *QTabla=new TQuery(frmElegirRendimiento);

if (cbTabla->Text!="")
{
try {
QTabla->DatabaseName=Base;
sqlstring="SELECT Fecha, Hora FROM UpdatesHeader.db WHERE Metodo='";

if (Tipo==0)
else
AppendStr(sqlstring, " AND Nombre_Tabla='");
AppendStr(sqlstring,cbTabla->Text);
AppendStr(sqlstring,"' ORDER BY Fecha DESC");
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");}
}
delete(QTabla);
}
//---------------------------------------------------------------------------
D.3.5. URendimiento
D.3.5.1. URendimiento.h
//---------------------------------------------------------------------------
#ifndef URendimientoH
#define URendimientoH
//---------------------------------------------------------------------------
class TFrmRendimiento : public TForm
{
TStringGrid *GridResultados;
private: // User declarations
public: // User declarations
__fastcall TFrmRendimiento(TComponent* Owner);
};
//---------------------------------------------------------------------------
extern PACKAGE TFrmRendimiento *FrmRendimiento;
//---------------------------------------------------------------------------
#endif
D.3.5.2. URendmiento.cpp
//---------------------------------------------------------------------------
#pragma hdrstop

//---------------------------------------------------------------------------
TFrmRendimiento *FrmRendimiento;
//---------------------------------------------------------------------------
__fastcall TFrmRendimiento::TFrmRendimiento(TComponent* Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TFrmRendimiento::FormClose(TObject *Sender,
{
Action = caFree;
}
//---------------------------------------------------------------------------
D.3.6. Uarbol
D.3.6.1. UArbol.h
//---------------------------------------------------------------------------
#ifndef UArbolH
#define UArbolH
//---------------------------------------------------------------------------
#include <ComCtrls.hpp>
#include "UTipos.h"
//--------------------------------------------------------------------------
class Tfrm_Arbol : public TForm
{
TTreeView *ArbolRes;
TOpenDialog *fod_Archivo;
void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose);
private:
/*String que tendrá los valores posibles para el clasificador*/
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"
//---------------------------------------------------------------------------
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,

{int 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;
{
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 <Db.hpp>
#include <fstream.h>
#include <math.hpp>
#include "UTipos.h"

//---------------------------------------------------------------------------
class TDMID3 : public TDataModule
{
TTable *TTennis;
TDataSource *DSTTennis;
TQuery *QGral;
TQuery *QUpdates;
void __fastcall DMID3Destroy(TObject *Sender);
private:
short int EvaluarResultados(AnsiString NombreTabla);
public:
__fastcall TDMID3(TComponent* Owner);
//----------------------------------------------------------------------------
//--------------------DECLARACION DE FUNCIONES--------------------------------
//----------------------------------------------------------------------------
tree_ptr Principal ( short int MedidorGanancia); /*Módulo principal*/
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
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 las

reglas obtenidas*/
short int EvaluarReglas(int codigoReglas);/*Evalua las reglas obtenidas sobre
los 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, TTablaCorrel
tabla);
/*Esta función devuelve la información de un conjunto antes de realizar la
partición*/
float Iposterior(int cant_clasificadores, int cant_descriptores, TTablaCorrel
tabla);
/*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, TTablaCorrel
tabla);
/*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"
//---------------------------------------------------------------------------
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 el
algoritmo 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;
Params=Parametros;
TTennis->DatabaseName=Params->NombreBD;
TTennis->TableName=Params->TablaBD;
TTennis->Active=true;

//especificada
QGral->DatabaseName=Params->NombreBD;
for (i=0; i<MAX_NIVELES;i++)

{
VecValores[i]="";
VecDescriptores[i]="";
}

QGral->SQL->Clear();
QGral->SQL->Add(sqlstring);
QGral->ExecSQL();
TTennis->Close();
TTennis->Open();
}
/******************************************************************************
Verifica la uniformidad de un conjunto de filas, por uniformidad nos referimos
al hecho que todos los valores del clasificador para dicho conjunto sean iguales
Devuelve:
0 si todos los valores son "Yes"
3 si los valores no son uniformes
4 si hubo un error
******************************************************************************/
short int TDMID3::EsUniforme(int nivelArbol)
{//begin EsUniforme

short int aux;

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->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->Open();
if (QGral->FieldByName("valor")->AsString == Params-
>LClasificadores->Strings[0])
aux=0;
else
aux=1;
QGral->Close();
return(aux);
}
}
catch(...)
{
ShowMessage("No se pudo abrir el Query");
return(4);
}
}//fin EsUniforme
/******************************************************************************
Obtiene la cantidad de descriptores presentes en la tabla
que 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 por
no ofrecer ninguna ganancia de información
Devuelve: 0 si no hubo problemas
1 si hubo algún error
/******************************************************************************/
int TDMID3::BuscarPK(short int ValidDs[])
{
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 ");
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(...)
{
ShowMessage("No se pudo abrir el Query");
return(1);
}
}
//---------------------------------------------------------------------------
/******************************************************************************
Función recursiva que arma el árbol de decisión según el
algoritmo 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 niveles
del á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érmino
cant: cantidad de ocurrencias de ese elemento
total: total de elementos en el conjunto
InfoTermino=-(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ón
cant_clasificadores: cantidad de valores posibles para los clasificadores, es
decir, la cantidad de filas de la tabla de correlación
cant_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ón
Ianterior(T)=Sum(i=1, i<k)(-(cant/Total)log2(cant/total))
******************************************************************************/
float TDMID3::Ianterior(int cant_clasificadores, int cant_descriptores, TTablaCorrel
tabla)
{
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_d
escriptores]);
}
return(auxI);
}
/******************************************************************************
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
cant_clasificadores: cantidad de valores posibles para los clasificadores, es
decir, la cantidad de filas de la tabla de correlación
cant_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ón
Iposterior(T)=Sum(i=1, i<k)(-(cant/Total)log2(cant/total))
******************************************************************************/

float TDMID3::Iposterior(int cant_clasificadores, int cant_descriptores, TTablaCorrel

tabla)
{
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_descri
ptores]))*Itemp;
}
}
return(Iaux);
}
/******************************************************************************
Ganancia debida a la partición del conjunto según el atributo en
cuestión
Gain=Ianterior-Iposterior;
******************************************************************************/
float TDMID3::Gain(float Ianterior, float Iposterior)
{
return(Ianterior-Iposterior);
}
/******************************************************************************
Información debida a la partición realizada
Sum(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, TTablaCorrel

tabla)
{
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_descrip
tores])*(float(tabla[cant_clasificadores][i])/float(tabla[cant_clasificadores][cant_desc
riptores]));
}
}
return(SIaux);
}
/******************************************************************************
Proporción de ganancia debida a la partición del conjunto según el atributo en
cuestión
Gain=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 de
la 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ón
Nivel: es el nivel del árbol que se está analizando
desc: es el descriptor según el que se quiere armar la tabla
Hubo 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->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 un
descriptor");
delete lista;
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->Add(sqlstring2);
QGral->Open();
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 con
un valor determinado de descriptor");
delete lista;
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 conjuntos
como valores pueda tomar el descriptor.
desc: es el nro de descriptor con el que trabajamos
pNode: es el nodo del árbol desde el cual se está haciendo la partición
valores: es la lista de valores posibles que puede tomar el descriptor
******************************************************************************/
int TDMID3::Particionar(int desc, int nivel, tree_ptr pNode, TStringList *valores)
{
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++)
{
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->ExecSQL();
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);
}
particion.~AnsiString();
delete lista;
return(0);
}
catch(...)
{
ShowMessage("No se pudo realizar la actualización");
particion.~AnsiString();
delete lista;
return(1);
}
}
//---------------------------------------------------------------------------
/******************************************************************************
/*realiza el "pruning" del árbol obtenido
Devuelve 0 si todos los valores son "Yes"
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"
2 si todos los valores son mixtos
-1 si no son iguales*/

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;
{
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=".";
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++;
//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,"', 'ID3', '");
AppendStr(sqlstring, Date());
AppendStr(sqlstring,"', '");
AppendStr(sqlstring, Time());
AppendStr(sqlstring,"')");
QUpdates->SQL->Add(sqlstring);
QUpdates->ExecSQL();
//Concatenamos fecha y hora en los archivos

DateSeparator='-';
TimeSeparator='_';
//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();
}
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 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();
}
{
//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,VecValores[VecReglas[j]]);
FReglas << rule << endl;
j++;
{
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,VecValores[VecReglas[j]]);
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->Add(sqlstring2);
QUpdates->ExecSQL();
}
else //no es hoja
{
i=0;
nroRegla++;
{
ObtenerReglas(Tree->pHijos[i], VecReglas, nroRegla,codigo);
/*Eliminamos el valor de la ultima rama recorrida porque
estamos cambiando de rama*/
j=0;
{j++;}
VecReglas[j-1]=-1;
i++;
}
}//end else
tabla.~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;
{VecVal[i]=VecValores[i];}
};
void TDMID3::InformarDescrip(TVecValores VecDesc)
/*Recibe las descripciones del arbol generado*/
{int 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);
}
//Evalua los resultados de las reglas aplicadas sobre la tabla de NombreTabla

short 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);
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;
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]);
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";
QClases->Close();
QRes->Close();
delete(QClases);
delete(QRes);
return(0);
}
catch(...)
{
delete(QClases);
delete(QRes);
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;
{
VecValores[i].~AnsiString();
VecDescriptores[i].~AnsiString();
}
}
//---------------------------------------------------------------------------

D.4.2. UDMC45
D.4.2.1. UDMC45.h
//---------------------------------------------------------------------------
#ifndef UDMC45H
#define UDMC45H
//---------------------------------------------------------------------------
#include <Db.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
{
TDataSource *DSTTennis;
TTable *TTennis;
void __fastcall DMC45Destroy(TObject *Sender);
private:
/* 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,ItemCount
TotalItems);
/* 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,ItemCount

Errors);
/* 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 las
reglas 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 todas
las pruebas */
void FormRules(Tree t);/*Creación de un conjunto de reglas del árbol de decisión
t */
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, lo
guardamos.*/
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 de
producció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, bool
Arrow);
/*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 C45(); //dispara el proceso del C4.5 con los parámetros recibidos
void GenerarReglasC45(); //dispara el proceso de generación de las reglas de
decisión
};
//---------------------------------------------------------------------------
extern PACKAGE TDMC45 *DMC45;
//---------------------------------------------------------------------------
#endif
D.4.2.2. UDMC45.cpp
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "UDMC45.h"
//---------------------------------------------------------------------------
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)
{
TQuery *QGral=new TQuery(DMC45);
Params=Parametros;
TTennis->DatabaseName=Params->NombreBD;
TTennis->TableName=Params->TablaBD;
TTennis->Active=true;

//especificada

QGral->ExecSQL();
TTennis->Close();
TTennis->Open();
delete(QGral);
}
//---------------------------------------------------------------------------
void __fastcall TDMC45::DMC45Destroy(TObject *Sender)
{int i,j;
delete ClassName;
delete AttName;

{
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='_';
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<<" ítems):";
FVitacora<<endl;
Evaluate(false, Best);

if ( UNSEENS )
{
GetData();
FVitacora<<endl;
FVitacora<<"Evaluación sobre los datos de prueba (";
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;
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();
sqlstring=") as Campo from ";
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->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 del
archivo","Error",MB_OK|MB_ICONWARNING);
}
delete(QGral);
}
//---------------------------------------------------------------------------
/*************************************************************************/
/* */
/* 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 del
archivo","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 */
{
int cantReg,res;
cantReg=TTennis->RecordCount;
try
{
sqlstring="SELECT COUNT(DISTINCT ";
AppendStr(sqlstring,Atrib);
AppendStr(sqlstring," ) as Cant FROM ");
QGral->Open();
QGral->First();
if (QGral->FieldByName("Cant")->AsInteger==cantReg)
{res=0;} //es PK
else
{res=1;}
}
catch(...)
{
res=-1;
}
delete (QGral);
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='_';
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;
{
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;
{
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 casos

para 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);

{
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,ItemCount
TotalItems)
{
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 la

info 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,ItemCount
Errors)
{
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<<" ";
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<<" = ";
FVitacora<<AttValName[Att][Last].c_str();
FVitacora<<":";
break;
}
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));
{
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;
}
{
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();

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));
{
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;
{
T->Subset[v] = (Conjunto) malloc(Bytes);
StreamIn((char *) T->Subset[v], Bytes);
}
}
T->Branch = (Tree *) calloc(T->Forks + 1, sizeof(Tree));

{
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 )
{
{
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 )
{
{
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));
{
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));
{
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 ganancia

y 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<<" no tiene valores conocidos ";
FVitacora<<endl;
}
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)
{
Verbosity(3) PrintDistribution(Att, MaxAttVal[Att], true);
FVitacora<<"inf ";
FVitacora<<PrevInfo;
FVitacora<<PrevGain;
FVitacora<<" val=";
FVitacora<<PrevVal;
FVitacora<<endl;
}
/* Eliminamos de Freq[] and ValFreq[] aquellos valores del atributo

que no están representados, y creamos un subconjunto nuevo para
cada 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];
{
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<<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<<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), o
val >= 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);
{
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<<BestGain;
FVitacora<<" val ";
FVitacora<<BestVal;
Verbosity(3)
{
FVitacora<<" combinación ";
FVitacora<<BestV1;
FVitacora<<" ";
FVitacora<<BestV2;
PrintDistribution(Att, Blocks, false);
}
}
}
MINOBJS = SaveMINOBJS;
if ( PrevVal <= 0 )
{
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<<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);
/* 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;
}
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)
{
Verbosity(3) PrintDistribution(Att, MaxAttVal[Att], true);
FVitacora<<Info[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 casos

de 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 */
{
{
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 ";
}
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;
{
ValFreq[0] += Freq[0][c];
}

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;
}
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 la

informació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;

else
if ( 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 )
{

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<<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;
{
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;
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;
{
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<<" ( ";
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;
{
Ep = Group(v, Kp, Lp, T);
if ( Kp <= Ep )
{
Factor = CountItems(Kp, Ep) / KnownCases;
if ( Factor >= MaxFactor )

{
MaxBr = v;
MaxFactor = Factor;
}

{
Weight[i] *= Factor;
}
TreeErrors += EstimateErrors(T->Branch[v], Fp, Ep, Sh+1, UpdateTree);
Group(0, Fp, Ep, T);

{
Weight[i] /= Factor;
}
}
}
if ( ! UpdateTree )
{
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<<" á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 hoja

o 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<<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;
}
EstimateErrors(T->Branch[MaxBr], Fp, Lp, Sh, true);
memcpy((char *) T, (char *) T->Branch[MaxBr], sizeof(tree_record));
Changed = true;
}
else
{
T->Errors = TreeErrors;
}
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 */
{
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);
{
CopyBits(Bytes, T->Subset[v], PossibleValues[A]);
CheckPossibleValues(T->Branch[v]);
}
CopyBits(Bytes, HoldValues, PossibleValues[A]);
free(HoldValues);
}
else
if ( T->NodeType )
{
{
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)
{
if ( ! ClassSum )
{
ClassSum = (float *) malloc((MaxClass+1) * sizeof(float));
}
{
ClassSum[c] = 0;
}
Classify(CaseDesc, DecisionTree, 1.0);
BestClass = 0;
{
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;

{
case 0: /* hoja */
if ( T->Items > 0 )
{
/* Actualizamos a partir de TODAS las clases */
{
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
{
{
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)
{
}
}
else
{
v = ( Cv <= T->Cut ? 1 : 2 );
}
return;
case BrSubset: /* prueba sobre un subconj de valores discretos */
a = T->Tested;
dv = DVal(CaseDesc, a);
if ( dv )
{
{
if ( In(dv, T->Subset[v]) )
{

return;
}
}
}
/* Valor desconocido o no encontrado en ningún subconjunto */
{
}
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<<" ";
{
FVitacora<<" ------";
}
FVitacora<<endl;
ForEach(Row, 0, MaxClass)
{
FVitacora<<" ";
{
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
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 reglas

a 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;
{
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;
{
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));
{
x->Subset[v] = t->Subset[v];
}
}
Stack[d]->CondTest = FindTest();
{
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;


{
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] )
{
{
if ( Match[r][i] )
{
Covered[i]++;
}
}
}
}
/* Agregamos o eliminamos la regla con la mayor reducción en el costo

de 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;
{
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++;
}
else
if ( ThisClass == FocusClass )
{
FNeg++;
}
}
{
{
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 ( 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)
{
{
if ( Included[c] ) continue;
FalsePos[c] = 0;
{
if ( Covered[i] || Class(Item[i]) == c ) continue;
{
if ( Rule[r].Rhs == c && RuleIn[r] && Match[r][i] )
{
FalsePos[c]++;
break;
}
}
}
}
BestC = -1;
{
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;
{
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;
{
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;
strcat(Fn, ".rules");
if ( ! ( TRf = fopen(Fn, "w") ) )
{FReglas<<"Error al abrir el archivo de reglas";}
if ( ! ( TRf = fopen(Fn, "w") ) )
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;
if ( ! ( TRf = fopen(Fn, "r") ) )
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;
{
Deleted[d] = false;
}
/* Evaluamos la matriz de satisfacción */
TargetClassFreq[0] = TargetClassFreq[1] = 0;
{
{
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");
{
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;
{
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;
{
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);
}
else
if ( Misses == 1 )
{
UpdateCount(Total, Errors, Missed[0], CorrectClass);
}
}
/* Ajustamos las cuentas para reflejar todos los casos q satisfacen

todas 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 */
{
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]++;
}
else
if ( 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;
{
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, porque
Better 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ÁMICO
typedef 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;
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

~TParametros(); //destructor

int RefrescarParams();
int GrabarParams();
};
//---------------------------------------------------------------------------
#endif
D.5.1.2. UTipos.cpp
//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "UTipos.h"
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// IMPLEMENTACIÓN DE LA CLASE TParametros
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
TParametros::TParametros(AnsiString ArchIni) //constructor

{
int 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, sizeof
Buffer, ArchivoIni.c_str());
if (Buffer!="???")
ColClasificador=Trim(Buffer);
GetPrivateProfileString("Clasificadores", "lClasif", "???", Buffer, sizeof
if (Buffer!="???")
{
LClasificadores->Add(AnsiString(strtok(Buffer, ",")));
i=0;
while (Trim(LClasificadores->Strings[i])!="")
{
LClasificadores->Add(AnsiString(strtok(NULL, ",")));
i++;
}
LClasificadores->Delete(i);
}

GetPrivateProfileString("BaseDeDatos", "Tabla", "???", Buffer, sizeof Buffer,
ArchivoIni.c_str());
if (Buffer!="???")
TablaBD=Trim(Buffer);
GetPrivateProfileString("BaseDeDatos", "Alias", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
NombreBD=Trim(Buffer);
//Cargamos los datos asociados con las reglas de decisión

GetPrivateProfileString("Reglas", "Extension", "???", Buffer, sizeof Buffer,
if (Buffer!="???")
ExtensionFileReglas=Trim(Buffer);
GetPrivateProfileString("Reglas", "Formato", "???", Buffer, sizeof Buffer,

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,
if (Buffer!="???")
iSistema=StrToInt(Trim(Buffer));
GetPrivateProfileString("Resolucion", "Criterio", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
iCriterio=StrToInt(Trim(Buffer));
GetPrivateProfileString("Resolucion", "Poda", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
iPoda=StrToInt(Trim(Buffer));
//Cargamos los datos asociados con el C4.5

GetPrivateProfileString("C45", "Conjuntos", "???", Buffer, sizeof Buffer,
if (Buffer!="???")

iConjuntos=StrToInt(Trim(Buffer));
GetPrivateProfileString("C45", "MinObjs", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
iMinObjs=StrToInt(Trim(Buffer));
GetPrivateProfileString("C45", "CF", "???", Buffer, sizeof Buffer,

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()
{
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, sizeof
if (Buffer!="???")
ColClasificador=Trim(Buffer);
GetPrivateProfileString("Clasificadores", "lClasif", "???", Buffer, sizeof
if (Buffer!="???")
{
LClasificadores->Add(AnsiString(strtok(Buffer, ",")));
i=0;
while (Trim(LClasificadores->Strings[i])!="")
{
LClasificadores->Add(AnsiString(strtok(NULL, ",")));
i++;
}
LClasificadores->Delete(i);
}

GetPrivateProfileString("BaseDeDatos", "Tabla", "???", Buffer, sizeof Buffer,
if (Buffer!="???")
TablaBD=Trim(Buffer);
GetPrivateProfileString("BaseDeDatos", "Alias", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
NombreBD=Trim(Buffer);
//Cargamos los datos asociados con las reglas de decisión

GetPrivateProfileString("Reglas", "Extension", "???", Buffer, sizeof Buffer,
if (Buffer!="???")
ExtensionFileReglas=Trim(Buffer);

GetPrivateProfileString("Reglas", "Formato", "???", Buffer, sizeof Buffer,

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,
if (Buffer!="???")
iSistema=StrToInt(Trim(Buffer));
GetPrivateProfileString("Resolucion", "Criterio", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
iCriterio=StrToInt(Trim(Buffer));
GetPrivateProfileString("Resolucion", "Poda", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
iPoda=StrToInt(Trim(Buffer));
//Cargamos los datos asociados con el C4.5

GetPrivateProfileString("C45", "Conjuntos", "???", Buffer, sizeof Buffer,
if (Buffer!="???")
iConjuntos=StrToInt(Trim(Buffer));
GetPrivateProfileString("C45", "MinObjs", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
iMinObjs=StrToInt(Trim(Buffer));
GetPrivateProfileString("C45", "CF", "???", Buffer, sizeof Buffer,

if (Buffer!="???")
iCF=StrToInt(Trim(Buffer));
return(0);
}
catch(...) {
return(-1);
}
}
//---------------------------------------------------------------------------
int TParametros::GrabarParams()
{
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(),
WritePrivateProfileString("BaseDeDatos", "Tabla", TablaBD.c_str(),
WritePrivateProfileString("Reglas", "Extension", ExtensionFileReglas.c_str(),
//Clasificadores
lista= "";
index=0;
while (index<LClasificadores->Count)
{
AppendStr(lista, LClasificadores->Strings[index]);
AppendStr(lista, ", ");
index++;
}

WritePrivateProfileString("Clasificadores", "lClasif", lista.c_str(),

//Formato de las reglas

lista=IntToStr(iFormatoReglas);
WritePrivateProfileString("Reglas", "Formato", lista.c_str(),
//Sistema de resolución
lista=IntToStr(iSistema);
WritePrivateProfileString("Resolucion", "Sistema", lista.c_str(),
lista=IntToStr(iCriterio);
WritePrivateProfileString("Resolucion", "Criterio", lista.c_str(),
lista=IntToStr(iPoda);
WritePrivateProfileString("Resolucion", "Poda", lista.c_str(),
//C4.5
lista=IntToStr(iConjuntos);
WritePrivateProfileString("C45", "Conjuntos", lista.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
[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 of
Ljubljana, Eslovenia. Department of Internal Diseases, Oskarshamn
County Hospital, Suecia.
[Baldwin et al, 2000] Baldwin, J.F., Lawry, J., Martin, T.P. 2000 Mass Assignment
Induction of Decision Trees on Words. A.I. Group, Departament of
Engineering Mathematics, University of Bristol, Reino Unido,
{jim.baldwin, j.lawry, trevor.martin}@bristol.ac.uk
[Bergadano et al, 1992] Bergadano, F., Matwin, S. Michalski, R. S., Zhang, J. (1992)
Learning Two-TieredDescriptions of flexible Concepts: the
POSEIDON 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 Logical
Decision Trees. Katholieke Universiteit Leuven, Departament of
Computer Science, Celestijnelaan, Bélgica
[Blum, Langley, 1997] Blum, A., Langley, P. 1997 Selection of Relevant Features and
Examples in Machine Learning. School of Computer Science,
Carnegie Mellon University, Pittisburgh, Pennsylvania, Institute for
the Study of Learning and Expertise, Palo Alto, California, EE.UU.
[Blurock, 1996] Edward S. Blurock, 1996 The ID3 Algorithm, Research Institute for
Symbolic 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: Neural
Networks, 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 Learning
Characteristic Decision Trees by Controlling the Degree of
Generalization. Departament of Computer Science, Lund University,
Suecia
[DeJong, Mooney, 1986] DeJong, G.F., Mooney, R.J. 1986. Explanation-Based Learning. An
Alternative 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-Level
Decision Trees. Departament of Computer Science, University of
Helsinki, 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, San
Mateo, 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 Global
Discretization, Proceedings 16th International Conference on Machine
Learning, 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. Dynamic
ID3: A Symbolic Learning Algorithm for Many-Valued Attribute
Referencias Magdalena Servente 341

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 de
aprendizaje de conceptos para sistemas inteligentes. Anales del V
Congreso 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. En
Abecasis, S. y Heras, C. Metodología de la Investigación. Prologado
por el Dr. L. Santaló. Editorial Nueva Librería. Argentina
[García Martínez, 1997] García Martínez, R. 1997 Sistemas Autónomos: Aprendizaje
Automá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. Data
Mining Research: Opportunities and Challenges, A Report of three
NSF Workshops on Mining Large, Massive, and Distributed Data,
January 1999, Chicago, EE.UU.
[Hall, 1998] Hall, P.W. 1998. Machine Learning – ID3 Classification.
Philipv@apk.net, http://junior.apk.net/~philiv/rschmlid.htm
[Holsheimer, Siebes, 1994] Holsheimer, M., Siebes, A.P.J.M. 1994. Data Mining: the search for
knowledge in databases. Computer Science/Departament of
Algorithmics and Architectire, Centrum voor Wiskunde en
Informatica, CS-R9406, Amsterdam, Holanda.
[Holte, 1993] Holte, R.1993. Very Simple Classification Rules Perform Well on
Most 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 Tour
Guide 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. Web
Watcher: Machine Learning and Hypertext, School of Computer
Science, 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-Down
Decision Tree Learning Algorithms, AT&T Research, Tel-Aviv
University, Israel.
[Klemettinen et al, 1994] Klemettinen, M., Mannila, H., Ronkainen, P., Toivonen, H., Verkamo,
A. 1994. Finding Interesting Rules from Large Sets of Discovered
Association Rules, University of Helsinki, Department of Computer
Science, Helsinki, Finlandia.
[Korab, 1997] Korab, H. 1997. Rule Induction: Decision Trees and Rules,
http://www.ncsa.uiuc.edu/News/Access/Stories/97Stories/KUFRIN.ht
ml
[Mannila et al, 1994] Mannila, H., Toivonen, H., Verkamo, A. 1994. Efficient Algorithms
for Discovering Association Rules, University of Helsinki, Department
of Computer Science, Helsinki, Finlandia.
[Michalski et al, 1998] Michalski, R.S., Bratko, I., Kubat M. 1998. Machine Learning and
Data 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 Annual
Symposium on Computer Applications on Medical Care, George
Washington University, Medical Center, Washington, DC, EE.UU.
[Michalski, 1983] Michalski, R. S. 1983. A Theory and Methodology of Inductive
Learning. En Michalski, R. S., Carbonell, J. G., Mitchell, T. M. (eds.).
(1983) Machine Learning: An Artificial Intelligence Approach, Vol. I.
342 Magdalena Servente Referencias

Morgan-Kauffman, EE.UU.
[Michalski, 1991] Michalski, R. S. 1991. Towards an Unified Theory of Learning: An

Outline of Basic Ideas, Proceedings of the 3rd World Conference on
the Fundamentals of Artificial Intelligence, Paris, Julio 1-5, 1991
[Michalski, Tecuci, 1994] Michalski, R. S., Tecuci, G. (eds) 1994. Machine Learning: A
Multistrategy 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, Carnegie
Mellon 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 de
conocimientos, 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 and
Layered Search in Empirical Learning. Basser Departament of
Computer Science, University of Science, Australia.
[Quinlan, 1986] Quinlan, J.R. 1986. Induction of Decision Trees. En Machine
Learning, 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 Artificial
Intelligence, páginas. 304-307. San Mateo, CA., Morgan Kaufmann,
EE.UU.
[Quinlan, 1988b] Quinlan, J.R. 1988. Decision trees and multi-valued attributes. En
J.E. Hayes, D. Michie, and J. Richards (eds.), Machine Intelligence,
Volumen II, páginas. 305-318.Oxford University Press, Oxford, Reino
Unido
[Quinlan, 1989] Quinlan, J.R. 1989. Unknown Attribute Values in Induction. Basser
Departament of Computer Science, University of Science, Australia.
[Quinlan, 1990] Quinlan, J. R. 1990. Learning Logic Definitions from Relations. En
Machine 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.) Machine
Learning, The Artificial Intelligence Approach. Morgan Kaufmann,
Vol. I, Capítulo 6, páginas149-167. San Mateo, CA: Morgan
Kaufmann, EE.UU.
[Quinlan, 1993b] Quinlan, J.R. 1993. Learning Efficient Classification Procedures and
Their Application to Chess Games, En R. S. Michalski, J. G.
Carbonell, & T. M. Mitchells (Eds.) Machine Learning, The Artificial
Intelligence 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-Based
Learning. Basser Departament of Computer Science, University of
Science, Australia.
[Quinlan, 1993d] Quinlan, J.R. 1993 C4.5: Programs for Machine Learning. Morgan
Kaufmann Publishers, San Mateo, California, EE.UU.
[Quinlan, 1995] Quinlan, J.R. 1995 MDL and Categorical Theories. Basser
Departament of Computer Science, University of Science, Australia.
Referencias Magdalena Servente 343

[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 by
minimum 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 Engineering
Statistics 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 the
Construction of ID3 decision trees, Sun Microsystems, University of
MO-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 Comparison
of Different Learning Algorithms, Carnegie Mellon University,
Pittisburgh, EE.UU.
[Thrun et al, 1998] Thrun, S., Faloustos, C., Mitchell, T., Wasserman, L. 1998 Automated
Learning and Discovery: State-Of-The-Art and Research Topics in a
Rapidly Growing Field. CMU-CALD-98-100, Center for Automated
Learning and Discovery, Carnegie Mellon University, Pittisburgh,
EE.UU.
[Witten y Frank, 2000] Witten, I.H., Frank, E. 2000. Data Mining: Practical Machine
Learning Tools and Techniques with Java Implementations. Morgan
Kaufmann, San Diego, EE.UU.
344 Magdalena Servente Referencias

Mode Lo 1

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Mode Lo 1

Hochgeladen von

Copyright:

Verfügbare Formate

ALGORITMOS TDIDT APLICADOS A LA

MINERIA DE DATOS INTELIGENTE

TESIS DE GRADO EN INGENIERIA INFORMATICA

LABORATORIO DE SISTEMAS INTELIGENTES

TESISTA: Srta. Magdalena SERVENTE

DIRECTOR: Prof. Dr. Ramón GARCIA MARTINEZ

Resumen Magdalena Servente

Resumen Magdalena Servente

Indice Magdalena Servente i

CAPÍTULO 2: ESTADO DEL ARTE 5

2.1. Aprendizaje Automático 6

2.2. Minería de Datos 14

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

2.4 La Familia TDIDT 27

ii Magdalena Servente Indice

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

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

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.2. Descripción General de los Algoritmos 52

Indice Magdalena Servente iii

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

4.5. Sistema integrador 83

CAPÍTULO 5: RESULTADOS OBTENIDOS 97

5.1. Interpretación de los resultados 97

5.2. Descripción de los dominios 100

iv Magdalena Servente Indice

5.2.4. Estudio sobre hongos 103

5.3. Resultados Obtenidos con el ID3 107

5.4. Resultados Obtenidos con el C4.5 135

Indice Magdalena Servente v

5.4.5.1. Utilizando la ganancia como criterio de decisión 158

5.6. Análisis general de los resultados obtenidos 187

CAPÍTULO 6: CONCLUSIONES 191

6.1. Conclusiones Generales 191

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

ANEXO A: MANUAL DEL USUARIO 197

A.1. Características Generales 197

A.2. Funcionalidad 198

vi Magdalena Servente Indice

A.2.2. Descripción del menú 198

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.3. Estructuras de datos 209

ANEXO D: CÓDIGO FUENTE 213

D.1. TDIDT.cpp 213

Indice Magdalena Servente vii

D.2. Módulos de Pantallas Principales 214

D.3. Módulos de opciones generales 219

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

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

viii Magdalena Servente Indice

D.5.3. Defns.h 339

Indice Magdalena Servente ix

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

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

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