Diseño de un algoritmo de minería de datos

basado en grafos para la tarea de

aprendizaje de conceptos
Por

Rigoberto Salomón Fonseca Delgado

Tesis sometida como requisito parcial para obtener el grado de

MAESTRO EN CIENCIAS EN LA ESPECIALIDAD DE

CIENCIAS COMPUTACIONALES

en el

Instituto Nacional de Astrofísica, Óptica y Electrónica

Tonantzintla, Puebla
Febrero 2012

Supervisada por:

Dr. Jesús A. González Bernal

Investigador del INAOE

Dra. María del Pilar Gómez Gil

Investigadora del INAOE

Dr. Iván Olmos Pineda

Profesor Investigador Facultad de Ciencias de la Computación
Benemérita Universidad Autónoma de Puebla

©INAOE 2012
Derechos Reservados
El autor otorga al INAOE el permiso de reproducir y
distribuir copias de esta tesis en su totalidad o en
partes
 A mi familia

I
II
Agradecimientos

Primero quiero agradecer al pueblo de México por pagar sus impuestos y brindarme la
oportunidad de realizar la Maestría en Ciencias de la Computación.

Le agradezco al CONACyT el apoyo otorgado a través de la Beca para estudios de

Maestría # 40281. Este trabajo fue parcialmente apoyado por el Proyecto CONACYT
88990-B.

Un agradecimiento muy especial a las personas que dirigen y conforman al

CRECTEALC y al INAOE.

Agradezco directamente a mis asesores: el Dr. Jesús González, la Dra. Pilar Gómez y
el Dr. Iván Olmos.

Aprovecho para agradecerles con mucho cariño a mi familia, a Liliana, y a mis amigos
por estar siempre a mi lado.

III
IV
Resumen

En muchos dominios se está volviendo cada vez más común almacenar datos que
poseen inherentemente una estructura o características relacionales. Este tipo de datos se
representan mejor con grafos, los cuales pueden, de forma natural, representar entidades,
sus atributos, y su relación con otras entidades. En este trabajo de tesis se presenta un
algoritmo de minería de datos con una primera fase no supervisada para dividir los datos, y
otra fase supervisada que realiza la minería generando solo candidatos posibles para
obtener patrones útiles en la tarea de clasificación sobre datos estructurados. La primera
parte que se diseñó fue un novedoso espectro para grafos etiquetados. Este espectro se
implementó en un algoritmo de agrupamiento de grafos denominado Spectral_SOM. Los
grafos etiquetados de entrada se transforman a su representación espectral y se le dan como
entrada a una red SOM capaz de agrupar estos grafos en tiempo polinomial, lo que se
muestra con el análisis de complejidad realizado. La segunda parte que se desarrolló es un
algoritmo de minería de datos basado en grafos para buscar conceptos, CL_COBRA. Este
algoritmo utiliza códigos DFC y requirió modificar el algoritmo SICOBRA para
aprovechar en mejor manera la búsqueda de subgrafos isomorfos. Finalmente, se integró
Spectral_SOM con CL_COBRA para obtener el algoritmo KODISSOM_COBRA,
resultado de esta tesis. El algoritmo fue evaluado con conjuntos de datos sintéticos y datos
reales. Los resultados muestran que los patrones encontrados son competitivos en la tarea
de clasificación con los encontrados por el algoritmo de aprendizaje de conceptos basado
en grafos SubdueCL. El algoritmo desarrollado puede mejorar su tiempo de ejecución
aumentando el soporte mínimo requerido, sin embargo existe un compromiso entre tiempo
de ejecución y calidad de patrones encontrados. Un resultado adicional es la
implementación de un marco de trabajo inicial para manejar grafos, con utilidades de
agrupamiento, extracción de características, isomorfismo, dibujado de grafos y minería de
datos.

V
VI
Abstract

In many domains, it is becoming more common to store data that inherently possess a
structure or relational features. Such data are better represented with graphs, which can
quite naturally, represent entities, its attributes, and their relationship with other entities. In
this thesis, we present a data mining algorithm firstly with an unsupervised phase to divide
the data, and another supervised phase that performs data mining generating only possible
candidates to find useful patterns in the classification task for structured data. The first task
was to design a new spectrum for labeled graphs. This spectrum was implemented in the
graph clustering algorithm called Spectral_SOM. The input labeled graphs are transformed
in their spectral representation, which are given as input to an SOM network; this network
can group these graphs in polynomial time, which is shown through the complexity
analysis performed. The second task developed was a data mining graph based algorithm
for searching concepts, CL_COBRA. This algorithm uses DFC codes and it was necessary
to modify the SICOBRA algorithm to better use the isomorphic subgraphs searching.
Finally, the CL_COBRA algorithm was integrated with Spectral_SOM to develop the
algorithm KODISSOM_COBRA, result of this thesis. The algorithm was tested with sets of
synthetic data and real data. The results show that the patterns found are competitive in the
classification task with those found by the concept learning graph based algorithm
SubdueCL. The algorithm developed can improve the runtime increasing the minimum
support required, but there exists a compromise between runtime and quality of patterns
found. An additional outcome is the implementation of an initial framework for working
with graphs, with profits of clustering, feature extraction, isomorphism, graphs’ drawing
and data mining.

VII
VIII
Tabla de contenido

Capítulo 1. Introducción .............................................................................................. 1

1.1 Problemática actual........................................................................................... 1

1.1.1 Aprendizaje de conceptos.......................................................................... 1

1.1.2 Patrón útil o discriminativo ....................................................................... 2

1.1.3 Principales problemas en la búsqueda de conceptos ................................. 3

1.2 Objetivo general ............................................................................................... 4

1.3 Objetivos específicos ........................................................................................ 4

1.4 Propuesta de solución ....................................................................................... 5

1.5 Aportaciones ..................................................................................................... 8

1.6 Organización de esta tesis................................................................................. 8

Capítulo 2. Marco teórico ............................................................................................ 9

2.1 Conceptos preliminares .................................................................................... 9

2.2 La lista de códigos VEV (Vértice-Enlace-Vértice) ......................................... 12

2.3 Formas canónicas ........................................................................................... 14

2.3.1 Secuencia de códigos DFS ...................................................................... 15

2.3.2 Secuencias de códigos DFC .................................................................... 16

2.4 Mapas auto organizados ................................................................................. 18

2.5 Minería de datos basada en grafos (MDBG) .................................................. 19

2.5.1 Algoritmo SICOBRA .............................................................................. 20

2.5.2 Aprendizaje de conceptos........................................................................ 24

IX
 2.5.3 SubdueCL ................................................................................................ 25

2.6 Área bajo la curva ROC (“Receiver operating characteristics”) ................... 26

2.7 Resumen del marco teórico ............................................................................ 28

Capítulo 3. Trabajo relacionado ................................................................................. 29

3.1 Agrupando grafos como objetos ..................................................................... 29

3.2 La red neuronal SOM en la minería de datos ................................................. 30

3.3 La red neuronal SOM en el agrupamiento de grafos ...................................... 31

3.3.1 Agrupamiento utilizando el espectro del grafo ....................................... 31

3.4 Agrupamiento de grafos utilizando subestructuras frecuentes ....................... 32

3.5 Búsqueda de subgrafos útiles en grafos previamente clasificados ................. 32

3.5.1 Aprendizaje de conceptos con SubdueCL ............................................... 34

3.6 Resumen de los trabajos relacionados ............................................................ 34

Capítulo 4. Algoritmo propuesto ............................................................................... 37

4.1 Transformación de grafos ............................................................................... 37

4.1.1 Representación espectral de un grafo utilizando códigos VEV .............. 38

4.2 SOM para agrupar grafos utilizando su espectro............................................ 44

4.2.1 Propuesta de medida de evaluación del agrupamiento............................ 46

4.3 Búsqueda de patrones útiles utilizando códigos DFC .................................... 47

4.3.1 Algoritmo SICOBRA-Modificado .......................................................... 55

4.4 Integración de algoritmos Spectral_SOM y CL_COBRA ............................. 56

4.5 Resumen del algoritmo desarrollado .............................................................. 58

Capítulo 5. Resultados experimentales ...................................................................... 59

5.1 Conjuntos de grafos utilizados en la experimentación ................................... 59

5.2 Primer caso de prueba..................................................................................... 63

5.3 Segundo caso de prueba ................................................................................. 66

X
 5.4 Tercer caso de prueba ..................................................................................... 69

5.5 Cuarto caso de prueba..................................................................................... 74

5.5.1 Evaluación del algoritmo variando el número de grafos......................... 75

5.5.2 Evaluación del algoritmo variando el número de vértices y de enlaces.. 78

5.6 Quinto caso de prueba .................................................................................... 80

5.7 Discusión ........................................................................................................ 83

Capítulo 6. Conclusiones, aportaciones y trabajo futuro ........................................... 85

6.1 Conclusiones................................................................................................... 86

6.2 Aportaciones ................................................................................................... 87

6.3 Trabajo futuro ................................................................................................. 88

Referencias ................................................................................................................. 91

Anexo A. Definiciones Generales ................................................................................ 97

Anexo B. Documentación del Software ..................................................................... 109

Anexo C. SubdueCL ................................................................................................... 113

XI
XII
Índice de figuras

Figura 1.1 Diagrama de la solución propuesta ................................................................ 6

Figura 2.1 Ejemplo de la matriz de adyacencia de un grafo pesado . ..................... 11
Figura 2.2. Ejemplo de listas de códigos vértice-enlace-vértice. .................................. 13
Figura 2.3 Comparación códigos DFS y DFC............................................................... 17
Figura 2.4. Ejemplo de un mapa auto-organizado (Gómez Gil, 2010). ........................ 18
Figura 2.5. Buscando un isomorfismo de subgrafos basado en listas de códigos ......... 21
Figura 2.6. Matriz de confusión y métricas de desempeño calculadas ......................... 26
Figura 2.7. Área bajo dos curvas ROC .......................................................................... 28
Figura 3.1. Flujo de la minería basada en encontrar los subgrafos frecuentes .............. 33
Figura 4.1. Conjunto de grafos . ................................................................................. 40
Figura 4.2. Grafos pesados obtenidos asignados a partir de los grafos y . ... 43
Figura 4.3. Esquema del algoritmo de minería de datos KODISSOM_COBRA .......... 57
Figura 5.1. Ejemplo de la primera representación de moléculas utilizada .................... 61
Figura 5.2. Esquema de la segunda representación ....................................................... 61
Figura 5.3. Estadística obtenida con los datos del PTC ................................................ 64
Figura 5.4. Agrupamiento obtenido de los datos de prueba del caso 1. ........................ 65
Figura 5.5. Grafos coloreados de acuerdo al grupo al que fueron asignados ................ 66
Figura 5.6. Grafos del ejemplo casa de Subdue (González, Holder, & Cook, 2001). ... 70
Figura 5.7. Imágenes adaptadas del ejemplo casa de Subdue ....................................... 70
Figura 5.8. Ejemplo del proceso de expansión seguido ................................................ 71
Figura 5.9. Patrón encontrado por el algoritmo de CL_COBRA .................................. 72
Figura 5.10. Semillas utilizadas para generar los grafos del caso de prueba. ............... 75
Figura 5.11. Tendencia del tiempo de ejecución necesario al aumentar el número de
grafos del algoritmo CL_COBRA. ................................................................................ 76

XIII
Figura 5.12. Comparación de la ejecución de SubdueCL y CL_COBRA variando el
número de grafos. .......................................................................................................... 77
Figura 5.13. Tendencia de crecimiento en tiempo del agrupamiento realizado con la red
Spectral_SOM ............................................................................................................... 78
Figura 5.14. Tendencia en tiempo al aumentar el número de vértices y el soporte
mínimo utilizando el algoritmo CL_COBRA. .............................................................. 79
Figura 5.15. Comparación del algoritmo de CL_COBRA con el algoritmo SubdueCL
al utilizar ejemplos sintéticos en los que varía el número de vértices y de enlaces. ..... 80
Figura 5.16. Curvas ROC obtenidas con el algoritmo CL_COBRA y SubdueCL con los
datos del PTC ................................................................................................................ 82

XIV
Índice de tablas

Tabla 2.1 Cánones de ordenamiento para la construcción de secuencias DFS “Depth

First Search” (Yan & Han, 2002). ................................................................ 15
Tabla 2.2. Generación de secuencias de códigos DFC (Olmos Pineda, 2006). ............ 16
Tabla 2.3. Algoritmo SICOBRA, tomado de la tesis de Olmos (Olmos Pineda, 2006).
Devuelve verdadero si existe un subgrafo de isomorfo a . .................... 22
Tabla 2.4. Algoritmo de poda. ....................................................................................... 23
Tabla 2.5. Procesado recursivo de búsqueda. ................................................................ 24
Tabla 3.1. Trabajos relacionados más sobresalientes del estado del arte. ..................... 35
Tabla 4.1. Función de creación de códigos VEV ......................... 39
Tabla 4.2. Demostración de que la función de creación de códigos VEV es simétrica. 39
Tabla 4.3. Cálculo de la lista del grafo . ...................................................... 41
Tabla 4.4. Lista de los grafos y de la Figura 4.1. ........................... 42
Tabla 4.5. Matrices de adyacencia de los grafos y ...................................... 43
Tabla 4.6. Espectros de los grafos , y de la Figura 4.1. .................................. 44
Tabla 4.7. Algoritmo de entrenamiento Spectral_SOM. ............................................... 45
Tabla 4.8. Búsqueda de conceptos utilizando códigos DFC y SICOBRA. CL_COBRA
(Concept Learning COde Based Representation Algorithm). ...................... 49
Tabla 4.9. Función que crea un índice de todos los enlaces y grafos según su código
VEV. ............................................................................................................. 50
Tabla 4.10. Minar Subgrafos. Busca los subgrafos más útiles que crecen a partir de
enlaces con un código VEV dado. ................................................................ 51
Tabla 4.11. Procedimiento Visitar del Algoritmo SICOBRA.. ..................................... 54
Tabla 4.12. Algoritmo SICOBRA-Modificado. ............................................................ 55
Tabla 4.13. Algoritmo de poda modificado................................................................... 56
Tabla 5.1. Ejemplos de datos relacionados al clima ...................................................... 64

XV
Tabla 5.2. Resultados de comparar el agrupamiento obtenido por Spectral_SOM y
GraphClust con el agrupamiento del Experto. .............................................. 67
Tabla 5.3. Comparación del algoritmo Spectral_SOM y el algoritmo GraphClust
utilizando la representación sin electrones del conjunto PTC. ..................... 69
Tabla 5.4. Resultados del algoritmo CL_COBRA con la base de datos house. ............ 73
Tabla 5.5. Resultados del algoritmo Subdue_CL con la base de datos house............... 74
Tabla 5.6. Ejecución del algoritmo KODISSOM_COBRA con redes SOM de 10x10,
5x5................................................................................................................. 83

XVI
 Capítulo 1. Introducción

1.1 Problemática actual

La cantidad de datos actualmente disponibles es muy grande y sigue creciendo cada

día. El descubrimiento de conocimiento en esta información es indispensable para una
correcta toma de decisiones. Esto ha motivado muchos avances en el área de
Descubrimiento de Conocimiento en Bases de Datos (KDD, por sus siglas en inglés)
(Fayyad, Piatetsky-Shapiro, & Smyth, 1996). Con frecuencia, estos datos solamente se
pueden describir con una representación estructurada, como son los predicados lógicos o
los grafos. Este es el caso de las bases de datos de proteínas, los árboles filogenéticos, los
grafos moleculares, páginas Web, etc. Un grafo está compuesto por dos conjuntos, uno de
vértices y otro de enlaces entre pares de vértices (Godsil & Royle, 2001). La Minería de
Datos Basada en Grafos (GDM por sus siglas en inglés “Graph-Based Data Mining”) es la
tarea de encontrar patrones significativos, útiles y novedosos en una representación basada
en grafos de los datos originales (Holder & Cook, Graph-Based Data Mining, 2005).

1.1.1 Aprendizaje de conceptos

El aprendizaje de conceptos es la tarea de inducir una función (concepto) a partir de un

conjunto de ejemplos de entrenamiento. Los ejemplos de entrenamiento están clasificados
como positivos si pertenecen al concepto; tienen una clasificación negativa en caso
contrario. Los ejemplos de entrenamiento son utilizados para guiar la búsqueda de la
función objetivo. Al finalizar la tarea, esta función debe ser capaz de clasificar un nuevo
ejemplo correctamente. Este nuevo ejemplo no pertenece al conjunto de entrenamiento.
Entonces, si los ejemplos de entrada representan adecuadamente al dominio, es posible
aprender una función que permita reconocer nuevos ejemplos (González Bernal, 2001).

1
 Durante el aprendizaje de conceptos, el algoritmo de aprendizaje considera un número
de posibles hipótesis llamado espacio de hipótesis (el mismo que depende de la
representación de los datos) (González Bernal, 2001). Se dice que se genera candidatos
cuando se prueban todas las combinaciones posibles como espacio de hipótesis, aunque no
necesariamente se presenten en el conjunto de entrenamiento. El crecimiento de patrones
permite reducir el número de candidatos con respecto al enfoque a priori. (Gago, 2010).

1.1.2 Patrón útil o discriminativo

Un patrón es una expresión, definida en un lenguaje, la cual describe un conjunto de

objetos (García Barroto, 2010). Una lista de patrones discriminativos (útiles) se puede
aprovechar para decidir si un nuevo objeto pertenece o no pertenece a un conjunto en
particular. Tomando a cada patrón como una regla se tiene una lista de decisión. Una lista
de decisión es una lista ordenada de reglas conjuntivas. Para clasificar nuevos ejemplos las
reglas se evalúan en orden y la primera regla que se cumple sobre el ejemplo a clasificar es
utilizada para clasificarlo (Martí & Llisterri, 2002). No hay una metodología
universalmente aceptada para medir la calidad de una lista de patrones discriminativos. Sin
embargo, existen algunas propiedades deseadas que esta lista debe cumplir (García Barroto,
2010):

Ser discriminante.- Cada patrón debe cubrir un cantidad significativa de objetos

(generalmente delimitado por un umbral de número de apariciones) en una clase, y un
pequeño grupo de objetos en la otra clase.

Simplicidad.- Deben ser pocos patrones, al menos un orden de magnitud menos que el
número de objetos. Violar esta propiedad puede degradar seriamente el grado de
comprensión del clasificador que utilice la lista de patrones.

No redundancia.- Cada patrón debe contener algún conocimiento nuevo, con respecto
al resto de patrones. Patrones redundantes pueden representar evidencia redundante en la
búsqueda de un objeto, desviando la clasificación a una clase en particular.

Generalidad.- Patrones que cubren un amplio número de objetos, generalmente, tienen

menos ruido.

2
 En esta tesis se evalúa la calidad de la lista de patrones (subgrafos) encontrados a
través de la tarea de clasificación. Esta estrategia se la utiliza exitosamente con el algoritmo
SubdueCL (González, Holder, & Cook, 2001).

En el dominio de grafos, la búsqueda de patrones útiles o discriminativos necesita

realizar pruebas de isomorfismo de subgrafos en los grafos de entrada, el cual es un
problema NP-Completo (Garey & Johnson, 1979). Algunos algoritmos de GDM dividen
los datos de entrada en varios grupos (Reforgiato, Gutierrez, & Shasha, 2008), con el
objetivo de reducir la complejidad en la búsqueda de patrones; de esta manera el número de
comparaciones entre los elementos se reduce.

Los algoritmos de minería de patrones útiles siguen dos estrategias diferentes para
obtener una alta calidad en el conjunto de patrones (García Barroto, 2010):

 Extraer patrones que pertenezcan a una familia particular:

o Patrones que cubren objetos de una clase única, siguiendo una estrategia
en particular.
o Patrones mínimos con respecto al conjunto de inclusión de sus
respectivas propiedades.
 Filtrar un amplio conjunto de patrones, buscando un subconjunto con las
propiedades deseadas.

1.1.3 Principales problemas en la búsqueda de conceptos

La búsqueda de conceptos en ejemplos representados como grafos requiere mucho

tiempo computacional, es necesario disminuir el número de operaciones para poder trabajar
con bases de datos de mayor tamaño. La diminución del número de operaciones se puede
plantear como dos problemas:

Problema 1. Dividir los ejemplos de entrada en conjuntos prometedores para poder trabajar
con conjuntos de menor tamaño. Esto se hace para no tener que comparar con todos los
ejemplos al mismo tiempo. Una de las dificultades en el agrupamiento inicial es encontrar
similaridades entre los grafos. Una forma de resolver este problema es: comparando los
grafos directamente mediante isomorfismo de subgrafos, pero cada comparación requiere

3
muchas operaciones. Para hacer un agrupamiento de los ejemplos de una manera eficiente,
se requiere de una representación apropiada de los grafos etiquetados que no necesite
pruebas de isomorfismo de subgrafos.

Problema 2. En la búsqueda de subgrafos útiles se han visto dos tendencias principales. La

primera es seguir una estrategia a priori generando candidatos, en esta línea SubdueCL
encuentra grafos útiles en la tarea de clasificación. La segunda tendencia es encontrar
primero los subgrafos frecuentes y a partir de ellos buscar los subgrafos que mejor
discriminan a una clase en particular (Ketkar, Holder, & Cook, 2009). En la búsqueda de
subgrafos frecuentes el crecimiento de patrones genera menos candidatos que la estrategia a
priori (Gago, 2010). La tarea de encontrar todos los subgrafos frecuentes puede generar un
conjunto de búsqueda demasiado grande (Eberle & Holder, 2011).

Con la finalidad de resolver estos problemas se plantearon los siguientes objetivos.

1.2 Objetivo general

Diseñar un algoritmo de minería de datos basado en un agrupamiento no supervisado

de grafos y un crecimiento de patrones con códigos DFC, para obtener patrones útiles en la
tarea de clasificación sobre datos estructurados.

1.3 Objetivos específicos

1) Diseñar una extensión de la red neuronal SOM para dividir el espacio de búsqueda
de una manera no supervisada y obtener patrones representativos de cada sub-
espacio.
2) Diseñar un algoritmo que expanda los patrones utilizando códigos DFC para la tarea
supervisada de aprendizaje de conceptos.
3) Integrar los algoritmos de los primeros dos objetivos específicos en uno que reciba
grafos y devuelva patrones útiles para la clasificación.

En seguida se muestra la propuesta de solución desarrollada.

4
1.4 Propuesta de solución

Con el objetivo de resolver el primer problema se agrupan los grafos de entrada. El

agrupamiento utiliza las características principales del grafo representadas por su espectro1.
Con esto se evita realizar pruebas de isomorfismo y se consigue un agrupamiento más
eficiente. En el estado del arte se observa que para utilizar el espectro de un grafo
etiquetado no se consideran las etiquetas de sus enlaces. En esta tesis se desarrolló un
novedoso espectro que asigna pesos a los enlaces en función de las etiquetas de sus vértices
y enlaces. Así, el espectro obtenido es más representativo que los métodos mostrados en el
estado del arte que no consideran las etiquetas de los enlaces.

El segundo problema se resuelve realizando un crecimiento de patrones en profundidad

utilizando códigos DFC y el algoritmo SICOBRA-modificado. De esa forma realiza un
aprendizaje de conceptos sin generación de candidatos. El algoritmo, encuentra patrones
relevantes sin tener que realizar la búsqueda de todos los patrones posibles. Los algoritmos
se integran como se muestra en la Figura 1.1.

En la Figura 1.1 se muestra la entrada al algoritmo que consiste en un conjunto de

grafos positivos y negativos previamente etiquetados. Al finalizar el algoritmo se encuentra
una lista de patrones que mejor representan a los ejemplos (grafos) positivos y que menos
representen a los ejemplos negativos. En el primer paso se dividen los grafos de entrada en
grupos prometedores para poder manejar grandes conjuntos de datos. La división se realiza
utilizando el espectro propuesto y una red neuronal SOM. Este algoritmo de agrupamiento
de grafos etiquetados lo denominamos Spectral_SOM. Las redes neuronales SOM (Self-
Organizing Maps) han mostrado ser muy útiles en la minería de datos (Vesanto &
Alhoniemi, 2000). A continuación, en cada grupo se realiza la búsqueda de patrones útiles.
El algoritmo que realiza la búsqueda se denominó CL_COBRA (“Concept Learning –
Code Based Representation Algorithm”), el mismo que sigue un crecimiento de patrones
utilizando códigos DFC y el algoritmo SICOBRA (Olmos, González, & Osorio, 2006)
modificado para discriminar en cuantos grafos positivos y en cuantos grafos negativos se
presenta un subgrafo dado.

1
El espectro de un grafo es el conjunto de eigenvalores de su matriz de adyacencia. Ver el Capítulo 2.

5
 Figura 1.1 Diagrama de la solución propuesta

Finalmente, los patrones encontrados por CL_COBRA en cada grupo son integrados en
una sola lista. Toda la solución propuesta fue llamada KODDISSOM_COBRA
(“KnOwledge DIscovery using Spectrum in SOM and COde Based Representation
Algorithm”).

Los algoritmos fueron evaluados individualmente con conjuntos de prueba sintéticos y

con datos reales. Los datos sintéticos fueron creados manualmente y también utilizando el
software subgen. Los datos reales utilizados son los del torneo de predicción toxicológica
(PTC, por sus siglas en inglés) y el conjunto Esponjas del repositorio de aprendizaje
automático UCI. La descripción de cómo se construyeron los grafos se encuentra en el
Capítulo 5.

El algoritmo Spectral_SOM es capaz de agrupar grafos etiquetados no dirigidos con

una complejidad de orden polinomial, esto se muestra en el Capítulo 4. El algoritmo de
agrupamiento fue evaluado con ejemplos sintéticos de forma manual y con ejemplos reales
de forma automática. En el experimento con ejemplos sintéticos la Spectral_SOM dividió
el conjunto de grafos perfectamente.

En la evaluación automática se comparó el agrupamiento obtenido por el algoritmo con

el propuesto por un experto. La comparación se realizó con una función propuesta en esta
tesis (CQ), en la cual el mejor valor posible es 1, y también se evaluó con la función de
similaridad de agrupamientos desarrollada por Rand (Rand, 1971). El agrupamiento
obtenido por Spectral_SOM se comparó con el agrupamiento devuelto por el algoritmo
GraphClust (Reforgiato, Gutierrez, & Shasha, 2008). El algoritmo GraphClust no considera
las etiquetas de los enlaces como los otros algoritmos del estado del arte. Este algoritmo se

6
ejecutó con sus parámetros por defecto. En ambos conjuntos reales Spectral_SOM obtuvo
mejores resultados que la ejecución de GraphClust con sus parámetros por defecto. Por otro
lado, se buscó la mejor combinación posible de parámetros para GraphClust. Con estos
parámetros los resultados obtenidos por este algoritmo fueron competitivos con los
devueltos por Spectral_SOM. Sin embargo, GraphClust utiliza subgrafos encontrados con
Subdue, buscar estos patrones tiene una complejidad exponencial mientras que
Spectral_SOM tiene una complejidad polinomial.

El algoritmo CL_COBRA fue probado el conjunto “Casa”, cuya referencia se detalla

en el Capítulo 5. En esta evaluación, el algoritmo encontró el subgrafo que mejor
discrimina a los ejemplos positivos de los negativos. El algoritmo fue probado con
diferentes conjuntos de grafos variando el número de grafos y el número de vértices. Con
estos datos, los resultados muestran el tiempo de ejecución del algoritmo depende del
número de vértices. Finalmente, el algoritmo fue probado con los datos del PTC. Entonces,
se compararon los patrones encontrados por CL_COBRA con los encontrados por
SubdueCL con el clasificador “Test”. Este clasificador se encuentra en el sitio de Subdue.
El algoritmo CL_COBRA tuvo resultados competitivos a los del algoritmo SubdueCL. En
cuanto a tiempo de ejecución la búsqueda “beam” implementada por SubdueCL fue más
eficiente en el conjunto PTC, pero fue competitiva en el dominio “Casa”. De esto se
concluye que la implementación del algoritmo CL_Cobra se puede mejorar, y de esta forma
se podrán tener mejores resultados en tiempo comparado con el algoritmo SubdueCL
(González, Holder, & Cook, 2001).

Una alternativa para disminuir el tiempo de ejecución de CL_COBRA es dividir los

datos de entrada y así poder ejecutar el mismo algoritmo con diferentes datos en diferentes
equipos. El algoritmo KODISSOM_COBRA permite ejecutar Spectral_SOM y
CL_COBRA en un mismo equipo. Se ejecutó este algoritmo con los datos del PTC. En este
dominio se puede ver que existe un compromiso entre el tiempo de ejecución y la calidad
de patrones encontrados. El tiempo de ejecución disminuye al aumentar el número de
grupos sin embargo la precisión obtenida fue máxima al trabajar con un solo conjunto.

7
1.5 Aportaciones

En este trabajo se realizan las siguientes aportaciones:

 Se diseñó una representación espectral de un grafo etiquetado que resume sus

características. Esta representación incluye información estructural y de las
etiquetas tanto de vértices como de enlaces. Además, la representación permite
un agrupamiento de grafos como objetos de una manera eficiente.
 Se diseñó un algoritmo de aprendizaje de conceptos utilizando códigos DFC y
SICOBRA-modificado.
 Se diseñó un algoritmo de minería de datos integrando un agrupamiento basado
en el espectro y el aprendizaje de conceptos utilizando códigos DFC y
SICOBRA-modificado.

1.6 Organización de esta tesis

Este documento está organizado de la siguiente manera. El capítulo dos presenta los
conceptos necesarios para entender claramente el problema y el resto de la tesis. El capítulo
tres resume el estado del arte de la minería de datos basada en grafos. El capítulo cuatro
contiene el algoritmo desarrollado. Los experimentos realizados y sus resultados se
presentan en el capítulo cinco. El capítulo seis contiene las conclusiones, aportaciones y
trabajo futuro.

8
 Capítulo 2. Marco teórico

En este capítulo se describen los conceptos básicos necesarios para entender el

problema de la minería de datos basada en grafos y otros conceptos. Se inicia introduciendo
definiciones de teoría de grafos. Se describe la red neuronal SOM y su utilidad en minería
de datos. Se explican las ventajas de los códigos DFC y su aplicación en el problema del
isomorfismo de subgrafos. Se da una introducción del algoritmo SubdueCL que realiza
aprendizaje de conceptos basado en grafos.

2.1 Conceptos preliminares

Las organizaciones continuamente están investigando cómo tomar mejores decisiones

basadas en sus datos. Los medios actuales permiten almacenar datos más complejos y en
mayores cantidades. Ejemplos de estos datos son los componentes químicos, estructuras de
proteínas, bases de datos XML, enlaces de páginas Web, redes sociales, etc. (Soussi,
Aufaure, & Baazaoui, 2010). Estos datos se representan de manera natural a través de
grafos, cuyo uso ha sido muy exitoso en tareas de aprendizaje y minería de datos (Holder &
Cook, Graph-Based Data Mining, 2005). Los grafos son un modelo general del cual
descienden otras representaciones como los árboles, las rejillas, las secuencias (Han &
Kamber, 2006). A continuación se da una definición formal de un grafo y de otros términos
asociados.

Un grafo está compuesto por un conjunto de vértices y un conjunto de enlaces

. Un enlace es un par no ordenado de vértices que se denota . Un grafo
es subgrafo de si y y se denota (Godsil & Royle, 2001).
Además, si se especifica la dirección de la relación se tiene un grafo dirigido. Por otro lado
un grafo pesado tiene asociado una función de pesos satisfaciendo que
si existe un enlace y 0 en caso contrario. Un grafo puede ser representado

9
por la matriz de adyacencia (Godsil & Royle, 2001). Ésta es una matriz entera con
filas y columnas indexadas por los vértices de , tal que la entrada de es igual al
peso del arco desde a . La matriz de adyacencia contiene elementos, donde es el
número de vértices en el grafo.

La comparación de grafos tiene un alto costo computacional. Se dice que dos grafos
y son isomorfos si existe una función de mapeo biyectiva (uno a
uno) (llamada un isomorfismo) tal que sí y solo si .
Cuando se busca un subgrafo contenido en un grafo se tiene que resolver el problema de
isomorfismo de subgrafos. Éste es un problema del tipo NP-Completo2, demostrado por
Garey (Garey & Johnson, 1979).

Una manera de representar un grafo es a través de los componentes principales de su

matriz de adyacencia (Jolliffe, 2002), a fin de reducir la dimensionalidad de los datos
reteniendo lo más posible la variación entre los diferentes grafos involucrados. Una forma
de extraer las características de la matriz de adyacencia de un grafo no dirigido es por
medio de sus valores propios. Dada una matriz simétrica de dimensión y la
ecuación:

(2.1)
Donde es un escalar y es un vector , si la ecuación (2.1) tiene una solución de
para un no nulo, entonces se denomina valor propio, raíz característica o raíz latente
de , y el vector no nulo que satisface la ecuación para un en particular es llamado
vector propio, vector característico o vector latente correspondiente para (Mathai, 2008).

Para resolver la ecuación (2.1), primero se iguala a 0, entonces considerando que es

no nulo resulta la siguiente ecuación:

(2.2)
Al evaluar el determinante de se obtiene un polinomio conocido como
polinomio característico. Las raíces de este polinomio son los valores propios de la matriz
A.

2
Ver definición de NP-Completo en el anexo A.

10
 A continuación se presenta un ejemplo del cálculo de valores propios de la matriz de
adyacencia de un grafo pesado.

Dado el grafo que se muestra en la Figura 2.1. (a), la matriz de adyacencia se

muestra en (b), aquí se puede observar que las columnas y filas están asociadas con los
identificadores de cada vértice.

a) Grafo b) Matriz de adyacencia

1 2 3
1 0 1 1
2 1 0 1

3 1 1 0

Figura 2.1 Ejemplo de la matriz de adyacencia de un grafo pesado .

Al reemplazar la matriz de adyacencia en la ecuación (2.2) se obtiene el siguiente

polinomio:

Las raíces del polinomio son los valores característicos de , los mismos se muestran
a continuación:

Godsil y Royle (Godsil & Royle, 2001) definen al espectro de un grafo como la lista
de valores propios de su matriz de adyacencia , junto con sus multiplicidades (número de
apariciones). Por otro lado, dada una orientación arbitraria del grafo y la matriz de
incidencia3 de , entonces se tiene que el Laplaciano de es la matriz .
Esto implica que el Laplaciano considera las dos orientaciones posibles de cada enlace. De
aquí que el Laplaciano no depende de la orientación. Algunos estudios mencionan que es
más útil obtener el espectro a partir del Laplaciano de un grafo en vez de a partir de la

3
La matriz de incidencia es una matriz binaria, en la que las columnas de la matriz representan los
enlaces del grafo, las filas representan los vértices. Por cada vértice unido por un enlace se pone un uno en el
lugar correspondiente y se llena el resto de ubicaciones de con ceros (Godsil & Royle, 2001).

11
matriz de adyacencia (Schaeffer, 2007). La matriz simétrica se denomina
“Laplaciano Generalizado de ”, tal que cuando y son vértices adyacentes de
y cuando y son distintos y no adyacentes. Para un grafo pesado el
Laplaciano Generalizado se define como (Chung, 1994):

(2.3)

Donde es el peso en el enlace y es el número de enlaces de un vértice

conocido como grado. En conclusión, el espectro del Laplaciano Generalizado de un
grafo guarda las características principales del grafo (Godsil & Royle, 2001).

Al asignar etiquetas tanto a los vértices como a los enlaces se tiene un grafo etiquetado.
Se puede representar a un grafo etiquetado por la 6-tupla conformada por el conjunto de
vértices , el conjunto de enlaces , la lista de etiquetas de vértices y lista de etiquetas
de enlaces . Además, se requiere una función de obtención de etiquetas tanto de vértices
y una función de obtención de etiquetas de enlaces . Entonces un grafo etiquetado se
define como (Olmos Pineda, 2006):

(2.4)

2.2 La lista de códigos VEV (Vértice-Enlace-Vértice)

En un grafo, etiquetado dados los vértices y el enlace , cada

componente tiene una etiqueta respectiva. Así el vértice tiene la etiqueta , al vértice
le corresponde la etiqueta , y el enlace obtiene su etiqueta de .
Primeramente, se asume que las etiquetas están ordenadas. El código vértice-enlace-vértice
del enlace está formado por la tripleta , donde
, y si ; si
entonces , y . Los códigos VEV fueron
propuestos por Olmos (Olmos Pineda, 2006), se adaptó la notación para facilitar el trabajo
en esta tesis.

12
 En la construcción de la lista de códigos vértice-enlace-vértice se recorren los
enlaces del grafo y se aumentan en la lista , únicamente, los códigos diferentes.
La lista se ordena lexicográficamente, es decir dados dos códigos y
se dice que es menor a si se cumple cualquiera de las siguientes
condiciones:

(2.5)

En el ejemplo de la Figura 2.2: (a) es el grafo con la descripción de sus

componentes: (b) conjunto de vértices , el identificador de cada vértice se dibuja cerca del
vértice en (a), conjunto de enlaces , conjunto de etiquetas de vértices , conjunto de
etiquetas de enlaces , (c) muestra la función de asignación de etiquetas de vértices , (d)
la función de asignación de etiquetas de enlaces . En la parte inferior (e) muestra la lista
del grafo . La lista se ordenó siguiendo la ecuación (2.5), una vez ordenada se
asignó un identificador secuencial a cada código según su posición. Finalmente, a cada
enlace se le asigna un código respectivo como se muestra en (f).

(a) G 1 (b) (c)

A 1 A
a a
2 B
a a
B C A 3 A
2 4 5 4 C
b b
5 A
A
3
(d) (e) (f)
a 1
a 1 3
b 2 2
a 3 5
b 4 4
a 5 3
Figura 2.2. Ejemplo de listas de códigos vértice-enlace-vértice, (a) grafo , (b)
conjuntos de vértices , enlaces , etiquetas de vértices y etiquetas de enlaces , (c)
función de asignación de etiquetas de vértices , (d) función de asignación de etiquetas de
enlaces , (e) lista del grafo , (f) asignación de códigos a los enlaces del grafo.

13
 Prosiguiendo con las definiciones, un grafo es conectado si existe una secuencia de
distintos enlaces para cada par de vértices. Por otra parte, se tienen los conceptos de lazo,
camino y circuito. Un lazo en un grafo es un enlace que inicia y llega al mismo vértice. Un
camino es una secuencia de enlaces que unen un vértice origen con uno de destino. Un
circuito es una secuencia de enlaces que parten de un vértice dado y termina en el mismo
vértice (Godsil & Royle, 2001).

Un grafo árbol o simplemente árbol es un grafo conectado sin circuitos (Giudici E. &
Bris Lluch, 1997). Un vértice de un grafo dirigido se dice ser una raíz del grafo dirigido
si todos los vértices son accesibles desde . Un árbol con raíz (o árbol dirigido) es un grafo
dirigido tal que posee una raíz y su grafo asociado es un árbol (Caicedo Barrera, Wagner de
García, & Méndez Parra, 2010). Dado un grafo , un árbol de expansión o de cobertura es
un árbol que contiene todos los vértices de , aunque no necesariamente todos sus enlaces
(Yan & Han, 2002).

2.3 Formas canónicas

Una forma canónica es una secuencia de símbolos que identifica de manera única a
cada grafo. En la construcción de estas secuencias se requiere un ordenamiento de los
vértices del grafo. Este ordenamiento puede obtenerse mediante la búsqueda de árboles de
cobertura (Yan & Han, 2002). La construcción de estos árboles puede iniciar en cualquier
vértice. En consecuencia, existen muchas formas de realizar el ordenamiento de los
vértices. Mediante las formas canónicas se puede construir una descripción única de cada
grafo. Con este fin, se selecciona de entre todas las posibles secuencias que representan un
grafo, a la que se cumpla ciertos cánones o características especiales. Generalmente, esta
selección requiere realizar una búsqueda. Las búsquedas más usadas son: primero en
profundidad (“depth first”), primero en anchura o a lo ancho (“breadth first”), búsqueda
con un haz, “branch and bound” (Morales & Sucar, 2011).

Enseguida, se presentan dos criterios de ordenamiento, para encontrar la forma

canónica de un grafo, los códigos DFS, “Depth First Search” (Yan & Han, 2002) y los
códigos DFC, “Depth First Code” (Olmos, González, & Osorio, 2006).

14
2.3.1 Secuencia de códigos DFS

La construcción de una secuencia de código DFS sigue una estrategia de búsqueda

primero en profundidad. Las reglas o cánones utilizados en el ordenamiento de los códigos
DFS se muestran en la Tabla 2.1. Estas consideraciones para construir la secuencia definen
un orden lexicográfico ( ) entre dos aristas cualesquiera. Es importante notar que la
representación del grafo debe contener todos sus enlaces. Así, mientras los enlaces que son
parte del árbol de expansión se marcan como “hacia adelante, forward”, y los enlaces que
forman circuitos se señalan como “hacia atrás, backward” (Yan & Han, 2002).

En una secuencia de códigos DFC cada arista es representada por una 5-tupla
donde y son los índices de los vértices (origen y destino respectivamente),
y son las etiquetas de tales vértices, y es la etiqueta de la arista. Los enlaces hacia
delante se encuentran en el conjunto , mientras que los enlaces hacia atrás pertenecen al
.

En la Tabla 2.1 se muestran las reglas que se utilizan para ordenar los enlaces en una
secuencia de códigos DFS (Yan & Han, 2002). En resumen, en la construcción de un
código DFS, siguiendo una búsqueda en profundidad, primero se visitan los vértices cuya
etiqueta tenga el menor orden lexicográfico (Olmos Pineda, 2006).

Tabla 2.1 Cánones de ordenamiento para la construcción de secuencias DFS “Depth

First Search” (Yan & Han, 2002).

Sean y dos aristas cualesquiera, la relación de

orden se cumple si y solo si cumple una de las siguientes condiciones:
Si . Si .
Si . Si .
Si . Si .
Si . Si
.

15
2.3.2 Secuencias de códigos DFC

Los códigos DFC son una mejora de los códigos DFS. Estos se basan en las reglas de
orden lexicográfico DFS, pero además agregan dos restricciones en la selección de los
vértices (Olmos, González, & Osorio, 2006).

a) Primero, visitar los vértices de mayor grado,

b) Luego visitar los vértices cuya etiqueta tenga el mayor número de instancias en
el grafo,
c) Finalmente, visitar los vértices cuya etiqueta tenga el menor orden
lexicográfico.

El modelo DFC es una secuencia ordenada de códigos ,

donde: , son índices asociados a los vértices adyacentes del enlace ,
, es una marca que indica si se construyó hacia delante (“forward”) o hacia
atrás (“backward”). La construcción de la secuencia DFC se realiza con una estrategia
primero en profundidad basada en el algoritmo de Tarjan (Tarjan, 1971), visitando primero
los vértices que: a) tengan mayor grado, b) su etiqueta sea la más frecuente y c) menor
orden lexicográfico. Este algoritmo se muestra en la Tabla 2.2.

Tabla 2.2. Generación de secuencias de códigos DFC (Olmos Pineda, 2006).

Función
Entrada:
Salida:
1.
2.
.
3.
.
4.
.
.
5.
.
6.

7.
.

16
 El costo de construir una representación DFC es de , donde es el número
de vértices y el número de enlaces del grafo (Olmos Pineda, 2006).

A diferencia de los códigos DFS, los códigos DFC requieren almacenar el grado de los
vértices y la frecuencia de las etiquetas. Pero los códigos DFC funcionan mejor en aquellos
casos en que existan etiquetas repetidas y el grafo sea denso. Esto lo demuestra Olmos en
sus tesis de doctorado (Olmos Pineda, 2006). En el ejemplo de la Figura 2.3 ilustra la
ventaja de los códigos DFC sobre los códigos DFS.

Dado el grafo de la Figura 2.3, asumimos que el mismo grafo se puede construir
cambiando el orden de los vértices. El orden de los vértices se dibuja cerca de cada vértice.
Al utilizar códigos DFS existen dos opciones de raíz para el árbol de expansión de .
Seleccionar la raíz depende de cuál sea el vértice 1 (en verde como raíz), cambiando el
orden cambia la raíz tanto en b) como en c). En contraste, utilizando códigos DFC en este
caso existe un único vértice de inicio que es el vértice 4 en verde como raíz.

Grafo G DFS DFC

a) 1 b) 2 d) 1
A A A

C B A C B A C B 2
A
3 4 2 3 4 1 3 4

c) 1
A

C B A
3 4 2

Figura 2.3 Grafo con dos posibles inicios (con vértices 1 en color verde) utilizando
códigos DFS. En contraste, con los códigos DFC solo se tiene un posible inicio (con vértice
1 en color verde).

En el resto de esta sección se describen algoritmos que son utilizados más adelante en
esta tesis.

17
2.4 Mapas auto organizados

Los mapas auto organizados (SOM, Self-organizing maps) (Kohonen, 1990) son un
tipo de red neuronal compuesta por una capa de entrada y una o varias capas de salida. La
principal ventaja de la red SOM es transformar un vector de entrada de una dimensión
arbitraria en un mapa discreto de una o dos dimensiones. El mapa de salida está compuesto
por vectores prototipos, cada vector de entrada se conecta con todos los prototipos de
salida. La Figura 2.4 muestra en un ejemplo las partes de una red neuronal SOM (Kohonen,
1990).

Figura 2.4. Ejemplo de un mapa auto-organizado (Gómez Gil, 2010).

El algoritmo de entrenamiento es no supervisado. El proceso comienza inicializando

los pesos sinápticos en la red. Esto se puede realizar asignando valores aleatorios pequeños
(entre 0 y 1) a los prototipos. A continuación, se siguen tres procesos: competitivo,
cooperativo y adaptación sináptica.

Dado un número definido de iteraciones sobre el conjunto de entrenamiento, el

algoritmo adapta los pesos que conectan con la neurona ganadora. Esto lo hace en un
proceso de competencia entre todas las neuronas del nivel de salida. Entonces, la neurona
ganadora se define como el prototipo de menor distancia al ejemplo y se obtiene calculando
la distancia que hay entre el vector de entrada y cada uno de los pesos de cada neurona en
el nivel de salida como lo muestra la ecuación:

(2.6)

18
 En el proceso de cooperación se adaptan los pesos del vecindario de influencia de la
neurona ganadora, el que es representado por . La función se puede definir de
diferentes maneras, en el presente trabajo se hace por posiciones en una rejilla. Así se
consideran los 4, 8, 12, 16, 20 y 24 vecinos más cercanos a la neurona ganadora. El
coeficiente de aprendizaje disminuye conforme transcurren las iteraciones, la función
más recomendada (Haykin, 2005) para actualizar el coeficiente de aprendizaje es la
siguiente:

(2.7)

Donde es una constante de tiempo. La adaptación de los pesos de la red neuronal

SOM está dada por la ecuación:

(2.8)

2.5 Minería de datos basada en grafos (MDBG)

Holder (Holder & Cook, Graph-Based Data Mining, 2005) define la MDBG como la
tarea de encontrar patrones (grafos) que sean útiles utilizando una representación basada en
grafos de los datos originales. Una manera de realizar minería de datos es buscando los
subgrafos frecuentes. La minería de subgrafos frecuentes es un problema bastante
estudiado en el área de minería de grafos. Generalmente, en esta técnica se tiene un límite
de frecuencia dado por el usuario y se retornan todos los subgrafos que tengan una
frecuencia mayor o igual (Ranu & Singh, 2009). Los algoritmos que buscan subgrafos
frecuentes pueden ser divididos en las siguientes tres categorías (Smalter, Huan, Jia, &
Lushington, 2010).

Estrategia por niveles.- Los algoritmos generan todos los candidatos, evalúan y
seleccionan los frecuentes. En esta categoría se incluyen algoritmos como: "A-priori-based
graph mining (AGM) (Inokuchi, Washio, & Motoda, 2000)" y "frequent subgraph
discovery (FSG) (Kuramochi & Karypis, 2001)". Estos desarrollan una operación de unión
(join), la que toma un par de grafos de de entrada y produce un
supergrafo común a los dos grafos con .

19
 Estrategia de búsqueda en profundidad.- Estos comienzan de un grafo frecuente,
enumeran los supergrafos de G, seleccionan los frecuentes y repiten el proceso
recursivamente. Si ninguno de los supergrafos es frecuente, entonces se retrocede un nivel.
Algunos de estos algoritmos son gSpan (Yan & Han, 2002) y FFSM (Huan, Wang, & Prins,
Efficient Mining of Frequent Subgraph in the Presence of Isomorphism, 2003). La ventaja
de la búsqueda en profundidad es una mejor utilización de memoria y enumerar sus
supergrafos, en lugar de tener todos los subgrafos de en memoria.

Estrategia de minado progresivo.- No trabajan directamente en el espacio de grafos,

primero proyectan el espacio de grafos a otro espacio como árboles, entonces identifican
patrones en el espacio proyectado, y finalmente reconstruyen todos los patrones frecuentes
en el espacio de grafos. Algoritmos en esta categoría incluyen SPIN (Huan, Wang, Prins, &
Yang, SPIN: mining maximal frequent subgraphs from graph databases, 2004) y GASTON
(Nijssen & Kok, 2004).

El presente trabajo sigue la estrategia de búsqueda en profundidad, usando listas de

códigos “Depth First Code” (DFC) que son utilizados exitosamente en el algoritmo para el
problema de subgrafos isomorfos SICOBRA (Olmos Pineda, 2006).

2.5.1 Algoritmo SICOBRA

El algoritmo SICOBRA detecta instancias del grafo (subgrafo buscado) en

(supergrafo o conjunto de grafos). Su éxito radica en acercarse a una función que
retorne un etiquetado canónico del grafo; donde un etiquetado canónico significa que
si y solo si y son isomorfos (Fortin, 1996). El presente trabajo
implementa conceptos como la representación basada en secuencias de códigos, un modelo
de expansión paso a paso sin generación de candidatos, una búsqueda en anchura y
profundidad, y una fase de poda.

2.5.1.1 Representación basada en listas de códigos

El algoritmo SICOBRA inicia construyendo la secuencia de códigos DFC del grafo de
. Entonces explora el grafo usando el como guía, donde el proceso de
comparación trata de construir una secuencia lineal . Al encontrar dos secuencias

20
idénticas se tiene que es subgrafo isomorfo de y se representa . La Figura 2.5,
tomada de la tesis de Olmos (Olmos Pineda, 2006), muestra la búsqueda de la secuencia de
códigos en las posibles secuencias de códigos del grafo .

… …
…

…
=

Figura 2.5. Buscando un isomorfismo de subgrafos basado en listas de códigos.

Primero, el código es generado, entonces es explorado esperando construir un
con la misma dimensión y entradas que , tomada de la tesis de Olmos
(Olmos Pineda, 2006).

2.5.1.2 Descripción del algoritmo SICOBRA

El algoritmo SICOBRA realiza dos procesos importantes que son: una poda (Tabla
2.4) y el proceso recursivo de búsqueda (Tabla 2.5). El pseudo código general se muestra
en la Tabla 2.3. El algoritmo inicia construyendo la representación DFC del grafo que se
desea buscar (subgrafo). Le sigue una fase de podado que elimina muchas alternativas
inválidas, que son los enlaces que no cumplen con un soporte mínimo, los vértices que no
tienen el grafo mínimo de acuerdo a su etiqueta y los grafos que no tienen al menos el
mismo número de vértices y enlaces.

A continuación, se seleccionan los vértices mapeables al vértice inicial del primer

código del subgrafo objetivo. El vértice será mapeable a un vértice si tienen la

21
misma etiqueta, el grado del vértice es mayor o igual al grado del vértice . El conjunto
de los códigos de los enlaces adyacentes del vértice está contenido en el conjunto
del vértice .

Tabla 2.3. Algoritmo SICOBRA, tomado de la tesis de Olmos (Olmos Pineda, 2006).
Devuelve verdadero si existe un subgrafo de isomorfo a .

Función
Entrada: o grafo a buscar

Salida:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

12.

En la Tabla 2.4 se muestra el algoritmo de poda. El primer paso en la poda consiste en

remover todos los enlaces y vértices cuyas etiquetas no estén contenidas en el grafo
objetivo o grafo a buscar. A continuación, retira los enlaces que no cumplen un mínimo
número de repeticiones. Prosigue quitando los vértices que no cumplen con el mínimo
grado según la etiqueta. El resultado de la fase de poda es un conjunto de grafos conexos
que pueden ser isomorfos con el subgrafo objetivo. Este grupo de grafos se denomina
conjunto de grafos podado.

El costo computacional de la fase de poda, considerando el subgrafo buscado y el

supergrafo en el que se busca , está delimitado por

; lo demuestra Olmos en su tesis (Olmos Pineda, 2006).

22
 Tabla 2.4. Algoritmo de poda.

Función
Entrada:

Salida:
1.
.
2.
.
3.
:
y
.
4.
5.

Prosiguiendo, la fase de procesado realiza una iteración recursiva, buscando empatar

todos los vértices y enlaces del subgrafo objetivo con uno de los grafos devueltos por la
fase de poda en el conjunto . El algoritmo que se muestra en Tabla 2.5 sigue una
estrategia de búsqueda en profundidad, además respeta las reglas de generación de códigos
DFC. Termina cuando encuentra un grafo que sea isomorfo al subgrafo objetivo o haya
probado todos lo grafos de con lo cual se puede asegurar que no existe ningún
subgrafo isomorfo al subgrafo objetivo.

23
 Tabla 2.5. Procesado recursivo de búsqueda.

Función
Entrada:

Salida:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

2.5.2 Aprendizaje de conceptos

Según González (González Bernal, 2001), un concepto puede definirse como una
función capaz de clasificar correctamente un ejemplo como positivo o negativo. La tarea de
inducir esta función a partir de ejemplos previamente clasificados se denomina aprendizaje

24
de conceptos. Al finalizar la tarea, la función debe ser capaz de clasificar correctamente un
nuevo ejemplo que no estuvo en el conjunto de entrenamiento.

En el dominio estructurado se buscan las estructuras (subgrafos) que más representen a

los ejemplos positivos y menos a los negativos. Un concepto puede verse como el conjunto
de las mejores estructuras, también conocidas como patrones emergentes (García Barroto,
2010). El concepto aprendido es evaluado en la tarea de clasificación, dado un ejemplo
un clasificador le asigna la clase con mayor puntuación. La puntuación es calculada en base
a los subgrafos contenidos en .

2.5.3 SubdueCL

SubdueCL realiza la tarea de aprendizaje de conceptos. El algoritmo SubdueCL

(González Bernal, 2001) es una extensión del algoritmo Subdue. La entrada al algoritmo
son grafos clasificados previamente. El algoritmo sigue una estrategia tipo “set-covering”.
Es decir, el concepto encontrado es un conjunto de disyunciones de conjunciones.
SubdueCL forma una de estas conjunciones (reglas) en cada iteración. Los ejemplos
positivos que son descritos por una regla, encontrada en una iteración previa, son
removidos del conjunto de ejemplos para las iteraciones siguientes. Los ejemplos negativos
no son removidos.

En la evaluación de las subestructuras se busca las que mejor representen a los

ejemplos positivos y menos ejemplos negativos las contengan. Esto se logra considerando
una penalización ( ) a la subestructura que representa ejemplos negativos. La ecuación que
utiliza se muestra a continuación (González Bernal, 2001):

(2.9)

Donde las variables son: ejemplos positivos no cubiertos ( ), ejemplos

negativos cubiertos ( ), ejemplos negativos ( ), ejemplos positivos
( ) y penalización ( ). El algoritmo SubdueCL se pude ver con mayor detalle en el
Anexo C.

25
2.6 Área bajo la curva ROC (“Receiver operating characteristics”)

Una gráfica ROC es una técnica para visualizar, organizar y seleccionar clasificadores
basados en su desempeño (Fawcett, 2006). Estas gráficas presentan propiedades que las
hacen especialmente útiles para dominios con una distribución desbalanceada y diferente
costo de error por mala clasificación. Son conceptualmente simples, se puede iniciar su
estudio con problemas de clasificación usando dos clases. Formalmente, a cada ejemplo
(instancia) se le asigna un elemento del conjunto de clases positivas o negativas. Un
clasificador relaciona las instancias con las clases predichas. Para distinguir entre la clase
actual y la predicha se usan las etiquetas para las predicciones producidas por el
modelo.

Dada una clasificación y una instancia existen cuatro posibles salidas. Si la instancia es
verdadera y es clasificada verdadera, se cuenta como verdadero positivo; si la misma
instancia verdadera es clasificada como negativa, se cuenta como falso negativo. Si la
instancia es negativa y es clasificada como negativa, se cuenta como verdadero negativo; si
esa instancia negativa es clasificada como verdadera, entonces es contada como falso
positivo.

Dado un clasificador y un conjunto de instancias (el conjunto de prueba), una matriz de

confusión de dos por dos (también llamada tabla de contingencia) puede construirse
representando la disposición del conjunto de instancias. La Figura 2.6 muestra una matriz
de confusión. Los números de la diagonal mayor representan los resultados correctos,
mientras que los de la otra representan los errores (la confusión) entre varias clases.

Clase verdadera
p n

Y Verdaderos Positivos Falsos Positivos

Clase hipotética
N Falsos Negativos Verdaderos Negativos

Columnas totales: P N

Figura 2.6. Matriz de confusión y métricas de desempeño calculadas de la matriz

(Fawcett, 2006).

26
 La tasa de verdaderos positivos (también llamada tasa de éxito y recuerdo) de un
clasificador se estima:

(2.10)

La tasa de falsos positivos (también llamada tasa de falsa alarma) de un clasificador

es:

(2.11)

Otros términos asociados con las gráficas ROC se pueden ver en el Anexo A.

Las gráficas ROC son gráficas de dos dimensiones, en el eje se dibuja la

y la en el eje . Una gráfica representa la relación entres los beneficios
(verdaderos positivos) y el costo (falsos positivos), describiendo el desempeño de un
clasificador. Al comparar clasificadores se desea tener un escalar que represente su
desempeño. Un método común consiste en calcular el área bajo la curva ROC. Al tener
mayor área se tiene un mejor desempeño. Es posible que un clasificador tenga mejor
desempeño en una región específica del espacio ROC.

La Figura 2.7 muestra el área bajo la curva ROC de dos clasificadores A con fondo gris
y B con cuadrados. Se puede decir que el clasificador A tiene mejor desempeño en el
espacio derecho de la curva ROC, en cambio el clasificador B tiene mejor resultado en el
espacio izquierdo. En general, el clasificador B tiene mayor área bajo su curva y por lo
tanto se considera de mejor desempeño en general.

27
 Figura 2.7. La gráfica muestra el área bajo dos curvas ROC, la de cuadros del
clasificador B y la de fondo gris del clasificador A. El clasificador B tiene una mayor área
bajo la curva y en general se considera que tiene un mejor desempeño (Fawcett, 2006).

2.7 Resumen del marco teórico

En este capítulo se resumen los conceptos utilizados en el desarrollo de esta tesis. La

primera parte incluye conceptos básicos de teoría de grafos. También se introdujeron
definiciones de: valores propios, espectro del grafo pesado, códigos vértice-enlace-vértice,
códigos primero en profundidad (DFC por sus siglas en inglés), y la representación de
grafos basada en listas de códigos. Esta sección tiene la definición de la red neuronal SOM
que se utilizará para agrupar los grafos. El capítulo también contiene: el concepto de
minería de datos basada en grafos, el algoritmo de isomorfismo de subgrafos SICOBRA, el
algoritmo de aprendizaje de conceptos SubdueCL, y la gráfica que representa la relación
entres los beneficios y los costos ROC.

28
 Capítulo 3. Trabajo relacionado

En muchos dominios, la cantidad de datos disponibles ha incrementado tanto que los

humanos necesitan ayuda de métodos automáticos computarizados para extraer
información relevante. Además, se está volviendo más y más común almacenar datos que
poseen inherentemente una estructura o características relacionales. Este tipo de datos se
representan mejor con grafos, los cuales pueden, muy naturalmente, representar entidades,
sus atributos, y su relación con otras entidades (Da San Martino & Sperduti, 2010). En la
minería de datos en general, agrupar los ejemplos de entrada ha sido aplicado
eficientemente en la búsqueda de patrones útiles evaluados en la tarea de clasificación (Ng
& Han, 1994). En este capítulo se revisa el estado del arte de la minería de datos basada en
grafos. En forma particular el capítulo se enfoca al problema de agrupamiento de grafos
como objetos y al problema de obtener subgrafos útiles.

3.1 Agrupando grafos como objetos

En esta sección, se discute el problema de agrupar grafos en bases de datos con

múltiples grafos. Este problema se reduce a agrupar objetos arbitrarios, donde el objeto
tiene características estructurales. Muchos de los algoritmos convencionales se pueden
extender al caso de una representación basada en grafos. Los principales cambios
requeridos para realizar la extensión son los siguientes (Aggarwal & Wang, 2010):

 La mayoría de los algoritmos utilizan una función de distancia4 con el objetivo

de medir cuan similares son dos objetos. Entonces, se necesitan medidas
apropiadas para definir la distancia entre objetos estructurados. La distancia de
edición de grafos es una de las más utilizadas; sin embargo, calcular esta
distancia es un problema NP-difícil (Zeng, Tung, Wang, Feng, & Zhou, 2009).

4
La definiciones de función de distancia y función de similaridad se puede ver en (Irigoien & Arenas,
2006)

29
  Muchos de los algoritmos de agrupamiento, como k-means (Han & Kamber,
2006) utilizan objetos representativos como centroides con varios pasos
intermedios. Mientras esto requiere muchas operaciones en objetos de varias
dimensiones, se necesitan muchas más con objetos representados como grafos.
Por esta razón, se requieren métodos más apropiados con el fin de crear objetos
representativos. En algunos casos es más robusto utilizar extractos
representativos (Aggarwal & Wang, 2010).

3.2 La red neuronal SOM en la minería de datos

En el campo minería de datos no estructurados, Vesanto (Vesanto & Alhoniemi, 2000)

propone que la red neuronal SOM es una excelente herramienta en la fase de exploración.
Esta red neuronal definida originalmente por Haykin (Haykin, 2005), proyecta el espacio de
entrada en prototipos de baja dimensionalidad en una matriz regular. Estos prototipos se
pueden utilizar para visualizar y explorar propiedades de los datos. Además, permite
realizar un agrupamiento rápido, robusto y visualmente eficiente. La red propuesta por
Vesanto realiza el agrupamiento en dos etapas. Una vez entrenada la red SOM, en la
primera etapa por cada prototipo se crea un grupo. Entonces, todos los ejemplos son
comparados con todos los prototipos; al prototipo con menor distancia Euclidiana a un
ejemplo se le conoce como prototipo ganador o neurona ganadora de ese ejemplo. Los
ejemplos se insertan en el grupo de su prototipo ganador. En la segunda etapa se agrupan
los prototipos utilizando el algoritmo k-means. Los grupos de prototipos contendrán los
ejemplos asociados con cada prototipo. El beneficio más importante de este procedimiento
es que la carga computacional de ejecutar el algoritmo k-means sólo depende del número
de prototipos de la red SOM.

En el artículo (Vesanto & Alhoniemi, 2000) se evalúa la calidad de los grupos de una
manera visual, para ello dibujan en un plano los ejemplos y sobreponen un borde en los
grupos obtenidos. Adicionalmente, en este trabajo se utiliza la “entropía relativa
condicional” para comparar la exactitud del agrupamiento.

La entropía relativa condicional expresa el grado en que un analista, en virtud de haber

observado el sistema, tiene más información de lo que hubiera tenido sólo por conocer el

30
ordenamiento inicial de las entidades en el sistema. Es decir, la entropía relativa
condicional refleja la cantidad media de información sobre la transición de una entidad
entre dos estados consecutivos, teniendo en cuenta el conocimiento de un estado inicial
(Collins & Ruefli, 1996). Vesanto (Vesanto & Alhoniemi, 2000) utiliza la entropía
condicional relativa para describir la incertidumbre de un agrupamiento si un
agrupamiento es conocido.

3.3 La red neuronal SOM en el agrupamiento de grafos

Uno de los primeros trabajos que utiliza la red SOM para agrupar grafos fue propuesto
por Günter y Bunke (Günter & Bunke, 2002). En su algoritmo modifica la red SOM para
que utilice grafos como prototipos. En éste, utiliza la función de distancia de edición de
grafos, tanto para la selección de la neurona ganadora como para la adaptación de pesos. Es
importante notar que calcular la distancia de edición entre dos grafos es un problema NP-
difícil.

Hagenbuchner y colaboradores (Hagenbuchner, Tsoi, Sperduti, & Kc, 2008)

desarrollan varias extensiones a la red neuronal SOM capaces de trabajar con grafos. Se
basan en una estructura que almacena el grafo recursivamente. Su primer algoritmo SOM-
SD solo trabaja con árboles. A continuación, introducen una red contextual SOM-SD
(CSOM-SD) que extiende las capacidades del primer modelo, permitiendo el
procesamiento de grafos dirigidos delimitados posicionalmente que pueden contener ciclos.
Finalmente, modifica CSOM-SD creando un método llamado “Graph Self-Organizing
Map” (GraphSOM). Estos algoritmos no trabajan con grafos etiquetados.

3.3.1 Agrupamiento utilizando el espectro del grafo

En el agrupamiento de subgrafos dentro de un mismo grafo etiquetado, Shaeffer

(Schaeffer, 2007) indica que el uso del espectro del grafo ha dado buenos resultados, en
particular utilizando una representación lineal del grafo. Esta representación se obtiene
transformando los enlaces en vértices y viceversa. Posteriormente, se les asigna pesos a las
etiquetas. En consecuencia, al calcular el espectro a partir de la matriz de adyacencia, o del

31
Laplaciano Generalizado del grafo, se consideran las etiquetas de los vértices (Schaeffer,
2007). Sin embargo, no se toman en cuenta las etiquetas de los enlaces.

3.4 Agrupamiento de grafos utilizando subestructuras frecuentes

Reforgiato y colaboradores (Reforgiato, Gutierrez, & Shasha, 2008) presentan el

algoritmo GraphClust. Éste es un método para el agrupamiento de grafos como objetos. El
algoritmo asume que cada nodo de la base de datos tiene un único número de identificación
y una etiqueta. No se consideran etiquetas para los enlaces. GraphClust trabaja tanto con
grafos dirigidos como no dirigidos.

La fase inicial encuentra subestructuras, las cuales son utilizadas para agrupar los
grafos. Las subestructuras se pueden encontrar de dos maneras: la primera manera utiliza
el algoritmo AllPairShortestPath de Giugno y Shasha (2002). Para cada grafo del conjunto
de entrada y para cada vértice , el algoritmo encuentra todos los caminos pequeños que
tienen a lo sumo una longitud y parten del vértice . Cada camino es representado por
una secuencia de etiquetas de vértices en ese camino. El conjunto de tales secuencias
representa la subestructura alrededor del vértice . La segunda manera de encontrar
subestructuras, utiliza el algoritmo de descubrimiento de subestructuras Subdue (Holder &
Cook, Graph-Based Data Mining, 2005); en este caso, para cada grafo g del conjunto de
entrada, primero encuentra las subestructuras comunes o aproximadamente comunes de .

En la siguiente fase del algoritmo GraphClust se construye una matriz . Ésta tiene un
número de columnas igual al número de subestructuras encontradas y un número de filas
igual al número de grafos de entrada. Cada entrada representa el número de veces que
la subestructura está presente en el grafo . Una vez obtenida la matriz, el agrupamiento se
realiza utilizando el algoritmo k-means. Éste agrupa los elementos determinando centroides
para cada grupo y va adaptando los centroides hasta que no haya cambios.

3.5 Búsqueda de subgrafos útiles en grafos previamente clasificados

Dada una base de datos de grafos y una función objetivo , una

definición general del problema de buscar subgrafos útiles se puede formular de dos

32
maneras diferentes: (1) buscar todos los subgrafos tal que donde es un
umbral; o (2) buscar un subgrafo tal que (Aggarwal & Wang,
2010). El número de subgrafos que se pueden construir a partir de un grafo completo es
(González Bernal, 2001), donde es el número de vértices. Probar todos los
subgrafos posibles se convierte en un cuello de botella como lo muestra la Figura 3.1.

No obstante la formulación o función objetivo utilizada, un algoritmo de minería

eficiente debe encontrar patrones útiles sin llevar a cabo una búsqueda exhaustiva sobre
todo el conjunto de subgrafos posibles (Aggarwal & Wang, 2010). Los patrones útiles o
subgrafos útiles se utilizan para crear una lista de decisión. Esta lista sirve para clasificar
ejemplos que no participaron en el entrenamiento, es decir, la lista define un “concepto”
(González Bernal, 2001).

Existen varios algoritmos propuestos con diferentes funciones objetivo y técnicas de

poda (Aggarwal & Wang, 2010). Algunos trabajos primero encuentran los patrones
frecuentes (Aggarwal & Wang, 2010). Luego de entre ellos buscan cuales son los de mayor
utilidad. El encontrar todos los patrones frecuentes puede ser un proceso muy costoso. La
Figura 3.1 ilustra que este proceso de búsqueda se convierte en un cuello de botella, ya que
generalmente los patrones útiles son un conjunto mucho menor que el conjunto de todos los
subgrafos posibles.

Figura 3.1. Flujo de la minería basada en encontrar los subgrafos frecuentes. Primero
se buscan todos los subgrafos frecuentes, a partir de ellos se encuentran los patrones útiles
que generalmente son un conjunto de menor tamaño (Aggarwal & Wang, 2010).

33
 En el área de encontrar patrones útiles para la clasificación de grafos, el algoritmo
SubdueCL es uno de los que mejores resultados ha presentado, el cual se explica a
continuación.

3.5.1 Aprendizaje de conceptos con SubdueCL

SubdueCL (González, Holder, & Cook, 2001) es una extensión de Subdue (Holder,
Cook, & Djoko, Substructure Discovery in the SUBDUE System, 1994), utiliza funciones
del núcleo de Subdue para realizar operaciones de grafos, pero el proceso de aprendizaje es
diferente. SubdueCL trabaja con un enfoque supervisado, diferenciando ejemplos positivos
y negativos, y utilizando una estrategia set-covering (una explicación formal se puede
encontrar en (Han & Kamber, 2006)) en lugar de una compresión de grafos. La hipótesis
con la que trabaja este algoritmo es una disyunción de conjunciones (subestructuras).
SubdueCL forma una de estas conjunciones (reglas) en cada iteración. Los ejemplos
(grafos) positivos que son descritos por la subestructura encontrada en una iteración
anterior son removidos del grafo para iteraciones subsecuentes (González, Holder, & Cook,
2001). Cabe mencionar que el proyecto Subdue se ha mantenido activo desde su primera
publicación en 1994. Incluso, se han optimizado las estructuras de datos que utiliza, razón
por la cual es muy eficiente. La última versión del sistema Subdue se publicó en el 2011,
esto se puede ver en http://ailab.wsu.edu/subdue/.

3.6 Resumen de los trabajos relacionados

En síntesis, los trabajos más relacionados del estado del arte con la propuesta de este
trabajo se muestran en la Tabla 3.1. La tabla tiene 6 columnas, las cuales son: (1) número
secuencial para ordenar los trabajos, (2) el nombre del trabajo, (3) si se realiza
agrupamiento, (4) si se encuentra o utiliza patrones frecuentes, (5) si se realiza aprendizaje
de conceptos5, y finalmente (6) características de cada trabajo.

Las redes neuronales SOM han sido muy útiles en la minería de datos como lo muestra
el trabajo de Vesanto (Vesanto & Alhoniemi, 2000). Las capacidades de la red SOM se han
extendido para trabajar con grafos utilizando la distancia de edición de grafos, el cálculo de

5
La tarea de aprendizaje de conceptos se define en el capítulo de marco teórico.

34
esta distancia implica buscar todas las posibles operaciones de edición para seleccionar la
de menor costo. Una alternativa es utilizar el espectro del grafo, el espectro del grafo ha
sido desarrollado únicamente para grafos pesados. Algunas opciones proponen llevar al
grafo a una representación lineal, en esta se crean vértices con las etiquetas de los enlaces y
los enlaces tienen las etiquetas de los vértices (Schaeffer, 2007). El inconveniente, es que
no se consideran las etiquetas de los enlaces. En el siguiente capítulo se propone un
novedoso espectro que considera las etiquetas de los enlaces utilizando los códigos DFC.

Tabla 3.1. Trabajos relacionados más sobresalientes del estado del arte.

# Título Utiliza Utiliza Aprende Característica

agrupamiento patrones conceptos
frecuentes
1. Agrupamiento usando El agrupamiento por
mapas auto-organizados medio de redes SOM
(Vesanto & Alhoniemi, X es un paso muy útil en
2000) la minería de datos en
general.
2. Mapas auto-organizados Agrupamiento de
para agrupamiento en el grafos basado en la
X
dominio de grafos. distancia de edición de
(Günter & Bunke, 2002) grafos.
3. GraphClus: Un método Agrupa grafos como
para agrupamiento de objetos. Se basa en
bases de datos basadas características comunes
X X
en grafos (Reforgiato, entres los grafos, las
Gutierrez, & Shasha, que pueden ser
2008) caminos o subgrafos.
4. Aplicación del Extensión del
aprendizaje de conceptos algoritmo Subdue para
basado en grafos en el la tarea de aprendizaje
X
dominio de predicción de de conceptos.
toxicología (González,
Holder, & Cook, 2001)

El aprendizaje de conceptos basado en grafos ha dado muy buenos resultados como los
presenta (González, Holder, & Cook, 2001). El algoritmo SubdueCL utiliza una estrategia
de generación de candidatos para encontrar los subgrafos útiles, lo cual requiere mucho
tiempo de procesamiento. Un camino posible es realizar un crecimiento de patrones y así
encontrar los subgrafos sin generar candidatos que no existen.

35
 En la minería de datos basada en grafos se puede dividir los grafos de entrada en
subconjuntos que compartan muchas características. Luego, en estos subconjuntos se
buscan los subgrafos que permitan discriminar una clase de otra. Un algoritmo que realice
estas dos tareas simultáneamente no se ha propuesto en lo revisado del estado del arte.

36
 Capítulo 4. Algoritmo propuesto

En este capítulo se presenta el algoritmo desarrollado. La primera parte que se diseñó

fue un novedoso espectro para grafos etiquetados. Los grafos etiquetados de entrada se
transforman a su representación espectral y se le dan como entrada a una red SOM capaz de
agrupar estos grafos en tiempo polinomial, lo que se muestra con el análisis de complejidad
realizado. El algoritmo de agrupamiento de grafos basado en el espectro se denominó
Spectral_SOM. La segunda parte que se desarrolló es un algoritmo de minería de datos
basado en grafos para buscar conceptos utilizando códigos DFC. Este algoritmo requirió
modificar el algoritmo SICOBRA (Olmos Pineda, 2006) para aprovechar en mejor manera
la búsqueda de subgrafos isomorfos, el algoritmo se denominó CL_COBRA (Concept
Learning COde Based Representation Algorithm). Finalmente, se integró el agrupamiento
de grafos Spectral_SOM con la minería de datos basada en grafos CL_COBRA para
obtener el algoritmo KODISSOM_COBRA (KnOwledge DIscovery using Spectrum in
SOM and COde Based Representation Algorithm), principal resultado de esta tesis.

4.1 Transformación de grafos

Un problema al trabajar con grafos, cuando son comparados con vectores de

características, es el incremento significativo en la complejidad de los algoritmos. Un
enfoque para superar la falta de herramientas algorítmicas eficientes en el dominio de
grafos consiste en llevar los grafos a un espacio vectorial (Bunke & Riesen, 2011). El
objetivo de hacer este “transformación” de grafos en vectores, es beneficiarse de la
universalidad de los grafos para representar relaciones estructurales y la conveniencia
computacional de manejar vectores.

37
4.1.1 Representación espectral de un grafo utilizando códigos VEV

Como se explicó en el marco teórico, el espectro Laplaciano de un grafo pesado está

formado por el conjunto de valores propios del Laplaciano generalizado del grafo pesado.
El espectro de un grafo etiquetado se puede obtener asignando pesos directamente a sus
etiquetas. Debe notarse que en este caso no se toma en cuenta la información de las
etiquetas de los vértices. Con el objetivo de considerar las etiquetas de los vértices, se
puede llevar el grafo a su representación lineal, en la que los vértices se convierten en
enlaces y viceversa (Schaeffer, 2007); de esta manera intervienen las etiquetas de los
vértices pero se pierden las etiquetas de los enlaces.

El cálculo de valores propios requiere de una matriz simétrica (Mathai, 2008). Por esta
razón, el Laplaciano generalizado del grafo pesado necesita que el peso asignado a un
enlace sea igual al peso del enlace (Chung, 1994). El peso del enlace se puede
asignar considerando las etiquetas tanto del enlace como las de sus vértices adyacentes. Si
se tomaran las permutaciones de las etiquetas como función de peso, esta función no sería
simétrica ya que se podría tener un peso diferente para el enlace y para el enlace
.

Una alternativa para asignar un peso a un enlace que contenga información tanto de los
vértices como del enlace, es utilizar los códigos VEV6. La función de creación de códigos
VEV fue propuesta por Olmos en (Olmos Pineda, 2006). Se adaptó la definición original a
otra notación para facilitar el trabajo en esta tesis. Esta función recibe un enlace que
conecta a un vértice con un vértice y retorna una tripleta de etiquetas que representan al
código VEV. Se asume que el enlace pertenece a un grafo etiquetado sin múltiples enlaces.
En la Tabla 4.1 se muestra la función de creación de códigos VEV , donde es

la función de asignación de etiquetas de vértices y es la función de asignación de

etiquetas de enlaces. Estas funciones corresponden a la definición de grafo etiquetado que
se describe en el capítulo de marco teórico.

6
La definición de los códigos VEV se puede ver en el Marco Teórico.

38
 Tabla 4.1. Función de creación de códigos VEV

donde:
,
,
, si ,o
, , ,
si

En esta tesis se asume que existe un orden en las etiquetas. Para los ejemplos y pruebas
se utiliza el orden lexicográfico. La entrada del algoritmo propuesto en esta tesis es un
conjunto de grafos etiquetados . El conjunto de las etiquetas de los vértices de todos los
grafos se denominará , el conjunto de etiquetas de los enlaces se representará con .
De la misma manera, las funciones de asignación de etiquetas para todos los vértices y
enlaces para todo el conjunto de grafos serán y respectivamente.

Tabla 4.2. Demostración de que la función de creación de códigos VEV es simétrica.

1. Dado el enlace , donde .

2. Sean y
3. Evaluando , se tiene que:
a. , ,y
b. , ,y
4. Dado que entonces,
5. ,
6. Se tiene que por ser grafo simple no dirigido.
7. Si se remplaza 5 en 3.b se tiene que:
8. entonces .
9. Finalmente, por lo tanto:
10. , entonces es simétrica.

39
 La función de creación de códigos VEV es una función simétrica. La demostración se
encuentra en la Tabla 4.2. Se desea demostrar que la función devuelve el mismo valor
cuando recibe un enlace y cuando recibe el mismo enlace de la forma . Se
asume que el enlace pertenece a un grafo etiquetado sin múltiples enlaces. Sin pérdida de
generalidad, en la demostración se utilizan las funciones de asignación de etiquetas y
. En conclusión, los códigos VEV se pueden utilizar para asignar pesos a los enlaces del
grafo. Estos pesos contienen información tanto de las etiquetas de los vértices como de las
etiquetas de los enlaces.

Los códigos VEV de todos los grafos en son almacenados en una lista de códigos
VEV general . De esta manera, códigos iguales en diferentes grafos tendrán el mismo
peso. La lista está ordenada lexicográficamente y no admite códigos repetidos. Cada
código puede tener un peso de acuerdo a su posición en la lista . Finalmente, a cada
enlace se le asigna un peso igual al de su código VEV. A continuación se ilustra en un
ejemplo el proceso de asignación de pesos a todos los enlaces de un conjunto de tres grafos
etiquetados. El resultado es la matriz de adyacencia de los grafos pesados obtenidos a partir
de los grafos etiquetados.

4.1.1.1 Ejemplo de la asignación de pesos a grafos etiquetados

Dado el conjunto de grafos de la Figura 4.1, se desea asignar pesos a los enlaces de
los elementos de en función de la lista . Los grafos de la figura son y .
Cada grafo tiene etiquetas tanto en los vértices como en los enlaces. Los vértices se
reconocen en este ejemplo por sus índices. Los índices de cada vértice se representan por
una letra seguida de un valor entero positivo.

v1 v1
C C
c c
l v2 c c c v2 c v3
R R c c
l lc c c c P B O
v1 v2 c
I A I A c
v3 v4 v3 v4
l c v4 F

Figura 4.1. Conjunto de grafos .

40
 Primer paso: generación de la lista de códigos VEV general de

La asignación de pesos a los enlaces comienza con la generación de . El paso

inicial es leer los vértices y en seguida los enlaces, los cuales se leen de acuerdo a como
ingresan al algoritmo. En la implementación se sigue el orden del archivo de entrada. En
este ejemplo, para facilitar la explicación, se agruparon los enlaces que son adyacentes al
vértice que se está procesando y los vértices se leen de acuerdo a su índice. A continuación,
en la Tabla 4.3, se muestra la obtención de del grafos de la Figura 4.1. En esta
construcción, se parte del primer vértice del grafo. En seguida se procesan los enlaces
adyacentes al vértice. Por cada enlace se crea el código VEV utilizando
. Luego, este código se inserta en . El mismo proceso se sigue con
y .

Tabla 4.3. Cálculo de la lista del grafo .

Procesando
A partir del vértice 1
Enlace Código VEV Insertar en la lista
c → → Insertar en lista ordenada
C A
l → → Insertar en lista ordenada
C I
c → → Insertar en lista ordenada
C R
A partir del vértice 2
c → → Insertar en lista ordenada
R A
C l → → Insertar en lista ordenada
R I
c → Enlace ya registrado → Sin acción
R C
A partir del vértice 3
l → Enlace ya registrado → Sin acción
I R
l → Enlace ya registrado → Sin acción
I C
l → → Insertar en lista ordenada
I A

La Tabla 4.3 tiene tres columnas. La primera muestra el enlace que se procesa, la
segunda columna contiene el código VEV generado a partir del enlace. Si el código ya ha
sido procesado anteriormente, se muestra “Enlace ya registrado”. En la tercera columna

41
está la acción realizada en la lista . Las acciones posibles son primero “insertar en
lista ordenada”. En esta acción se inserta el código en la lista de acuerdo al orden
lexicográfico del código. La siguiente acción posible es “código duplicado”, en este caso no
se inserta el código por estar ya registrado en la lista . Finalmente, si no se ejecuta
ninguna acción se muestra “Sin acción”.

La lista resultante de procesar los tres grafos se muestra en la Tabla 4.4. En la

columna de la izquierda está la posición en la lista y en la columna derecha se muestra el
código VEV.

Tabla 4.4. Lista de los grafos y de la Figura 4.1.

Lista
Posición Código VEV
1
2
3
4
5
6
7
8
9
10
11
12
13

Segundo paso: asignar pesos a los enlaces

El siguiente paso consiste en asignarle pesos a los enlaces utilizando la lista .A

cada código VEV se le asigna un peso igual a su posición en la lista, este peso lo asignamos
a los enlaces respectivos. Se decidió realizar esta asignación de pesos asumiendo un orden
lexicográfico en las etiquetas. En la Figura 4.2 se muestran los grafos y con pesos
asignados a los enlaces.

42
 C C

9 9 7 6
10 1 8 1 P B O
R R
13 3 12 3 11
5
I A I A F
4 2

Figura 4.2. Grafos pesados obtenidos asignados a partir de los grafos y .

Los grafos se pueden representar con la matriz de adyacencia. La matriz de adyacencia

se construye poniendo en las filas y en las columnas los identificadores de los vértices. En
la posición de la matriz se pone el peso del enlace que existe entre el vértice y el
vértice , si no existe un enlace se asigna un . En la Tabla 4.5, se muestran las matrices de
adyacencia de los grafos y . Cada vértice tiene un grado ( ), el grado de cada
vértice se muestra en la parte superior de las matrices.

Tabla 4.5. Matrices de adyacencia de los grafos y

3 3 3 3 3 3 3 3 1 3 2 2
C R I A C R I A P B O F
C 0 9 10 1 1 0 9 8 1 P 0 7 0 0
R 9 0 13 3 2 9 0 12 3 B 7 0 6 5
I 10 13 0 4 3 8 12 0 2 O 0 6 0 11
A 1 3 4 0 4 1 3 2 0 F 0 5 11 0

4.1.1.2 Cálculo del espectro del Laplaciano Generalizado de los grafos pesados
El último paso de la transformación de grafos es la obtención del espectro del
Laplaciano Generalizado de los grafos pesados. Este paso recibe como entrada la matriz de
adyacencia del grafo pesado y sigue el proceso descrito en el marco teórico. En resumen,
primero se calcula el Laplaciano Generalizado del grafo pesado con la ecuación (2.3). A
continuación, se encuentran los valores propios de la matriz resultante. El conjunto de estos
valores propios forma el espectro generalizado del grafo pesado. El número de valores
propios es igual al número de vértices del grafo. Un valor propio 0 no aporta información.
En esta tesis se normaliza el número de elementos del espectro aumentando ceros. El

43
número de valores propios que tendrán todos los espectros es igual al número de vértices
del grafo de mayor número de vértices. En la Tabla 4.6 se muestran los espectros de los
grafos y de la Figura 4.1.

Este espectro, además de considerar la relación estructural, también contiene

información de las etiquetas de los vértices y de las etiquetas de los enlaces. Por esta razón,
este novedoso espectro es más representativo que los espectros de grafos etiquetados en el
estado del arte, como (Schaeffer, 2007).

Tabla 4.6. Espectros de los grafos , y de la Figura 4.1.

Grafo etiquetado Espectro propuesto

4.2 SOM para agrupar grafos utilizando su espectro

La red neuronal SOM tiene la gran ventaja de que puede entrenarse y evaluarse en
tiempo polinomial. La entrada del algoritmo de entrenamiento es un conjunto de ejemplos
de entrenamiento (grafos de entrada), cuyo número se representa con En el proceso de
entrenamiento, estos ejemplos con un máximo número de vértices deben evaluarse con
neuronas de la capa de salida, y modificar el peso de una neurona ganadora y sus vecinos.
El proceso se repite un número de épocas que se entrena la red (Haykin, 2005). Entonces,
la complejidad de la red neuronal SOM está acotada por .

La Tabla 4.7 muestra el algoritmo Spectral_SOM, el cual recibe de entrada un conjunto

de grafos y el número de neuronas en la capa de salida. El número será el número de
grupos que se pueden crear, determinar automáticamente es un problema
algorítmicamente difícil (Hamerly & Elkan, 2003), el cual se podría abordar en trabajos
futuros. En los experimentos se probó con varios valores de y se seleccionó el mejor

44
resultado. La función inicia con la generación de la lista de códigos VEV para todo el
conjunto de entrada. La función de creación de códigos VEV se ejecuta con todos los
enlaces de los grafos en . Crear un código VEV es una operación que se puede ejecutar en
un tiempo constante y se debe repetir por todos los enlaces del conjunto de entrada . El
número de enlaces de en el peor de los casos con grafos completos sería .
El proceso de inserción tiene una cota superior de donde es el máximo número de
elementos de la lista. Dadas las listas de etiquetas de vértices y de enlaces de todo

el conjunto , entonces (Olmos Pineda, 2006). En el peor de los casos

cuando todos los enlaces y todos los vértices tengan etiquetas diferentes ,
eliminando las constantes podemos decir que la cota superior de la construcción de la lista
de códigos VEV es .

El siguiente paso del algoritmo es generar el Laplaciano generalizado para todos los
grafos del conjunto de entrada. En este proceso se elabora una matriz cuadrada siguiendo la
ecuación (2.3) descrita en el marco teórico para el Laplaciano generalizado propuesta en
(Chung, 1994). El tamaño de la matriz es igual al número de vértices del grafo. Los grafos
de entrada tienen como máximo vértices. Finalmente, esta etapa del proceso quedará
acotada por , donde m es .

Tabla 4.7. Algoritmo de entrenamiento Spectral_SOM.

Función
Entrada:

Salida:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

45
 En la obtención del espectro se necesitan los valores propios del Laplaciano
generalizado. El cálculo de valores propios tiene una complejidad de (Press,
Teukolsky, Vetterling, & Flannery, 1988). Entonces, la generación de espectro para todos
los grafos tiene una complejidad de .

El siguiente paso, “normalizar el espectro”, consiste en igualar el número de elementos

del espectro de cada grafo. Esto se realiza aumentando ceros a los espectros hasta que
tengan una dimensión . Realizar este paso tiene una complejidad de .

Finalmente, se entrena la red neuronal SOM un número de épocas y se agrupan los

grafos en utilizando los prototipos de pesos de la red SOM. Cada neurona de la red
SOM es un prototipo que representa a un subconjunto de grafos del conjunto de
entrenamiento. A continuación, cada elemento de es comparado con los prototipos de la
red SOM entrenada para crear los grupos o subconjuntos. El prototipo ganador es el que
menor distancia Euclidiana tiene con el espectro del ejemplo (grafo). El ejemplo se asigna
al subconjunto del prototipo ganador. La complejidad de crear los grupos está dada por el
entrenamiento de la red SOM más el agrupamiento de los ejemplos .

En conclusión, la complejidad de la función Spectral_SOM es que

corresponde a la complejidad máxima de todos los pasos, de acuerdo a la regla del máximo
(Brassard & Bratley, 1996).

4.2.1 Propuesta de medida de evaluación del agrupamiento

El algoritmo devuelto por Spectral_SOM fue evaluado independientemente. Esta

evaluación requiere comparar dos agrupamientos el que obtiene Spectral_SOM con el
definido por un experto en el dominio. Entonces se propuso una función de evaluación de
agrupamientos, la misma que se denominó calidad de agrupamiento ( por sus siglas en
inglés) (Fonseca, Gómez-Gil, González, & Olmos, 2011). La función mide la calidad
con respecto a otro agrupamiento que se considera correcto o válido. La entrada a la
función está compuesta de dos conjuntos: el conjunto de grupos que se asume como válido
, donde es el número de grupos obtenidos, y el conjunto de grupos a

46
comparar . Enseguida se construye la siguiente matriz de similaridades
entre grupos:

(4.1)

En las filas de esta matriz se encuentran los grupos de y en las columnas los grupos
de . En cada posición de la matriz se asigna un valor que indica cuán similares son los
conjuntos y . La función cumple los requisitos para ser una función de
similaridad entre dos conjuntos. La calidad del agrupamiento se obtiene con la ecuación:

(4.2)

En el mejor caso, cuando cada tenga los mismos elementos que uno y solo uno de los
grupos y además no compartan elementos con ningún otro grupo, vale 1. Esto es porque en
cada fila y en cada columna de la matriz sólo existe un valor de 1 y las otras posiciones de la matriz
son 0. En el peor caso será un número cercano a , lo que significa que los grupos de y son
diferentes.

4.3 Búsqueda de patrones útiles utilizando códigos DFC

En cada grupo obtenido por Spectral_SOM se realiza una búsqueda de patrones útiles.
La búsqueda de patrones sigue un proceso de crecimiento de patrones 7. La entrada del
algoritmo es un conjunto de grafos previamente clasificados como positivos o negativos,
mientras que la salida es una lista de subgrafos útiles , los cuales representan
más a los ejemplos positivos y menos a los ejemplos negativos. Esta lista de grafos se
puede utilizar como una lista de decisión para reconocer ejemplos que no participaron en el
proceso de entrenamiento, lo que se denomina concepto (González, Holder, & Cook, 2001).
El algoritmo de búsqueda de patrones útiles utilizando códigos DFC se denominó
CL_COBRA (Concept Learning COde Based Representation Algorithm).

7
Ver definición de crecimiento de patrones en Anexo A.

47
 Los parámetros de entrada al algoritmo son: el número subgrafos a mantener en la lista
parcial , el mínimo que debe cumplir cada subgrafo, el peso extra con el que
se castiga a los subgrafos que representan a grafos negativos , el número
total de grafos positivos y el número total de grafos negativos. También se tienen dos
banderas que son y . Cuando se marca
, al terminar de procesar un código VEV, éste se elimina de . De esta
forma, la próxima iteración del algoritmo, se tendrá un conjunto de menor tamaño.
Complementariamente, si se marca , se implementa una estrategia set
covering. Es decir, cuando se selecciona un patrón se eliminan los ejemplos positivos que
contienen a este patrón.

La Tabla 4.8 describe la función de búsqueda de conceptos CL_COBRA. Dados los

grafos de entrada se determina el número total de grafos positivos y el número total de
grafos negativos. El siguiente paso es construir los grafos de uno y dos vértices.
Primeramente, se tiene una lista global de etiquetas de vértices . Cada etiqueta de esta
lista mantiene un registro del número de grafos positivos y grafos negativos que la
contienen, además del número de veces que la etiqueta se presenta en los vértices de los
grafos. De manera semejante se tiene una lista global de etiquetas de enlaces y la lista
global de códigos VEV . Los grafos de un vértice se pueden obtener recorriendo la
lista , mientras que los grafos de dos vértices se encuentran barriendo la lista de .

El siguiente paso consiste en eliminar todos los códigos VEV que no cumplan con el
soporte mínimo8 requerido por el usuario ( ) y se eliminan los códigos VEV que
únicamente representen ejemplos negativos y no representen ejemplos positivos.

Continuando con la función, los grafos son indexados de acuerdo a los códigos VEV
de sus enlaces. El proceso de indexar se muestra en la Tabla 4.9. Entonces, se toma el
primer índice, el cual relaciona a todos los enlaces con un código VEV en particular y los
grafos que los contienen. El proceso continúa minando todos los subgrafos que se obtienen,
haciendo crecimiento de patrones, con ese índice. Este proceso se muestra en la Tabla 4.10.

8
El soporte se define como el número de apariciones de un objeto en un conjunto determinado. El
soporte mínimo es un umbral definido por el usuario para considerar solo los elementos que al menos se
repitan un número de veces.

48
Una vez que se tienen los subgrafos útiles minados a partir del índice, si está activada la
bandera se eliminan los grafos positivos representados por los
patrones. Luego entonces estos subgrafos útiles se añaden a y se remueven
de la lista parcial . Finalmente, si está marcada la bandera se
eliminan todos los enlaces de relacionados por el índice, para disminuir el tamaño de .
El proceso continúa hasta recorrer todos los índices. Cabe hacer notar que existe un índice
por cada tipo de código VEV.

Tabla 4.8. Búsqueda de conceptos utilizando códigos DFC y SICOBRA. CL_COBRA

(Concept Learning COde Based Representation Algorithm).

Función
Entrada:

Salida:
1.
2.
3.
4.
5.
6. ,
7.
8.
9.
10.

11.
12.
13.

Los grafos se manejan en estos algoritmos utilizando listas de adyacencia, lo que

implica que un enlace no dirigido se represente a través de dos estructuras de datos
tipo enlace asociado. El primer enlace considera como origen y destino mientras que el
segundo tiene como origen y destino . Esto es necesario pues en este algoritmo los

49
enlaces se manejan como dirigidos, es decir, diferencian el origen del destino, y se
representan por .

La Tabla 4.9 contiene la función Indexar, la cual, al crear el índice, relaciona los
enlaces considerando su dirección. El proceso recorre todos los grafos de . Entonces, la
función hace un barrido de los vértices de cada grafo. A continuación se revisan todos los
enlaces adyacentes al vértice, se asocia cada enlace y el grafo que lo contiene con un índice
respectivo según el código VEV del enlace, entonces se inserta en el índice general. Esto
permite probar todos los inicios posibles de un enlace tanto los que parten desde
hacia como de hacia .

Tabla 4.9. Función que crea un índice de todos los enlaces y grafos según su código
VEV.

Función
Entrada:
Salida:
1.
2.
3.
4.
5.

6.
7.
8.
9.

El procedimiento de Minar_subgrafos (Tabla 4.10) recibe el conjunto de grafos y

una lista parcial en la que almacenará los -mejores subgrafos
encontrados. El objeto se recibe como parámetro. También se requiere un
puntero a un índice . El índice relaciona todos los grafos que tienen un tipo de
enlace según su código VEV. Esto permite que al buscar un subgrafo solo se realice la
prueba de isomorfismo de subgrafos en los grafos que tienen al menos un enlace en común.
Esto está inspirado en el algoritmo gSpan (Yan & Han, 2002). Por otro lado, el algoritmo
gSpan adiciona un árbol en el que cada rama contiene un subgrafo expandido. Las raíces
son los subgrafos de dos vértices y un enlace posibles. La ventaja de ese árbol es evitar

50
realizar expansiones innecesarias. La estructura de gSpan se basa en los códigos DFS, en un
trabajo a futuro se puede adaptar la estructura utilizada por gSpan a los códigos DFC, para
aumentarla a este algoritmo.

Tabla 4.10. Minar Subgrafos. Busca los subgrafos más útiles que crecen a partir de
enlaces con un código VEV dado.

Procedimiento
Entrada:

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

Inicialmente, se toma el primer grafo al que apunta el índice ; solo se

considera a los grafos positivos. Con cada enlace de , relacionado también por el índice
, se marcan los vértices y enlaces de g como no visitados. Entonces, se marcan
y como visitados. Luego, se crea un no dirigido con dos vértices y un
enlace. Al primer vértice se le asigna la etiqueta del y el otro vértice tiene la
etiqueta de . A continuación, en la función Visitar (ver Tabla 4.11) se expande el
utilizando a como grafo guía, a partir de .

En el procedimiento Minar_subgrafos, si se tuviera el peor caso se evaluarían todos los

grafos posibles. El peor caso corresponde a grafos completamente conectados9 con la
misma etiqueta para todos los vértices y enlaces. El número de subgrafos posibles en grafos

9
Un grafo completamente conectado es aquel en el que todos sus vértices están interconectados por un
enlace.

51
completamente conectados es igual a , donde es el número de vértices. La
demostración de este valor se puede ver en (Chung, 1994).

Un grafo puede ser extendido adicionándole una nueva arista . El grafo resultante
de esta extensión se denota como . Se suele decir que es un hijo de en el
espacio de búsqueda, y que es el padre de (Gago, 2010).

En el procedimiento Visitar (ver Tabla 4.11) se extiende el subgrafo dado un grafo

guía. El grafo guía se recorre a partir del vértice guía . Los subgrafos que se van
extendiendo son evaluados tomando en cuenta su frecuencia de aparición en . Este
número de apariciones debe ser mayor o igual al soporte . Si un
subgrafo cumple con el soporte mínimo, entonces es evaluado y se sigue expandiendo. Si
por el contrario no cumple con el soporte mínimo, se deja de extender, ya que sus hijos no
van a cumplir con el soporte. Esto es posible gracias a la propiedad de clausura
descendente. Esta propiedad se presenta con detalle en (Agrawal & Srikant, 1994).

En la evaluación, al subgrafo se le asigna un valor de error con la finalidad de obtener

los subgrafos más útiles. Este error toma en cuenta el número de grafos positivos no
cubiertos , es decir, el número de grafos que no contienen y el número de
grafos negativos cubiertos que son los grafos de que contienen . La función
de error se adaptó de la utilizada por SubdueCL (González Bernal, 2001) y se muestra en la
siguiente ecuación:

(4.3)

En esta ecuación el error se calcula sumando el número de ejemplos positivos no

cubiertos con el número de ejemplos negativos cubiertos y dividiendo el resultado de la
suma entre el total de grafos. El número total de grafos es igual al número de ejemplos
positivos más el número de ejemplos negativos . Adicionalmente, se
asigna un peso , por defecto igual a 3 como el utilizado en SubdueCL (González Bernal,
2001), a los ejemplos negativos representados. La asignación de un peso extra a
es similar en SubdueCL ya que de la misma manera se desea encontrar los
subgrafos que menos ejemplos negativos representen.

52
 El subgrafo que cumple con el soporte mínimo, se considera útil cuando representa al
menos al doble de ejemplos positivos que ejemplos negativos, entonces se le calcula el
valor de error con la ecuación de error y es insertado en la lista parcial , la cual
solo mantiene los -mejores patrones sin duplicados y desecha los de menor valor de
evaluación. Desechar los otros patrones disminuye el número de pruebas de isomorfismos
requeridas para desechar grafos duplicados. Se modificó el algoritmo SICOBRA para que
pueda realizar pruebas de isomorfismo o subisomorfimo. Se cambió también para que
devuelva el número de ejemplos positivos y el número de ejemplos negativos en los que
está presente un grafo. Además, se aumentó que devuelva una lista apuntando a todos los
grafos positivos que contienen al subgrafo objetivo. Estos cambios se explican mejor en la
sección 4.3.1.

La lista parcial considera que los mejores patrones son los que menor error tienen.
Además, ordena los patrones poniendo en las primeras posiciones los de menor error.
Luego entonces, si un subgrafo tiene un error de 0 se retiran todos los ejemplos positivos
que representa, ya que es el mejor patrón posible.

El procedimiento descrito se muestra en la Tabla 4.11. Las entradas son: el vértice guía
, el subgrafo que está creciendo , el conjunto de grafos de entrada , la lista de
subgrafos útiles, y el evaluador el cual contiene los parámetros de evaluación. No es
necesario que ingrese el grafo que se utiliza como guía ya que es un grafo conectado, y a
partir del vértice guía se puede recorrer todo el grafo guía.

Revisar la frecuencia de un objeto puede ser un proceso trivial en objetos no

estructurados, pero en la minería de datos basada en grafos se requiere realizar pruebas de
isomorfismo de subgrafos. El problema de isormorfismo de subgrafos es un problema NP-
Completo (Garey & Johnson, 1979). Un algoritmo que resuelve el problema del
isomorfismo de subgrafos, eficientemente, es el algoritmo SICOBRA. Éste recibe dos
archivos: uno con un conjunto de grafos y otro con el grafo objetivo que se desea
buscar en el conjunto de entrada. La salida del algoritmo es el número de veces que se
repite el grafo objetivo en los elementos del conjunto D, también incluye el número de
apariciones del grafo en un mismo elemento de . El autor de SICOBRA (Olmos Pineda,
2006) realizó la demostración de que el algoritmo es completo aunque no menciona si

53
considera traslapes o no, en un pequeño ejemplo ejecutado se obtuvo un resultado que
SICOBRA si considera traslapes.

Tabla 4.11. Procedimiento Visitar del Algoritmo SICOBRA. Visita los vértices del
grafo dado partiendo de un enlace en particular, buscando los subgrafos útiles.

Procedimiento
Entrada:

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.

54
4.3.1 Algoritmo SICOBRA-Modificado

Se modificó el algoritmo SICOBRA con la finalidad de poder determinar el número de

ejemplos positivos representados, el número de ejemplos negativos representados y que no
se consideren repeticiones del subgrafo objetivo en un mismo grafo elemento de . El
algoritmo SICOBRA-modificado se muestra en la Tabla 4.12. Adicionalmente, se
aumentaron estructuras a los grafos para que tengan contadores tanto del número de grafos
positivos representados, como para el número de grafos negativos representados. Además,
se le aumentó una lista que contiene los grafos positivos representados. Esta lista tiene la
finalidad de facilitar la eliminación de estos ejemplos.

Tabla 4.12. Algoritmo SICOBRA-Modificado, se modificó para que además de

determinar la frecuencia de un subgrafo devuelva los datos necesarios para determinar si el
subgrafo es útil.

Función -
Entrada:

Salida:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

55
 La modificación realizada al algoritmo SICOBRA solo incrementa el número de
operaciones en un valor constante, entonces se puede decir que el algoritmo mantiene su
complejidad original que es exponencial por manejar un problema NP-Completo (Olmos
Pineda, 2006) ya que los valores constantes se pueden despreciar (Brassard & Bratley,
1996).

En la Tabla 4.13 se muestra el algoritmo de poda, que también fue modificado. En el

algoritmo original de SICOBRA, a partir de un grafo conexo (grafo padre), durante el
proceso de poda, se pueden crear grafos no conexos. Estos grafos son considerados como
grafos independientes (grafos hijo). El cambio realizado consistió en que cada grafo conexo
tenga asociado un padre para así poder contar las apariciones de solo una vez en cada
grafo padre (se aumentó la línea 4 al algoritmo de poda original).

Tabla 4.13. Algoritmo de poda modificado para asociar todos los grafos conexos con
su padre.

Función -
Entrada:

Salida:
1.
.
2.
.
3.
:
y
.
4.
5.
6.

4.4 Integración de algoritmos Spectral_SOM y CL_COBRA

El algoritmo KODISSOM_COBRA, “KnOwledge DIscovery using Spectrum in SOM

and COde Based Representation Algorithm”, es un algoritmo de minería de datos basada en

56
grafos que integra una primera fase no supervisada para dividir los datos y otra supervisada
que realiza la búsqueda de patrones útiles sin generación de candidatos.

La Figura 4.3 esquematiza el funcionamiento de KODDISOM_COBRA. El primer

paso es dividir el conjunto de entrada de una forma inteligente utilizando Spectral_SOM.
Esta división se puede hacer de tres maneras: 1) dividir solo los ejemplos positivos de y
en cada grupo aumentar todos los ejemplos negativos, 2) dividir todos los ejemplos
asignándolos al prototipo ganador de Spectral_SOM, 3) una vez realizada la división (2) a
cada grupo se le aumentan los ejemplos de sus grupos vecinos, el vecindario es una función
rectangular. Cuando se tienen los subconjuntos de ejemplos, cada uno es enviado al
algoritmo CL_COBRA para buscar los subgrafos útiles. Entonces, se unen todos los
subgrafos útiles encontrados en una sola lista de patrones útiles.

Figura 4.3. Esquema del algoritmo de minería de datos KODISSOM_COBRA

desarrollado en esta tesis. La entrada es un conjunto de grafos de entrenamiento y la salida
es una lista de patrones útiles para clasificar a ejemplos que no participaron en el proceso
de entrenamiento.

57
4.5 Resumen del algoritmo desarrollado

El algoritmo desarrollado recibe por entrada un conjunto de grafos etiquetados no-

dirigidos previamente clasificados como positivos o negativos y devuelve una lista de
patrones útiles (subgrafos) que representan más a los grafos positivos que a los grafos
negativos.

El proceso inicia con el agrupamiento de los grafos de entrada en máximo grupos.

Esta división del conjunto de entrada lo realiza el algoritmo Spectral_SOM en un tiempo
polinomial, esto se demuestra en la sección 4.2. A continuación, en cada grupo el algoritmo
CL_COBRA busca los subgrafos que mejor separan los ejemplos positivos de los
negativos. Este algoritmo sigue una estrategia de crecimiento de patrones utilizando
códigos DFC y el algoritmo SICOBRA-Modificado. En el peor de los casos, al crecer un
grafo, se pueden evaluar grafos al igual que en SubdueCL, donde es el
número de vértices del grafo. Un ejemplo de este peor caso puede ser cuando se manejan
grafos completamente conectados con las mismas etiquetas, lo que es equivalente a no tener
etiquetas.

58
 Capítulo 5. Resultados experimentales

En este capítulo se presentan los resultados experimentales obtenidos. Los objetivos de

estos experimentos son: (1) probar el código y la efectividad tanto del agrupamiento como
de la búsqueda de patrones útiles, (2) ver la evolución del desempeño en el tiempo, (3)
medir las ventajas de la clasificación con y sin agrupamiento previo. El trabajo desarrollado
en esta tesis incluye los algoritmos Spectral_SOM, CL_COBRA y finalmente el algoritmo
que los integra KODISSOM_COBRA. Los algoritmos fueron evaluados primero en forma
separada. El algoritmo Spectral_SOM es comparado con el algoritmo GraphClust
(Reforgiato, Gutierrez, & Shasha, 2008) en cuanto a calidad de agrupamiento y tiempo de
ejecución. Mientras que, CL_COBRA es comparado con SubdueCL en tiempo de ejecución
y también en función de la utilidad de los patrones encontrados en la tarea de clasificación.
En la última parte de esta sección, se evalúo el algoritmo KODISSOM_COBRA.

5.1 Conjuntos de grafos utilizados en la experimentación

Las bases de datos bioquímicas, en especial las colecciones de moléculas, forman uno
de los principales campos de aplicación de la minería de datos basada en grafos
etiquetados. El repositorio de datos bioquímicos más utilizado en el estado del arte es el del
“Predictive Toxocology Challenge” (Helma & Kramer, 2003). El “US National Toxicology
Program (NTP)” realizó ensayos químicos, exponiendo roedores (ratas y ratones) a un
grupo de compuestos químicos, con la intención de identificar sustancias que podrían
causar cáncer en seres humanos. De los grupos de ensayos se seleccionó el de
“TREYMERS”, el cual se denominará conjunto PTC. La base de datos PTC está disponible
en http://www.predictive-toxicology.org10. Este conjunto de datos incluye una
especificación clara de la relación estructural de los compuestos químicos. Los ensayos de

10
La descripción del grupo de ensayos seleccionados se encuentra en: http://www.predictive-
toxicology.org/ptc/data/treymers.txt

59
PTC están divididos en datos de entrenamiento y prueba, además cuentan con un archivo
que indica un agrupamiento de los ensayos de entrenamiento y otro archivo con el
agrupamiento de los ensayos de prueba. Los datos de PTC también contienen datos no
estructurados que se obtuvieron en los ensayos químicos; aumentar estos datos implica
aumentar enlaces a todos los datos estructurados para relacionarlos con un vértice central y
éste asociarlo con los datos no estructurados. Considerar estos datos mejoraría los
resultados de predicción pero aumentaría considerablemente el tiempo de ejecución. Se
decidió trabajar únicamente con las relaciones estructurales, ya que ese es nuestro objetivo
inicial.

Los datos del conjunto PTC se convirtieron con grafos utilizando dos representaciones.
La primera considera únicamente los átomos y sus relaciones estructurales (ver Figura 5.1);
no se consideraron otros datos sin información estructural. La segunda representación
considera los electrones de cada átomo y la capa en que se encuentran (ver Figura 5.2). Los
nombres de las capas se representan por un número, al que se llamará parte numérica,
seguido de un conjunto de letras como s, px, etc., las cuales se llamarán parte alfabética.
Los nombres de las capas se tomaron del archivo de datos del PTC (http://www.predictive-
toxicology.org/ptc/data/TREYMERS.tar.gz).

En la Figura 5.1 se muestra la primera representación utilizada. Por cada átomo se crea
un vértice cuya etiqueta es el compuesto del átomo, por ejemplo: O oxígeno, H hidrógeno,
etc. Las etiquetas se tomaron del archivo de datos del PTC. A continuación, se dibuja un
enlace por cada enlace molecular. La etiqueta del enlace es el número de electrones que
comparten los átomos en el enlace molecular. Este número es un entero que va de 1 a 7. La
parte a) muestra un esquema de un grafo para una molécula de cuatro átomos en el que se
aumenta un enlace por cada enlace molecular existente y b) muestra un ejemplo de una
molécula de agua compuesta por dos átomos de hidrógeno y uno de oxígeno con dos
enlaces de un electrón.

60
 Figura 5.1. Ejemplo de la primera representación de moléculas utilizada, a) muestra
una molécula de 4 átomos conectados con cuatro enlaces, b) es una molécula de agua .

La Figura 5.2 presenta en a) un esquema con la relación entre los átomos y además se
dibuja la relación con sus electrones. Cada átomo tiene un conjunto de electrones en
diferentes capas; se dibuja un vértice por cada electrón unido al átomo por un enlace. La
etiqueta de este enlace es la parte numérica del nombre de la capa, y la etiqueta del vértice
es la parte alfabética del nombre de la capa en la que se encuentra el electrón. Los datos del
PTC han sido utilizados para evaluar varios algoritmos que manejan datos estructurados, y
se pueden considerar como un benchmark con el que se han validado algoritmos como
SubdueCL (González, Holder, & Cook, 2001), SICOBRA (Olmos Pineda, 2006) y otros
(Toivonen, Srinivasan, King, Kramer, & Helma, 2003).

Los datos del PTC han sido utilizados para probar algoritmos para datos estructurados
como son los basados en lógica (Toivonen, Srinivasan, King, Kramer, & Helma, 2003).

Figura 5.2. Esquema de la segunda representación, a) muestra que además de

considerar las relaciones entre átomos, también se dibujan las relaciones del átomo con sus
electrones. En b) se encuentra un ejemplo de una molécula hipotética con sus electrones, el
resto de electrones se representan por puntos y líneas entrecortadas.

61
 Los datos del PTC también tienen un grupo específico de datos para pruebas. Estos
datos se unieron con los datos de entrenamiento, la finalidad fue tener una base de datos de
mayor tamaño. Este conjunto de datos es el que se utilizó en las pruebas del algoritmo
CL_COBRA y KODDISSOM _COBRA. Las características de la base de datos del PTC se
muestran en la Tabla 5.1. En la tabla, la primera columna contiene el nombre de la
característica, la segunda tiene los valores de la representación basada en grafos que
considera electrones, la tercera columna muestra los valores de los grafos que no toman en
cuenta los electrones, y por último la cuarta columna contiene las características de la base
de datos PTC que une los ejemplos de prueba y entrenamiento.

Tabla 5.1. Características de la base de datos PTC.

Datos PTC Con Sin Sin Electrones prueba y

Electrones Electrones entrenamiento
Número de grafos 376 376 485
Número de vértices 90 575 9 113 15 004
Número de enlaces 90 715 9 253 15 379
Número vértices promedio por grafo 240.8910 24.2367 30.9361
Número enlaces promedio por grafo 241.2633 24.6090 31.7093
Enlaces por vértice promedio 1.0015 1.0154 1.0250
Ejemplos positivos 132 132 141
Ejemplos negativos 244 244 344

Los valores ND, en la Tabla 5.1, significan "no disponible". Los grafos de los
conjuntos "Con Electrones" y "Sin Electrones" se utilizaron para las pruebas de
agrupamiento, por esa razón no se especificó la clase. El número total de grupos de la base
de datos PTC es de 49.

Un conjunto real con un agrupamiento base es el de Esponjas del repositorio de

aprendizaje automático UCI. Los datos se pueden descargar de la dirección
http://archive.ics.uci.edu/ml/datasets/Sponge. Los datos son vectoriales y se llevaron a una
representación basada en grafos. Los grafos se construyeron con un vértice central de

62
etiqueta “objeto”, a partir de este vértice parte un enlace por cada atributo, cada enlace tiene
de etiqueta el nombre del atributo y llega a un vértice cuya etiqueta es el valor del atributo.

Los otros conjuntos de datos utilizados fueron generados sintéticamente y se describen

junto a los casos de prueba en los que se utilizaron.

Los experimentos se ejecutaron en un equipo con 3GB de RAM y un procesador AMD

Athlon X2 de 2.19 GHz con un sistema operativo Linux Ubuntu 10. Algunos experimentos
se ejecutaron en otros equipos, cuando sea el caso, se presenta la respectiva aclaración al
inicio de cada caso de prueba.

5.2 Primer caso de prueba

El objetivo de este primer caso es validar la efectividad del agrupamiento en forma

visual. La red crea un conjunto de vectores prototipo que representan los datos. El resultado
es la proyección de los ejemplos de entrada de alta dimensionalidad en un espacio de dos
dimensiones. Cada prototipo representará un subconjunto de grafos y los subconjuntos que
comparten características entre sí quedan asociados a prototipos que son cercanos en la
matriz de salida. Esto se puede apreciar fácilmente al ver la matriz resultante.

Los grafos utilizados en este caso de prueba se muestran en la Figura 5.3. La figura
contiene dos grupos de grafos. El primer grupo fue generado a partir de datos relacionados
al clima que se muestran en la Tabla 5.2. Los grafos se construyeron con un vértice en el
centro con la etiqueta ex; por cada columna se aumenta un vértice, el nombre de la columna
es la etiqueta del enlace y el valor de la columna es la etiqueta del vértice. Estos datos son
utilizado en sistema de clasificación ya que tienen características que se pueden dividir, se
espera encontrar subgrupos dentro de este grupo. El segundo grupo es un conjunto de
grafos no isomorfos pero que tienen etiquetas similares y estructura similar, existen
estructuras semejantes pero con diferentes etiquetas se espera que se creen subgrupos
considerando tanto la estructura como las etiquetas.

La tabla de datos del clima es un ejemplo no estructural que fue llevado a una
representación de grafos conectados no dirigidos.

63
 Tabla 5.2. Ejemplos de datos relacionados al clima

Temperatura (t) Clima (c) Viento (v) Humedad (h)

nublado (n) t5 h3 no (n)
lluvioso (ll) t2 h5 no (n)
lluvioso (ll) t2 h3 no (n)
nublado (n) t2 h2 si (s)
soleado (s) t2 h2 no (n)
lluvioso (ll) t4 h3 no (n)
soleado (s) t4 h2 si (s)
nublado (n) t3 h4 si (s)
nublado (n) t5 h3 no (n)

A los grafos de la Figura 5.3 se les aumentó un identificador encerrado en un rombo

para poder reconocerlos.

Figura 5.3. Primer conjunto de grafos, consta de dos grupos: a) grafos generados a
partir del ejemplo del clima, y b) grafos no isomorfos que comparten etiquetas y muestran
una estructura similar (Fonseca, Gómez-Gil, González, & Olmos, 2011).

En este primer experimento, se realizó un agrupamiento utilizando una capa de salida

de 5x5 en la red SOM, lo que podría generar máximo 25 grupos. La finalidad es que se
separen los dos grupos conocidos y se separen también los posibles subgrupos, además se
desea comprobar si los subgrupos que comparten características quedan más cercanos en la
matriz resultante. La red se entrenó durante 500 épocas. El resultado en la red SOM fue la

64
obtención de 5 grupos. Los ejemplos generados a partir de la tabla del clima quedaron
agrupados en las posiciones y de la capa de salida, mientras que el otro grupo
de grafos quedó distribuido en las posiciones , y . Hay que recordar que
cada posición representa un grupo de grafos; estos fueron marcados con colores diferentes
en la Figura 5.4. Los identificadores de los grafos contenidos en cada grupo se muestran
encerrados en la posición respectiva. La Figura 5.4 muestra la capa de salida y los grupos
obtenidos por la red SOM (Fonseca, Gómez-Gil, González, & Olmos, 2011).

Figura 5.4. Agrupamiento obtenido de los datos de prueba del caso 1. Los grupos
generados a partir de la tabla de datos del clima quedaron en grupos continuos en la parte
inferior de la figura, mientras que los otros ejemplos se muestran en los grupos de la parte
superior (Fonseca, Gómez-Gil, González, & Olmos, 2011).

La Figura 5.5 muestra los ejemplos coloreados según el grupo al que fueron asignados.
Si asignamos los colores de cada grupo que observamos en la Figura 5.4 a los ejemplos
representados se obtiene la Figura 5.5, en ésta, cada grafo tiene un color que lo asocia con
su grupo.

El conjunto de entrada tiene dos grupos como se observa en la Figura 5.3. Los grafos
de cada grupo tienen diferencias entre sí y eso se refleja en la Figura 5.4 al obtenerse varios
grupos. El algoritmo Spectral_SOM separó el conjunto de entrada en 5 grupos sin embargo
los grupos de grafos quedaron más cerca de los grupos que contienen grafos similares, y
más lejos de los grupos con grafos diferentes, esto se puede validar visualmente.

65
 Figura 5.5. Grafos coloreados de acuerdo al grupo al que fueron asignados, a) contiene
los grupos de datos del clima y b) los grupos de los ejemplos artificiales. Se puede ver que
el agrupamiento separó los ejemplos de a) y b) (Fonseca, Gómez-Gil, González, & Olmos,
2011).

El algoritmo Spectral_SOM también fue ejecutado utilizando una capa de salida de 1x2
neuronas en la red SOM. La red se entrenó durante 500 épocas. El agrupamiento obtenido
es el ideal con dos conjuntos de grafos, el primer conjunto tiene todos los grafos del grupo
a) y el segundo conjunto tiene los grafos del grupo b). Se pude concluir que el algoritmo
Spectral_SOM separó correctamente los grafos de este conjunto de prueba.

5.3 Segundo caso de prueba

En este caso el objetivo es comparar el agrupamiento utilizando el algoritmo

Spectral_SOM desarrollado con el algoritmo de agrupamiento de grafos GraphClust
(Reforgiato, Gutierrez, & Shasha, 2008). Se decidió utilizar GraphClust porque agrupa los
grafos como objetos, además de que el código fuente se encuentra disponible en
http://cs.nyu.edu/shasha/papers/GraphClust.html. Los datos que se agruparon fueron los del
PTC utilizando la representación que incluye información de los electrones y los del
conjunto Esponjas. Estos datos ya tienen un agrupamiento conocido, al cual llamaremos
“agrupamiento del experto”.

66
 En este experimento se ejecutó GraphClust con su configuración por defecto, “sin
ajuste manual”, también se ejecutó GraphClust buscando manualmente la mejor
configuración, “con ajuste manual”. A continuación, se compararon los resultados con el
agrupamiento del experto. Los resultados se muestran en la Tabla 5.3, los mejores
resultados están marcados con negrita. Los agrupamientos fueron evaluados con la función
de evaluación propuesta (CQ) y una función de similaridad de agrupamientos (MC)
propuesta por Rand (Rand, 1971). Tanto GraphClusst como Spectral_SOM recibieron
como parámetro el número de grupos que es igual a 49.

Tabla 5.3. Resultados de comparar el agrupamiento obtenido por Spectral_SOM y

GraphClust con el agrupamiento del Experto, con los conjuntos PTC utilizando la
representación con electrones y Esponjas. Se evaluó con la función propuesta (CQ) y la
función de similaridad de agrupamientos (MC) (Rand, 1971).

GraphClust Spectral_SOM
Sin ajuste manual Con ajuste manual Por Defecto
PTC con Evaluación MC 0.2766 0.9153 0.9195
electrones Evaluación CQ 0.3166 0.4198 0.3321
Tiempo 350.20 357.60 6 148.61
[segundos]
Esponjas Evaluación MC 0.6691 0.8937 0.8053
Evaluación CQ 0.3890 0.7213 0.4269
Tiempo 60 60 3.69
[segundos]

Los resultados fueron repetidos 10 veces cambiando la semilla del generador de

números aleatorios. Las diferencias entre los resultados fueron sometidas a una prueba de
hipótesis nula. La hipótesis decía que la media de las diferencias es 0. La hipótesis nula fue
rechazada con un 5% de significancia. El tiempo de ejecución de spectral_som con el
ejemplo de esponjas fue mucho menor que el de graphclust.

La calidad del agrupamiento se calculó siguiendo las ecuaciones mostradas en la

sección 4.2. En la base de datos PTC, cuando se comparó el agrupamiento de
Spectral_SOM con los grupos del experto, se obtuvo que . Al

67
comparar GraphClust (con sus parámetros por defecto) con el agrupamiento dado se obtuvo
. Considerando que el mejor caso es cuando y en el peor
caso tiende a 0. En este experimento , se concluye que
para este conjunto de datos Spectral_SOM realizó un mejor agrupamiento que la primera
configuración de GraphClust (Fonseca, Gómez-Gil, González, & Olmos, 2011). La
evaluación utilizando la función de similaridad MC favorece por 0.6 puntos al
agrupamiento obtenido por Spectral_SOM. El tiempo de ejecución de GraphClust fue
menor al de Spectral_SOM, esto se debe a que GraphClust tiene programada una
restricción del tamaño del grafo, entonces este algoritmo omitió los enlaces que no aportan
mucha información y trabajó con grafos más pequeños.

En el conjunto de esponjas los resultados utilizando la configuración por defecto de

GraphClust favorecen al algoritmo Spectral_SOM. Sin embargo al utilizar la mejor
configuración de GraphClust, éste obtiene mejores resultados que Spectral_SOM. Esto es
lo que se esperaba ya que GraphClust utiliza subestructuras y Spectral_SOM utiliza un
espectro en el que se pierden características para disminuir la complejidad.

En cuanto a eficiencia, cabe recordar que el algoritmo GraphClust se basa en

subestructuras encontradas por el algoritmo Subdue. De acuerdo a Djoko y colaboradores
(Djoko, Cook, & Holder, 1995) Subdue tiene una complejidad exponencial dependiente del
número de vértices en el grafo de entrada. Por otro lado, Spectral_SOM tiene una
complejidad de orden polinomial (ver sección 4.2). Para mostrar este punto, se ejecutó un
experimento utilizando la representación de la base de datos del PTC que no considera
electrones. Este experimento se realizó en un equipo con procesador Core Quad de 2.4 GHz
con 2 GB de RAM. Los resultados se muestran en la Tabla 5.4, la cual muestra dos
columnas principales con los clasificadores. Los mejores resultados están marcados con
negrita. El algoritmo GraphClust se ejecutó con su valor por defecto, “sin ajuste manual”, y
buscando su mejor configuración, “con ajuste manual”. El algoritmo Spectral_SOM se
ejecutó con su configuración por defecto. La tabla tiene tres filas las dos primeras indican el
resultado de la evaluación y la última el tiempo de ejecución en segundos.

68
 Tabla 5.4. Comparación del algoritmo Spectral_SOM y el algoritmo GraphClust
utilizando la representación sin electrones del conjunto PTC.

GraphClust Spectral_SOM
Sin ajuste manual Con ajuste manual Por Defecto
Evaluación MC 0.2766 0.9134 0.9328
Evaluación CQ 0.2831 0.4208 0.3023
Tiempo ejecución [segundos] 521.2 516 6.635

Los resultados fueron evaluados con una prueba de hipótesis nula, en la cual se
rechazo la hipótesis de que la media de la diferencia es 0. En la Tabla 5.4 se observa que
utilizando la función de similaridad el mejor resultado lo obtuvo spectral_som, mientras
que con la función de evaluación CQ el valor devuelto por graphclust, utilizando la
distancia euclidiana, fue el mejor agrupamiento. Finalmente, el tiempo de ejecución de
Spectral_Som fue mucho menor.

5.4 Tercer caso de prueba

El objetivo de este caso de prueba es validar el correcto funcionamiento del algoritmo

de búsqueda de conceptos CL_COBRA desarrollado en esta tesis. Los datos utilizados
están disponibles en “/graphs/house.g” dentro del paquete de distribución de Subdue, el
cual está disponible en http://ailab.wsu.edu/subdue/. Este conjunto de grafos dirigidos
consiste de 4 grafos positivos que representan el concepto de casa, y 4 grafos negativos que
no representan al concepto. La Figura 5.6, tomada de (González, Holder, & Cook, 2001)
ilustra los grafos utilizados. El concepto a encontrar es el de una casa. Se utilizan vértices
para representar objetos o atributos; las relaciones entre objetos y las relaciones entre
objetos y atributos son representadas con enlaces.

En la Figura 5.6 las relaciones tienen una dirección que indica su origen y destino. El
concepto casa consta de un objeto con forma de triángulo que se encuentra sobre un objeto
con forma de cuadrado, ésta es la abstracción que representa el grafo de la derecha.

69
 Figura 5.6. Grafos del ejemplo casa de Subdue (González, Holder, & Cook, 2001).

Los enlaces dirigidos fueron cambiados por enlaces no dirigidos. La relación

estructural del concepto se sigue manteniendo como se puede ver en la Figura 5.7, la cual
muestra la abstracción que representan los grafos transformados a partir del ejemplo de
Subdue. Cada imagen en la figura representa a un grafo, las imágenes rojas (1, 2, 3, 4) son
ejemplos negativos mientras que las de color gris (5, 6, 7, 8) son ejemplos positivos.

Figura 5.7. Imágenes adaptadas del ejemplo casa de Subdue, cada imagen representa a
un grafo del ejemplo, grises positivos (5, 6, 7, 8) y rojos negativos (1, 2, 3, 4).

Por ejemplo, la imagen 1) de la Figura 5.7, representa un objeto con forma de cuadrado
sobre un objeto con forma de triángulo, el cual a su vez está sobre otro objeto con forma de
triángulo; éste es un ejemplo negativo. La imagen 7) representa un objeto con forma de
triángulo, sobre un objeto con forma de cuadrado, sobre un objeto con forma de rectángulo.

70
 El algoritmo CL_COBRA fue ejecutado con un de tamaño 3 por defecto, con un
soporte mínimo de 10%. La Figura 5.8 fue generada utilizando una interfaz también
construida en esta tesis, la interfaz permite dibujar grafos gracias al software GraphViz
(http://www.graphviz.org/). Los grafos se pueden dibujar en cada momento de la
expansión, cada grafo tiene una etiqueta con su nombre. El poder visualizar el recorrido en
el grafo ayuda a verificar si el algoritmo está funcionando correctamente.

1) 2)

n)

Figura 5.8. Ejemplo del proceso de expansión seguido por el algoritmo de búsqueda.
Inicia en (1) en el vértice 5 y el vértice 2; en (2) se expande al vértice 1. Cada subgrafo es
evaluado. Si el subgrafo cumple con el soporte mínimo el proceso se repite hasta recorrer
todo el grafo.

En la Figura 5.8, los vértices y enlaces en color azul son los visitados. En 1) el vértice
5 y el enlace (5,2) ambos en verde son el enlace inicial. Los enlaces no dirigidos se dibujan
como dos enlaces dirigidos en ambas direcciones. La Figura 5.8 mantiene los nombres
originales de las etiquetas en inglés, ya que así se utilizaron en el experimento. La búsqueda

71
inicia a partir de los enlaces con menor código VEV11, como se muestra en la. A partir del
enlace se va expandiendo el grafo; el siguiente enlace a aumentar es
. Posteriormente se valida si el grafo creado cumple con el requerimiento
de soporte. Si cumple el requerimiento se inserta en la lista parcial, si la lista tiene más de
beam elementos se elimina el último en función de su error ver ecuación (4.3). Luego
entonces, se sigue expandiendo hasta completar el grafo. El proceso se repite con todos los
inicios posibles en cada grafo hasta encontrar grafos que no tengan error o hasta terminar el
espacio de búsqueda.

Al ejecutar CL_COBRA con un soporte mínimo del 50% se encuentra un solo patrón
con error 0, este se muestra en la Figura 5.9, el subgrafo representa a una casa formada por
un objeto triángulo sobre un objeto cuadrado. Dado el orden que sigue el algoritmo
CL_COBRA desarrollado, se encontró también que las casas siempre se encuentran sobre
otro objeto; esto se puede apreciar en los ejemplos de entrenamiento.

Figura 5.9. Patrón encontrado por el algoritmo de CL_COBRA; se utilizó los grafos
del ejemplo casa de Subdue y un 50% de soporte mínimo.

El patrón encontrado, en la Figura 5.9, representa a todos los ejemplos positivos y a

ningún negativo. El Interpretándolo, dice que existe un objeto con figura de triangulo se
encuentra encima de un objeto con forma de cuadrado, estos objetos siempre se encuentran
sobre otro objeto; este objeto en el conjunto de entrenamiento varía entre cada ejemplo por

11
Ver sección 4.1.1 para una explicación del cálculo de la lista de códigos VEV.

72
esa razón no se identifica su forma. Se concluye que el sistema aprendió el concepto de
casa (triangulo sobre un cuadrado) y una característica extra: que las casas siempre están
sobre otro objeto. Por lo tanto la búsqueda de conceptos para este conjunto de datos
funcionó correctamente.

El algoritmo CL_COBRA se ejecutó variando el soporte y la bandera de eliminar

ejemplos. El experimento se realizó con una validación cruzada de 8 pliegues. Los
resultados promedio se muestran en la Tabla 5.5. Esta tabla tiene en su primera columna el
soporte mínimo utilizado, la segunda columna indica con 1 si se habilitó la bandera de
eliminar ejemplos, la tercera columna contiene el número promedio de subestructuras
encontradas, la columna de segundos tiene el tiempo de ejecución del algoritmo y
finalmente se muestra el área bajo la curva ROC.

Tabla 5.5. Resultados del algoritmo CL_COBRA con la base de datos house y
validación cruzada de 8 pliegues, se varió el soporte y la bandera de eliminar ejemplos.

Soporte Eliminar Subestructuras Segundos AUC

10 1 5.75 0.023 0.125
20 1 5.75 0.029 0.125
30 1 1.00 0.023 0.875
40 1 1.00 0.027 0.875
50 1 1.00 0.018 0.875
10 0 4.88 0.047 0.375
20 0 4.88 0.045 0.375
30 0 1.13 0.023 0.875
40 0 1.13 0.029 0.875
50 0 1.13 0.025 0.875

El algoritmo CL_COBRA obtuvo su mejor resultado en tiempo cuando se probó con el

50% de soporte mínimo, y en este conjunto de datos ese es el caso en el que encuentra el
mejor patrón, por ello obtiene un buen resultado. Esto sucede porque al aumentar el soporte
mínimo se eliminan datos que no aportan información en este conjunto de datos. El tiempo
es mucho menor al eliminar ejemplos representados que cuando no se los elimina sin

73
embargo los resultados de clasificación en general son mejor cuando no se eliminan los
ejemplos.

El algoritmo Subdue_CL se ejecutó variando el beam y el número de iteraciones. El

experimento se realizó con una validación cruzada de 8 pliegues. Los resultados promedio
se muestran en la Tabla 5.6. La tabla tienen en la primera columna el beam utilizado, la
segunda contiene el número de iteraciones, la tercera columna contiene el número
promedio de subestructuras encontradas, la columna de segundos tiene el tiempo de
ejecución del algoritmo y finalmente se muestra el área bajo la curva ROC.

Tabla 5.6. Resultados del algoritmo Subdue_CL con la base de datos house y
validación cruzada de 8 pliegues, se varió beam y el número de iteraciones.

Beam Iteraciones Subestructuras Segundos AUC

3 1 1 0.023 0.750
3 10 1 0.016 0.750
1 1 1 0.011 0.875

El algoritmo Subdue_CL obtuvo su mejor resultado en tiempo y en clasificación al

probar con un beam y una iteración. Esto se debe al pequeño tamaño y complejidad de la
base de datos. Al comparar los resultados de Subdue_CL con los de CL_COBRA se puede
ver que en cuanto a clasificación obtienen el mismo resultado, pero el tiempo de ejecución
de Subdue_CL fue menor en especial al utilizar un beam pequeño ya que recorre un menor
espacio de búsqueda.

5.5 Cuarto caso de prueba

El objetivo de este caso de prueba es observar la tendencia del desempeño, con

respecto al tiempo de ejecución, del algoritmo propuesto y compararlo con el algoritmo
SubdueCL. Primero se muestran experimentos en los que se compara el algoritmo de
Búsqueda de Conceptos con el algoritmo SubdueCL. Después, se muestran experimentos
utilizando el agrupamiento de la Spectral_SOM.

74
 En este caso de prueba se crearon grafos sintéticos, a partir de semillas conocidas para
asegurar que los patrones encontrados sean correctos. Los grafos se crearon utilizando la
herramienta subgen, la cual se puede descargar de http://ailab.wsu.edu/subdue. Esta
herramienta crea un nuevo grafo aumentando vértices y enlaces a un grafo semilla. Se
definieron dos semillas, que se muestran en la Figura 5.10: a) la semilla positiva de color
gris y b) la semilla negativa de color rojo. Las semillas seleccionadas son muy similares
entre sí, teniendo solo dos enlaces de diferencia.

Figura 5.10. Semillas utilizadas para generar los grafos del caso de prueba. La semilla
positiva es el grafo a) y la semilla negativa es el grafo b).

A partir de los grafos semilla se construyeron dos conjuntos de grafos. En el primer

conjunto mantiene 8 vértices y de 9 enlaces en cada grafo. Se crearon varios archivos, en
los que se varió el número de grafos de 5 a 4,000 grafos. El segundo conjunto mantiene
constante el número de grafos por archivo, pero varía el número de vértices de 5 a 1,000 y
los enlaces requeridos para mantener la semilla y que sean grafos conexos.

5.5.1 Evaluación del algoritmo variando el número de grafos

En este primer experimento se ejecutó el algoritmo CL_COBRA, cambiando el soporte

mínimo. En la Figura 5.11 se muestra la tendencia de crecimiento del tiempo al aumentar el
número de grafos y aumentar el soporte mínimo, se puede notar que el tiempo de ejecución
aumenta al aumentar el número de vértices, aunque no sigue una función lineal. Por otro
lado, el tiempo de ejecución disminuyó considerablemente al aumentar el soporte mínimo a

75
20%, sin embargo no sucedió lo mismo al aumentar el soporte de 5% a 10%. En el caso del
soporte mínimo de 20% se eliminaron muchos enlaces aumentados por subgen; los
patrones encontrados fueron las semillas originales. En los casos de 5 y 10% se encontraron
otros patrones aumentados por el generador de grafos; sin embargo en el caso del 10%, se
encontraron grafos de mayor tamaño antes de encontrar el subgrafo de error 0 que
diferenciaba a todos los ejemplos positivos de los ejemplos negativos. En general se
esperaba que al aumentar el soporte disminuyera el tiempo esto sucedió solo hasta
aumentarlo al 20%, el crecimiento no lineal al aumentar el número de grafos se debe al
cálculo de la lista de códigos VEV.

Figura 5.11. Tendencia del tiempo de ejecución necesario al aumentar el número de

grafos del algoritmo CL_COBRA. La figura muestra como disminuye el tiempo al
aumentar el soporte mínimo entre 5, 10 y 20 por ciento de los grafos del conjunto.

El soporte mínimo es muy importante ya que ayuda a disminuir el tiempo de ejecución

como reportan los trabajos del estado del arte de minería de grafos frecuentes (Yan & Han,
2002), es importante notar que, en el ejemplo con la base de datos house y en este, al
aumentar el soporte mínimo se eliminan datos que no aportan información y por lo tanto se
obtienen mejores resultados.

Utilizando los mismos datos se ejecutó el algoritmo SubdueCL con un parámetro beam
de 10; los resultados obtenidos por SubdueCL se compararon con los obtenidos por la
Búsqueda de Conceptos con un soporte de 20%. Los resultados se muestran en la Figura

76
5.12. Se puede notar que utilizando este conjunto de datos, el algoritmo SubdueCL y el
algoritmo de CL_COBRA son muy competitivos en cuanto a tiempo de ejecución. Con
pocos grafos, la estrategia de búsqueda beam de SubdueCL fue más eficiente en tiempo; al
aumentar el número de grafos disminuye la tendencia de crecimiento del algoritmo
Búsqueda de Conceptos con respecto a la tendencia del algoritmo SubdueCL.

Figura 5.12. Comparación de la ejecución de SubdueCL y CL_COBRA variando el

número de grafos.

Se realizó otro experimento utilizando el algoritmo KODISSOM_COBRA, en el cual

Spectral_SOM creó dos conjuntos con los datos de entrada, uno con los grafos positivos y
otro con los grafos negativos; por lo tanto no fue necesario realizar la búsqueda de los
subgrafos ya que la red entrenada puede dividir a los ejemplos de esta prueba
perfectamente. En la Figura 5.13 se muestra la tendencia de crecimiento en tiempo del
agrupamiento, utilizando la red Spectral_SOM al variar el número de grafos en los datos de
este experimento. Como se puede apreciar, con estos datos la tendencia de crecimiento en
tiempo variando el número de grafos es lineal. Esto se debe a que todos los grafos tienen el
mismo tamaño; al aumentar el número de vértices, la tendencia será polinomial.

77
 Agrupamiento Spectral_SOM
90
80
70
Tiempo [Segundos] 60
50
40
30
20
10
0
0 500 1000 1500 2000 2500 3000
Número de grafos

Figura 5.13. Tendencia de crecimiento en tiempo del agrupamiento realizado con la red
Spectral_SOM con el conjunto de datos generado artificialmente. Se varía el número de
grafos, el número de enlaces y vértices permanece constante.

5.5.2 Evaluación del algoritmo variando el número de vértices y de enlaces

En el siguiente experimento se utilizó el conjunto de grafos en los que varía el número

de vértices y de enlaces. Se ejecutó el algoritmo de Búsqueda de Conceptos variando el
soporte mínimo entre 5, 10 y 20%. Al principio con un soporte mínimo de 5%, el tiempo de
ejecución oscila de forma importante como se puede apreciar en la Figura 5.14. Esto se
debe a que el algoritmo sigue una estrategia de búsqueda en profundidad y explora muchos
caminos antes de llegar a la solución. Al disminuir estos caminos, filtrando los enlaces que
no cumplen con un soporte mínimo, se tienen menos opciones en este conjunto de grafos.

78
 Figura 5.14. Tendencia en tiempo al aumentar el número de vértices y el soporte
mínimo utilizando el algoritmo CL_COBRA.

Se concluye que, con este conjunto de grafos, al aumentar el número de vértices

aumenta el tiempo de ejecución aunque no sigue una función clara. Esto se debe a que la
búsqueda termina cuando se encuentra un grafo que separe a los dos conjuntos;
dependiendo de donde se encuentre este grafo en el espacio de búsqueda será el tiempo de
ejecución. Al aumentar el soporte mínimo la función de crecimiento tiende a normalizarse
(ver Figura 5.14) y esto es consecuencia de que se eliminen muchos grafos de los
aumentados por el generador de grafos.

A continuación, se probó con los mismos datos, pero utilizando el algoritmo SubdueCL
con un beam de 10. En la Figura 5.15 se observa que con este conjunto de ejemplos la
tendencia de crecimiento del tiempo de ejecución de SubdueCL es menor que la obtenida
por CL_COBRA. Esta tendencia es menor gracias a la estrategia de búsqueda beam que
implementa SubdueCL, y principalmente por la representación de los datos del PTC ya que
son grafos con pocos enlaces.

79
 Figura 5.15. Comparación del algoritmo de CL_COBRA con el algoritmo SubdueCL
al utilizar ejemplos sintéticos en los que varía el número de vértices y de enlaces.

Cabe mencionar que implementar este tipo de algoritmos es muy complicado, ya que
se requiere utilizar estructuras muy eficientes. El algoritmo de SubdueCL se encuentra
implementado en el software Subdue, el cual ha sido optimizado continuamente en cuanto a
estructuras de datos; su última versión se publicó el año 2011. La versión del algoritmo
implementada en esta tesis mejoraría utilizando un indexado inverso para el manejo de
listas. Un aporte que ayudaría a disminuir la complejidad del algoritmo es disminuir el
número de subgrafos que son evaluados innecesariamente, esto se podría hacer incluyendo
la estrategia del punto de corte desarrollado por Gago (Gago, 2010).

5.6 Quinto caso de prueba

El objetivo de este caso de prueba es comparar la competitividad en la tarea de

clasificación de los patrones obtenidos por CL_COBRA con los devueltos por SubdueCL.
Los datos utilizados para esta prueba son los del conjunto PTC sin considerar vértices para
los electrones. Estos grafos fueron divididos en 10 subconjuntos. Se realizó una validación
cruzada de 10-pliegues utilizando estos subconjuntos con los algoritmos CL_COBRA y
SubdueCL.

80
 Los patrones encontrados por los dos algoritmos fueron evaluados utilizando el
software Test de Subdue. Test recibe un conjunto de patrones y un conjunto de prueba,
luego entonces clasifica los elementos del conjunto de prueba utilizando el conjunto de
patrones. Un ejemplo se clasifica como positivo si contiene a alguno de los elementos del
conjunto de patrones, si no contiene ningún elemento entonces se clasifica como negativo.
Los resultados obtenidos por los dos algoritmos se analizan calculando el área bajo la curva
ROC (descrita en el capítulo de Marco Teórico).

Primeramente, se ejecutó el algoritmo Búsqueda de Conceptos sin un soporte mínimo.

No se encontraron patrones con un error de 0. Los primeros patrones de la lista tienen un
error promedio de 0.27 por que no representan a todos los ejemplos positivos, aunque no
representan ejemplos negativos, mientras que los últimos patrones de la lista tienen un error
de 0.40 debido a que representan ejemplos negativos. Estos patrones con mayor error
aumentan el error general al evaluar la lista de patrones en la tarea de clasificación.

El área bajo la curva ROC, obtenida con los resultados del CL_COBRA con un soporte
de 1%, activando la bandera eliminar ejemplos es de 0.62 en 2939 segundos. Utilizando el
algoritmo SubdueCL con un beam de 20 y 70 iteraciones, se obtuvo un área bajo la curva
ROC de 0.61 en 784 segundos. Las gráficas de las curvas ROC se muestran en la Figura
5.16. La curva ROC fue trazada utilizando un único punto ya que el clasificador solo
devuelve verdadero o falso. Se requiere un clasificador que devuelva un porcentaje de
certeza para obtener más puntos en la curva ROC.

81
 Gráfica ROC - CL_COBRA y SUBDUE_CL con
datos del conjunto PTC
1

0.9

0.8
Tasa de verdaderos positivos

0.7

0.6

0.5 No significativo

0.4 SUBDUE_CL
CL_COBRA
0.3

0.2

0.1

0
0 0.2 0.4 0.6 0.8 1
Tasa de falsos positivos

Figura 5.16. Curvas ROC obtenidas con el algoritmo CL_COBRA y SubdueCL con los
datos del PTC sin considerar datos no estructurales ni vértices para los electrones.
CL_COBRA con soporte mínimo de 1% y activada la bandera de eliminar ejemplos,
SUBDUE_CL con un beam de 20 y 70 iteraciones.

Se puede concluir que los patrones obtenidos por el algoritmo CL_COBRA son
competitivos con los obtenidos por el algoritmo SubdueCL en este conjunto de datos y en
algunos casos pueden ser mejores. Además el algoritmo CL_COBRA puede disminuir su
tiempo de ejecución aumentando el soporte mínimo aunque en este caso no es conveniente
ya que se eliminan ejemplos representativos de la base de datos. Los ejemplos se eliminan
por que la base de datos no está balanceada. El problema de clases desbalanceadas no se
trabaja en esta tesis.

En la Tabla 5.7 se muestran los resultados de la ejecución del algoritmo

KODISSOM_COBRA con redes SOM de 10x10 y 5x5, también se probó agrupando los
ejemplos de grupos vecinos a 1 posición de distancia y cambiando el agrupamiento para
solo agrupar positivos y en cada grupo incluir a todos los negativos. Los experimentos se
ejecutaron con una validación cruzada de 10 pliegues y se promedió los resultados.

82
 Tabla 5.7. Ejecución del algoritmo KODISSOM_COBRA con redes SOM de 10x10,
5x5, también se varía el agrupamiento incluyendo vecinos a 1 posición de distancia (1) y
agrupamiento de positivos considerando en cada grupo a los negativos (-1).

SOM Tipo Eliminar Tiempo en AUC

agrupamiento ejemplos segundos
10x10 1 0 3773.479 0.57
10x10 -1 1 1880.093 0.55
10x10 1 0 1879.625 0.50
5x5 -1 0 4389.630 0.53
5x5 -1 1 2104.538 0.56
5x5 1 0 6633.324 0.49
5x5 1 1 1958.687 0.51

El algoritmo KODISSOM_COBRA disminuyó el tiempo de ejecución del algoritmo

CL_COBRA de 2939 segundos a un tiempo 1880 segundos, sin embargo también
disminuyó el área bajo la curva ROC a 0.55. En algunos casos se disminuyó más el tiempo
pero el área bajo la curva ya no es representativa.

5.7 Discusión

En este trabajo de tesis se diseñó, implementó y evaluó un algoritmo de minería de

datos basado en grafos para la tarea de aprendizaje de conceptos. El algoritmo consta a su
vez de dos algoritmos. El primero, Spectral_SOM, es un algoritmo de agrupamiento de
grafos etiquetados basado en un novedoso espectro desarrollado en esta tesis. El espectro es
novedoso debido a que toma en cuenta las etiquetas de los enlaces, y a la fecha de
publicación de esta tesis no se encontraron en el estado del arte trabajos que utilicen estos
conceptos. Gracias a este espectro, el algoritmo de agrupamiento de grafos etiquetados
tiene una complejidad polinomial.

Esta Spectral_SOM fue comparada con el algoritmo de agrupamiento de grafos como

objetos GraphClust. Utilizando una medida de calidad de grupos CQ (descrita en el capítulo
4), la medida de calidad se basa en evaluar cuan similares son los grupos obtenidos con los
grupos que se asumen como correctos (Fonseca, Gómez-Gil, González, & Olmos, 2011).

83
También se evaluaron los resultados con la función de similaridad de agrupamientos
propuesta por Rand (Rand, 1971), el algoritmo Spectral_SOM obtuvo mejores resultados
que GraphClust con su configuración por defecto.

El segundo algoritmo desarrollado en esta tesis se llama CL_COBRA; este algoritmo

utiliza códigos DFC y sigue una estrategia de crecimiento de patrones para encontrar los
subgrafos que más representen a los grafos positivos y menos representen a los grafos
negativos. Se requirió modificar el algoritmo de isomorfismo de grafos SICOBRA, el cual
es un algoritmo muy eficiente pero muy complicado de implementar y modificar. Las
modificaciones realizadas se reportan en el capítulo 4. El algoritmo CL_COBRA fue
comparado con el algoritmo SubdueCL. Los patrones encontrados por CL_COBRA son
competitivos con los encontrados por SubdueCL en la tarea de clasificación con los
conjuntos de datos utilizados. Sin embargo el tiempo de ejecución de SubdueCL es menor
en algunos casos. Esto es porque SubdueCL utiliza una búsqueda con un beam dinámico.
La estrategia de búsqueda ayuda mucho ya que mientras CL_COBRA realiza toda la
búsqueda en profundidad, SubdueCL busca a lo ancho y con un beam pequeño. Por esa
razón SubdueCL encuentra el mismo patrón pero en menor tiempo. Se propone modificar la
estrategia de búsqueda del algoritmo CL_COBRA en un trabajo futuro.

Finalmente, se integraron los algoritmos desarrollados en un algoritmo de minería de

datos basado en grafos denominado KODISSOM_COBRA. El agrupamiento fue muy
exitoso en el experimento sintético ya que separó perfectamente los ejemplos positivos de
los negativos. En consecuencia, en este caso de prueba no fue necesario buscar subgrafos
porque la red Spectral_SOM entrenada es suficiente para distinguir los datos de ese
conjunto.

Un resultado secundario del desarrollo de esta tesis es el software resultante, el cual

está completamente comentado y agrupado en librerías escritas en C++ estándar. Esto
permitirá continuar el trabajo de investigación más fácilmente.

84
 Capítulo 6. Conclusiones, aportaciones
y trabajo futuro

Los grafos son una poderosa herramienta de representación que ha sido ampliamente
utilizada en el área de aprendizaje automático y minería de datos. Una forma de buscar
patrones novedosos y útiles para la toma de decisiones es realizando pruebas de sub-
isomorfismo. Estas pruebas son un problema NP-Completo. En este trabajo se presentan
algoritmos para buscar información relevante tratando de disminuir el tiempo de ejecución.

En esta tesis primero se desarrollo un novedoso espectro para grafos etiquetados, el

cual considera información tanto de las etiquetas de los vértices como de las etiquetas de
los enlaces. El espectro se implementó en un algoritmo de agrupamiento no supervisado
utilizando una red neuronal SOM, el algoritmo se denominó Spectral_SOM (Fonseca,
Gómez-Gil, González, & Olmos, 2011). El siguiente paso de la tesis consistió en
desarrollar un algoritmo capaz de encontrar patrones útiles, en bases de datos representadas
por grafos. Los grafos de entrada son previamente clasificados como positivos y negativos.
El algoritmo devuelve una lista de subgrafos que permiten discriminar si un nuevo ejemplo
que no participó en el entrenamiento pertenece o no a la clase positiva. Este algoritmo se
llamó CL_COBRA, el mismo que sigue una estrategia de crecimiento de patrones
utilizando códigos DFC. El resultado de la tesis fue integrar Spectral_SOM y CL_COBRA
en un novedoso algoritmo denominado KODISSOM_COBRA que realiza el agrupamiento
no supervisado y en cada grupo busca los subgrafos útiles.

En el capítulo 5 se presentan los resultados experimentales obtenidos. Los algoritmos

fueron probados primero por separado y finalmente en conjunto. El algoritmo
Spectral_SOM se evaluó con el algoritmo GraphClust con datos del PTC, del UCI y grafos
artificiales. En cuanto a agrupamiento correcto el algoritmo Spectral_SOM obtuvo mejores

85
resultados en algunos casos y requirió menor tiempo de ejecución puesto que su
complejidad es polinomial en cambio la complejidad de GraphClust es exponencial.

El algoritmo CL_COBRA se comparó directamente con el algoritmo SubdueCL. En

general los resultados obtenidos por CL_COBRA son competitivos. El algoritmo
SubdueCL en algunos casos requiere menor tiempo esto se debe a que se requiere un
soporte mínimo de 1% para encontrar los patrones más discriminativos. Además la
estrategia de búsqueda a lo ancho con un beam le ayuda a SubdueCL a encontrar los
patrones más rápido. Finalmente, se probó el algoritmo KODISSOM_COBRA con el
algoritmo SubdueCL. Con los ejemplos sintéticos, KODISSOM_COBRA solo necesita el
agrupamiento de Spectral_SOM para distinguir a los ejemplos positivos de los negativos.
Con la base de datos del PTC, los mejores resultados se obtuvieron al realizar grupos solo
con ejemplos positivos, y después a cada grupo se le aumentaron los ejemplos negativos. El
tiempo de ejecución total disminuyó en comparación con CL_COBRA, pero el porcentaje
de clasificados correctamente también fue menor.

6.1 Conclusiones

En el presente trabajo de investigación se abordó el problema de minería de datos

utilizando una representación basada en grafos obtenida de los datos originales. De acuerdo
a los experimentos realizados y los resultados alcanzados se pueden hacer las siguientes
conclusiones:

En lo referente al espectro para grafos etiquetados propuesto, se confirmó que

representa mejor al grafo que otros métodos espectrales que no consideran las etiquetas de
los enlaces. El algoritmo Spectral_SOM obtuvo una mejor calidad de agrupamiento que el
algoritmo GraphClust con los datos del PTC. La calidad de agrupamiento fue mejor en 0.02
puntos utilizando la medida CQ propuesta.

En el estado del arte, puede notarse que los algoritmos que calculan el espectro de
grafos solo consideran las etiquetas de los vértices (Schaeffer, 2007). Si se desea extender
esos algoritmos para considerar las etiquetas de los enlaces, una alternativa sería aumentar
vértices que contengan las etiquetas de los enlaces. En consecuencia, se aumentaría

86
notablemente el tiempo de ejecución ya que el cálculo del espectro depende del número de
vértices. En comparación, el espectro propuesto permite aumentar la información de las
etiquetas de los enlaces sin la necesidad de aumentar nuevos vértices al grafo. En este
mismo sentido, el algoritmo Spectral_SOM es un algoritmo de agrupamiento de grafos
etiquetados que tiene un orden polinomial. Este algoritmo se puede aprovechar mejor en
escenarios donde los grafos tienen muchos enlaces, o están cerca de ser completos ya que el
proceso de mayor complejidad depende del número de vértices y no del número de enlaces.
Por otro lado, los algoritmos basados en crecimiento de patrones en el peor de los casos
revisan todos los enlaces, teniendo su peor escenario cuando se manejan grafos altamente
conexos.

El algoritmo CL_COBRA aprovecha la poda ligera de soporte mínimo para eliminar

muchos enlaces y así disminuir el número de subgrafos a evaluar. Esto implica una
disminución significativa en el tiempo de ejecución. Sin embargo, en los experimentos
realizados, la estrategia de búsqueda en profundidad de CL_COBRA no fue más eficiente
que la búsqueda beam de SubdueCL. Este algoritmo se puede mejorar cambiando la manera
de crecimiento seguida. Una alternativa sería realizar el crecimiento en dirección a los
códigos VEV con mayor frecuencia de aparición en ejemplos positivos y menor frecuencia
de aparición en ejemplos negativos.

En los experimentos realizados, los subgrafos encontrados por el algoritmo

CL_COBRA son competitivos en la tarea de clasificación con respecto a los encontrados
por el algoritmo SubdueCL. Finalmente, el algoritmo KODISSOM_COBRA une las
ventajas de dividir el conjunto de entrada de una manera inteligente, para luego realizar la
búsqueda de subgrafos discriminativos en cada subconjunto. Este algoritmo se podría
mejorar utilizando de mejor manera el agrupamiento que realiza Spectral_SOM.

6.2 Aportaciones

La primera aportación de esta tesis es el desarrollo de un novedoso espectro para grafos

etiquetados. Este espectro considera la información tanto de las etiquetas de los vértices
como la información de las etiquetas de los enlaces. Por lo tanto, es un espectro que

87
considera mayor información. Basado en el espectro propuesto se desarrolló el algoritmo de
agrupamiento de grafos etiquetados Spectral_SOM.

Por otro lado, el algoritmo CL_COBRA es un novedoso algoritmo de aprendizaje de

conceptos basado en códigos DFC y en el algoritmo SICOBRA-Modificado. Este algoritmo
encuentra conceptos que son competitivos con los encontrados por el algoritmo SubdueCL
en la tarea de clasificación, con los conjuntos de datos utilizados. El trabajo desarrollado es
una base para proyectos futuros.

Finalmente, se desarrolló el algoritmo KODISSOM_COBRA que une, en un solo

algoritmo, las ventajas de dividir los datos de entrada para poder buscar conceptos más
eficientemente en cada nuevo subconjunto.

Derivado de este trabajo de tesis se realizó la siguiente publicación:

Fonseca, R. S., Gómez-Gil, P., González, J. A., & Olmos, I. (2011). Finding Patterns in
Labeled graphs Using Spectrum Feature Vectors in a SOM Network. International Joint
Conference on Neural Networks IJCNN 2011 (pág.77-85). San Jose, California: IEEE.

6.3 Trabajo futuro

El trabajo futuro inmediato es aumentarle al algoritmo CL_COBRA la estructura que

utiliza el algoritmo gSpan (Yan & Han, 2002), con el objetivo de disminuir el número de
pruebas de isomorfismo. Una vez realizado esto, se puede investigar si el punto de corte
propuesto en el algoritmo gRed (Gago, 2010) se cumple con los códigos DFC. Se espera
que sí, ya que los códigos DFC se basan en los códigos DFS que son la base tanto de gSpan
como de gRed. Finalmente, se puede mejorar la estrategia de búsqueda utilizada por el
algoritmo Búsqueda de Conceptos para hacerlo más eficiente; una alternativa es una
búsqueda tipo beam, como la utilizada en el algoritmo SubdueCL.

En cuanto a la teoría de espectros de grafos, se puede analizar el impacto de considerar

la información de las etiquetas tanto de vértices como de enlaces en el problema de grafos
co-espectrales (grafos que tienen el mismo espectro pero no son isomorfos).

88
 Dado que el tiempo de ejecución de los algoritmos que buscan subgrafos
discriminativos depende del número de enlaces de los grafos, se propone investigar la
aplicabilidad y eficacia que se podría conseguir al trabajar con grafos no conexos que
representen a los datos. Por un lado se aprovecharían las ventajas de la información
estructural que sería la parte conexa, y por otro lado se utilizaría también la información no
estructural, sin aumentar enlaces que incrementan el tiempo de ejecución de los algoritmos.

89
90
Referencias

Aggarwal, C. C., & Wang, H. (2010). Managing and Mining Graph Data (First ed.). New
York, United States of America: Springer.

Agrawal, R., & Srikant, R. (1994). Fast Algorithms for Mining Association Rules.
Proceedings of the 1994 International Conference on Very Large Data Bases (VLDB’94),
(pp. 487-499). Santiago, Chile.

Brassard, G., & Bratley, P. (1996). Fundamentals of Algoritmics (First ed.). (I. Zucker, Ed.)
New Jersey, United States of America: Prentice Hall.

Bunke, H., & Riesen, K. (2011). Recent advances in graph-based pattern recognition with
applications in document analysis. Pattern Recognition , 1057–1067.

Caicedo Barrera, A., Wagner de García, G., & Méndez Parra, R. M. (2010). Introducción a
la teoría de grafos (Primera edición ed.). Armenia, Quindío: Elizcom.

Chung, F. R. (1994). Spectral graph theory. Conference Board of the Mathematical

Sciences Regional Conference Series in Mathematics Number 92 (pp. 1-14). California
State: American Mathematical Society.

Collins, J. M., & Ruefli, T. W. (1996). Strategic Risk. Springer.

Da San Martino, G., & Sperduti, A. (2010). Mining Structured Data. IEEE Computational
Intelligence Magazine , 5 (1), 42-49.

Djoko, S., Cook, D. J., & Holder, L. B. (1995). Analyzing the benefits of domain
knowledge in substructure discovery. Proceedings of the First International Conference on
Knowledge Discovery and Data Mining (pp. 75-80). Montreal, Canada: American
Association for Artificial Intelligence.

91
Eberle, W., & Holder, L. (2011). Graph-based Knowledge Discovery: Compression vs.
Frequency. International Conference of the Florida Artificial Intelligence Research Society
(FLAIRS) (pp. 1-2). Florida: Florida Artificial Intelligence Research Society.

Fawcett, T. (2006). An introduction to ROC analysis. ELSEVIER, Pattern Recognition

Letters , 27 (8), 861–874.

Fayyad, U., Piatetsky-Shapiro, G., & Smyth, P. (1996). From Data Mining to Knowledge
Discovery in Databases. 17 (3), 37-54.

Fonseca, R. S., Gómez-Gil, P., González, J. A., & Olmos, I. (2011). Finding Patterns in
Labeled graphs Using Spectrum Feature Vectors in a SOM Network. International Joint
Conference on Neural Networks 2011 (p. Por publicar). San Jose, California: IEEE.

Fortin, S. (1996). The Graph Isomorphism Problem. Reporte Técnico, Departamente of

Computer Science, The Univeristy of Alberta, Edmonton.

Gago, A. A. (2010). Minería de subgrafos conexos frecuentes en colecciones de grafos

etiquetados, tesis sometida como requisito para obtener el grado de Doctor en Ciencias
Computacionales. Tonantzintla, Puebla, México: INAOE.

García Barroto, M. (2010). Searching Extended Emerging Patterns for Supervised

Classification Phd Dissertation in Computer Science. Tonantzintla, México: National
Institute of Astrophysics, Optics and Electronics.

Garey, M. R., & Johnson, D. S. (1979). Computers and Intractability, A Guide to the
Theory of NP-Completeness. W. H. Freeman and Company.

Giudici E., R., & Bris Lluch, Á. (1997). Introducción a la teoría de grafos. Caracas,
Venezuela: EQUINOCCIO.

Godsil, C., & Royle, G. (2001). Algebraic Graph Theory (Primera edición ed.). (S. Axler,
F. Gehring, & K. Ribet, Eds.) New York, USA: Springer-Verlang.

Gómez Gil, M. d. (2010, 07). Notas del curso de Redes Neuronales Avanzadas. Retrieved
from "Redes Neuronales Avanzadas": http://ccc.inaoep.mx/~pgomez

92
González Bernal, J. A. (2001). Empirical and Theorical Analysis of Relational Concept
Learning using a Graph-Based Representation, Phd Dissertation. Arlington: The
University of Texas at Arlington.

González, J. A., Holder, L. B., & Cook, D. J. (2001). Graph-Based Concept Learning.
Proceedings of the Florida Artificial Intelligence Research Symposium. Florida: FLAIRS.

González, J., Holder, L., & Cook, D. (2001). Application of Graph-Based Concept
Learning to the Predictive Toxicology Domain. Proc. of the Predictive Toxicology
Challenge Workshop .

Günter, S., & Bunke, H. (2002). Self-organizing map for clustering in the graph domain.
Pattern Recognition Letters , 23, 405–417.

Hagenbuchner, M., Tsoi, A. C., Sperduti, A., & Kc, M. (2008). Efficient Clustering of
Structured Documents Using Graph Self-Organizing Maps. In Focused Access to XML
Documents (Vol. 4862, pp. 207-221). Berlin / Heidelberg: Springer.

Hamerly, G., & Elkan, C. (2003). Learning the k in k-means. Seventeenth Annual
Conference on Neural Information Processing Systems (NIPS) (pp. 281-288). Vancouver:
NIPS.

Han, J., & Kamber, M. (2006). Graph Mining. In J. Han, & M. Kamber, Data Mining:
Concepts and Techniques (2da ed.). University of Illinois at Urbana-Champaign.

Haykin, S. (2005). Neural Networks (Second ed.). Delhi, India: Pearson Prentice Hall.

Helma, C., & Kramer, S. (2003). A survey of the Predictive Toxicology Challenge 2000-
2001. BIOINFORMATICS , 1179-1182.

Holder, L. B., & Cook, D. J. (2005). Graph-Based Data Mining. In J. Wang (Ed.),
Encyclopedia of Data Warehousing and Mining. Idea Group Publishing.

Holder, L. B., Cook, D. J., & Djoko, S. (1994). Substructure Discovery in the SUBDUE
System. Procedings of the AAAI Workshop on Knowledge Discovery in Databases (pp.
169-180). AAAI.

93
Huan, J., Wang, W., & Prins, J. (2003). Efficient Mining of Frequent Subgraph in the
Presence of Isomorphism. Proceedings of the 3rd IEEE International Conference on Data
Mining (ICDM), (pp. 549-552). Melbourne.

Huan, J., Wang, W., Prins, J., & Yang, J. (2004). SPIN: mining maximal frequent
subgraphs from graph databases. Proceedings of the tenth ACM SIGKDD international
conference on Knowledge discovery and data mining, (pp. 581-586). Seattle.

Inokuchi, A., Washio, T., & Motoda, H. (2000). An A priori-Based Algorithm for Mining
Frequent Substructures from Graph Data. In D. Zighed, J. Komorowski, & J. Zytkow
(Eds.), Principles of Data Mining and Knowledge Discovery (pp. 13-23). Osaka, Japón:
Springer Berlin.

Irigoien, I., & Arenas, C. (2006). Clasificación: Análisis de clusters (Clustering). In B.

Sierra Araujo, Aprendizaje Automático: conceptos básicos y avanzados Aspectos prácticos
utilizando el software WEKA (pp. 261-294). Madrid, España: PEARSON EDUCACIÓN,
S.A.

Jolliffe, I. T. (2002). Principal component analysis (Segunda edición ed.). New York,
USA: Springer-Verlag.

Ketkar, N. S., Holder, L. B., & Cook, D. J. (2009). Empirical comparison of graph
classification algorithms. Computational Intelligence and Data Mining, (pp. 259-266).
Nashville, TN.

Kohonen, T. (1990). The self-organizing map. Proceedings of the IEEE , 78 (9), pp. 1464-
1480.

Kuramochi, M., & Karypis, G. (2001). Frequent Subgraph Discovery. IEEE International
Conference on Data Mining. California: IEEE International Conference on Data Mining.

Martí, M. A., & Llisterri, J. (2002). Tratamiento del Lenguaje Natural. Barcelona:
Universitat de Barcelona.

Mathai, A. M. (2008). Linear Algebra Part II Determinats And EigenValues. Pala, Kerala,
India: Centre for Mathematical Sciences South, Pala and Hill Area Campuses.

94
Morales, E., & Sucar, E. (2011, 04 25). Notas del curso Inteligencia Artificial. Retrieved
from "Inteligencia Artificial":
http://ccc.inaoep.mx/~emorales/Cursos/Representa/principal.html

Ng, R. T., & Han, J. (1994). Efficient and Effective Clustering Methods for Spatial Data
Mining. Proceedings of the 20th International Conference on Very Large Data Bases (pp.
144-155). San Francisco, CA, USA: Morgan Kaufmann Publishers Inc.

Nijssen, S., & Kok, J. N. (2004). A quickstart in frequent structure mining can make a
difference. KDD '04: Proceedings of the tenth ACM SIGKDD international conference on
Knowledge discovery and data mining (pp. 647-652). Seattle, WA, USA: ACM.

Olmos Pineda, I. (2006). Common Subgraph Search Based on Vertex-Edge-Vertex Codes

and a Breadth-Depth Search, Phd Dissertation in Computer Science. Tonantzintla, Puebla,
México: National Institute of Astrophysics, Optics and Electronics.

Olmos, I., González, J. A., & Osorio, M. (2006). Inexact Graph Matching: A Case of
Study. Florida Artificial Intelligence Research Society Conference. Florida: FLAIRS.

Press, W. H., Teukolsky, S. A., Vetterling, W. T., & Flannery, B. P. (1988). Numerical
Recipes in C, The Art of Scientific Computing. New York: CAMBRIDGE UNIVERSITY
PRESS.

Rand, W. M. (1971). Objective Criteria for the Evaluation of Clustering Methods. Journal
of the American Statistical Association , 66 (336), 846-850.

Ranu, S., & Singh, A. K. (2009). GraphSig: A Scalable Approach to Mining Significant
Subgraphs in Large Graph Databases. IEEE International Conference on Data
Engineering, (pp. 844-855). Santa Barbara.

Reforgiato, D., Gutierrez, R., & Shasha, D. (2008). GraphClust: A Method for Clustering
Dabase of Graphs. World Scientific , 7 (4), 231-241.

Schaeffer, S. E. (2007). Graph clustering. Computer Science Review , 1 (1), 27-64.

95
Smalter, A., Huan, J., Jia, Y., & Lushington, G. (2010). GPD: A Graph Pattern Diffusion
Kernel for Accurate Graph Classification with Applications in Cheminformatics.
IEEE/ACM Transactions on Computational Biology and Bioinformatics , 7 (2), 197 - 207.

Soussi, R., Aufaure, M. A., & Baazaoui, H. (2010). Towards Social Network Extraction
Using a Graph Database. Second International Conference on Advances in Databases,
Knowledge, and Data Applications, (pp. 28-34). Menuires, France.

Tarjan, R. (1971). Depth-first search and linear grajh algorithms. Foundations of Computer
Science, Annual IEEE Symposium on , 0, 114-121.

Toivonen, H., Srinivasan, A., King, R. D., Kramer, S., & Helma, C. (2003). Statistical
evaluation of the Predictive Toxicology Challenge 2000–2001. BIOINFORMATICS , 19
(10), 1183-1193.

Vesanto, J., & Alhoniemi, E. (2000). Clustering of the Self-Organizing Map. IEEE
Transactions on Neural Networks , 11 (3), 586-600.

Vicens Salort, E., Órtiz Bas, Á., & Guarch Bertolín, J. J. (1997). Métodos Cuantitativos
(Vol. I). Valencia, España: Servicio de Publicaciones.

Yan, X., & Han, J. (2002). gSpan: Graph-Based substructure Pattern Mining. Proceedings
of the 2002 IEEE International Conference on Data Mining (pp. 721-724). Washington:
IEEE Computer Society.

Zeng, Z., Tung, A. K., Wang, J., Feng, J., & Zhou, L. (2009). Comparing stars: on
approximating graph edit distance. Proceedings of the VLDB Endowment , 2 (1), 25-36.

96
Anexo A. Definiciones generales
Propiedad de clausura Descendente

“La frecuencia de cualquier patrón A es mayor o igual que la frecuencia de cualquier

patrón B que contenga a A”.

Tipos de grafos

Los enlaces y sus características ayudan a definir tipos de grafos. Todos los enlaces
indican la dirección de incidencia desde el vértice origen al vértice destino sin embargo,
pero al tener una relación bidireccional es más cómodo no indicarla explícitamente,
teniendo de esta manera grafos dirigidos cuando se especifica la dirección de la relación o
no dirigidos en el caso contrario. Por otro lado, un grafo es simple cuando no existen
enlaces que tengan como origen el mismo vértice de destino. Un grafo es llamado completo
si cada par de vértices son adyacentes, y el grafo completo de vértices se denota por .
Un grafo sin enlaces pero con al menos un vértice se denomina vacío. El grafo sin vértices
ni enlaces es el grafo nulo. Una trayectoria es el camino que se recorre para llegar desde un
vértice a otro, la conforman los vértices y enlaces visitados. Si existe una trayectoria que
regrese al vértice origen se dice que el grafo tiene ciclos. Cuando existen trayectorias entre
cualquier par de vértices se tiene un grafo conexo (o conectado) (Vicens Salort, Órtiz Bas,
& Guarch Bertolín, 1997).

Definición 1. Grafo pesado no dirigido

Un grafo pesado no dirigido (posiblemente con lazos) tiene asociado a él una función
de pesos satisfaciendo y . Por consiguiente,
si , entonces . Los grafos no pesados son un caso especial donde los
pesos son 0 o 1 (Godsil & Royle, 2001). Los grafos tienen múltiples representaciones, una
de ellas es la matriz de adyacencia12.

12
Ver definiciones formales y conceptos básicos en el anexo de definiciones generales.

97
Definición 2. Grafo etiquetado

En un grafo etiquetado los vértices tienen etiquetas al igual que los enlaces. Un grafo
se puede representar por la 6-tupla conformada por el conjunto de vértices , el conjunto
de enlaces , la lista de etiquetas de vértices y la lista de etiquetas de enlaces .
Adicionalmente, se tienen las funciones de obtención de etiquetas tanto de vértices
como de enlaces . De esta manera, el grafo queda definido por la expresión
(Olmos Pineda, 2006). La frecuencia de un vértice, en un grafo
etiquetado, se puede obtener contando el número de veces que se repite su etiqueta.

Representaciones de grafos

Los grafos se pueden representar de varias formas, una de ellas es la matriz de

adyacencia.

Definición 3. Matriz de adyacencia

La matriz de adyacencia de un grafo dirigido es la matriz entera con filas y

columnas indexadas por los vértices de , tal que la entrada de es igual al número
de arcos desde a (el cual es usualmente ó ). Si es un grafo no dirigido, entonces
es una matriz-01 simétrica. Si el grafo no tiene lazos, las entradas de la diagonal de
son ceros.

Análisis de componentes principales

Definición 4. Análisis de componentes principales

La idea central del análisis de componentes principales (PCA) es reducir la

dimensionalidad de un conjunto de datos consistente de un gran número de variables
interrelacionadas, tratando de retener lo más posible la variación del conjunto de datos.
Esto se logra transformando los datos a un nuevo conjunto de variables, los componentes
principales (PCs), los cuales no están relacionados, y están ordenados de tal forma que los
pocos primeros contienen la mayoría de la variación presente en todas las variables
originales (Jolliffe, 2002). Una forma de obtener los componentes principales es por medio
del cálculo de los valores propios de una representación matricial.

98
Definición 5. Eigenvalores y eigenvectores

Los valores propios o valores característicos son definidos únicamente para matrices
cuadradas. Sea una matriz . Considerando la ecuación (Mathai, 2008)

(A.1)

Donde es un escalar y es un vector . Si la ecuación tiene una solución para

y para un no nulo entonces se denomina valor propio o raíz característica o raíz
latente de y el vector no nulo que satisface la ecuación para en particular es llamado
eigenvector o vector característico o vector latente correspondiente para el valor propio .

Examinando la ecuación más cercanamente.

(A.2)

Si este sistema lineal homogéneo tiene una solución no nula

entonces debe ser singular. Si es no singular entonces su regular inversa
existe y al multiplicar ambos lados por se tiene la única solución . Si
es singular entonces su determinante debe ser cero. Como esto,

(A.3)

Los valores propios también se pueden definir como las raíces de la ecuación
"determinantal" (Mathai, 2008).

Laplaciano de la matriz de adyacencia

El Laplaciano es otra matriz importante asociada con un grafo y el espectro Laplaciano

es el espectro de esta matriz. Formalmente, dada una orientación arbitraria del grafo y
la matriz de incidencia de , el Laplaciano de es la matriz . Al
considerarse la matriz de incidencia y su transpuesta el laplaciano no depende de la
orientación (Godsil & Royle, 2001). Este concepto se puede generalizar de la siguiente
manera.

99
Definición 6. Laplaciano generalizado

Sea un grafo con vértices. La matriz simétrica se denomina Laplaciano

generalizado de si cuando y son vértices adyacentes de y cuando
y son distintos y no adyacentes (Godsil & Royle, 2001).

Definición 7. Laplaciano del grafo pesado

Para iniciar, se considera la matriz definida como:

(A.4)

Donde es el grado del vértice . Sea T la matriz diagonal formada por los grados de
los vértices. El Laplaciano de G se define por

(A.5)

En otras palabras:

(A.6)

Hay relaciones entre los vértices que no se expresan por medio de pesos, sino usando
etiquetas. Este tipo de grafos se denominan grafos etiquetados.

Distancia y Similaridad

Supongamos casos recogidos en un conjunto que llamaremos y denotaremos

. Teniendo en cuenta que nuestro objetivo principal es hallar clusters que
contentan los casos similares, va a ser necesario medir las similitud o bien las distancias
que hay entre los casos.

100
Definición 8. Distancia

Una distancia sobre un conjunto es una función :

Tal que verifica lo siguiente:

1.

2.

3.

La primera de las propiedades dice que todas las distancias deben ser no negativas o
visto de otra manera. ¿Qué sentido puede tener una distancia negativa? La segunda
propiedad dice que cada caso no puede distar de sí mismo y la última de las propiedades
establece la simetría. Es decir, que la distancia que puede haber de un caso a otro caso es
la misma que del caso al . En general, cuanto mayor sea la distancia , más
diferentes entre sí serán los casos y .

Cuando además de las tres propiedades anteriores se cumple la desigualdad triangular,

esto es, , diremos que la distancia es métrica y que
forma un espacio métrico.

Definición 9. Similaridad

Una similaridad sobre un conjunto es una función :

101
 Tal que:

1.

2.

3.

“La primera propiedad dice que la similaridad debe ser no negativa y establece una
escala. La segunda, que cada caso se parece a sí mismo más que a cualquier otro caso y la
última establece la simetría. Y en cuanto a la interpretación se puede decir que cuanto
mayor sea la similaridad , más parecidos entre sí serán los casos y ” (Irigoien &
Arenas, 2006).

Definición 10. Isomorfismo

Dos grafos y son isomorfos si existe una función de mapeo

biyectiva (uno a uno) (llamada un isomorfismo) tal que si y solo si
(Olmos, González, & Osorio, 2006). Cuando se busca un subgrafo
contenido en un grafo se tiene el problema de isomorfismo de subgrafos. Éste es un
problema NP-Completo, la demostración se puede ver en el libro de Garey (Garey &
Johnson, 1979).

Definición 11. Distancia de Edición de Grafos

Hablando informalmente, una operación de edición en un grafo es una inserción o

borrado de un vértice/enlace o re-etiquetado de un vértice. Un vértice se puede eliminar
únicamente si no tiene enlaces conectados. Generalmente, se asume que cada operación
tiene un mismo costo. Sea una operación de edición, un alineamiento es una secuencia
de operaciones de edición , la cual puede transformar un grafo en otro
grafo . Así, se dice que puede llegar a a través de . Varios alineamientos pueden
llevar a , alineamientos óptimos entre y son aquellos que contienen el número
mínimo de operaciones de edición.

102
 La distancia de edición de grafos se define como la distancia entre y , denotada
por , y es el costo total de operaciones de edición en el alineamiento óptimo que
lleva del grafo a .

Fases de la red neuronal SOM (Mapas Auto-Organizados)

Una red neuronal SOM consta de las siguientes fases (Haykin, 2005):

Adaptación sináptica.- Este último mecanismo, les permite a las neuronas activadas
incrementar sus valores individuales de la función discriminante; en relación a la entrada de
patrones a través de un adecuado ajuste de los pesos sinápticos. El ajuste es tal que mejora
la respuesta ante un patrón de entrada similar. El coeficiente de aprendizaje debe
disminuir con el tiempo . Este requerimiento se satisface con una disminución
exponencial como el propuesto en (Haykin, 2005).

(A.7)

Donde es otra constante de tiempo del algoritmo SOM. La neurona ganadora se define
como la neurona cuyo peso tiene la menor distancia con el vector de entrada, y sigue:

(A.8)

Donde es el número de conexiones del nodo . Finalmente, se puede definir la adaptación

de los pesos por la siguiente ecuación.

(A.9)

La función se define como:

(A.10)

103
Vecindario basado en las posiciones

En el presente trabajo el vecindario se determina por las posiciones en la rejilla,

considerando los 4, 8, 12, 16, 20 y 24 vecinos más cercanos a la neurona ganadora. Su
distribución se muestra en la figura A.1.

a) 4 b) 8 c) 12
Vecinos Vecinos Vecinos

d) 16 e) 20 f) 24
Vecinos Vecinos Vecinos
Figura A.1. Vecindarios de 4, 8, 12, 16, 20 y 24 vecinos.

El proceso de adaptación tiene dos fases que son ordenamiento y convergencia.

Fase de auto-organización u ordenamiento.- Sucede durante al principio del proceso

adaptivo, en donde el ordenamiento del vector de pesos tiene lugar. El ordenamiento puede
tener más de 1000 iteraciones del algoritmo SOM. Cuidadosas consideraciones se deben
realizar para seleccionar los parámetros de coeficiente de aprendizaje y vecindario.

1. El coeficiente de aprendizaje debe iniciar en un valor cercano a 0.1, entonces

debe decrecer gradualmente, pero manteniéndose por encima de 0.01.
2. La función de vecindario inicialmente debe incluir a todas las neuronas con
centro en la neurona ganadora, y continúa reduciéndose lentamente con el
tiempo.

Fase de convergencia.- Esta segunda fase del proceso adaptivo es necesaria para afinar el
mapa de características, para proveer una cuantificación estadística precisa del espacio de

104
entrada. Como regla general, el número de iteraciones debe ser de al menos 500 veces el
número de neuronas en la red (Haykin, 2005).

1. Para una buena precisión estadística, el coeficiente de aprendizaje debe

mantenerse en un valor pequeño cerca de 0.01, no debe llegar a 0.
2. El vecindario solo debe considerar a los vecinos más cercanos de la neurona
ganadora. Eventualmente, se puede reducir el número de vecinos a 1 o 0.

Aprendizaje de conceptos

El aprendizaje de conceptos es una técnica del aprendizaje computacional, en el cual el

proceso de aprendizaje es dirigido por ejemplos positivos y negativos enviados a una
máquina que los aprenda “Learner”. A partir de estos ejemplos, el learner construye una
hipótesis (concepto) que describe a los ejemplos positivos y excluye a los ejemplos
negativos (González, Holder, & Cook, 2001).

El aprendizaje de conceptos es el proceso de inducción de una función (concepto) a

partir de ejemplos de entrenamiento. Los ejemplos están previamente clasificados como
positivos y negativos. Los ejemplos son utilizados para guiar la búsqueda de la función
objetivo. Después del proceso, esta función debe ser capaz de clasificar correctamente un
nuevo objeto, no incluido en los ejemplos de entrenamiento (González Bernal, 2001).

Crecimiento de Patrones

Un grafo puede ser extendido adicionándole una nueva arista . Hay dos formas de
realizar esta extensión en dependencia de que la arista esté compuesta por dos vértices de
(extensiones cerradas), o un vértice en y un vértice nuevo (extensiones por vértice).

El grafo resultante de esta extensión se denota como . Se suele decir que es un

hijo de en el espacio de búsqueda, y que es el padre de (Gago, 2010).

A.2 Términos Asociados con las gráficas ROC

La sensibilidad también conocida como recuerdo y que es igual a la tasa de verdaderos

positivos. Representa la proporción de los positivos correctamente clasificados.

105
 (A.11)

La precisión es el porcentaje de ejemplos etiquetados como positivos que actualmente

son positivos.

(A.12)

La exactitud se refiere a cuán cerca del valor real se encuentra el valor medio.

(A.13)

La especificidad mide la proporción de los ejemplos negativos que fueron

correctamente clasificados.

(A.14)

La función también conocida como o , se puede

interpretar como el promedio pesado de la precisión y el recuerdo. Su mejor valor es 1 y el
peor es 0.

(A.15)

Prueba de hipótesis

Una suposición que se hace acerca de la distribución de una variable aleatoria se denomina
una hipótesis estadística. Una prueba de hipótesis es un procedimiento en el cual se utiliza
una muestra con el fin de determinar cuándo se puede “no rechazar” (“aceptar”) la hipótesis
(Kreyszig, 1982).

106
Comparación de las medias de dos distribuciones

Al comparar dos métodos se tienen dos escenarios:

Caso A. Las muestras tienen el mismo tamaño. Además, a cada valor de la primera muestra
corresponde precisamente a un valor de la otra.

Caso B. Las dos muestras son independientes y no necesariamente del mismo tamaño.

En el caso A se puede formar un conjunto con las diferencias de valores correspondientes y

probar la hipótesis de que la población correspondiente a las diferencias tiene media cero.

El caso B requiere una prueba considerando dos variables, mayor información se puede
encontrar en (Kreyszig, 1982).

107
108
Anexo B. Documentación del software
En esta sección está la documentación del software desarrollado para esta tesis. La
primera parte resume los requerimientos generales del sistema. A continuación, está el
manual de usuario de los ejecutables utilizados para los experimentos. La descripción
detallada de las clases construidas se incluye en la carpeta documentación del software, esta
carpeta se encuentra en el CD adjunto.

B.1. Requerimientos Generales

Los requerimientos generales que cubre el sistema desarrollado se resumen en el

diagrama de casos de uso de la figura B.1. El primer caso de uso es “Manejar Grupos de
Grafos”. Este caso de uso considera las funciones relacionadas con la administración de
grupos de grafos como son: cargar un grupo de grafos a partir de un archivo, crear, insertar,
eliminar y buscar grafos a través de un identificador, dibujar grafos y grupos de grafos;
además incluye funciones para realizar cálculos con los grafos, estas operaciones son:
generación de la matriz de adyacencia, generación de lista de códigos VEV para todo el
conjunto de grafos, cálculo del Laplaciano generalizado del grafo, cálculo del valores
propios de una matriz. Las funciones utilizadas para dibujar grafos utilizan el software
Graphviz que se puede descargar en http://www.graphviz.org/. El cálculo de valores
propios se realiza utilizando el paquete de software de las recetas numéricas, el cual se
puede obtener en el sitio http://www.nr.com/.

El sistema desarrollado tiene diversas funciones que permiten el fácil manejo de

conjuntos de grafos. El resultado obtenido es un marco de trabajo (framework) que permitió
implementar el algoritmo desarrollado en esta tesis. Las clases involucradas y sus
relaciones se encuentran documentadas al final de esta sección.

El segundo caso de uso requiere agrupar grafos en tiempo polinomial, utilizando el

software desarrollado se implementó el algoritmo Spectral_SOM. La red recibe como
entrada el espectro de los grafos. El código de generación de espectro se encuentra en el
CD adjunto en el archivo "generarespectro.cpp", mientras que el código para agrupar grafos

109
en función del espectro se encuentra en el archivo "somespectral.cpp". El tercer caso de uso
necesita realizar un crecimiento de patrones para poder realizar la tarea de aprendizaje de
conceptos basada en grafos. En este punto se implementó el algoritmo CL_COBRA. El
código se encuentra en el archivo "busqueda.cpp".

System
Framework de Trabajo KODISSOM_COBRA

Manejar Grupos de Grafos

Agrupar Grafos - Spectral_SOM

Usuario

Aprendizaje de Conceptos - CL_COBRA

Figura B.1. Diagrama de casos de uso del sistema desarrollado.

Una vez implementados Spectral_SOM y CL_COBRA se utilizaron para desarrollar el

algoritmo KODISSOM_COBRA que es el resultado de esta tesis.

B.2. Manual de usuario

El código está escrito en ANSI C++, por esta razón se puede compilar en la mayoría de
arquitecturas de hardware existentes. Las pruebas se realizaron en Linux y el manual de
instalación está asociado con este sistema operativo.

Instalación en Linux

Lo primero es compilar los ejecutables necesarios, para ello se debe tener instalado
g++ y a continuación ejecutar el comando: sh compilar.sh. Este comando va a generar un
conjunto de archivos con extensión .exe, copie estos archivos en el directorio de
ejecutables.

La evaluación de los patrones encontrados se la realiza utilizando el ejecutable test que

viene con el software de Subdue, este se puede descargar de http://ailab.wsu.edu/subdue/.

110
Una vez descargado siga las instrucciones de instalación que vienen con el software y copie
el ejecutable de test en el directorio donde va a tener todos los ejecutables del sistema.

Shells para facilitar ejecución

En la etapa de pruebas se utilizó Linux y aquí se implementaron shells para facilitar la

utilización de los ejecutables. Un Shell es un conjunto de comandos que son ejecutados por
un intérprete. Los shells desarrollados son:

CL_COBRA

Este Shell se encarga de realizar el aprendizaje de conceptos en un conjunto de grafos

previamente clasificados utilizando el algoritmo CL_COBRA. El archivo ejecutable es
busquedaPorLista.sh, este recibe un archivo con la lista de parámetros, los cuales son: el
archivo de grafos a procesar, el soporte mínimo, el valor de la variable Beam, la bandera
remover ejemplos, y el archivo con los grafos que se utilizan para la evaluación de los
conceptos aprendidos.

La sintaxis de ejecución es: sh busquedaPorLista.sh lista_parametros.txt

KODISSOM_COBRA

El objetivo de este Shell es implementar el algoritmo KODISSOM_COBRA. El

archivo ejecutable es KodisomPorLista.sh. La entrada al Shell es una lista de parámetros.
Los parámetros son: ruta del archivo de grafos, número de filas y número de columnas de la
red neuronal SOM, número de épocas que se va a entrenar la red, soporte mínimo y
variable Beam para CL_COBRA, tipo de agrupamiento, ruta del archivo con grafos para
pruebas y bandera remover ejemplos. Los tipos de agrupamiento son: (0) - Agrupamiento
con la neurona ganadora, es decir, los grafos son asignados al grupo de su neurona
ganadora. (1..n) - Agrupamiento por vecindario rectangular, los grafos son asignados a
grupos de igual forma que en el agrupamiento con la neurona ganadora, pero al momento
de escribir el resultado se unen los grupos con sus grupos vecinos en la capa de salida de la
red neuronal. (-1) - Agrupamiento con negativos, en este tipo de agrupamiento se entrena la
red neuronal SOM solo utilizando los ejemplos positivos, luego entonces se crean grupos

111
de la forma Agrupamiento con la neurona ganadora, finalmente, a cada grupo se le
aumentan todos los grafos negativos.

La sintaxis de ejecución es: sh KodissomPorLista.sh lista_parametros.txt

Acerca del proyecto

El proyecto se puede abrir con Visual Studio 2010 en el Sistema Operativo Windows
XP o Windows 7, también se puede abrir en Linux con Netbeans 7.0.1 más el plug-in de
C++. Si se desea utilizar Netbeans en Windows es necesario instalar cygwin siguiendo el
manual de Netbeans que se encuentra en: http://netbeans.org/community/releases/60/cpp-
setup-instructions_es.html.

112
Anexo C. SubdueCL
El algoritmo SubdueCL se muestra en a la tabla C.1 y la tabla C.2. La función principal
(tabla C.1) recibe como parámetros los ejemplos positivos , los ejemplos negativos , el
tamaño del Beam y el límite del número de subestructuras a incluir en la búsqueda. La
función principal llama a la función SubdueCL (Tabla C.2) para formar hipótesis que
describen a los ejemplos positivos (González Bernal, 2001).

Tabla C.1. Algoritmo SubdueCL función principal (González Bernal, 2001).

Función
Entrada:

Salida:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

Una subestructura se aumenta a cada vez que se llama a la función . En el

caso que retorne , el Beam aumenta un para que un mayor espacio
de búsqueda sea explorado en la búsqueda de . Los ejemplos positivos cubiertos
por una subestructura encontrada son removidos.

La tabla C.2 muestra la función , que inicia construyendo un

creando una subestructura por cada vértice en el grafo con una diferente etiqueta,
manteniendo únicamente un número de subestructuras igual al . El calificador
“ ” significa que la lista mantiene solo tantas subestructuras como el tamaño del
. Cada subestructura se expande con un enlace o un vértice y un enlace en todas las

113
maneras posibles y se evalúa según la ecuación (2.6). El parámetro se utiliza para
generar tantas subestructuras como el valor del , pero si la lista está vacía
después de generar los candidatos, el límite se incremente un hasta encontrar por lo
menos un candidato (González Bernal, 2001). En esta tesis se compara el algoritmo
propuesto con SubdueCL.

Tabla C.2. Función SubdueCL (González Bernal, 2001)

Función
Entrada:

Salida:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

114