COMPORTAMIENTO DE INTEGRACIÓN DE …sistemas.unla.edu.ar/sistemas/gisi/TFLS/Panchuk-TFL.pdf · Figura 2. 19 - Ejemplo de cubrimiento donde las condiciones entre reglas son diferentes.

Universidad Nacional de Misiones

Facultad de Ciencias Exactas Químicas y Naturales

Tesis de Grado Licenciatura en Sistemas de Información

COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS

PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A

GRUPOS

Autor: José David PANCHUK

Directores:

Dr. Ramón GARCÍA-MARTÍNEZ (UNLa) y Lic. Sebastian MARTINS (UNLa)

Año 2015

COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS

TRABAJO FINAL DE LICENCIATURA EN SISTEMAS DE INFORMACIÓN JOSÉ DAVID PANCHUK



AGRADECIMIENTOS

Al Dr. Ramón García-Martínez y al Lic. Sebastian Martins por ayudarme y guiarme con paciencia

durante el desarrollo de esta tesis.

A mi familia por la paciencia y confianza que invirtieron en mí y por apoyarme siempre.

A la Facultad de Ciencias Exactas Químicas y Naturales de la Universidad Nacional de Misiones por la

excelente formación brindada durante estos años.

A mis amigos por acompañarme durante todos estos años de aprendizaje.





RESUMEN

La presente tesis estudia el comportamiento de la integración de algoritmos de agrupamiento e

inducción en el marco del proceso de explotación de información de descubrimiento de reglas de

pertenencia a grupos, con la característica de que se utilizaran distintos tipos de dominios

experimentales, definidos mediante la variación de los parámetros que conforman los distintos

experimentos, con el fin de estudiar cómo estos afectan a los resultados obtenidos por las distintas

combinaciones de algoritmos y lograr determinar cuáles de estas combinaciones funciona mejor para

cada tipo de complejidad.

Palabras Claves: algoritmos, agrupamiento, inducción, explotación de información, reglas, dominios,

complejidad.

ABSTRACT

This thesis studies the behavior of the integration of clustering and induction algorithms in the context

of the information mining process of the discovery of group membership rules, with the characteristic

that different types of experimental domains will be used, defined by varying the parameters that are

part of the various experiments, in order to study how they affect the results obtained by different

combinations of algorithms and establish which of these combinations work best for each type of

complexity.

Keywords: algorithms, clustering, induction, information mining, rules, domains, complexity.



ÍNDICE COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS


i

ÍNDICE

1. Introducción .......................................................................................................................................... 1

1.1. Contexto de la Tesis ....................................................................................................................... 1

1.2. Objetivos de la Tesis ...................................................................................................................... 1

1.2.1. Objetivos Generales ................................................................................................................ 1

1.2.2. Objetivos Específicos .............................................................................................................. 2

1.2.3. Metodología de Desarrollo ...................................................................................................... 2

1.3. Visión General de la Tesis ............................................................................................................. 3

2. Estado de la Cuestión ............................................................................................................................ 5

2.1. Procesos de Explotación de Información ....................................................................................... 5

2.1.1. Descubrimiento de Reglas de Comportamiento...................................................................... 5

2.1.2. Descubrimiento de Grupos ...................................................................................................... 6

2.1.3. Ponderación de Interdependencia de Atributos ...................................................................... 7

2.1.4. Descubrimiento de Reglas de Pertenencia a Pertenencia a Grupos ........................................ 8

2.1.5. Ponderación de Reglas de Comportamiento o de Pertenencia a Grupos ................................ 9

2.2. Algoritmos de Agrupamiento....................................................................................................... 11

2.2.1. Introducción a los Algoritmos de Agrupamiento .................................................................. 11

2.2.2. Algoritmo SOM .................................................................................................................... 12

2.2.3. Algoritmo EM ....................................................................................................................... 13

2.2.4. Algoritmo KMeans ............................................................................................................... 14

2.2.5. Algoritmo Farthest First ........................................................................................................ 15

2.2.6. Algoritmo NNC o KNN ........................................................................................................ 16

2.3. Algoritmos de Inducción .............................................................................................................. 17

2.3.1. Introducción a los Algoritmos de Inducción ......................................................................... 18



ii

2.3.2. Algoritmos de la Familia TDIDT.......................................................................................... 19

2.3.3. Algoritmo AQ15 ................................................................................................................... 21

2.3.4. Algoritmo CN2 ..................................................................................................................... 22

2.3.5. Algoritmo PART ................................................................................................................... 24

2.3.6. Algoritmo Apriori ................................................................................................................. 25

2.4. Complejidad del Dominio ............................................................................................................ 26

2.5. Cubrimiento de Reglas ................................................................................................................. 30

3. Descripción del Problema ................................................................................................................... 33

3.1. Delimitación del problema de investigación ................................................................................ 33

3.2. Resumen de las preguntas de investigación ................................................................................. 34

4. Materiales y Métodos .......................................................................................................................... 35

4.1. Método de Experimentación ........................................................................................................ 35

4.2. Herramienta de Experimentación ................................................................................................. 35

4.2.1. Introducción .......................................................................................................................... 35

4.2.2. Funcionalidades .................................................................................................................... 36

4.2.3. Dinámica Completa de la Herramienta ................................................................................. 48

5. Experimentos ...................................................................................................................................... 49

5.1. Introducción ................................................................................................................................. 49

5.2. Diseño Experimental .................................................................................................................... 49

5.2.1. Características de las Experiencias Realizadas ..................................................................... 49

5.2.2. Presentación de las Variables a Utilizar ................................................................................ 50

5.2.3. Panorama General de la Ejecución de las Experiencias ....................................................... 51

5.3. Resultados Obtenidos ................................................................................................................... 55

5.3.1. Formato de los Resultados .................................................................................................... 55

5.3.2 Matriz de Valores Finales Promedios .................................................................................... 55



iii

6. Conclusiones ....................................................................................................................................... 59

6.1. Análisis Comparativo de los Resultados Obtenidos .................................................................... 59

6.2. Conclusiones Finales.................................................................................................................... 63

6.3. Futuras Líneas de Trabajo ............................................................................................................ 64

7. REFERENCIAS .................................................................................................................................. 67

A. Metodología ....................................................................................................................................... 71

A.1. Requerimientos ........................................................................................................................... 71

A.2. Análisis ........................................................................................................................................ 72

A.2.1. Casos de Uso ........................................................................................................................ 72

A.2.2. Diagramas de Secuencia ...................................................................................................... 74

A.3. Diseño ......................................................................................................................................... 76

A.3.1. Diagrama de Clases .............................................................................................................. 76

A.3.1. Descripción de Clases .......................................................................................................... 77

B. Manual de Usuario ............................................................................................................................. 79

B.1. Introducción................................................................................................................................. 79

B.1.1. Componentes de la Herramienta .......................................................................................... 79

B.1.2. Plataforma y Lenguaje.......................................................................................................... 79

B.1.3. Librerías Utilizadas .............................................................................................................. 80

B.2. Instalación y Configuración ........................................................................................................ 81

B.2.1. Requerimientos ..................................................................................................................... 81

B.2.2. Configuración ....................................................................................................................... 81

B.3. Uso de la Herramienta ................................................................................................................. 82

B.3.1. Generación de Dominio ........................................................................................................ 83

B.3.2. Experiencia Simple ............................................................................................................... 85

B.3.3. Experimentación Completa .................................................................................................. 87



iv



v

ÍNDICE DE FIGURAS

Figura 2. 1 - Proceso de Descubrimiento de Reglas de Comportamiento. [Britos & García-Martínez,

2009] ......................................................................................................................................................... 6

Figura 2. 2 - Proceso de Descubrimiento de Grupos. [Britos & García-Martínez, 2009] ........................ 7

Figura 2. 3 - Proceso de Ponderación de Interdependencia de Atributos. [Britos & García-Martínez,

2009] ......................................................................................................................................................... 8

Figura 2. 4 - Proceso de Descubrimiento de Reglas de Pertenencia a Grupos. [Britos & García-

Martínez, 2009] ......................................................................................................................................... 9

Figura 2. 5 - Proceso de Ponderación de Reglas de Comportamiento o de Pertenencia a Grupos.

[Britos & García-Martínez, 2009] ........................................................................................................... 10

Figura 2. 6 - Algoritmo de entrenamiento para red SOM. [Mehrotra et al, 1997]. ................................ 13

Figura 2. 7 - Algoritmo EM. .................................................................................................................... 14

Figura 2. 8 - Algoritmo KMeans. ............................................................................................................ 15

Figura 2. 9 - Algoritmo Farthest First. [Hochbaum y Shmoys, 1985]. .................................................. 16

Figura 2. 10 - Algoritmo de Agrupamiento NNC. [Bubeck & Von Luxberg, 2009] ............................... 17

Figura 2. 11 - Pseudocódigo para la creación de árboles TDIDT. [López Nocera, 2012; Kogan Zahavi,

2007] ....................................................................................................................................................... 20

Figura 2. 12 - Pseudocódigo Algoritmo AQ15. [Afify, 2004] ................................................................ 22

Figura 2. 13 - Pseudocódigo Algoritmo CN2. [Clark y Niblett, 1989] ................................................... 23

Figura 2. 14 - Pseudocódigo para Crear un Árbol Parcial a Partir de un Conjunto de Ejemplos. [Frank

& Witten, 1998] ...................................................................................................................................... 25

Figura 2. 15 - Algoritmo Apiori. [Wu et al, 2007] .................................................................................. 26

Figura 2. 16 - Grafica que representa el estudio de dominios variando la cantidad de clases que los

rigen, para distinta cantidad de atributos que tienen los ejemplos. [Kogan Zahavi, 2007]................... 28

Figura 2. 17- Ejemplo de Diagrama de Kiviat. [Lopez Nocera, 2012, Figura 4.26 pp: 97] ................... 29

Figura 2. 18 - Ejemplo de cubrimiento ideal. ......................................................................................... 30

Figura 2. 19 - Ejemplo de cubrimiento donde las condiciones entre reglas son diferentes. [Kogan

Zahavi, 2007] .......................................................................................................................................... 30



vi

Figura 2. 20 - Ejemplos donde el mismo valor se repite varias veces. [Kogan Zahavi, 2007] ............... 31

Figura 4. 1 - Sección de carga de los parámetros del dominio………………………………………….38

Figura 4. 2 - Formato de Reglas Generadas. .......................................................................................... 39

Figura 4. 3 - Conjunto de Atributos y Valores Posibles.......................................................................... 39

Figura 4. 4 - Conjunto de Atributos y Valores Posibles Acotados para Reglas. .................................... 40

Figura 4. 5 - Generación de una regla. ................................................................................................... 41

Figura 4. 6 - Ejemplos Generados a Partir de una Regla....................................................................... 42

Figura 4. 7 - Contrastación de reglas iguales. ........................................................................................ 45

Figura 4. 8 - Contrastación de reglas más generales y específicas. ....................................................... 47

Figura 4. 9 - Dinámica completa del banco de pruebas. [Kogan Zahavi, 2007] .................................... 48

Figura 6. 1 - Resultados Obtenidos para las Combinaciones de KMeans a Través de Todas las

Complejidades…………………………………………………………………………………………..60

Figura 6. 2 - Resultados Obtenidos para las Combinaciones de EM a Través de Todas las

Complejidades ......................................................................................................................................... 61

Figura 6. 3 - Resultados Obtenidos para las Combinaciones de Farthest First a Través de Todas las

Complejidades ......................................................................................................................................... 61

Figura 6. 4 - Resultados Obtenidos para las Combinaciones de SOM a Través de Todas las

Complejidades ......................................................................................................................................... 62

Figura 6. 5 - Resultados Obtenidos para las Combinaciones de KNN a Través de Todas las

Complejidades ......................................................................................................................................... 62

Figura A. 1 – Diagrama de Casos de Uso con Alto nivel de abstracción....…………………………...72

Figura A. 2 – Diagrama de Casos de Uso Específico. ........................................................................... 73

Figura A. 3 – Diagrama de Secuencia Experiencia Simple. ................................................................... 74

Figura A. 4 – Diagrama de Secuencia Experiencia Completa. .............................................................. 75

Figura A. 5 – Diagrama de Clases. ........................................................................................................ 76

Figura B. 1 – Ventana Principal Herramienta………………………………………………………….82

Figura B. 2 – Ventana Generación de Dominio. ..................................................................................... 83



vii

Figura B. 3 – Ejemplo Contenido Archivo arff. ...................................................................................... 84

Figura B. 4 – Ventana Experiencia Simple. ............................................................................................ 85

Figura B. 5 – Resultados Experiencia Simple. ........................................................................................ 86

Figura B. 6 – Resultados Experiencia Simple II. .................................................................................... 86

Figura B. 7 – Ventana Experimentación Completa. ............................................................................... 87

Figura B. 8 – Ventana Experimentación Completa con Filtro de Complejidad. .................................... 88

Figura B. 9 – Ventana Experimentación Completa con Variación de Atributos. ................................... 89

Figura B. 10 – Resultados Ventana Experimentación Completa. ........................................................... 90

Figura B. 11 – Resultados Ventana Experimentación Completa II. ....................................................... 90

Figura B. 12 – Tabla Escenarios. ........................................................................................................... 91

Figura B. 13 – Tabla Resultados. ............................................................................................................ 91



viii



ix

ÍNDICE DE TABLAS

Tabla 5. 1 - Ejemplos Definición de Escenarios. .................................................................................... 51

Tabla 5. 2 - Matriz de Relación entre el Tipo de Complejidad y las Variables Independientes ............ 52

Tabla 5. 3 - Tabla de Valores .................................................................................................................. 52

Tabla 5. 4 - Matriz de Relación entre el Tipo de Complejidad y las Variables Independientes con el

Rango de Variación Definido ................................................................................................................. 53

Tabla 5. 5 - Resultados Promedios Complejidad Simple ........................................................................ 55

Tabla 5. 6 - Resultados Promedios Complejidad Media ........................................................................ 56

Tabla 5. 7 - Resultados Promedios Complejidad Oscilante ................................................................... 56

Tabla 5. 8 - Resultados Promedios Complejidad Compleja ................................................................... 57

Tabla 5. 9 - Resultados Promedios Complejidad Hipercompleja ........................................................... 57

Tabla 6. 1 - Resultados Promedios de Cada Combinación a Través de Todas las Complejidades........63



x



xi

GLOSARIO DE ACRÓNIMOS

Acrónimo Significado

Apriori Algoritmo de Inducción Apriori

AQ15 Algoritmo de Inducción AQ15

C4.5 Algoritmo de Inducción C4.5

CN2 Algoritmo de Inducción CN2

EM Algoritmo de Agrupamiento EM

FARTHEST FIRST Algoritmo de Agrupamiento FARTHEST FIRST

GNU-GPL GNU General Public License

ID3 Algoritmo de Inducción Induction of Decision Trees

J48 Implementación en Java del Algoritmo de Inducción C4.5

JAR Archivo de Java (Java Archive)

JDBC Conectividad a la Base de Datos de Java (Java Database Conectivity)

JDK Kit de Desarrollo de Java (Java Development Kit)

KMeans Algoritmo de Agrupamiento K-Medias

KNN Algoritmo de Clasificación de los K vecinos más Próximos (K-Nearest

Neighbour)

NNC Algoritmo de Agrupamiento del Vecino más Próximo (Nearest

Neighbour)

PART Algoritmo de Inducción PART

SOM Mapas Auto-Organizados de Kohonen (Self Organizing Maps)

SQL Lenguaje de Consulta Estructurado (Structured Query Language)

TDIDT Inducción de Arboles de Decisión (Top Down Induction of Decision

Trees)

WEKA Entorno Weikato para el Análisis de Conocimiento (Weikato Enviroment

for Knowledge Analysis)



xii

WWW Red de Informática Mundial (World Wide Web)

INTRODUCCION COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS


1

1. Introducción

En este capítulo se plantea el contexto de la tesis (Sección 1.1), se establece su objetivo (Sección 1.2), y

finalmente se resume la estructura de la tesis (Sección 1.3).

1.1. Contexto de la Tesis

Un procedimiento común en la minería de datos inteligente es tomar un conjunto de datos a estudiar,

aplicar un algoritmo de agrupamiento para separarlo en grupos y sobre cada uno de estos grupos aplicar

un algoritmo de inducción para obtener reglas que caractericen su conformación, lo que se conoce

como descubrimiento de reglas de pertenencia a grupos, una de las hipótesis con las que trabajan estos

algoritmos es que la complejidad del dominio sobre cuya información se trabaja, no incide sobre la

calidad de los patrones obtenidos. En [Lopez Nocera, 2012] se realizaron experimentos cuyos

resultados indican que la calidad de los patrones que se obtienen difiere en función de la complejidad

de los dominios a los cuales se aplica y de los algoritmos que se utilizan en el proceso, este trabajo

realizado por Lopez Nocera, estaba a su vez basado en [Kogan, 2007] donde se diseñó un experimento

para analizar el rendimiento del proceso de descubrimiento de conocimiento para un determinado par

de algoritmos.

El tema elegido para esta investigación está basado en los trabajos nombrados anteriormente y busca

profundizar en el tema, lo que implica tomar la caracterización de dominios propuesta por Lopez

Nocera y el modelo de experimentación propuesto por Kogan.

1.2. Objetivos de la Tesis

Se presentan aquí los objetivos del presente trabajo, que se clasifican en generales (Sección 1.2.1) y

específicos (Sección 1.2.2), a su vez se presenta la Metodología de Desarrollo (Sección 1.2.3).

1.2.1. Objetivos Generales

El objetivo de este trabajo es analizar cómo se comporta la integración de algoritmos de agrupamiento

e inducción al ser aplicados sobre distintos tipos de complejidades del dominio con el fin de obtener

reglas de pertenencia a grupos de calidad.



2

Para esto se busca evaluar la calidad de las reglas obtenidas sobre cada tipo de dominio y compararlas

entre sí para conocer cuál es la mejor combinación de algoritmos de agrupamiento e inducción en cada

tipo de dominio.

1.2.2. Objetivos Específicos

A continuación se detallan los objetivos específicos que se desprenden de los objetivos generales

presentados anteriormente.

1. Estudiar y comprender los conceptos de agrupamiento e inducción de reglas.

2. Investigar y estudiar los trabajos realizados en el área por otros autores.

3. Estudiar y refinar definiciones necesarias planteadas en trabajos anteriores, como el cubrimiento

de una regla original por una descubierta mediante inducción y el concepto de complejidad de

dominios.

4. Investigar y estudiar los distintos algoritmos de agrupamiento e inducción de reglas utilizados

en trabajos anteriores, e incrementar el estudio a través de la implementación de nuevos

algoritmos.

5. Diseñar e implementar una herramienta software donde llevar a cabo las experiencias.

6. Replicar las experiencias llevadas a cabo en trabajos anteriores mediante la realización de

experimentos que involucren los mismos algoritmos de agrupamiento e inducción aplicados

sobre los mismos tipos de complejidades del dominio definidos en ellos.

7. Extender el universo de estudio mediante la realización de nuevas experiencias utilizando nuevos

algoritmos de agrupamiento e inducción.

1.2.3. Metodología de Desarrollo

El presente trabajo se ha planificado en cuatro etapas bien definidas que se explican en las secciones

siguientes, Etapa I (Sección 1.2.3.1), Etapa 2 (Sección 1.2.3.2), Etapa 3 (Sección 1.2.3.3) y Etapa 4

(Sección 1.2.3.4)

1.2.3.1. Etapa I

Esta primera etapa se centra en la obtención de información de distintas fuentes, por ejemplo: internet,

libros, papers, y otras tesis con el objetivo de formar una base teórica sobre los distintos procesos de



3

explotación de información y los algoritmos de agrupamiento e inducción a utilizar, y de esta manera

conformar el estado del arte del presente trabajo.

1.2.3.2. Etapa 2

En esta etapa se lleva a cabo el diseño y desarrollo de la herramienta software utilizada para realizar los

experimentos de esta investigación, esta herramienta automatiza cada una de las etapas que conforman

un experimento y simplifica la configuración y ejecución de estos.

1.2.3.3. Etapa 3

En esta etapa se incluye el diseño de las experiencias de laboratorio y la realización de las mismas

mediante su carga y ejecución en la herramienta desarrollada especifica desarrollada en la etapa previa.

1.2.3.4. Etapa 4

En esta etapa se lleva a cabo el análisis de las experiencias realizadas mediante el procesamiento e

interpretación de los datos obtenidos a partir de los experimentos realizados, a su vez a partir de este

análisis se obtuvieron las conclusiones y se elaboró el informe final, incluyendo los aportes que se

derivaron del trabajo y las futuras líneas de investigación que surgen del mismo.

1.3. Visión General de la Tesis

La estructura de la tesis comienza con una introducción donde se plantea el contexto, se establecen los

objetivos generales y específicos, y se da una visión general de la misma.

En el capítulo Estado de la Cuestión (Capitulo 2) se describen las características de los algoritmos de

agrupamiento e inducción utilizados durante la fase experimental del presente trabajo, a su vez se

presentan distintas teoría y técnicas que son concurrentes con los objetivos de esta tesis, se presenta una

base teórica sobre los procesos de explotación de información, la complejidad del dominio y el proceso

de cubrimiento de reglas.

En el capítulo Descripción del Problema (Sección 3) se caracteriza el problema que da lugar a la

presente investigación y se proponen las preguntas de investigación a ser respondidas en la presente

tesis.



4

En el capítulo materiales y métodos (Sección 4) se define la herramienta utilizada para realizar las

experiencias, se nombran y definen sus funcionalidades y su funcionamiento interno.

En el capítulo Experimentación (Sección 5) se describe el diseño experimental, se definen las

características de las experiencias realizadas y las variables utilizadas, se describen las experiencias

realizadas y se muestran los resultados obtenidos a partir de la realización de las experiencias

El trabajo finaliza con el capítulo Conclusiones (Sección 6) donde se detallan las conclusiones

generales que se alcanzaron, incluyendo las respuestas a las preguntas de investigación formuladas en

el capítulo 3, y se enuncian las futuras líneas de investigación, posteriormente se detallan las

Referencias Bibliográficas (Sección 7) utilizadas y por último se incluyen los apéndices A

(Metodología) y B (Manual de Usuario) a la investigación.

ESTADO DE LA CUESTIÓN COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS


5

2. Estado de la Cuestión

En este capítulo se presenta el estado de la cuestión sobre distintas teorías y técnicas que son

concurrentes con los objetivos de esta tesis.

La Explotación de Información es una sub-disciplina de los Sistemas de Información, que brinda a la

Inteligencia de Negocio las herramientas para la trasformación de información en conocimiento

[García-Martínez et al, 2015] y se define como la búsqueda de patrones interesantes y de reglas

importantes, previamente desconocidas, en grandes cantidades de información almacenada en distintos

medios [Martins, 2013]. Un proceso de Explotación de Información consiste en un grupo de tareas

relacionadas que se realizan con el objetivo de obtener información útil y significativa a partir de

grandes cantidades de datos, para esto, estos procesos se valen de la utilización de algoritmos de

Minería de Datos (Data Mining) [García-Martínez et al, 2015; Martins, 2013], en este capítulo se

provee una introducción a los procesos de explotación de información (Sección 2.1) y luego se da una

descripción de los algoritmos de Minería de Datos que se utilizan en esta investigación, separándolos

en algoritmos de agrupamiento (Sección 2.2) y algoritmos de inducción (Sección 2.3), A continuación

de estos, se describe el concepto de complejidad del dominio (Sección 2.4) que sirve como base para la

experimentación realizada en este trabajo y por último se describe el cubrimiento de reglas (Sección

2.5) como técnica que se usa para determinar el resultado de cada experimento.

2.1. Procesos de Explotación de Información

Para los problemas de inteligencia de negocio, Britos & García-Martínez [2009] proponen cinco

procesos de explotación de información que se describen en las siguientes secciones: Descubrimiento

de reglas de comportamiento (Sección 2.1.1), descubrimiento de grupos (Sección 2.1.2),

descubrimiento de atributos significativos (Sección 2.1.3), descubrimientos de reglas de pertenencia a

grupos (Sección 2.1.4) y ponderación de reglas de comportamiento o de pertenencia a grupos (Sección

2.1.5).

2.1.1. Descubrimiento de Reglas de Comportamiento

El proceso de descubrimiento de reglas de comportamiento es aplicable cuando el objetivo es conocer

cuáles son las condiciones que determinan cierto resultado en el dominio del problema, para aplicar



6

este proceso, el primer paso es identificar todas las fuentes de información, e integrarlas en una sola a

la se llamara “datos integrados”, a partir de estos datos integrados el siguiente paso es identificar el

atributo clase de los mismos, por último se aplica un algoritmo de inducción al atributo clase

identificado para obtener las reglas que definen el comportamiento de dicha clase. Este proceso es útil

en situaciones donde por ejemplo, se desea identificar las características del local más visitado por los

clientes, o cuales son los rasgos de estos clientes [Britos & García-Martínez, 2009].

A continuación en la Figura 2.1 puede observarse el proceso de descubrimiento de reglas de

comportamiento completo.

Figura 2. 1 - Proceso de Descubrimiento de Reglas de Comportamiento. [Britos & García-Martínez, 2009]

2.1.2. Descubrimiento de Grupos

El proceso de descubrimiento de grupos se utiliza cuando se desea identificar una partición

determinada en la información disponible sobre un dominio del problema, para el descubrimiento de

grupos a partir de la información de un dominio cuando no se posee ningún criterio de agrupamiento se

propone la utilización de Mapas Auto Organizados de Kohonen (SOM) [Britos & García-Martínez,

2009], el uso de este algoritmo permite descubrir si el dominio del problema puede dividirse en grupos

que representen una partición significativa.

Los pasos del proceso de descubrimiento de grupos son los siguientes pueden observarse en la Figura

2.2, al igual que en el proceso de explotación de información descripto anteriormente, en primer lugar

se integran todas las fuentes de información identificadas en una sola llamada “datos integrados”, a

estos datos se aplica SOM con el objetivo de obtener distintos grupos (grupos identificados) que

representan una partición significativa, para cada grupo identificado se genera un archivo. Algunos



7

ejemplos de problemas donde se podría aplicar este proceso de explotación de información son: la

identificación de segmentos de clientes, la identificación de grupos sociales con características

similares o la identificación de grupos de estudiantes con características homogéneas.

Figura 2. 2 - Proceso de Descubrimiento de Grupos. [Britos & García-Martínez, 2009]

2.1.3. Ponderación de Interdependencia de Atributos

Este proceso se aplica con el objetivo de identificar cuáles son los factores de mayor incidencia o

frecuencia de ocurrencia sobre un determinado resultado del problema. Para ponderar en qué medida la

variación de los valores de cierto atributo afectan los valores de un atributo clase se propone utilizar

Redes Bayesianas [Britos & García-Martínez, 2009], el uso de Redes Bayesianas tiene como fin

determinar si existe una interdependencia entre los atributos que forman el dominio del problema.

El proceso de ponderación de interdependencia de atributos completo puede observarse en la Figura

2.3, para aplicar este proceso de explotación de información, el primer paso consiste en identificar y

luego integrar todas las fuentes de información en una sola llamada “datos integrados” a partir de los

cuales se procede a identificar el atributo clase de los mismos, el siguiente paso es aplicar el

aprendizaje estructural de las Redes Bayesianas al archivo con atributo clase identificado para obtener

el árbol de aprendizaje, al cual se le aplica el aprendizaje predictivo de las Redes bayesianas para

obtener el árbol de ponderación de interdependencias que tiene como raíz el atributo clase y como

nodos a los otros atributos junto con su incidencia sobre el atributo clase.



8

Figura 2. 3 - Proceso de Ponderación de Interdependencia de Atributos. [Britos & García-Martínez, 2009]

2.1.4. Descubrimiento de Reglas de Pertenencia a Pertenencia a Grupos

El proceso de descubrimiento de reglas de pertenencia a grupos aplica cuando se requiere identificar

cuáles son las condiciones de pertenencia de cada una de las clases en una partición desconocida “a

priori”, pero presente en la masa de información disponible sobre el dominio del problema. Para el

descubrimiento de reglas de pertenencia a grupos se propone la utilización de algoritmos de

agrupamiento para el hallazgo de los grupos existentes, y una vez identificados estos, la utilización de

algoritmos de inducción para establecer las reglas de pertenencia a cada uno [Britos & García-

Martínez, 2009]. En este trabajo se hace uso de este proceso de explotación de información.

El proceso de descubrimiento de reglas de pertenencia a grupos puede observarse en la Figura 2.4, en

ese caso se utiliza el algoritmo SOM para realizar el agrupamiento y algoritmos de la familia TDIDT

para la inducción de reglas.



9

El proceso es el mismo para cualesquiera sean los algoritmos de agrupamiento e inducción que se

deseen utilizar, por ejemplos, además de SOM se podría pensar en utilizar algoritmos como KMeans y

FARTHEST FIRST, y además de los algoritmos ID3 y C4.5 de la familia TDIDT se podrían aplicar

los algoritmos CN2, AQ15 o PART.

Figura 2. 4 - Proceso de Descubrimiento de Reglas de Pertenencia a Grupos. [Britos & García-Martínez, 2009]

2.1.5. Ponderación de Reglas de Comportamiento o de Pertenencia a Grupos

Este tipo de proceso de explotación de información puede aplicarse cuando se desea determinar cuáles

son las condiciones que inciden en mayor medida sobre la obtención de un determinado resultado en el

dominio del problema ya sean que inciden sobre un determinado comportamiento o las que mejor

definen la pertenencia a un grupo.

El procedimiento para la ponderación de reglas de comportamiento o de pertenencia a grupos, cambia

dependiendo si hay clases/grupos identificados o no:

Cuando hay clases/grupos identificados el procedimiento es el siguiente, al igual que en el resto

de los procesos de información, se toman todas las fuentes de información y se unen, formando

una sola fuente de datos llamada “datos integrados”, en estos datos se utilizan algoritmos de



10

inducción para descubrir las reglas de comportamiento de cada atributo clase y luego se utilizan

redes bayesianas para establecer cuál de los atributos definidos como antecedentes de las reglas

tiene mayor incidencia sobre el atributo definido como consecuente.

Figura 2. 5 - Proceso de Ponderación de Reglas de Comportamiento o de Pertenencia a Grupos.

[Britos & García-Martínez, 2009]



11

Cuando no existen clases/grupos identificados, se aplica sobre los datos integrados mapas auto

organizados (SOM), el resultado de esto son particiones del conjunto de datos que se llamaran

grupos identificados, para cada uno de estos se generara un archivo, y este conjunto de archivos

recibirá el nombre de grupos ordenados, el atributo “grupo” de cada grupo ordenado se

identifica como el atributo clase de dicho grupo, constituyéndose este en un archivo con

atributo clase identificado, el siguiente paso es aplicar redes bayesianas, por lo tanto se aplica el

aprendizaje estructural para obtener el árbol de aprendizaje, y a este se le aplica el aprendizaje

predictivo para obtener el árbol de ponderación de interdependencias, que tendrá como raíz al

atributo grupo y como nodos hojas a los otros atributos con su incidencia sobre el atributo

grupo.

En la Figura 2.5 pueden observarse los pasos completos para las dos posibilidades descriptas.

2.2. Algoritmos de Agrupamiento

En esta sección se hace primero una introducción teórica a los algoritmos de agrupamiento (Sección

2.2.1) y luego se procede a describir cada uno de los algoritmos de agrupamiento utilizados en la

investigación, SOM (Sección 2.2.2), EM (Sección 2.2.3), Kmeans (Sección 2.2.4), Farthest First

(Sección 2.2.5) y CNN (Sección 2.2.6).

2.2.1. Introducción a los Algoritmos de Agrupamiento

El proceso de agrupar objetos físicos o abstractos en clases de objetos similares es llamado

agrupamiento o clasificación no supervisada, esta técnica ayuda a construir particiones significativas de

un conjunto grande de objetos utilizando distintos métodos para descomponer un sistema a gran escala

en componentes más pequeños para simplificar diseño e implementación [Chen et al., 1996].

Como una tarea de minería de datos, el agrupamiento de datos, es el proceso de agrupar datos similares

en colecciones o “clusters”, la similitud entre los datos puede medirse mediante funciones de distancia

especificadas por usuarios o expertos. El objetivo es encontrar clusters de alta calidad que sean

escalables a grandes bases de datos y a data warehouses multidimensionales [Paola Britos et al., 2005;

Chen et al., 1996].



12

2.2.2. Algoritmo SOM

Los Modelos SOM (Self-Organizing Maps) son mapas de redes neuronales artificiales propuestas por

Kohonen [1982].

El algoritmo de aprendizaje del SOM está basado en el aprendizaje no supervisado y competitivo, lo

cual quiere decir que no se necesita intervención humana durante el mismo y que se necesita saber muy

poco sobre las características de la información de entrada, podríamos utilizar SOM para clasificar

datos sin saber a qué clase pertenecen los mismos.

El mismo provee un mapa topológico de datos que se representan en varias dimensiones utilizando

unidades de mapa (las neuronas) simplificando el problema, la neurona tiene las mismas dimensiones

que los vectores de entrada (datos de entrada), es decir que es n-dimensional. Las neuronas están

conectadas a las neuronas adyacentes por una relación de vecinos. Esta dicta la topología, o la

estructura, del mapa; usualmente, las neuronas están conectadas unas con otras en una topología

hexagonal o rectangular [López Nocera, 2012; Kogan Zahavi, 2007].

En el algoritmo básico del SOM, las relaciones topológicas y el número de neuronas son fijos desde el

comienzo, este número de neuronas determina la escala o granularidad del modelo resultante, la

selección de la granularidad afecta la certeza y la capacidad de generalizar del modelo, debe tenerse en

cuenta que la granularidad y la generalización son objetivos contradictorios, mejorando el primero se

pierde el segundo y viceversa, esto se debe a que si aumentamos el primero se obtendrán muchos más

grupos para poder clasificar los datos de entrada, evitando que se pueda generalizar el espacio en clases

más abarcativas, de manera inversa, si se generaliza demasiado se puede perder información que

caracterice a un grupo específico que quede incluido en otro por la falta de granularidad[López Nocera,

2012; Kogan Zahavi, 2007].

Los datos que alimentan al SOM incluyen toda la información que toma la red, por lo tanto es

importante realizar un pre procesamiento de los mismos, ya que si se presenta información errónea, el

resultado final será erróneo o de mala calidad, SOM debe eliminar el ruido y los errores en los datos,

por lo cual se debe trabajar con un subconjunto de los datos y estos deben ser relevantes para el modelo

a analizar, comúnmente los componentes de los datos de entrada se normalizan para tener una escala de

0 a 1, esto asegura que por cada componente, la diferencia entre dos muestras contribuye con un valor



13

igual a la distancia medida calculada entre una muestra de entrada y un patrón dados[López Nocera,

2012; Kogan Zahavi, 2007].

SOM debe pasar por un proceso de entrenamiento, este es un proceso iterativo a través del tiempo que

requiere un esfuerzo computacional importante, consta de muestras del conjunto de datos de entrada

que van ingresando a la red para que la misma los aprenda, el aprendizaje propiamente dicho, consiste

en elegir una neurona ganadora por medio de una medida de similitud y actualizar, en consecuencia los

valores de los patrones en el vecindario de la misma, este proceso se repite varias veces en forma

iterativa para poder ir refinando (y acotando) el error y acercar como ya se dijo las neuronas a una

representación más adecuada de los datos de entrada. El último paso es la validación del modelo, la

validación significa que el modelo debe ser probado para asegurar que devuelve valores razonables y

certeros [López Nocera, 2012; Kogan Zahavi, 2007]. La Figura 2.6 muestra el algoritmo de

entrenamiento para la red SOM de Kohonen.

Figura 2. 6 - Algoritmo de entrenamiento para red SOM. [Mehrotra et al, 1997].

2.2.3. Algoritmo EM

El algoritmo Expectation-Maximization (EM), es un importante algoritmo de minería de datos, el cual

encuentra estimaciones de máxima probabilidad para los parámetros, en problemas donde algunas

variables son desconocidas, casos espaciales del algoritmo datan de varias décadas atrás y su uso ha



14

crecido mucho desde que su extensa aplicabilidad y generalidad fue discutida por Dempster, Laird y

Rubin en 1977 [Dempster et al, 1977; Neal & Hinton, 1998; Sharma et al, 2012].

En cada iteración del algoritmo EM hay dos pasos, llamados el paso expectación (Expectation step o E-

step) y el paso de maximización (Maximization Step o M-step), en el paso expectación, se computa la

expectación de la probabilidad logarítmica evaluada usando el estimado actual para los parámetros y en

el paso de maximización se computan los parámetros maximizando la probabilidad logarítmica

esperada encontrada en el paso anterior. Cada iteración mejora la verdadera probabilidad o la deja sin

alterar si es que el máximo local ya fue alcanzado [McLachlan & Krishnan, 2008; Neal & Hinton,

1998; Sharma et al, 2012]. La figura 2.7 ilustra el algoritmo EM con los pasos de expectación y

maximización.

Figura 2. 7 - Algoritmo EM.

2.2.4. Algoritmo KMeans

El algoritmo KMeans (K Medias) es un método simple e iterativo para particionar un conjunto de

datos en un numero k de clusters definidos por el usuario [Wu et al, 2007], este algoritmo es uno de los

más utilizados para hacer clustering.

En primer lugar se debe especificar por adelantado cuantos clusters se van a crear. Este es el parámetro

k, para lo cual se seleccionan k elementos aleatoriamente, que representan el centro o media de cada

cluster, a continuación cada una de las instancias (ejemplos), es asignada al centro del cluster más

cercano de acuerdo con la distancia euclidiana que le separa de él. Para cada uno de los clusters así

construidos se calcula el centroide de todas sus instancias. Estos centroides son tomados como los



15

nuevos centros de sus respectivos clusters. Finalmente se repite el proceso completo con los nuevos

centros de los clusters. La iteración continúa hasta que se repite la asignación de los mismos ejemplos a

los mismos clusters, ya que los puntos centrales de los clusters se han estabilizado y permanecerán

invariables después de cada iteración. El algoritmo KMeans como se describió anteriormente, puede

verse en la figura 2.8.

Para obtener los centroides iniciales se pueden usar distintas técnicas las cuales incluyen, calcular la

media o moda según se trate de atributos numéricos o simbólicos, obtener una muestra aleatoria del

conjunto de datos, o establecerlos como la solución del agrupamiento de un subconjunto de los dato,

entre otras. [Wu et al, 2007].

Figura 2. 8 - Algoritmo KMeans.

2.2.5. Algoritmo Farthest First

El algoritmo Farthest First (Primero el más Lejano) propuesto por Hochbaum y Shmoys [1985] es una

variante de KMeans y utiliza el mismo procedimiento [Vadeyar & Yogish, 2014], con la diferencia



16

que Farthest First establece cada centro de cluster en el punto más alejado de los centros de clusters

existentes, este punto debe estar dentro del área de datos. Los puntos que están más lejos son agrupados

primero, esta característica del algoritmo aumenta la velocidad del proceso de agrupamiento en muchas

situaciones ya que menos reajuste y reasignación es necesario [Sehagl & Garg, 2014; Revathl & Nalini,

2013], el algoritmo Farthest First puede esquematizarse como se muestra en la figura 2.9.

Figura 2. 9 - Algoritmo Farthest First. [Hochbaum y Shmoys, 1985].

2.2.6. Algoritmo NNC o KNN

El algoritmo KNN (K-Nearest Neighbour) es una variación del algoritmo del vecino más próximo

NNC (Nearest Neighbour Cluster), la idea detrás de estos algoritmos es la siguiente, si se cuantifica la

similitud entre el ejemplo a clasificar y cada uno de los ejemplos de entrenamiento, la mayor de esas

similitudes medidas es la que estará indicando a que clase o categoría se debe asignar el ejemplo a

clasificar. Desde un punto de vista más práctico, el algoritmo del vecino más próximo puede aplicarse

con cualquier programa de recuperación de tipo best match [Figuerola et al, 2004; López Nocera,

2012].

NNC se basa entonces en localizar el ejemplo más similar o parecido al que se desea clasificar, para

esto no hay más que utilizar ese ejemplo como si fuera una consulta sobre la colección de

entrenamiento, una vez localizado el ejemplo de entrenamiento más similar, se sabe a qué categoría

pertenece y por ende a que categoría se debe asignar el ejemplo a clasificar. Su variante KNN en

cambio, consiste en tomar los k ejemplos más parecidos, en lugar de solo el primero, como en esos k

ejemplos los habrá, presumiblemente de varias categorías, se suman los coeficientes de cada uno de los

ejemplos de cada una de ellas, la que más puntos acumule será la candidata idónea [Figuerola et al,

2004; López Nocera, 2012].



17

Figura 2. 10 - Algoritmo de Agrupamiento NNC. [Bubeck & Von Luxberg, 2009]

La Figura 2.10 provee un resumen de alto nivel del algoritmo de Agrupamiento NNC, dada una

muestra finita X1,…,Xn ∈ Rd, el numero K de clusters a construir y un número m tal que K ≤ m ≪ n, de

manera aleatoria se selecciona un subconjunto de m “puntos semilla” Xs1,…, Xsm, y se asignan todos los

otros puntos de datos a su “punto semilla” más cercano, para cada punto semilla j = 1,…,m se define un

conjunto Zj como el subconjunto de puntos de datos cuyo punto semilla más cercano es Xsj, en otras

palabras los conjuntos Z1,…,Zm son las celdas Voronoi inducidas por las semillas Xs1,…, Xsm, todas las

particiones de Xn que son constantes en todos los conjuntos Z1,…,Zm definen las funciones f a partir de

las cuales se define el conjunto Fn de todas las funciones, el último paso consiste en evaluar la función

de calidad Qn (f) para cada f perteneciente al conjunto Fn y seleccionar la solución [Bubeck & Von

Luxberg, 2009].

2.3. Algoritmos de Inducción

En esta sección se hace primero una introducción teórica a los algoritmos de inducción (Sección 2.3.1)

y luego se procede a describir cada uno de los algoritmos de agrupamiento utilizados en la

investigación, comenzando con una descripción de los algoritmos de la familia TDIDT (Sección 2.3.2),

los algoritmos ID3 (Sección 2.3.2.1) y J48 (Sección 2.3.2.2), y se continua con el resto de los



18

algoritmos de inducción utilizados, AQ15 (Sección 2.3.3), CN2 (Sección 2.3.4), PART (Sección 2.3.5)

y A Priori (Sección 2.3.6).

2.3.1. Introducción a los Algoritmos de Inducción

La inducción de reglas es una de las técnicas más usadas para extraer conocimientos a partir de datos

ya que la representación de conocimiento mediante reglas si/entonces (if/then) es muy intuitiva y puede

ser fácilmente entendible por los expertos del problema o dominio [Pappa & Freitas, 2004].

Los algoritmos de inducción de reglas, como la mayoría de los descubridores de conceptos, fueron

diseñados para adquirir conceptos generales de un set de ejemplos de entrenamiento, en el contexto de

la tarea de clasificación, cada ejemplo de entrenamiento es representado por un conjunto de atributos

predictores y un atributo objetivo (o clase), el algoritmo trata de encontrar relaciones entre los atributos

predictores y el atributo objetivo, en el caso de los algoritmos de inducción de reglas, el modelo de

clasificación es representado por un conjunto de reglas, una regla tiene el formato SI condición1 Y

condición2 ENTONCES consecuencia, donde las condiciones en el antecedente son descritas por

asociaciones entre los atributos y sus valores y la consecuencia representa el valor previsto para el

atributo objetivo [Pappa & Freitas, 2004].

Investigación sobre los algoritmos de inducción de reglas se ha llevado a cabo por más de 30 años,

durante este tiempo muchos algoritmos de inducción han sido desarrollados, la mayoría de ellos sigue

una de las tres estrategias más comunes para inducir reglas a partir de datos. La primer estrategia

consiste en la generación de un árbol de decisión, usando la estrategia de dividir y conquistar (divide

and conquer), y luego extraer una regla por cada hoja en el árbol, esta estrategia es usada por ejemplo

por el algoritmo C4.5, la segunda estrategia es separar y conquistar (separete y conquer) también

conocida como cubrimiento secuencial, que consiste en aprender una regla a partir de un conjunto de

datos, remover del conjunto los ejemplos que son cubiertos por la regla y recursivamente aprender otra

regla que cubra los ejemplos restantes, hasta que todos o casi todos los ejemplos son cubiertos, esta

estrategia es utiliza en algoritmos como AQ15 y CN2, la tercer estrategia es utilizar algoritmos

evolutivos como algoritmos genéticos y programación genética para extraer reglas a partir de los datos

[Pappa & Freitas, 2004; Pappa & Freitas, 2006].



19

2.3.2. Algoritmos de 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 arboles de decisión, los arboles TDIDT, a

los cuales pertenecen los generados por los algoritmos ID3 y C4.5, se construyeron a partir del método

de Hunt que incluye calcular la ganancia de información, la poda de árboles generados y la aplicación

del principio de longitud de descripción mínima. [Quinlan, 1986; López Nocera, 2012; Kogan Zahavi,

2007]

La estructura de este método para construir un árbol de decisión a partir de un conjunto de datos de

entrenamiento se detalla a continuación. Con varias clases, existen tres posibilidades:

a) En la primera posibilidad, el conjunto contiene uno o más casos, todos pertenecientes a una

única clase. En este caso, el árbol de decisión para el conjunto es una hoja identificando la

clase.

b) Si el conjunto de datos 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 pertenezca al conjunto.

c) La última posibilidad es que el conjunto contenga casos pertenecientes a varias clases, la idea

consiste en refinarlo 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 sobre una única

variable, que tiene uno o más resultados, mutuamente excluyentes, y el conjunto se particiona

en subconjuntos donde cada uno contiene todos los casos del conjunto que tienen un resultado

dado para la prueba elegida. El árbol de decisión para el conjunto 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 a cada subconjunto de datos de entrenamiento, para que la i-

esima rama lleve al árbol de decisión construido por el subconjunto de datos de entrenamiento

correspondiente a ella.

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

prueba sobre las distintas variables y se realiza una partición según la mejor variable. Para encontrar

esta mejor variable, se utiliza la teoría de la información, que sostiene que la información se maximiza



20

cuando la entropía se minimiza, la entropía determina la condición de azarosidad o desestructuración

de un conjunto [López Nocera, 2012; Kogan Zahavi, 2007]. La figura 2.11 muestra el pseudocódigo

para la creación de árboles TDIDT, ya sea para el algoritmo ID3 o C4.5.

Figura 2. 11 - Pseudocódigo para la creación de árboles TDIDT. [López Nocera, 2012; Kogan Zahavi, 2007]

Es común realizar la poda de los arboles generados, debido principalmente a razones como la sobre

generalización, la evaluación de variables poco importantes o significativas y el gran tamaño del árbol

obtenido, existen dos enfoques para podar árboles, la pre-poda (pre-pruning) y la post-poda (post-

pruning), 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, mientras que en la post-poda se

podan algunas ramas del árbol una vez que este se terminó de construir [López Nocera, 2012; Kogan

Zahavi, 2007].

2.3.2.1. Algoritmo ID3

El algoritmos ID3 (Induction Decision Trees) fue desarrollado en los años ochenta por Quinlan, es un

sistema de aprendizaje supervisado que construye arboles 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



21

cada atributo de estas tuplas está limitado a un conjunto de valores [Servente, 2002], los dominios de

los atributos y de las clases deben ser discretos.

El objetivo de ID3 es crear una descripción eficiente de un conjunto de datos mediante la utilización de

una árbol de decisión, dados datos consistentes, 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

[López Nocera, 2012; Kogan Zahavi, 2007].

2.3.2.2. Algoritmo J48

El algoritmo J48 es la implementación en lenguaje JAVA del algoritmo C4.5 propuesto por Quinlan

[1993], es una extensión del ID3 que permite trabajar con valores continuos para los atributos, 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 [Servente, 2002].

2.3.3. Algoritmo AQ15

El Algoritmo AQ15 fue desarrollado por Michalski et al [1986], es un sistema de aprendizaje inductivo

que genera reglas de decisión, donde el antecedente es una forma lógica, tiene como característica 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 algoritmo ID3,

AQ15 está diseñado para la generación de reglas fuertes, para cada clase se construye una regla que

cubre todos los ejemplos positivos y ningún ejemplo negativo, se soluciona el problema de las 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 [Servente, 2002].



22

La figura 2.12 muestra el pseudocódigo para el algoritmo AQ15, las reglas de decisión de AQ15 estan

representadas como expresiones en el sistema de lógica de valores variables (Variable-Valued Logic

System), un selector relaciona un atributo a un valor o a una disyunción de valores usando un operador

relacional, un selector o una conjunción de selectores forma un Complejo (complex), un cubrimiento

(cover) es una disyunción de complejos describiendo todas las instancias positivas y ninguna instancia

negativa de un concepto, el cubrimiento define la parte condicional de una regla de decisión [Afify,

2004].

Figura 2. 12 - Pseudocódigo Algoritmo AQ15. [Afify, 2004]

2.3.4. Algoritmo CN2

El algoritmo CN2 fue desarrollado por Clark y Niblett [1989], es una adaptación del AQ15, el objetivo

del CN2 es incorporar el manejo de datos ruidosos al algoritmo ya que AQ15 elimina los ruidos



23

mediante pre y post procesamiento y ni durante la ejecución del algoritmo, CN2 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 comprensivas 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 inferibles a partir de los ejemplos [Servente, 2002]. La

figura 2.13 muestra el pseudocódigo del algoritmo CN2, al ser una adaptación de AQ15 tiene muchas

cosas en común con este, como por ejemplo el uso de complejos (complex) y el uso del método STAR

para aprendizaje inductivo.

Figura 2. 13 - Pseudocódigo Algoritmo CN2. [Clark y Niblett, 1989]



24

2.3.5. Algoritmo PART

El algoritmo PART fue propuesto por Frank y Witten [1998], se caracteriza por combinar dos grandes

paradigmas para la creación de reglas, la creación de reglas a partir de árboles de decisión y la

utilización de la técnica de aprendizaje de reglas “separar-y-conquistar”, y por no utilizar una técnica

de optimización global para descartar o ajustar reglas individuales para que trabajen mejor juntas.

PART está basado en los algoritmos C4.5 y RIPPER y combina dos de los enfoques más utilizados

para la generación de reglas, los arboles de decisión utilizados por el algoritmo C4.5 y el enfoque

“separar-y-conquistar” utilizado por RIPPER. C4.5 comienza generando un árbol de decisión que

luego transforma en un conjunto de reglas, y termina realizando una simplificación sobre estas reglas

para hacerlas más precisas, RIPPER primero determina cual es la reglas más poderosa del conjunto de

datos y separa los ejemplos que son cubiertos por ella, luego repite el proceso sobre los ejemplos

restantes, ambos algoritmos realizan un proceso de optimización global sobre el conjunto de reglas

inducido inicialmente, en el caso de C4.5 debido a que el conjunto de reglas inicial obtenido a partir de

un árbol de decisión es excesivamente grande y redundante y en el caso de RIPPER para incrementar

la precisión del conjunto de reglas revisando o reemplazando reglas individuales. Por otro lado PART

busca la combinación de los dos enfoques para evitar sus respectivos problemas, no necesita realizar

una optimización global sobre el conjunto de reglas obtenido inicialmente y esta simplificación

representa una de sus mayores ventajas. PART adopta la estrategia “separar-y-conquistar” en la

manera que crea una regla, remueve las instancias que cubre y continua creando reglas recursivamente

para las instancias restantes, pero difiere de este enfoque en la manera en la que las reglas son creadas,

en esencia para hacer una única regla un árbol de decisión podado es construido para el conjunto de

instancias actuales y la hoja con el mayor cubrimiento es transformada en una regla, luego el árbol es

descartado, realizando estos pasos recursivamente [Frank & Witten, 1998].

La idea principal detrás de PART es construir arboles de decisión “parciales” en lugar de árboles

enteros y completamente explorados, un árbol de decisión parcial es un árbol de decisión ordinario que

contiene ramas a subárboles indefinidos, para generarlo se integran las operaciones de construcción y

podado para poder encontrar un subárbol “estable” que ya no pueda ser simplificado, una vez que este

subárbol es encontrado se para la construcción del árbol y se lee una sola regla [Frank & Witten, 1998]

en la figura 2.14 se muestra el pseudocódigo para crear un árbol de decisión parcial a partir de un

conjunto de ejemplos.



25

Figura 2. 14 - Pseudocódigo para Crear un Árbol Parcial a Partir de un Conjunto de Ejemplos. [Frank & Witten, 1998]

2.3.6. Algoritmo Apriori

Uno de los enfoques de minería de datos más populares es encontrar conjuntos de elementos frecuentes

en un conjunto de datos de transacciones y luego derivar reglas de asociación, encontrar estos

conjuntos de elementos frecuentes, es decir, conjuntos de elementos con una frecuencia igual o mayor

al soporte mínimo especificado por el usuario no es una tarea trivial debido a su explosión

combinacional, una vez que los conjunto de elementos frecuentes son encontrados, es bastante sencillo

generar reglas de asociación con una confianza igual o mayor a la confianza mínima especificada por el

usuario [Wu et al, 2007].

Apriori, propuesto por Agrawal y Srikant [1994], es un algoritmo para encontrar conjuntos de

elementos frecuentes usando generación de candidatos, está caracterizado como un algoritmo de

búsqueda completa de nivel utilizando anti monotonicidad de los conjuntos de elementos, “si un

conjunto de elementos no es frecuente, ninguno de sus superconjuntos es frecuente”. Por convención A

priori asume que los elementos dentro de una transacción o conjunto de elementos están ordenados en

orden lexicográfico.

La figura 2.15 muestra el algoritmo A priori, Si el set de conjuntos de elementos frecuentes de tamaño

k se denota como Fk y sus candidatos como Ck, Apriori primero escanea la base de datos y busca los

conjuntos de elementos frecuentes con tamaño 1 acumulando la cuenta para cada elemento y

recolectando aquellos que satisfacen el requerimiento mínimo, luego itera en los siguientes tres pasos y

extrae los conjuntos de elementos frecuentes [Wu et al, 2007].



26

a) Genera Ck+1, candidatos de conjuntos de elementos frecuentes de tamaño k + 1, de los conjuntos

de elementos frecuentes de tamaño k.

b) Recorre la base de datos y calcula el soporte de cada candidato.

c) Agrega aquellos conjuntos de elementos que satisfagan el soporte mínimo requerido para Fk+1.

Figura 2. 15 - Algoritmo Apiori. [Wu et al, 2007]

A priori consigue un buen rendimiento al reducir el tamaño de los conjuntos de candidatos mediante la

implementación de un proceso de podado de los candidatos iniciales obtenidos durante el primer paso,

pero en situaciones donde los conjuntos de elementos sean demasiado frecuentes, los conjuntos de

elementos sean excesivamente grandes o el soporte mínimo establecido sea muy bajo, sufre por el costo

de generar un gran número de conjuntos de candidatos. [Wu et al, 2007].

2.4. Complejidad del Dominio

En minería de datos se parte del supuesto de que los dominios a los cuales se aplican los algoritmos

son equivalentes o indistinguibles entre sí a efectos experimentales, en su investigación Lopez Nocera

[2012] refuta esta hipótesis para el caso del proceso de explotación de información de reglas de

pertenecía a grupos y propone una caracterización de los dominios posibles en función de los

parámetros que los rigen.

De acuerdo a Lopez Nocera [2012], la complejidad de un dominio viene dada por las variables que

intervienen en el, en su caso: la cantidad de clases, la cantidad de reglas que definen la pertenencia a



27

cada clase, la cantidad de atributos que puede tener cada regla, la cantidad de valores distintos que

puede tener cada atributo y el porcentaje de reglas correctamente cubiertas. A partir de la observación

del comportamiento de estas variables por Lopez Nocera mediante el análisis de los gráficos obtenidos

por Kogan [2007] en sus experimentos sobre la integración de algoritmos de agrupamiento e inducción,

define la siguiente clasificación de dominios basada en su complejidad: complejidad simple,

complejidad mediana, complejidad oscilante, complejidad compleja y complejidad hipercompleja.

El procedimiento de análisis de gráficos utilizado por Lopez Nocera es el siguiente, por cada uno de los

18 gráficos obtenidos por Kogan Zahavi [2007], se estudia como varía la cantidad de reglas

descubiertas correctamente en relación a los valores que tomen las dos parámetros que se analicen en el

gráfico, y se representa esta relación mediante una esquematización del tipo “(↑, =, ↓)”, lo que permite

agrupar los gráficos en distintas categorías en función de la complejidad del dominio subyacente, por

ejemplo, la Figura 2.16 es una reproducción de un gráfico extraído del Capítulo 5, Sección 6 de Kogan

Zahavi [2007] y que se estudia en Lopez Nocera [2012] Capitulo 4, Sección 4.2, de la siguiente

manera, cuando aumenta el valor del parámetro Class Possible Values es decir cantidad de clases “(↑)”

en el eje X, y se mantiene fijo el parámetro attributes number es decir cantidad de atributos “(=)”

eligiendo solo una de las curvas de nivel del gráfico, se observa que disminuye el porcentaje de reglas

descubiertas correctamente “(↓)” a medida que aumenta el valor del eje X, obteniéndose así la primer

esquematización, (↑, =,↓) que se lee como “cuando aumenta el parámetro (↑) y se mantiene fijo el valor

de las series (=), el porcentaje de reglas correctamente cubiertas disminuye (↓).

Otros posibles análisis del grafico son tomar como constante el parámetro class possible values (=) por

ejemplo con el valor numérico 2 y decir que a medida que aumenta el valor del parámetro attributes

number (↑), disminuye el porcentaje de reglas descubiertas correctamente (↓), representándose de la

siguiente manera: (=, ↑, ↓), o ver la situación al revés diciendo que tomando como constante el

parámetro class possible values (=) y disminuyendo el valor del parámetro attributes number (↓),

aumenta el porcentaje de reglas descubiertas correctamente (↑). Representándose como (=, ↓, ↑).

Las representaciones obtenidas: (↑, =, ↓); (=, ↑, ↓); (=, ↓, ↑), representan el comportamiento del gráfico.

Lopez Nocera continúa el procedimiento analizando el resto de los gráficos y agrupando los que se

comporten de la misma manera, formando así grupos que describan el tipo de complejidad.



28

Figura 2. 16 - Grafica que representa el estudio de dominios variando la cantidad de clases que los rigen, para distinta

cantidad de atributos que tienen los ejemplos. [Kogan Zahavi, 2007]

Lopez Nocera define cuatro grupos: A, B, C, y D a partir del análisis de los gráficos y en base a estos

grupos se definen cuatro tipos de complejidad del dominio (uno para cada grupo) más un tipo de

complejidad que puede estar incluido en cualquiera de los grupos:

Complejidad Simple: cuando el aumento de la cantidad de ejemplos por regla mejora el

cubrimiento de reglas, independientemente de los parámetros que se utilicen.

Complejidad Mediana: cuando se tienen pocos atributos y pocas clases o pocas clases y pocas

reglas por clase.

Complejidad Oscilante: son dominios en los que intervienen como parámetros características

asociadas a los ejemplos (cantidad de atributos por ejemplo, cantidad de ejemplos por regla,

etc.) y provocan un comportamiento ambiguo, dispar y poco predecible.

Complejidad Compleja: son los dominios cuyos ejemplos poseen pocos atributos y muchos

valores posibles por atributo o inversamente, con muchos atributos y pocos valores posibles por

atributo.



29

Complejidad Hipercompleja: cuando los dominios tengan como parámetro la cantidad de

valores que puede tomar un atributo, el número de atributos, la cantidad de reglas por clase o la

cantidad de clases y se observe una gran fluctuación en los valores de estos parámetros,

generando oscilaciones importantes en las curvas que se grafiquen.

Una vez obtenidos sus resultados experimentales, Lopez Nocera utiliza los llamados diagramas de

Kiviat para la visualización y estudio de los resultados obtenidos para cada par de algoritmos de

agrupamiento e inducción utilizados, estos diagramas permiten visualizar las relaciones entre datos

afectados por múltiples variables. En la Figura 2.17 puede observarse un ejemplo de diagrama de Kviat

extraído del trabajo de Lopez Nocera, en el cada una de las 27 variables representan los distintos

escenarios que se utilizaron para las pruebas, cada escenario contiene una variación en los valores de

sus parámetros, y pertenece a uno de los tipos de dominios definidos anteriormente, los números del 0

al 100 en el interior de la figura representan los valores que toma la variable de interés del estudio, es

decir, el porcentaje de reglas correctamente cubiertas, de esta manera resulta fácil determinar cuáles

escenarios presentaron mejores y peores resultados.

Figura 2. 17- Ejemplo de Diagrama de Kiviat. [Lopez Nocera, 2012, Figura 4.26 pp: 97]



30

2.5. Cubrimiento de Reglas

En Kogan Zahavi [2007] se define el siguiente criterio de cubrimiento de una regla de pertenencia a

grupo sobre otra, “comparando cada uno de los atributos de las reglas entre sí, se debe cumplir para

todos los atributos que, si la regla a cubrir impone condiciones y la regla que cubre también lo hace, las

condiciones deben ser las mismas.”

En la Figura 2.18 se muestra un ejemplo de cubrimiento ideal, de acuerdo al criterio expuesto

anteriormente, se cuenta con seis atributos y sobre dos de estos se imponen condiciones, los atributos

sobre los que se imponen condiciones y sus respectivos valores son los mismos tanto para la regla que

cubre como para la regla a cubrir.

Figura 2. 18 - Ejemplo de cubrimiento ideal.

Además de lo expuesto anteriormente, se debe tener en cuenta la siguiente situación, en la figura 2.19

se muestra un ejemplo de cubrimiento donde las condiciones impuestas sobre la regla a cubrir no son

exactamente las mismas que las observadas en la regla que cubre, la regla que cubre no impone

condiciones sobre el 2° atributo, mientras que la regla a cubrir si lo hace, esto no es problema ya que se

dice que la regla a cubrir es “más específica” que la regla que cubre y se toma como cubierta, a pesar

de que la regla que cubre este imponiendo condiciones sobre el 6° atributo y la regla a cubrir no.

Figura 2. 19 - Ejemplo de cubrimiento donde las condiciones entre reglas son diferentes. [Kogan Zahavi, 2007]



31

El motivo por el cual se realiza esta concesión es que, de acuerdo a lo observado de forma experimental

por Kogan Zahavi [2007], la determinación al azar de los valores de los atributos libres puede arrojar

ejemplos en los cuales se repite varias veces el mismo valor, lo que puede provocar que el algoritmo de

inducción utilizado genere una regla que tenga como condición que un atributo tome esos valores

repetidos como se muestra en la figura 2.20.

Figura 2. 20 - Ejemplos donde el mismo valor se repite varias veces. [Kogan Zahavi, 2007]

La regla descubierta no impone condiciones sobre el 2° atributo porque quizás haciéndolo sobre el 4°

ya logro determinar un grupo de ejemplos. Sin embargo, la coincidencia de que el 6° atributo de los

ejemplos haya tomado el mismo valor para todos ellos, bien pudo haber provocado que la regla

descubierta imponga condiciones sobre este atributo ya que no hay manera de controlar dicha

coincidencia y diferenciarla de un patrón intencionado. De no realizarse esta concesión sobre el

cubrimiento de reglas el análisis de la cantidad de reglas cubiertas correctamente, no sería preciso

[Kogan Zahavi, 2007].

Debido a lo expuesto anteriormente, el proceso utilizado para determinar el cubrimiento de una regla

original por reglas descubiertas es el siguiente:

1. Para cada una de las reglas originales, se toma del conjunto de reglas descubiertas aquellas que

la cubren.



32

2. Se suma la cantidad de ejemplos que responden al conjunto de reglas descubiertas.

3. Si la suma de ejemplos computada en el paso 2 está comprendida entre la cantidad de ejemplos

que se sabe se generaron para la regla original y esta cantidad sumada a una desviación, se

considera que la regla original ha sido correctamente cubierta.

La 3ra condición responde a dos criterios, que las reglas descubiertas deben cubrir al menos la

misma cantidad de ejemplos que la original, y que es posible aceptar una desviación en la cantidad

de ejemplos cubiertos [Kogan Zahavi, 2007].

DESCRIPCIÓN DEL PROBLEMA COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS


33

3. Descripción del Problema

En este capítulo se presenta una descripción del problema a resolver (sección 3.1) y se realiza un

resumen de las preguntas de investigación identificadas (sección 3.2).

3.1. Delimitación del problema de investigación

Los procesos de explotación de información utilizan distintos algoritmos de minería de datos para

obtener patrones de conocimiento a partir de los ejemplos (instancias) que se tienen sobre el dominio

del problema [Britos & García-martínez, 2009], una de las hipótesis con las que trabajan estos

algoritmos es que la complejidad del dominio sobre cuya información se trabaja, no incide sobre la

calidad de los patrones obtenidos; esta hipótesis fue refutada por Lopez Nocera [2012] en oportunidad

de su tesis de magister donde demostró que para el caso del proceso de explotación de información de

reglas de pertenecía a grupos, la calidad de los patrones que se obtienen difiere en función de la

complejidad de los dominios a los cuales se aplica y de los algoritmos que se utilizan en el proceso

[López Nocera & Garcia-Martinez, 2012].

Este trabajo de investigación busca conocer como varía el comportamiento conjunto de los algoritmos

de agrupamiento e inducción en función de la complejidad del dominio sobre la que se apliquen, para

lograr esto, Se toma como base para el estudio llevado a cabo en el presente trabajo la caracterización

de dominios propuesta por Lopez Nocera, y el modelo de experimentación para estudiar la integración

de algoritmos de agrupamiento e inducción más el método para medir la calidad de las reglas obtenidas

propuesto por Ariel Kogan Zahavi [2007] para su tesis de grado en ingeniería.

Se ha elegido profundizar las siguientes líneas de investigación planteadas en los trabajos previos:

a) Extender el universo de conocimiento mediante la aplicación al problema de nuevos algoritmos

de agrupamiento e inducción, lo que llevara a un aumento de la cantidad de combinaciones de

algoritmos posibles.

b) Comparar los resultados obtenidos a partir de las experiencias con el objetivo de encontrar las

combinaciones de algoritmos que mejor trabajen con los tipos de dominio definidos en la

investigación de Lopez Nocera.

DESCRIPCIÓN DEL PROBLEMA COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS


34

3.2. Resumen de las preguntas de investigación

A partir de lo expuesto en la sección anterior se enumeran a continuación las preguntas de

investigación identificadas:

1. ¿Los resultados obtenidos por los algoritmos de agrupamiento e inducción utilizados se ven

afectados por el tipo de dominio sobre el que se aplican?

2. ¿Qué combinaciones de algoritmos de agrupamiento e inducción presentan mejores resultados

para cada tipo de dominio?

EXPERIMENTOS COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS


35

4. Materiales y Métodos

En este capítulo se presentan los métodos y herramientas metodológicas que se utilizaran, comenzando

con el método de experimentación (Sección 4.1) y luego se presenta la herramienta necesaria para la

realización de las experiencias prácticas (Sección 4.2).

4.1. Método de Experimentación

Para realizar las experimentaciones de este trabajo se decidió utilizar el banco de pruebas propuesto por

Kogan Zahavi [2007], adaptado con los cambios propuestos por Lopez-Nocera [2012] para tener en

cuenta la complejidad del dominio al generar los escenarios de experimentación. El uso de la

herramienta permite la automatización del proceso de experimentación, permitiendo el ahorro de una

gran cantidad de tiempo y haciendo que sea más fácil tener acceso a los resultados finales de cada etapa

del proceso de experimentación, ya que estos se almacenan en la base de datos utilizada y las salidas de

los procesos intermedios de agrupamiento e inducción se almacenan en archivos con extensión “.arff”,

archivos que son utilizados de forma nativa por las librerías de algoritmos utilizadas.

4.2. Herramienta de Experimentación

En esta sección se presenta la herramienta desarrollada para llevar a cabo los experimentos,

primeramente se da una introducción a la misma (Sección 4.2.1) seguido se nombran todas sus

funcionalidades (Sección 4.2.2) y finalmente se muestra la dinámica completa de la herramienta

(Sección 4.2.3).

4.2.1. Introducción

La herramienta usada para realizar las experiencias es un desarrollo propio, basado en el banco de

pruebas propuesto por Kogan Zahavi [2007], se desarrolló en lenguaje JAVA 1.8, utilizando el IDE

NetBeans 8.0 y como gestor de base de datos utiliza PostgreSQL 9.3. Además, la herramienta hace uso

de distintas librerías para la ejecución de los algoritmos de agrupamiento e inducción utilizados, estas

librerías son: WEKA 3.7, WEKA 3.6, WEKA Classification Algorithms 1.8, KEEL, y otras

librerías propias de JAVA como Math.



36

Se decidió utilizar JAVA como lenguaje de desarrollo, en primer lugar por ser el mismo utilizado en

los trabajos anteriores sobre los que se basa esta tesis, y segundo porque al ser un lenguaje popular, se

observó una facilidad a la hora de encontrar las librerías desarrolladas en este lenguaje con los

algoritmos necesarios.

WEKA (Weikato Environment for Knowledge Analysis), o Entorno Weikato para el análisis de

conocimiento, es un entorno de trabajo que incorpora varias técnicas de Machine Learning creado por

la universidad de Weikato, Nueva Zelanda. Las librerías de algoritmos utilizadas por WEKA son de

código abierto, y pueden ser utilizadas por cualquier persona para sus desarrollos propios, la librería

incluye algoritmos para el pre-procesamiento de los datos, clasificación, regresión, clustering, minería

de reglas de asociación y visualización, de esta librería se obtuvieron la mayoría de los algoritmos

utilizados en el presente trabajo: SOM, EM, KMeans, Farthest First, KNN, J48, PART y Apriori.

KEEL (Knowledge Extraction Based on Evolutionary Learning, o Extracción de conocimiento basado

en aprendizaje evolucionario) es una herramienta Open Source desarrollada en java que puede ser

utilizada para un gran número de diferentes tareas de descubrimiento de conocimiento en datos,

contiene una gran variedad de algoritmos clásicos de extracción de conocimiento. De esta librería se

obtuvieron los algoritmos ID3, CN2, AQ15.

4.2.2. Funcionalidades

A continuación se listan las funcionalidades que provee la herramienta para realizar los experimentos,

en primer lugar provee la capacidad de definir dominios sobre los cuales trabajar (Sección 4.2.2.1)

luego permite generar ejemplos para esos dominios (Sección 4.2.2.2), permite ejecutar algoritmos de

agrupamiento sobre esos ejemplos (Sección 4.2.2.3) y algoritmos de inducción (Sección 4.2.2.4),

finalmente permite realizar la contrastación entre dos grupos de reglas (Sección 4.2.2.5).

4.2.2.1. Definición del Dominio

De acuerdo a los valores dados a una serie de parámetros, la herramienta es capaz de definir un

dominio sobre el cual realizar la experimentación, esta definición responde a la modelización que se ha

realizado estableciendo los valores de los parámetros y generando al azar la información faltante. En la

figura 4.1 se muestra la sección de carga de datos del dominio a generar de la herramienta, los

parámetros sobre los cuales la herramienta genera los dominios son:



37

La cantidad de clases (CC): es la cantidad de clases diferentes que creara la herramienta, cada

clase contara con un conjunto de reglas propias y por consiguiente un conjunto de ejemplos, la

cantidad de clases dictara también la cantidad de grupos en los que se agruparan la totalidad de

los ejemplos generados en un experimento.

La cantidad de atributos (CA): es la cantidad de atributos que tendrán los ejemplos a generarse,

cada atributo a su vez tendrá una cierta cantidad de valores posibles que podrá tomar.

La cantidad de valores posibles por atributo (CVA): es la cantidad de valores diferentes que

puede llegar a tomar un atributo, tanto en el momento de generar una regla que impondrá una

condición sobre cierto atributo (en ese caso la cantidad de valores posibles estará acotada, como

se verá más adelante) o al generar los ejemplos.

El porcentaje de valores posibles por atributo en reglas (PCVA): es el porcentaje sobre la

cantidad de valores posibles por atributo que se tendrán en cuenta para armar las reglas.

El porcentaje de ejemplos usados para el entrenamiento de los algoritmos: es el porcentaje de

los ejemplos generados que se utilizarán para entrenar los algoritmos de agrupamiento e

inducción antes de ejecutarlos sobre la totalidad de los mismos, los ejemplos de entrenamiento

son seleccionados aleatoriamente a partir del conjunto de ejemplos completo, es decir si se

cuenta con una totalidad de 200 ejemplos y se utiliza el 10% de estos para entrenamiento, se

seleccionaran 20 ejemplos para realizar el entrenamiento de los algoritmos y luego se ejecutaran

la totalidad de los ejemplos generados (200).

La cantidad de reglas a generar por cada clase (CRC): es la cantidad de reglas que se generarán

para cada clase, las reglas generadas describen a cada clase, ya que a parir de estas se generan

los ejemplos del dominio.

La cantidad de ejemplos a generar por cada regla (CER): es la cantidad de ejemplos a generarse

para cada regla, debe tenerse en cuenta que la cantidad de ejemplos dependerá de la cantidad de

clases que se hayan definidos, de la cantidad de reglas a generar por clase que se haya definido

y a este parámetro en si, por lo tanto la cantidad de ejemplos generados se dispara rápidamente

dependiendo de los valores dados a los parámetros nombrados.



38

La cantidad de atributos a utilizar en cada regla (CAR): este parámetro puede traducirse a la

cantidad de condiciones que tendrá cada regla generada por la herramienta, el valor de este

parámetro deberá ser menor o igual a la cantidad de atributos definidos.

La semilla de generación de números aleatorios: es la semilla que utilizará la herramienta para

generar los números aleatorios que alimentan a todo el proceso de experimentación. Los

números aleatorios se generan mediante la librería math de JAVA, a la cual se le establece el

número de semilla.

Además la herramienta permite guardar los datos generados para el dominio en el directorio ingresado

en el parámetro “guardar en” con el nombre dado por defecto por la herramienta para el archivo que es

una composición de la fecha y hora de la ejecución o con un nombre particular que quiera ingresarse.

Si se desea, la herramienta puede generar automáticamente un dominio de determinada categoría

seleccionando la opción “complejidad” y el tipo de complejidad que se desea.

Figura 4. 1 - Sección de carga de los parámetros del dominio.

La definición de los dominios en condiciones de laboratorio, conlleva la generación de un conjunto de

reglas, que serán las reglas “originales” o conjunto “A” de reglas, a partir de estas reglas se generaran

más adelante ejemplos que les den soporte, en la Figura 4.2 se muestra un conjunto de reglas

regeneradas para un dominio por la herramienta, cada regla tiene el siguiente formato “if att1 = val1

and att2 = val2… and attn = valn then Cn” la cantidad de reglas a generar y la cantidad de condiciones

de las reglas, así como la cantidad clases, atributos y valores diferentes, viene dado por los valores que

tomen los parámetros del experimento.



39

Figura 4. 2 - Formato de Reglas Generadas.

El procedimiento de generación de reglas que utiliza la herramienta es el siguiente:

a) Se calcula el total de reglas a generar, mediante la multiplicación de los parámetros “cantidad de

reglas por clase” y “cantidad de clases”

b) Se establecen los valores del dominio, de acuerdo a los valores dados a los parámetros “cantidad

de atributos” y “cantidad de valores por atributo”, en la Figura 4.3 se muestra un ejemplo de los

atributos establecidos y sus posibles valores, suponiendo que el parámetro “cantidad de

atributos” haya tomado valor 6 y el parámetro “cantidad de valores por atributo” valor 8.

Figura 4. 3 - Conjunto de Atributos y Valores Posibles.



40

c) Se seleccionan aleatoriamente los atributos sobre los que se impondrán condiciones para las

reglas teniendo en cuanta el parámetro “cantidad de atributos por regla” y se acota la cantidad

de valores posibles que pueden tomar esos atributos seleccionados, de acuerdo al valor que haya

tomado el parámetro “porcentaje de valores posibles por atributo en reglas”. En la Figura 4.4 Se

muestra un ejemplo de esto, suponiendo que el parámetro “cantidad de atributos por regla” haya

tomado un valor de 2, en gris se muestran los atributos sobre los que la regla impondrá

condiciones, estos atributos fueron seleccionados aleatoriamente, de igual manera en gris se

muestra el conjunto acotado de valores que podrán tomar esos atributos sobre los que se

impondrán condiciones, la manera de determinar este conjunto de valores posibles es la

siguiente, para el ejemplo como se dijo anteriormente, el parámetro “cantidad de atributos”

tomó el valor 8 y el parámetro “porcentaje de valores posibles por atributo en reglas” tomó el

valor 50% primero se calcula la cantidad de valores posibles para el atributo condicionado, que

en este caso es la mitad (50%) de la cantidad de valores posibles (8), es decir 4. Luego estos 4

valores son seleccionados aleatoriamente de entre el total de valores posibles, generándose así

lo que se muestra en gris en la figura 4.4.

Figura 4. 4 - Conjunto de Atributos y Valores Posibles Acotados para Reglas.



41

d) Se genera una regla tomando de manera aleatoria un valor de entre los valores posibles para

cada atributo previamente seleccionado, en la Figura 4.5 se muestra la generación de una regla,

los dos atributos seleccionados anteriormente sobre los que se imponen condiciones toman un

valor del conjunto de valores posibles acotados, el resto de los atributos sobre los que no se

imponen condiciones toman valor “*” es decir indeterminado.

Figura 4. 5 - Generación de una regla.

e) Se repite el punto d) para cada regla a generar para esa clase

f) Se repite a partir del punto c) al e) para cada clase.

4.2.2.2. Generación de Ejemplos

Una vez definido un dominio, la herramienta generará los ejemplos necesarios para dar soporte a ese

dominio, la cantidad de ejemplos a generar es variable y depende de los valores que se le hayan dado a

los parámetros definidos al comienzo del experimento.

En la Figura 4.6 se muestra un conjunto de ejemplos generados para dar soporte a una regla original,

excepto los atributos sobre los que la regla impone condiciones, el resto de los valores para los

atributos son generados aleatoriamente por la herramienta mediante el uso de la librería Math incluida

en JAVA, para el ejemplo, cada ejemplo consiste en cinco valores para cada uno de los cinco atributos

definidos, los atributos dos y cinco están condicionados por la regla para la cual fueron generados, por

estos esos atributos toman los valores fijos 1 y 0. El resto de los atributos son libres de tomar valores

entre 0 y 7, seleccionados aleatoriamente.



42

Figura 4. 6 - Ejemplos Generados a Partir de una Regla.

El procedimiento para la generación de cada ejemplo es el siguiente:

a) Se toma una regla del conjunto de reglas para las que se debe generar ejemplos.

b) La regla impone condiciones sobre una cierta cantidad de atributos, al generar el ejemplo

primero se fijan los valores de los atributos sobre los cuales la regla impone condiciones, los

valores que toman serán los que indique la regla en cada uno.

c) Se seleccionan aleatoriamente los valores de los demás atributos, los valores posibles estarán

dados por el valor del parámetro cantidad de valores posibles por atributo. La selección

aleatoria se realiza nuevamente utilizando la librería Math.Random incluida en JAVA, se

generan una serie de valores aleatorios dentro de un rango de valores predeterminado, por

ejemplo si se estableció el valor 8 para el parámetro cantidad de valores posibles por atributo, se

generarán números aleatorios entre 0 y 7, que luego se establecerán con valores de cada uno de

los atributos.

d) Se repite el paso c) para cada ejemplo que se deba generar para una regla en particular.



43

e) Se repiten los pasos a) al d) para cada regla.

Todos los ejemplos generados se almacenan en un conjunto, sobre este se realizara en el próximo paso

el agrupamiento.

4.2.2.3. Agrupamiento

El banco de pruebas permite la aplicación de los siguientes algoritmos de agrupamiento sobre los

ejemplos generados: KMeans, EM, FarthestFirst, SOM, KNN, estos algoritmos están incluidos en la

herramienta mediante la utilización de distintas librerías, principalmente WEKA, y KEEL, y se

ejecutan automáticamente sobre los ejemplos una vez que estos son generados, los distintos grupos de

ejemplos generados a partir de la aplicación de los algoritmos de agrupamiento, son guardados ya que

luego sobre estos se aplicarán los algoritmos de inducción de reglas.

Para cada algoritmo de agrupamiento utilizado se mantiene su configuración por defecto, ya que se

observó que de esa manera se podía mantener una cierta correlación entre algoritmos que utilicen una

estructura parecida y de esta manera no favorecer a uno sobre los otros mediante la modificación de su

configuración, en los algoritmos donde se debiera seleccionar la cantidad de grupos a generar como ser

KMeans, se eligió establecer ese valor con el valor de la cantidad de clases generadas para el

experimento, de esta manera al generarse un dominio con 3 clases se busca la conformación de 3

grupos diferentes sobre los cuales luego aplicar los algoritmos de inducción.

4.2.2.4. Inducción

Una vez realizado el agrupamiento de los ejemplos con algún algoritmo de agrupamiento, la

herramienta aplica un algoritmo de inducción de reglas sobre cada uno de los grupos para obtener las

reglas que indican la pertenencia a estos, los algoritmos de inducción incluidos en la herramienta son

los siguientes: PART, J48, ID3, Apriori, CN2 y AQ15, también aplicados mediante la utilización de

las librerías de WEKA y KEEL. La salida del proceso de inducción es el conjunto “B” de reglas o

conjunto de reglas descubiertas, que deberán ser comparadas con las reglas originales.

Al igual que con los algoritmos de agrupamiento utilizados, la configuración de los algoritmos de

inducción es modificada mínimamente, la salida de cada algoritmo de inducción es un conjunto de

reglas que indican la pertenencia a un grupo, y asociado a cada regla un valor numérico que indica a

cuantos ejemplos cubre esa regla, el formato de las reglas de salida de cada algoritmo varían



44

dependiendo de a qué familia pertenezcan, así, por ejemplo: las salidas de los algoritmos J48 y ID3 son

idénticas, así como las salidas de los algoritmos CN2 y AQ15. Debido a esta diferencia de formatos

con las reglas originales definidas por la herramienta, se debe modificar la salida obtenida de los

algoritmos para que se asemejen a un único formato.

4.2.2.5. Contrastación

El banco de pruebas es capaz de realizar la contrastación entre dos conjuntos de reglas, es decir, es

capaz de establecer la cantidad de reglas de un conjunto A que son correctamente cubiertas por las

reglas de un conjunto B, el método de contrastación de reglas utilizado por la herramienta sigue los

lineamientos establecidos en la Sección 2.5. Del presente trabajo, además este módulo debe encargarse

de gestionar los distintos formatos de reglas obtenidos durante la inducción y transformarlos a uno en

común, también debe conectarse con la base de datos para almacenar los resultados calculados.

Para realizar de manera correcta la contrastación, el banco de pruebas debe encargarse de transformar

las reglas que se obtienen de cada algoritmo de inducción a un mismo formato para que sean

equivalentes entre si y a las reglas originales generadas por la herramienta y puedan ser comparadas de

manera correcta y automatizada, además la herramienta debe almacenar para cada regla el valor que

indica la cantidad de ejemplos que cubre esa regla, este valor viene dado por cada algoritmo de

inducción como salida junto con cada regla descubierta.

El objetivo de la contrastación de reglas es obtener el porcentaje que indica cuantas reglas originales

son correctamente cubiertas por las reglas descubiertas por cada algoritmo de inducción.

A continuación se listan los pasos que componen el procedimiento utilizado para la contrastación de

reglas dividido en dos partes, la primera para las reglas iguales y la segunda para reglas más generales

o específicas que la original, luego en la Figuras 4.7 y 4.8 puede observarse un diagrama de flujo de

cada parte:

a) Se toma una regla del conjunto de reglas originales.

b) Se toma una regla del conjunto de reglas descubiertas.



45

c) Se comprueba si la regla descubierta es completamente igual a la regla original, es decir si

imponen condiciones sobre los mismos atributos con los mismos valores y si la conclusión es la

misma.

d) En el caso que las reglas sean iguales, se cuenta la regla original como cubierta, se extrae del

conjunto de reglas originales y se regresa al punto a, en el caso de ser diferentes, se vuelve al

punto b para tomar otra regla descubierta.

e) El proceso se repite para cada regla original.

Figura 4. 7 - Contrastación de reglas iguales.



46

En el caso que queden reglas originales sin cubrir, se pasa a comprobar el cubrimiento de reglas

originales por reglas descubiertas que sean más generales o específicas.

a) Se toma una regla del conjunto de reglas originales.

b) Se toma una regla del conjunto de reglas descubiertas.

c) Se comprueba que la conclusión de ambas reglas sean iguales, en caso que no, se vuelve al paso

b).

d) Se comparan las condiciones de la regla original con las condiciones de la regla descubierta.

e) Si al menos una de las condiciones es completamente igual, se suma el valor que indica la

cantidad de ejemplos que cubre esa regla descubierta a una variable, y se vuelve al punto b. si

ninguna de las condiciones es igual, se vuelve al punto b.

f) Una vez recorrido todo el conjunto de reglas descubiertas, el objetivo es comparar la cantidad

de ejemplos que cubren todas las reglas descubiertas que son más generales o específicas de la

original (esta cantidad se encuentra almacenada en la variable del punto e) con la cantidad de

ejemplos que se sabe se generaron realmente para esa regla especifica en el módulo de

generación de ejemplos. Si la cantidad de ejemplos que cubren las reglas descubiertas se

encuentra entre la cantidad de ejemplos que cubre la regla original y ese valor más una

desviación (dada por un porcentaje establecido previamente) entonces se dice que la regla

original es correctamente cubierta y se suma una unidad a la variable “reglas correctamente

cubiertas”.

g) Se regresa al punto a)

h) El proceso se repite para cada regla original

i) Una vez recorrido completamente se obtiene el porcentaje que representa la cantidad de reglas

correctamente cubiertas, dividiendo la variable “reglas correctamente cubiertas” por la cantidad

total de reglas originales y multiplicando este valor por 100. este resultado es almacenado en la

base de datos.



47

Figura 4. 8 - Contrastación de reglas más generales y específicas.

El proceso es el mismo para cada conjunto de reglas descubiertas y cada valor se guarda en una tabla

de la base de datos para luego ser estudiado.

4.2.2.6. Resultados

Al desarrollar la herramienta se decidió que el almacenamiento de los resultados se realice de manera

sencilla y práctica, para lo cual, se definió una base de datos relacional en el gestor de base de datos

PostgreSQL con dos tabla, una tabla “escenario” donde se almacena la información de los escenarios

que se ejecutan, esta información está compuesta por los valores que toman todos los parámetros que

definen el dominio, y una tabla “resultados” relacionada con “escenario” donde se almacenan los

resultados obtenidos a partir de la ejecución de un escenario para cada combinación de algoritmo de

agrupamiento e inducción. De esta manera los resultados obtenidos para cada escenario pueden ser

fácilmente consultados, y extraídos para ser utilizados en otros programas o medios.



48

4.2.3. Dinámica Completa de la Herramienta

En la Figura 4.9, se observa la dinámica completa del banco de pruebas. Un experimento completo se

realiza en tres pasos como se muestra en la imagen:

Paso 1: en este paso se encuentran todas las tareas de preparación del experimento, es decir, la

definición/generación del dominio y la generación de los ejemplos.

Paso 2: llamado ejecución del experimento, se ejecutan los algoritmos de agrupamiento sobre

los ejemplos, y los algoritmos de inducción sobre los grupos obtenidos, con el objetivo de

obtener los conjuntos de reglas descubiertas.

Pasó 3: finalmente en este paso se realiza la comparación de los dos conjuntos de reglas, con el

fin de obtener la cantidad de reglas del conjunto original que son correctamente cubiertas por

las reglas del conjunto de reglas descubiertas.

Figura 4. 9 - Dinámica completa del banco de pruebas. [Kogan Zahavi, 2007]



49

5. Experimentos

Se presentan en este capítulo los rasgos generales del método de experimentación adoptado (sección

5.1), una descripción detallada del diseño experimental, que incluye las características de las

experiencias realizadas, la presentación y definición de las variables independientes y dependientes a

utilizar, y los detalles de las corridas a llevar a cabo en la ejecución de las experiencias (sección 5.2); y

por último el formato de los resultados, la presentación de los resultados finales (sección 5.3).

5.1. Introducción

Se realizan las experiencias con el objetivo de evaluar cual combinación de algoritmos de

agrupamiento e inducción es la mejor para obtener reglas de pertenencia a grupos para cada tipo de

dominio definido, el resultado obtenido de cada corrida en el sistema es un valor que indica el

porcentaje de reglas correctamente cubiertas para cada combinación de algoritmos de agrupamiento e

inducción, luego de realizar todas las experiencias se obtiene una matriz con los resultados promedios

finales para cada combinación de algoritmos en cada tipo de dominio, estos resultados son la base para

las conclusiones del presente trabajo.

5.2. Diseño Experimental

En esta sección se definen las características generales de las experiencias realizadas (sección 5.2.1), se

definen las variables independientes y dependientes utilizadas (sección 5.2.2).

5.2.1. Características de las Experiencias Realizadas

Se realizaron 100 experiencias para cada uno de los 5 tipos de dominios definidos, dando un total de

500 experiencias, a partir de las cuales se obtuvieron resultados para cada una de las 30 combinaciones

posibles de algoritmos de agrupamiento e inducción que se obtienen a partir de los 5 algoritmos de

agrupamiento y los 6 algoritmos de inducción seleccionados.

Cada experiencia conlleva la realización de los siguientes pasos, en primer lugar se prepara el

experimento, lo que involucra:



50

a) La generación del dominio, basado en la generación de las clases y las reglas que indican la

pertenencia a cada clase.

b) La generación de los ejemplos que respaldan esas reglas.

A partir de esto se obtiene el conjunto de reglas originales y el conjunto de muestras del dominio (los

ejemplos). El siguiente paso consiste en la ejecución del experimento, lo que involucra:

a) Aplicar un algoritmo de agrupamiento sobre el conjunto de ejemplos para obtener los distintos

clústeres o grupos de ejemplos.

b) Aplicar a cada clúster un algoritmo de inducción para obtener un conjunto de reglas que

caractericen la pertenencia ha dicho clúster, estas reglas conformarán el conjunto de reglas

descubiertas.

La salida de este paso será el conjunto de reglas descubiertas que se utilizará junto con las reglas

originales en el tercer y último paso que conlleva:

a) Realizar una comparación entre el conjunto de reglas originales obtenidas en el primer paso y el

conjunto de reglas descubiertas en el segundo paso.

La salida de este último paso será el porcentaje de reglas originales cubiertas correctamente por las

reglas descubiertas, este porcentaje define el éxito del experimento.

5.2.2. Presentación de las Variables a Utilizar

Para la experimentación se utilizaron las siguientes variables independientes:

a) Cantidad de Clases (CC): la cantidad de clases que rigen el dominio.

b) Reglas por clase (CRC): cantidad de reglas de clasificación que indican la pertenencia a cada

clase del dominio.

c) Cantidad de atributos (CA): cantidad de atributos de cada ejemplo.

d) Cantidad de valores posibles atributos (CVA): cantidad de valores posibles que puede tomar

cada atributo.

e) Ejemplos por regla (CER): cantidad de ejemplos por cada regla.

f) Cantidad de atributos regla (CAR): cantidad de atributos utilizados en la definición de las

reglas.



51

g) Porcentaje de valores posible atributo (PCVA): porcentaje sobre la cantidad total de valores

posibles por atributo, que se utilizara para limitar el número de valores posibles por atributo que

defina una clase.

A su vez se utiliza la siguiente variable dependiente:

h) Reglas cubiertas correctamente: porcentaje de las reglas generadas originalmente que son

correctamente cubiertas por el conjunto de reglas descubiertas.

5.2.3. Panorama General de la Ejecución de las Experiencias

Se realizaron 100 experiencias por cada uno de los 5 tipos de dominios definidos por Lopez-Nocera

[2012], los cuales son dominios simples, medianos, oscilantes, complejos e hipercomplejos; dando un

total de 500 experiencias.

Para cada una de las experiencias realizadas se definió un escenario diferente, cada escenario está

representado por un valor dado para cada una de las variables independientes definidas anteriormente,

cantidad de clases, cantidad de reglas por clase, cantidad de atributos, cantidad de valores posibles por

atributo, cantidad de ejemplos por regla, cantidad de atributos por regla, y porcentaje de valores

posibles para cada atributo en una regla. Un ejemplo de la definición de escenarios puede verse en la

tabla 5.1.

NUMERO DOMINIO CC CRC CAR CVA CER PCVA CA

1 M 2 1 2 8 10 80 5

2 M 2 2 2 8 10 80 5

3 M 2 3 2 8 10 80 5

4 M 2 4 2 8 10 80 5

5 M 2 5 2 8 10 80 5

6 M 3 1 2 8 10 80 5

7 M 3 2 2 8 10 80 5

8 M 3 3 2 8 10 80 5

Tabla 5. 1 - Ejemplos Definición de Escenarios.

Dependiendo el tipo de dominio ciertas variables varían en un cierto rango de valores, mientras que

otras variables se mantienen fijas, para determinar que variables afectan directamente a cada tipo de

dominio y el rango de valores en el que deberían variar se observaron los trabajos previos en el tema de

Lopez-Nocera [2012] y de Kogan Zahavi [2007] y se creó una matriz de relación entre el tipo de

complejidad y las variables independientes, en la tabla 5.2 se muestra la matriz resultante.



52

CC CRC CAR CVA CER PCVA CA

Simple X(↑)

Medianos X(↑↓) X(↓) X(↓) X(↑↓)

Oscilantes X(↑↓) X(↑↓)

Complejos X(↑↓) X(↑↓) X(↑↓) X(↑↓)

Hipercomplejos X(↑↓) X(↑↓) X(↑↓) X(↑↓) X(↑↓) X(↓)

Tabla 5. 2 - Matriz de Relación entre el Tipo de Complejidad y las Variables Independientes

La “X” en la matriz indica la variable cuyos valores varían para cada tipo de complejidad y las flechas

ascendentes y descendentes indican el tipo de variación dada en los experimentos observados. A

continuación en la tabla 5.3 se define el rango de valores en el que variarían cada una de las variables.

Variables Bajo Medio Alto

CC 2-4 5-7 8-10

CRC 1-5 6-10 11-15

CER 1-7 8-14 15-21

CAR 1-2 3-4 5-6

CVA 1-4 5-7 8-10

PCVA 1-40 41-70 71-100

CA 1-4 5-7 8-10

Tabla 5. 3 - Tabla de Valores

La selección de los rangos de variación presentados en la tabla 5.3 responde a los siguientes criterios:

Nociones empíricas obtenidas de los trabajos anteriores: se determinaron los rangos de

variación de algunas variables a partir de la observación de las experiencias realizadas en

trabajos anteriores.

Criterios computacionales: la utilización de valores elevados en algunas variables tienen un

efecto notorio en la velocidad con la que se ejecutan los experimentos, a partir de determinados

niveles, los tiempos de ejecución se tornan prohibitivos al trabajar con una plataforma de

cómputo pequeña.

Saturación del dominio: algunas variables están condicionadas al valor que tomen otras, por

ejemplos cantidad de atributos y cantidad de atributos por regla, o cantidad de atributos por

regla y cantidad de valores posibles por atributo con la variable cantidad de reglas por clase, por

lo tanto para evitar la saturación de dominios y la imposibilidad de ejecutar ciertos

experimentos, se limitó los valores de ciertas variables y se decidió controlar que no se ingresen

inconsistencias a la hora de realizar los experimentos.



53

Porcentajes: algunas variables están expresadas en porcentaje, por lo que su rango natural de

variación es de 0 a 100, aunque se considera de 1 a 100 ya que el valor 0 no tiene sentido

práctico de aplicación de los conceptos correspondientes.

Se puede observar que el rango de valores se divide en bajo, medio y alto, esta división se realizó para

delimitar mejor el rango de valores que puede tomar cierta variable en cierto tipo de complejidad, a

continuación en la tabla 5.4 se muestra la matriz final que cruza cada tipo de complejidad del dominio

con las variables independientes, utilizando como medida del rango de variación los valores definidos

en la tabla 5.3.

CC CRC CAR CVA CER PCVA CA

Simple Alto

Medianos Bajo Bajo Bajo Bajo-Medio

Oscilantes Medio-Alto Alto Alto

Complejos Medio Bajo-Medio Alto Medio Medio

Hipercomplejos Bajo Bajo Alto Alto Alto Bajo

Tabla 5. 4 - Matriz de Relación entre el Tipo de Complejidad y las Variables Independientes con el Rango de Variación

Definido

De esta manera se define por ejemplo que escenarios para dominios del tipo simple variarían solamente

en una variable, cantidad de ejemplos por regla, en valores altos, definidos como valores entre el 15 y

el 21, a continuación se enuncia como se componen los escenarios para cada tipo de complejidad:

Escenarios de complejidad Simple: para los escenarios de complejidad simple se varia la

variable Cantidad de Ejemplos por Regla en un rango que va desde 15 hasta 21 mientras se

mantiene fijo el valor del resto de las variables, en el capítulo 8 de anexos sección 8.1.1 se

puede apreciar la tabla completa de escenarios para dominios simples, para completar los 100

escenarios, se corre la misma tabla una cierta cantidad de veces pero variando el parámetros

semilla en la herramienta de software, lo que hace que los números generados aleatoriamente

por la herramienta sean diferentes, y por consiguiente generando dominios que se diferencien

entre sí con cada corrida de la tabla.

Escenarios de complejidad Media: en los escenarios de complejidad media, se varían las

variables: Cantidad de Clases en el rango de 2 a 4, Cantidad de Reglas por Clase en el rango 1

a 5, Cantidad de Atributos Regla en el rango 1 a 2 y Cantidad de Atributos en el rango 1 a 5. En

el Capítulo 8 de Anexos Sección 8.1.2 puede verse la tabla de escenarios para dominios



54

medianos completa, los valores de las variables cambian en el rango definido tratando de

formar todas las combinaciones posibles hasta llegar a los 100 escenarios.

Escenarios de complejidad Oscilante: en los escenarios de complejidad Oscilante, se varían las

variables: Cantidad de Atributos Regla en el rango 3 a 6, Cantidad de Valores Atributo en el

rango 8 a 10 y Cantidad de Ejemplos por Regla en el rango 15 a 21. En el Capítulo 8 de Anexos

Sección 8.1.3, puede verse la tabla de escenarios para dominios Oscilantes completa, los valores

de las variables cambian en el rango definido tratando de formar todas las combinaciones

posibles hasta llegar a los 100 escenarios.

Escenarios de complejidad Compleja: para los escenarios de complejidad Compleja, se varían

las variables: Cantidad de Atributos Regla en el rango de 3 a 4, Cantidad de Valores Atributo

en el rango 4 a 7, Cantidad de Ejemplos por Regla en el rango 15 a 21, Porcentaje de Valores

Posible Atributo en el rango 45 a 70 y Cantidad de Atributos en el rango 5 a 7. En el Capítulo 8

de Anexos Sección 8.1.4 puede verse la tabla de escenarios para dominios Complejos completa,

los valores de las variables cambian en el rango definido tratando de formar todas las

combinaciones posibles hasta llegar a los 100 escenarios.

Escenarios de complejidad Hipercompleja: en los escenarios de complejidad Hipercompleja, se

varían las variables: Cantidad de Clases en el rango de 2 a 4, Cantidad de Reglas por Clase en

el rango 1 a 5, Cantidad de Valores Atributo en el rango 8 a 10, Cantidad de Ejemplos por

Regla en el rango 15 a 21, Porcentaje de Valores Posibles Atributo en el rango 75 a 100 y

Cantidad de Atributos en el rango 2 a 4. En el Capítulo 8 de Anexos Sección 8.1.5 puede verse

la tabla de escenarios para dominios medianos completa, los valores de las variables cambian en

el rango definido tratando de formar todas las combinaciones posibles hasta llegar a los 100

escenarios.

Una vez definidos los escenarios para las experiencias, estos se corren en la herramienta diseñada para

el presente trabajo, esta herramienta realiza los pasos que se describen en la sección 5.2.1 de este

capítulo, es decir, la generación de las reglas y ejemplos que componen el dominio, la aplicación de

combinaciones de algoritmos de agrupamiento e inducción sobre esos ejemplos y la comparación de los

conjuntos de reglas originales y descubiertas para obtener la salida deseada que es el porcentaje de

reglas correctamente cubiertas de cada combinación de algoritmos.



55

5.3. Resultados Obtenidos

En esta sección se define el formato de los resultados obtenidos y el tratamiento que se les dio (sección

5.3.1) y se muestran las matrices de resultados promedios finales (sección 5.3.2).

5.3.1. Formato de los Resultados

Cada experiencia que se realiza en el sistema tiene como salida el porcentaje de reglas correctamente

cubiertas para cada combinación de los algoritmos de agrupamiento e inducción que se estudiaron, es

decir 30 combinaciones, KMeans-PART, KMeans-J48, KMeans-ID3, KMeans-A priori, KMeans-

CN2, KMeans-AQ15, EM-PART, EM-J48, EM-ID3, EM-A priori, EM-CN2, EM-AQ15, EM-

PART, EM-J48, EM-ID3, EM-A priori, EM-CN2, EM-AQ15, FarthestFirst-PART,

FarthestFirst-J48, FarthestFirst-ID3, FarthestFirst-A priori, FarthestFirst-CN2, FarthestFirst-

AQ15, SOM-PART, SOM-J48, SOM-ID3, SOM-A priori, SOM-CN2, SOM-AQ15, KNN-PART,

KNN-J48, KNN-ID3, KNN-A priori, KNN-CN2 y KNN-AQ15. Estos 30 valores se almacenan en la

tabla “Resultados” de la base de datos del sistema.

Luego de la realización de todas las experiencias los datos almacenados en la tabla “resultados” de la

base de datos se volcaron en un documento Excel para facilitar la manipulación de los datos y el

cálculo de distintos valores significativos para el estudio, como ser: los resultados promedios finales

para cada combinación de algoritmos de cada tipo de complejidad, la cantidad de resultados nulos

obtenidos, es decir las veces en las que el porcentaje de reglas correctamente cubiertas fue del 0% y el

promedio de cubrimiento sin tener en cuenta estos resultados nulos.

5.3.2 Matriz de Valores Finales Promedios

A continuación en las tablas 5.5 a la 5.9 se presentan los resultados promedios de todas las corridas

realizadas en el sistema para cada tipo de complejidad separadas por par de algoritmos.

PART J48 ID3 A priori CN2 AQ15

KMeans 50.5 57.25 60.37 51.37 15.25 8

EM 38.75 40.87 39.25 62.75 11.12 8

Farthest First 45.25 49 66.75 61.12 10.37 6.75

SOM 52.87 61 74.5 48.75 25.12 10.87

KNN 36.12 39 63.25 54.5 11.37 9.5

Tabla 5. 5 - Resultados Promedios Complejidad Simple



56

En la tabla 5.5 se observan los resultados promedios obtenidos para dominios de complejidad Simple

con cada combinación de algoritmos, se observa que la mejor combinación para este tipo de

complejidad son los algoritmos SOM y ID3 con un 74.5% de reglas correctamente cubiertas en

promedio, seguido por la combinación Farthest First y ID3 con un 66.75%, los resultados más altos

desde el punto de vista inducción pueden verse en la columna del algoritmo ID3 y desde el punto de

vista agrupamiento en la fila que pertenece al algoritmo SOM con sus respectivas combinaciones, los

resultados más bajos se encuentran en las combinaciones de los algoritmos de agrupamiento con los

algoritmos de inducción AQ15 y CN2.


KMeans 39.27 45.73 51.01 43.03 18.39 12.85

EM 32.84 34.97 41.72 49.63 15.18 9.71

Farthest First 35.05 38.11 52.32 46.08 15.70 8.94

SOM 40.61 45.16 51.70 40.03 18.09 11.26

KNN 38.66 41.45 45.74 34.10 18.76 13.01

Tabla 5. 6 - Resultados Promedios Complejidad Media

En la tabla 5.6 se encuentran los resultados promedios obtenidos para los dominios de complejidad

Media usados, la mejor combinación de algoritmos para este tipo de complejidad fue Farthest First y

ID3 con un 52.32% de reglas correctamente cubiertas en promedio, seguido por la combinación SOM

y ID3 con un 51.70%, en general se puede observar que para este tipo de complejidad los resultados

son menores en relación a los obtenidos para dominios de otras complejidades. Es interesante notar que

las combinaciones de los algoritmos CN2 y AQ15 a pesar de seguir siendo los menores mejoraron en

relación a los observados en la Tabla 5.5 de dominios Simples.


KMeans 49.5 59.75 70.25 83.75 25.5 13.25

EM 39.62 48.5 48.75 90.87 21.87 11.5

Farthest First 48.75 53.5 71.5 83.75 22.37 9.25

SOM 29.62 30.87 61.62 84 20.12 2.5

KNN 9.62 9.37 19.5 94.25 13 1.5

Tabla 5. 7 - Resultados Promedios Complejidad Oscilante


Oscilante, la mejor combinación de algoritmos para este tipo de complejidad fue KNN y A priori con

un 94.25% de reglas correctamente cubiertas en promedio, seguido por la combinación EM y A priori

con un 90.87%. Desde el punto de vista de los algoritmos de inducción claramente las combinaciones

del algoritmo A priori presenta los resultados más altos, mientras que desde el punto de vista de los



57

algoritmos de agrupamiento, el algoritmo KMeans con sus respectivas combinaciones tiene los

promedios más altos, se observa que las combinaciones del algoritmo AQ15 fueron las más bajas y las

combinaciones del algoritmo CN2 volvieron a aumentar.


KMeans 50 53.37 68.87 81.75 19 12.37

EM 22.12 24.12 27.87 90.25 16.87 5

Farthest First 54.75 54.63 77.75 82.5 16.75 10.75

SOM 46.62 50 72.25 80.62 17.37 8.25

KNN 27.12 27.25 54.62 87 16.87 4.625

Tabla 5. 8 - Resultados Promedios Complejidad Compleja


Compleja, la mejor combinación de algoritmos para este tipo de complejidad fue EM y A priori con

un 90.25% de reglas correctamente cubiertas en promedio, seguido de la combinación KNN y A priori

con 87%, nuevamente en este tipo de complejidad los resultados más altos se presentan en las

combinaciones del algoritmo A priori con los algoritmos de agrupamiento, cabe destacar que en para

este complejidad las combinaciones de ID3 también presentan valores altos y que desde el punto de los

algoritmos de agrupamiento, las mejores combinaciones son aquellas donde esta presenta el algoritmo

Farthest First.


KMeans 36.74 41.60 49.21 66.86 37.04 18.24

EM 25.54 28.64 29.65 76.66 30.19 10.97

Farthest First 30.31 35.46 40.65 70.84 31.81 12.81

SOM 34.67 40.96 52.17 61.34 37.051 19.65

KNN 22.65 25.59 34.24 70.31 31.051 12.28

Tabla 5. 9 - Resultados Promedios Complejidad Hipercompleja

En la tabla 5.9 se observan los resultados promedios obtenidos para dominios de complejidad

Hipercompleja con cada combinación de algoritmos, la mejor combinación de algoritmos para este tipo

de complejidad fue EM y A priori con un 76.66% de reglas correctamente cubiertas en promedio,

seguido de la combinación Farthest First y A priori con 70.84%, se observa además que en este tipo

de complejidad se presentan los resultados más altos para las combinaciones con el algoritmo CN2,

llegando a alcanzar y superar en ciertos casos a las combinaciones del algoritmo PART.

En las tablas de resultados presentadas se pueden observar los porcentajes de reglas correctamente

cubiertas promedios de las 100 experiencias realizadas para cada uno de los 5 tipos de complejidad.



58

Los promedios más altos según el tipo de complejidad del dominio corresponden a las siguientes

combinaciones de algoritmos de agrupamiento e inducción:

Para dominios de complejidad Simple la combinación SOM-ID3.

Para complejidad Media la combinación Farthest First-ID3.

Para complejidad del tipo Oscilante KNN-A priori.

Para dominios de complejidad Compleja EM-A priori.

Para dominios de complejidad Hípercompleja la combinación EM-A priori.

CONCLUSIONES COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS


59

6. Conclusiones

En este capítulo se dan las conclusiones obtenidas a partir del análisis de los resultados obtenidos,

primeramente se expone un análisis comparativo general de los resultados obtenidos (Sección 6.1)

luego se dan las conclusiones finales sobre el trabajo (Sección 6.2) y por último se presentan las futuras

líneas de trabajo (Sección 6.3).

6.1. Análisis Comparativo de los Resultados Obtenidos

A partir del análisis de los resultados obtenidos de los experimentos presentados en el Capítulo 5, se

pueden realizar las siguientes observaciones, los algoritmos de inducción CN2 y AQ15 presentan los

promedios de acierto más bajos, en especial AQ15, pero se puede observar una mejora gradual en sus

resultados a medida que la complejidad cambia, esto es cierto principalmente para las combinaciones

del algoritmo CN2, que comienza con resultados promedios del orden de 10% en la complejidad

simple y finaliza con resultados del orden del 30% en la complejidad Hipercompleja.

Si se observan los resultados teniendo en cuenta los promedios de las combinaciones de los algoritmos

PART, J48, ID3 y A priori con sus respectivas combinaciones con los algoritmos de agrupamiento, se

puede notar que los resultados de la complejidad media se encuentran distribuidos en un rango pequeño

en comparación con el resto de las complejidades, se observan resultados entre 30% y 50% para la

complejidad media en relación a resultados entre 30% y 70% para complejidad Simple y 10% y 90%

para complejidad Oscilante, 20% y 90% para complejidad Compleja y 20% y 70% para complejidad

Hipercompleja, esto puede deberse a que en los escenarios de complejidad Media no se realiza una

variación en los valores del atributo “Cantidad de Ejemplos por Regla” como si se realiza en el resto de

las complejidades.

Se observa que el algoritmo A priori presenta una gran mejora para las últimas tres complejidades, sin

importar los algoritmos de agrupamiento con el cual se lo empareje, llegando a valores que oscilan

entre 80% y 90% para las complejidades Oscilante y Compleja. A pesar de que para los dominios

Complejos e Hipercomplejos se determinó que la mejor combinación de algoritmos es la misma, es

decir la combinación EM y A priori, se puede observar una amplia variación en los resultados

obtenidos en todas las combinaciones para ambas complejidades, la complejidad Hipercompleja

presenta resultados mucho más bajos (alrededor de un 20% menos) para todas las combinaciones de



60

algoritmos, con excepción del algoritmo CN2 cuyas combinaciones presentan resultados un 20% más

altos en relación a los promedios observados en la complejidad Compleja.

En las Figuras 6.1 a la 6.5 se muestran gráficos de barras comparando los resultados obtenidos para

cada combinación de algoritmos categorizados por algoritmo de Agrupamiento, de manera general en

todos los gráficos se puede observar una clara predominancia de las combinaciones con Apriori para

las complejidades Oscilantes, Complejas e HiperComplejas, a su vez para las complejidades Simples y

Medias se observa que el algoritmo ID3 provee mejores resultados, pero nunca con valores tan altos

como los de Apriori.

Figura 6. 1 - Resultados Obtenidos para las Combinaciones de KMeans a Través de Todas las Complejidades

El grafico en la Figura 6.1 muestra los resultados obtenidos para todas las combinaciones del algoritmo

de agrupamiento KMeans con los algoritmos de inducción utilizados, como se mencionaba

anteriormente se observa que el algoritmo Apriori lidera con los resultados más altos para las

complejidades Oscilante, Compleja e HiperCompleja seguido por ID3, mientras que este último

algoritmo posee los valores más altos para las complejidades simples y medias, pero seguido de cerca

por el algoritmo J48.

En la Figura 6.2 los resultados para las combinaciones con el algoritmo EM muestran la mayor

diferencia en los valores de Apriori con el resto de los algoritmos tanto para complejidades Oscilantes y



61

Complejas se llegan a valores del 90%, para las combinaciones de PART, J48 Y ID3 pueden

observarse valores muy similares entre si a través de todas las complejidades.

Figura 6. 2 - Resultados Obtenidos para las Combinaciones de EM a Través de Todas las Complejidades

Figura 6. 3 - Resultados Obtenidos para las Combinaciones de Farthest First a Través de Todas las Complejidades

Los resultados para las combinaciones de algoritmos con Farthest First de la Figura 6.3 muestran un

aumento en los valores obtenidos por el algoritmo ID3 en todas las complejidades en relación a los

resultados observados anteriormente, lo mismo puede decirse de la figura 6.4 donde la combinación de

ID3 con SOM para el tipo de complejidad simple llega al valor más alto en comparación con los otros



62

gráficos, la combinación SOM-CN2 para la complejidad HiperCompleja presenta el valor más alto

obtenido por esa combinación en todos los gráficos, de manera general se observa que los algoritmos

CN2 y AQ15 presentan sus valores más altos en la complejidad HiperCompleja en relación al resto de

las complejidades.

Figura 6. 4 - Resultados Obtenidos para las Combinaciones de SOM a Través de Todas las Complejidades

Figura 6. 5 - Resultados Obtenidos para las Combinaciones de KNN a Través de Todas las Complejidades

En la Figura 6.5 la grafica muestra los resultados de la combinacion KNN con cada uno de los

algoritmos de induccion, se observa un disminucion importante de los valores para la complejidad

Oscilante, excepto por la combinacion KNN-Apriori cuyo valor fue el mas alto.



63

En la Tabla 6.1 Se muestran los valores promedios de cada combinación de algoritmos a través de

todas las complejidades, se observa que el mejor resultado corresponde a la combinación EM, A priori

lo cual tiene sentido teniendo en cuenta que esta combinación fue la mejor para dos tipos de

complejidades, en general las combinaciones del algoritmo A priori presentan mejores resultados que

el resto de los algoritmos, esto puede deberse, según pudo observarse durante la experimentación al

tipo de reglas que produce este algoritmos en comparación con el resto, las reglas obtenidas como

salida de este algoritmo son simples, es decir que solo se componen de una condición y muy precisas

desde el punto de vista de la cantidad de ejemplos que estas cubrían, ya que en muchas ocasiones la

cantidad de ejemplos cubiertos por la regla descubierta era la misma que la cantidad de ejemplos que

fueron creados para cada regla original.


KMeans 45.20 51.54 59.94 65.35 23.04 12.94

EM 31.77 35.42 37.44 74.03 19.05 9.04

Farthest First 42.82 46.14 61.79 68.86 19.40 9.70

SOM 40.88 45.60 62.45 62.95 23.55 10.51

KNN 26.83 28.53 43.47 68.03 18.21 8.18

Tabla 6. 1 - Resultados Promedios de Cada Combinación a Través de Todas las Complejidades.

Entre los algoritmos PART, J48 e ID3, este último presenta mejores resultados promedios, y entre los

algoritmos PART y J48 puede observarse una cierta similitud con una separación menor al 5% en la

mayoría de los casos.

Desde el punto de vista de los algoritmos de agrupamiento, el algoritmo KNN presenta los resultados

más bajos en promedio, y los resultados más altos se reparten entre los algoritmos KMeans, Farthest

First y SOM, el algoritmo EM presenta resultados de valor “medio” en comparación con el resto de

los algoritmos de agrupamiento, hasta su combinación con el algoritmo A priori donde se observa una

gran mejora, produciendo el valor más alto de la Tabla 6.1.

6.2. Conclusiones Finales

De acuerdo con los datos obtenidos a partir de los experimentos realizados en esta investigación, es

posible aseverar la suposición de que los algoritmos de agrupamiento e inducción no son

independientes del dominio, se observó que mediante la modificación de los parámetros que conforman

los dominios, las distintas combinaciones de algoritmos presentan resultados diferentes.



64

Los resultados obtenidos por cada combinación de los algoritmos utilizados en esta investigación

varían de manera que son más precisos o menos precisos (el porcentaje de reglas correctamente

cubiertas aumenta o disminuye) dependiendo de la complejidad de los dominios sobre los que trabajan,

de esta manera para cada tipo de complejidad definida se pudo determinar una cierta combinación de

algoritmos de agrupamiento e inducción que trabaja mejor que el resto, estos combinaciones son:

<SOM, ID3> para dominios Simples, <Farthest First, ID3> para dominios Medios, <KNN, A

PRIORI> para dominios Oscilantes, <EM, A PRIORI> para dominios Complejos y <EM, A

PRIORI> para dominios Hipercomplejos.

6.3. Futuras Líneas de Trabajo

A partir de la realización de la presente investigación se identificaron las siguientes posibles líneas de

investigación sobre la investigación y sobre la herramienta utilizada.

Sobre la herramienta:

Extender la herramienta de manera que sea posible utilizar otros algoritmos de agrupamiento e

inducción, y poder generar mayor cantidad de combinaciones de algoritmos.

Ampliar las variables aceptadas a variables de tipo continuo, de esta manera se podrán generar

reglas del tipo “mayor a”, “menor a” y no únicamente del tipo “es igual a”, además esto podría

permitir utilizar otros algoritmos de agrupamiento e inducción que solo trabajan con atributos

numéricos.

Mejorar la eficiencia de procesamiento de la herramienta de manera que sea posible una mayor

eficiencia y rapidez en la carga y ejecución de experimentos.

Extender la cantidad de parámetros utilizados y configurables de manera que se incluyan

parámetros específicos de los algoritmos utilizados.

Incorporar visualizaciones a la herramienta de manera que sea posible mostrar gráficamente los

resultados obtenidos y los datos generados.

Permitir al usuario decidir si desea desestimar aquellos casos en lo que todos los algoritmos

presentan resultados nulos.



65

Sobre la Investigación:

Tener en cuenta el tiempo que toma la ejecución de cada combinación de algoritmos como

parámetro de la investigación, se puede incluir al banco de pruebas la funcionalidad para que

tome el tiempo de ejecución de cada algoritmo o par de algoritmos y almacenar este valor para

ser estudiado luego.

Ampliar la investigación incorporando adaptaciones en la configuración de los algoritmos

utilizados y estudiar cómo estas modificaciones afectan los resultados obtenidos.



66

REFERENCIAS COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS


67

7. REFERENCIAS

Afify, A. A. (2004). Design and Analysis of Scalable Rule Induction Systems. School of Engineering,

University of Wales, Cardiff. United Kingdom.

Agrawal, R. & Srikani, R. (1994). Fast Algorithms for Mining Associations Rules. Proceedings of the

20th

VLDB Conference, Santiago, Chile.

Britos, P. & García-martínez, R. (2009). Propuesta de Procesos de Explotación de Información.

Proceedings XV Congreso Argentino de Ciencias de la Computación. Workshop de

Base de Datos y Mineria de Datos, 1041–1050.

Britos, P., Hossian, A., García-martínez, R., & Sierra, E. (2005). Mineria De Datos Basada en Sistemas

Inteligentes. Editorial Nueva Libreria, 1era. Edicion, 1124 paginas, Buenos Aires,

Argentina, ISBN 987-1104-30-8.

Bubeck, S., Von Luxburg, U. (2009). Nearest Neighbor Clustering: A Baseline Method for Consistent

Clustering with Arbitrary Objective Functions. Journal of Machine Learning

Research, Vol. 10, Paginas 657-698.

Chen, M., Han, J., & Yu, P. (1996). Data Mining: an Overview from Database Perspective. IEEE

Transactions on Knowledge and Data Engineering.

Clark, P. & Niblett, T. (1989). The CN2 Induction Algorithm. Machine Learning, Vol. 3, Paginas 261-

283. Kluwer Academic Publishers.

Dempster, A. P., Laird, N. M., Rubin, D. B. (1977). Maximun Likelihood From Incomplete Data Via

the EM Algorithm. Journal of the Royal Statistical Society. Series B (Methodological),

Vol. 39, No. 1, pp. 1-38.

Figuerola, G, Alonso Berrocal, J. L., Zazo Rodríguez, A. F. y Rodríguez, E. (2004). Algunas técnicas

de clasificación automática de documentos. Artículo disponible en el sitio Web del

grupo Reina de la Universidad de Salamanca:

http://reina.usal.es/biblio/files/figuerola2005algunas.pdf (Vigente al 02/05/2015)

http://reina.usal.es/biblio/files/figuerola2005algunas.pdf



68

Frank, E. & Witten, I. H. (1998). Generating Accurate Rule Sets Without Global Optimization.

Department of Computer Science, University of Waikato. Hamilton, New Zealand.

García-Martínez, R., Diez, E., García, R., Martins, S., Baldizzoni, E. (2015). Modelos de Proceso para

Ingenieria de Explotacion de Informacion para Pymes: Abordaje Agil y Abordaje

Robusto. Proceedings XVII Workshop de Investigadores en Ciencias de la

Computacion, ISBN 978-987-633-134-0.

Hochbaum, D. S. & Shmoys D. B. (1985). A Best Possible Heuristic for the K-Center Problem.

Mathematics of Operations Research, Vol. 10, No. 2, May 1985, pp. 180-184.

Kogan Zahavi, A. (2007). Integracion de Algoritmos de Induccion y Agrupamiento. Estudio del

Comportamiento. Facultad de Ingenieria, Universidad de Buenos Aires.

Kohonen, T. (1982). Self-Organized Formation of Topologically Correct Feature Maps. Biological

Cybernetics, Vol. 43, pp. 11-15.

López Nocera, M. U. (2012). Descubrimiento de Conocimiento Mediante la Integracion de Algoritmos

de Explotacion de Información. Tesis de Maestría en Ingeniería en Sistemas de la

Información. Ciudad Autónoma de Buenos Aires. Universidad Tecnologica Nacional.

López Nocera, M. & Garcia-Martinez, R. (2012). Variabilidad del Comportamiento de Agrupamiento e

Inducción Basado en las Características del Dominio. Requirement Engineering &

Software Testing Latin American Congress, 23–28.

Martins, S. (2013). Derivación del proceso de Explotacíon de Informacíon desde el Modelado del

Negocio. Departamente de Desarrollo Productivo y Tecnologico, Universidad

Nacional de Lanus.

McLachlan, G. J. & Krishnan, T. (2008). The EM Algorithm and Extensions. Editorial: Wiley-

Interscience, Segunda Edicion, ISBN: 978-0-471-20170-0.

Mehrotra, K., Mohan, C. K., Ranka, S. (1997). Elements of Artificial Neural Networks. Complex

Adaptive Systems, Bradford Books, pp. 189, ISBN: 0-262-13328-8.



69

Michalski, R. S., Mozetic I., Hong J., Lavrac, N. (1986). The Multi-Purpose Incremental Learning

System AQ15 and its Testing Application to Three Medical Domains. Department of

Computer Science, University of Illinois at Urbana-Champaign.

Neal, R. & Hinton, G. (1998). A View of the EM Algorithm that Justifies Incremental, Sparse, and

Other Variants. in Learning in Graphical Models, M. Jordan (ed.), Dordrecht: Kluwer

Academic Publishers, Boston, MA., pp. 355–368.

Revathl, S. & Nalini, T. (2013). Performance Comparison of Various Clustering Algotrithm.

International Journal of Advaned Research in Computer Science and Software

Engineering. ISSN: 2277-128X, Vol. 3, Issue 2, February 2013.

Sehagl, G. & Garg, K. (2014). Comparison of Varius Clustering Algorithms. International Journal of

Computer Science and Information Technologies (IJCSIT). ISSN: 0975-9646, Vol. 5

(3), 2014, 3074-3076

Servente, M. (2002). Algoritmos TDIDT Aplicados a la Minería de Datos Iinteligente. Facultad de

Ingenieria, Universidad de Buenos Aires.

Sharma, N., Bajpai, A., Litoriya, R. (2012). Comparison the Various Clustering Algorithms of Weka

Tools. International Journal of Emerging Technology and Advanced Engineering.

ISSN 2250-2459, Volume 2, Issue 5, pp. 73-80, May 2012.

Pappa, G. L., Freitas, A. A. (2004). Towards a Genetic Programming Algorithm for Automatically

Evolving Rule Induction Algorithms. Computing Laboratory, University of Kent.

Pappa, G. L., Freitas, A. A. (2006). Automatically Evolving Rule Induction Algorithms. Computing

Laboratory, University of Kent.

Quinlan, J. R. (1986), Induction of Decision Trees. Morgan Kaufmann Publishers, Vol. 1, Paginas 81 a

106. San Mateo, California, Estados Unidos.

Quinlan, J. R. (1993), C4.5: Programs for Machine Learning. Morgan Kaufmann Publishers. San

Mateo, California, Estados Unidos.



70

Vadeyar, D. A. & Yogish, H. K. (2014). Farthest First Clustering in Links Reorganization.

International Journal of Web & Semantic Technology (IJWesT), Vol. 5, No. 3, July

2014.

Wu, X., Kumar, V., Quinlan J. R., Ggosh, J., Yang, Q., Motoda, H., Mclachlan, G. J., Ng A., Liu, B.,

Yu, P.S., Zhou, Z., Steinbach, M., Hand, D. J., Steinberg, D. (2007). Top 10

Algorithms in Data Mining. Knowledge and Information Systems. January 2008,

Volume 14, Issue 1, pp 1-37.

APÉNDICES COMPORTAMIENTO DE INTEGRACIÓN DE ALGORITMOS PARA DESCUBRIMIENTO DE REGLAS DE PERTENENCIA A GRUPOS

TRABAJO FINAL DE LICENCIATURA EN SISTEMAS JOSÉ DAVID PANCHUK

71

A. Metodología

En este capítulo se describe la metodología utilizada para la creación de la herramienta software

utilizada en este trabajo. Primeramente se enumeran los requerimientos de la herramienta (Sección

A.1.), luego se muestra el análisis de la misma (Sección A.2.) donde se incluyen los diagramas de casos

de uso y de secuencia, y finalmente se despliega el diseño (Sección A.3) donde se incluye el diagrama

de clases.

A.1. Requerimientos

La herramienta de software para realizar los experimentos debe ser capaz de realizar todos los pasos

que estos conllevan, es decir, permitir:

Definir experimentos: mediante la definición de los valores que tomaran las variables que

conforman un escenario y la definición de parámetros de experimento como la cantidad de

iteraciones a realizar o la variación de variables en ciertos rangos.

Generar Dominios: una vez definido el escenario, la herramienta deberá poder generar un

dominio completo, compuesto por un conjunto de reglas y un conjunto de ejemplos que den

soporte a estas reglas.

Ejecutar Experimentos: la herramienta deberá permitir la ejecución de experimentos sobre los

dominios generados, un experimento conlleva la ejecución de algoritmos de agrupamiento y

luego de inducción sobre los dominios generados, el procesamiento de las salidas generadas por

cada algoritmo aplicado y la obtención del valor de interés del experimento que es el porcentaje

de reglas correctamente cubiertas mediante la contrastación de las reglas generadas

originalmente por la herramienta con las reglas obtenidas como salida de los algoritmos de

inducción.

Almacenar datos del experimento: la herramienta deberá ser capaz de almacenar los datos que

conforman los experimentos en una base de datos, estos datos incluye los datos que definen el

escenario y los resultados obtenidos a partir de la ejecución del experimento sobre ese

escenario.



72

A.2. Análisis

En esta sección se presenta el análisis realizado para la herramienta de software desarrollada para

realizar los experimentos de este trabajo, se comienza con los Casos de Uso (Sección A.2.1.) y luego se

presentan los diagramas de secuencia de la herramienta (Sección A.2.2.)

A.2.1. Casos de Uso

A continuación se presentan los casos de uso de la herramienta con un alto grado de abstracción, la

Figura A.1 representa las acciones que el experimentador realiza sobre el sistema.

Figura A. 1 – Diagrama de Casos de Uso con Alto nivel de abstracción.

A.2.1.1. Correr Experimentación Simple

En la Figura A.2 se observa un caso de uso más detallado del proceso de ejecución de una experiencia

simple, este tipo de experiencia no genera dominios por lo tanto debe seleccionarse uno que haya sido

previamente creado para cargarse, luego la herramienta continua mediante la ejecución del algoritmo

de agrupamiento y el algoritmo de inducción elegidos, para devolver como resultado las reglas

obtenidas.

A.2.1.2. Correr Experimentación Completa

En la figura A.2 se observa el caso de uso de una experiencia completa, en este tipo de experimento se

genera el dominio y luego se corren sobre este todos los algoritmos de agrupamiento e inducción para



73

formar todos los pares de algoritmos posibles, luego se determina el cubrimiento de reglas, entre las

reglas originales generadas con el dominio y las reglas obtenidas por el paso anterior.

Figura A. 2 – Diagrama de Casos de Uso Específico.



74

A.2.2. Diagramas de Secuencia

En esta sección se incluyen los Diagramas de Secuencia de Sistema de las acciones Experiencia Simple

(Sección A.2.2.1) y Experiencia Completa (Sección A.2.2.2).

A.2.2.1. Diagrama de Secuencia Experiencia Simple

En la Figura A.3 se muestra el Diagrama de Secuencia del Método Experiencia Simple, el

experimentador realiza un Experiencia Simple, para lo cual debe especificar la ruta hacia un archivo

que contenga un dominio previamente creado y debe seleccionar un algoritmo de agrupamiento y otro

de inducción con los cuales se realizara el experimento, el sistema se comunica con la entidad Dominio

para cargar los datos del dominio desde el archivo a la memoria, luego el sistema procede a ejecutar

sobre los ejemplos del dominio primero el algoritmo de agrupamiento seleccionado y luego sobre los

grupos de ejemplos obtenidos el algoritmo de inducción, como resultado se obtiene un conjunto de

reglas descubiertas que son devueltas al experimentador por medio de la interfaz gráfica.

Figura A. 3 – Diagrama de Secuencia Experiencia Simple.



75

A.2.2.2. Diagrama de Secuencia Experiencia Simple

En la Figura A.4 se muestra el Diagrama de Secuencia de una Experiencia Completa, el

Experimentador define los datos del dominio, con los cuales el sistema genera el dominio, es decir, las

reglas originales y los ejemplos que dan soporte a estas, luego el sistema ejecuta sobre los ejemplos

todas las combinaciones posibles de los algoritmos de Agrupamiento e Inducción con los que trabaja,

una vez obtenidas la totalidad de las reglas descubiertas el sistema realiza una comparación de las

reglas originales con las reglas descubiertas por cada combinación de algoritmos y se obtiene como

resultado un número que representa el porcentaje de reglas correctamente cubiertas para cada

combinación, estos porcentajes son devueltos al usuario mediante la interfaz gráfica.

Figura A. 4 – Diagrama de Secuencia Experiencia Completa.



76

A.3. Diseño

En esta sección se muestra el diseño de la herramienta software desarrollada, se presenta el diagrama

de clases de la misma y una breve descripción de cada clase.

A.3.1. Diagrama de Clases

En la Figura A.5 se muestra el diagrama de clases de la herramienta software.

Figura A. 5 – Diagrama de Clases.



77

A.3.1. Descripción de Clases

A continuación se describen las clases incluidas en el Diagrama de clases.

Experimentación: esta clase caracteriza los experimentos, recibe todos los parámetros que

definen un escenario y los parámetros que definen la cantidad de experimentos a realizar, ya sea

solo uno o una serie de experimentos donde varíen dos variables.

Experimento: esta es la clase principal de un experimento, sirve de conexión con la clase de

generación de dominio y la de contrastación de reglas, sus tareas incluyen: obtener el dominio,

ejecutar los algoritmos de agrupamiento e inducción sobre el dominio, y obtener los resultados

finales, y conectarse con la base de datos para almacenar tanto los datos del escenario como los

resultados obtenidos. Para ejecutar los algoritmos correspondientes de agrupamiento e

inducción, esta clase se conecta con las librerías donde se encuentran estos algoritmos.

GeneracionDominio: esta clase se encarga de generar los dominios para los experimentos, tiene

como entrada los parámetros del dominio definidos por el usuario y genera como salida el

conjunto de reglas originales y el conjunto de ejemplos que dan soporte a estas reglas.

ComparacionReglas: esta clase se encarga de realizar la contrastación de reglas originales con

reglas descubiertas con el objetivo de obtener el porcentaje de reglas correctamente cubiertas

para cada par de algoritmos de agrupamiento e inducción.



78



79

B. Manual de Usuario

A continuación se incluye el manual de usuario de la herramienta software desarrollada para llevar a

cabo los experimentos, se comienza dando una introducción a la misma (Sección B.1), luego se

continua con una descripción de los pasos para la correcta instalación y configuración de la herramienta

(Sección B.2) por último se describe como hacer uso de la herramienta (Sección B.3).

B.1. Introducción

La herramienta software desarrollada para esta tesis permite realizar experimentos con el fin de estudiar

el comportamiento de distintas combinaciones de algoritmos de agrupamiento e inducción al ser

ejecutados sobre distintos tipos de dominios generados por la misma herramienta de acuerdo a los

valores de entrada dados por el usuario.

A continuación se da una breve descripción de los componentes de la herramienta (Sección B.1.1.), el

lenguaje de programación utilizado (Sección B.1.2.) y las distintas librerías utilizadas (Sección B.1.3.)

B.1.1. Componentes de la Herramienta

La herramienta está integrada por los siguientes elementos:

Las clases que contienen toda la lógica de la aplicación y que permiten realizar los

experimentos, además de servir como conexión con la base de datos, estas clases se encuentran

dentro del archivo JAR ejecutable desde el cual se ejecuta el sistema.

Las librerías utilizadas por la herramienta, donde se encuentran los algoritmos utilizados para

correr los experimentos, estas librerías están incluidas dentro del JAR ejecutable.

La base de datos utilizada para realizar la persistencia de los datos de entrada a la herramienta y

los datos de salida.

B.1.2. Plataforma y Lenguaje

El sistema fue desarrollado en lenguaje de programación JAVA, utilizando como motor de base de

datos PostgreSQL, la decisión de utilizar JAVA como lenguaje para la programación se basó en la

facilidad de uso y rapidez que presenta, además de la amplia gama de librerías de algoritmos de minería



80

de datos que utilizan este lenguaje, otra de las ventajas de la utilización de JAVA es que es

multiplataforma y los ejecutables JAR obtenidos pueden utilizarse tanto en sistemas operativos

Windows como Linux.

B.1.3. Librerías Utilizadas

En esta sección se nombran y describen las librerías utilizadas por la herramienta las cuales incluyen

WEKA (Seccion B.1.3.1), WEKA Classification Algorithms (Seccion B.1.3.2) y KEEL (Seccion

B.1.3.3)

B.1.3.1. WEKA

WEKA (Weikato Environment for Knowledge Analysis), o Entorno Weikato para el análisis de

conocimiento, es un entorno de trabajo que incorpora varias técnicas de Machine Learning creado por

la universidad de Weikato, Nueva Zelanda. Las librerías de algoritmos utilizadas por WEKA son de

código abierto, y pueden ser utilizadas por cualquier persona para sus desarrollos propios, la librería

incluye algoritmos para el pre-procesamiento de los datos, clasificación, regresión, clustering, minería

de reglas de asociación y visualización.

B.1.3.2. WEKA Classification Algorithms

Este proyecto funciona como complemento a la librería principal de WEKA, provee la implementación

de una serie de algoritmos de inteligencia artificial, entre los que se encuentra el algoritmo SOM, es un

software libre publicado bajo Licencia Pública General GNU.

B.1.3.3. KEEL

KEEL (Knowledge Extraction Based on Evolutionary Learning, o Extracción de conocimiento basado

en aprendizaje evolucionario) es una herramienta Open Source desarrollada en java que puede ser

utilizada para un gran número de diferentes tareas de descubrimiento de conocimiento en datos,

contiene una gran variedad de algoritmos clásicos de extracción de conocimiento.



81

B.2. Instalación y Configuración

A continuación se especifican cuáles son los requerimientos software (Sección B.2.1) necesarios para

poder ejecutar la herramienta y las configuraciones (Sección B.2.2.) necesarias para que funciones de

manera correcta.

B.2.1. Requerimientos

En esta sección se describen cuáles son los requerimientos software para poder ejecutar la herramienta,

también se indica donde es posible conseguir estos software de manera gratuita, JAVA (Seccion

B.2.1.1) y PostgreSQL (Seccion B.2.1.2).

B.2.1.1 JAVA

Para poder ejecutar la herramienta software es necesario tener instalada la Máquina Virtual de JAVA

(JVM), es necesaria la versión 1.8 o superior, la JVM puede descargarse de forma gratuita en el

siguiente enlace: https://www.java.com/es/download/

B.2.1.2 PostgreSQL

La herramienta utiliza PostgreSQL como motor de base de datos para almacenar la información de

salida del sistema, además del motor de base de datos, es conveniente instalar pgAdmin, una

herramienta administradora de bases de datos y servidores de PostgreSQL que provee la ventaja de ser

amigable al usuario y contar con interfaz gráfica.

Tanto el motor de base de datos PostgreSQL como pgAdmin pueden ser descargados de esta página:

http://www.enterprisedb.com/products-services-training/pgdownload#windows

B.2.2. Configuración

Antes de poder utilizar la herramienta, es necesario realizar una serie de pasos antes, para lograr su

correcto funcionamiento:

Crear una base de datos en PostgreSQL para ser utilizada por la herramienta, existen dos

maneras de crear la base de datos, puede crearle utilizando la herramienta pgAdmin mencionada

anteriormente o mediante la consola SQL de PostgreSQL.

https://www.java.com/es/download/

http://www.enterprisedb.com/products-services-training/pgdownload#windows



82

Preparar las carpetas de uso del sistema, para esto deberá copiar la carpeta llamada

“ArchivosHerramienta” en el disco C: de su computadora, dentro de esta carpeta se encuentran

dos más, una llamada “ResultadosClusters” en la cual la herramienta creara archivos con

información temporal de los procesos que realiza, en su mayoría archivos ARFF con los

resultados de la aplicación de los algoritmos de agrupamiento, y una carpeta “Archivos” que

contiene archivos variados utilizados por la herramienta.

B.3. Uso de la Herramienta

En esta sección se describirá la forma de uso de la herramienta para realizar distintos experimentos,

mediante la descripción de las distintas ventanas que la conforman y el uso de ejemplos. Primeramente

se describe el modo de uso del módulo de Generación de Dominios (Sección B.3.1), luego el

funcionamiento de una Experiencias Simple (Sección B.3.2) y finalmente el modo de realizar una

experimentación completa (Sección B.3.3).

En la Figura B.1 puede observarse la ventana principal de la herramienta, que aparecerá cuando la

misma se ejecute, esta ventana funciona a modo de menú para re direccionar al usuario hacia cada tipo

de experimento que desee realizar.

Figura B. 1 – Ventana Principal Herramienta.



83

B.3.1. Generación de Dominio

Esta funcionalidad permite crear un dominio completo y guardarlo en un archivo “.arff” donde puede

ser consultado o utilizado más adelante para realizar una experiencia simple, en la Figura B.2 se

muestra la ventana de Generación de Dominio.

Figura B. 2 – Ventana Generación de Dominio.

En la parte de entrada de datos, denominada “Datos”, se deben especificar los valores que tomaran las

variables que definen el dominio, estas variables son (siguiendo el orden de la ventana): cantidad de

clases, cantidad de reglas por clase, cantidad de atributos, cantidad de ejemplos por regla, cantidad de

valores posibles por atributo, cantidad de atributos usados en regla, porcentaje de valores posibles por

atributo en regla y la semilla (Seed) a utilizar para generar los números aleatorios en la herramienta,

los campos de texto “Guardar en” y “Nombre” permiten definir en donde y que nombre tendrá el

archivo arff donde se almacena el dominio generado, si no se indica un nombre el archivo tendrá como

nombre la fecha y hora en que fue generado.

En el cuadro de texto ubicado a la derecha del lugar de entrada de los datos se despliegan las reglas

resultantes de la generación del dominio, mientras que en el archivo arff generado pueden encontrarse

cada uno de los ejemplos generados para estas reglas.

Los archivos “arff” (Attribute-Relation File Format) son utilizados por WEKA y otras librerías para

entrada de datos, estos archivos se componen de una estructura de tres partes, una cabecera donde se



84

define el nombre de la relación de los datos con el formato “@relation <nombre-de-la-relación>”,

luego se declaran los atributos que compondrán el archivo junto a su tipo con la siguiente sintaxis

“@attribute <nombre-del-atributo> <tipo>” y finalmente una sección de datos donde se declaran los

datos (ejemplos) que componen la relación separando con comas los atributos y con saltos de línea las

relaciones, antes de la declaración de los datos, se separa el resto de las secciones de esta mediante la

línea “@data”.

En la Figura B.3 se muestra un ejemplo del contenido del archivo arff generado al ejecutar la

generación de dominio mostrada en la imagen B.2, en ella se pueden observar cada una de las partes

mencionadas anteriormente.

Figura B. 3 – Ejemplo Contenido Archivo arff.



85

B.3.2. Experiencia Simple

Este experimento permite probar la inducción de reglas a partir de la carga de un dominio previamente

creado y guardado en forma de un archivo .ARFF

La ventana de inducción de reglas se muestra en la Figura B.4, esta se divide en tres partes, una parte

llamada “Datos” en la cual se selecciona el archivo .arff donde se encuentra guardado el dominio a

cargar, la selección se realiza presionando el botón “…” y seleccionando el archivo deseado, la

siguiente parte llamada “Algoritmos” es donde se selecciona un algoritmo de Clustering y otro de

Inducción para realizar el experimento, es importante cargar correctamente el número de “clusters” a

formar por el algoritmo al realizar el agrupamiento, este número vendrá dado por la cantidad de clases

distintas en las que se encuentran divididos los ejemplos del dominio, en el caso del ejemplo son dos,

en el campo “Index” debe cargarse cuál es la ubicación del atributo índice dentro del archivo con los

datos, generalmente el atributo índice es el último de la serie, en este caso el dominio posee cinco

atributos, numerados del 0 al 4, y el 5 es el atributo índice, la última parte de la ventana es el área de

texto donde se muestran los resultados del experimento.

Figura B. 4 – Ventana Experiencia Simple.



86

Una vez cargados todos los datos, se procede a hacer clic en el botón “Ejecutar” y los resultados se

mostraran en el campo correspondiente, como puede observarse en la Imagen B.5 que se muestra a

continuación.

Figura B. 5 – Resultados Experiencia Simple.

Figura B. 6 – Resultados Experiencia Simple II.



87

En la Imagen B.5 se observa los resultados del experimento utilizando el algoritmo de agrupamiento

SOM y el algoritmos de inducción J48, primero se muestran los resultados para el algoritmo de

agrupamiento, es decir como agrupo cada ejemplo del dominio, luego desplazando la barra lateral

pueden observarse los resultados del algoritmo de inducción seleccionado, es decir, las reglas obtenidas

mediante la inducción, un ejemplo de esto se muestra en la Imagen B.6 donde se muestran los

resultados del algoritmo A priori.

B.3.3. Experimentación Completa

Este tipo de experimentación es el principal del programa y fue el utilizado para realizar las

experiencias de la presente tesis, reúne las características de la experimentación completa observada

anteriormente y agrega la lógica de la complejidad del dominio al experimento, dando así la posibilidad

de automatizar la generación de escenarios de ser necesario, además se caracteriza por utilizar todas las

combinaciones de algoritmos en todos los experimentos y por guardar los resultados en la base de datos

para ser consultados luego.

Figura B. 7 – Ventana Experimentación Completa.



88

En la Imagen B.7 se puede observar la pantalla de esta experimentación en la herramienta, la misma se

encuentra dividida en tres partes, una de entrada de datos para el experimento, una parte opcional de

variación de valores de atributo y un cuadro de texto donde se muestran los resultados del experimento.

En la parte de entrada de datos, se deben especificar los valores que tomaran las variables que definen

el dominio, estas variables son (siguiendo el orden de la ventana): cantidad de clases, cantidad de reglas

por clase, cantidad de atributos, cantidad de ejemplos por regla, cantidad de valores posibles por

atributo, cantidad de atributos usados en regla, porcentaje de valores posibles por atributo en regla y la

semilla a utilizar para generar los números aleatorios en la herramienta, además, se puede definir un

porcentaje de entrenamiento, que indica que porcentaje de los ejemplos se usara para el entrenamiento

de los algoritmos, y como opcional la cantidad de iteraciones a realizar del experimento. Los campos

de texto “Guardar en” y “Nombre” permiten definir en donde y que nombre tendrá el archivo arff

donde se almacena el dominio generado, si no se indica un nombre el archivo tendrá como nombre la

fecha y hora en que fue generado.

Figura B. 8 – Ventana Experimentación Completa con Filtro de Complejidad.



89

En la parte superior del cuadro de datos es posible definir, si se desea, el tipo de dominio que se quiere

generar y la herramienta bloqueara los campos que definen el tipo de dominio seleccionado ya que se

encargara de darle un valor aleatorio al momento de realizar el experimento, el experimentador solo

podrá definir los valores de las variables que no definan al tipo de dominio, una explicación más

específica de este tema puede consultarse en el Capítulo 5 Sección 5.2.3 de esta tesis. En la Figura B.8

puede observarse un ejemplo de selección de tipo de complejidad Hipercompleja, por lo tanto los

campos bloqueados (en gris) serán definidos internamente por la herramienta al realizar el experimento.

En la sección “variar atributo” de la pantalla, puede definirse si se desea un rango de variación para dos

atributos, en la Figura B.9 se muestra un ejemplo de esto, en el ejemplo se desea variar los atributos

cantidad de clases y cantidad de reglas por clase, el primero en el rango de 2 a 5 con saltos de 1, es

decir el la variable cantidad de clases tomara los valores 2,3,4,5 y la variable cantidad de reglas por

clase tomara los valores 15,16,17,18,19,20,21. Por cada combinación de los valores la herramienta

realiza un experimento diferente, por lo tanto en este caso se realizaran 4 x 7 = 28 experimentos.

Figura B. 9 – Ventana Experimentación Completa con Variación de Atributos.



90

Como en las otras ventanas, en el cuadro de texto ubicado a la derecha se muestran los resultados del

experimento una vez ejecutado, en las siguientes Figuras B.10 y B.11 se muestra un ejemplo de los

resultados de un experimento, en el cuadro de texto primero se muestran las reglas encontradas por

cada algoritmo de inducción de acuerdo al agrupamiento realizado por cada algoritmo de agrupamiento

(Figura B.10) y luego se muestran los porcentajes de reglas correctamente cubiertas para cada

combinación de algoritmos (B.11).

Figura B. 10 – Resultados Ventana Experimentación Completa.

Figura B. 11 – Resultados Ventana Experimentación Completa II.



91

Los resultados obtenidos por este tipo de experimento también se almacenan en las tablas de la base de

datos a la que está conectada la herramienta, utilizando la herramienta pgAdmin, es posible acceder a

esta información almacenada, la tabla “escenario” contiene la información de los escenarios ejecutados,

es decir los valores de cada una de las variables que definen un dominio, en la Figura B.12 se muestra

esta tabla.

Figura B. 12 – Tabla Escenarios.

Figura B. 13 – Tabla Resultados.



92

Mientras que la tabla “resultados” contiene los resultados obtenidos para cada uno de estos escenarios,

cada valor de esta tabla representa el porcentaje de reglas correctamente cubiertas para par de

algoritmos establecido en el encabezado de cada columna, estos datos pueden utilizarse en otros

programas como Excel si se desea para obtener más información a partir de ellos, como promedios o

gráficos, la tabla resultados se muestra en la Figura B.13.

COMPORTAMIENTO DE INTEGRACIÓN DE …sistemas.unla.edu.ar/sistemas/gisi/TFLS/Panchuk-TFL.pdf · Figura 2. 19 - Ejemplo de cubrimiento donde las condiciones entre reglas son diferentes.

Documents