Yolis Tesisingenieriainformatica

ALGORITMOS GENTICOS APLICADOS A
LA CATEGORIZACIN AUTOMTICA DE
DOCUMENTOS

TESIS DE GRADO EN INGENIERIA
INFORMATICA

FACULTAD DE INGENIERIA
UNIVERSIDAD DE BUENOS AIRES

TESISTA: Sr. Eugenio YOLIS
DIRECTOR: Prof. Dr. Ramn GARCIA-MARTINEZ
Laboratorio de Sistemas Inteligentes
ABRIL 2003

ALGORITMOS GENTICOS APLICADOS A LA
CATEGORIZACIN AUTOMTICA DE DOCUMENTOS

TESIS DE GRADO EN INGENIERIA INFORMATICA

Laboratorio de Sistemas Inteligentes

FACULTAD DE INGENIERIA
UNIVERSIDAD DE BUENOS AIRES

Sr. Eugenio Yolis Dr. Ramn Garca Martnez
Tesista Director

ABRIL 2003

Resumen

La categorizacin automtica de documentos ha estado recibiendo creciente
atencin debido al incremento en la cantidad de informacin disponible en forma
electrnica y a la necesidad cada vez mayor de encontrar la informacin buscada en un
tiempo mnimo. Si bien existen numerosos algoritmos para categorizar documentos,
todos ellos evaluan un subconjunto pequeo del espacio de posibles soluciones. Estea
tesis presenta un algoritmo gentico adaptado al problema de categorizacin de
documentos. El algoritmo propuesto introduce 5 nuevos operadores, diseados
especficamente para la resolucin del problema de categorizacin. Los resultados
obtenidos demuestran que el algoritmo gentico logra explorar el espacio de bsqueda
ms amplia y eficientemente que los algoritmos previos tomados como referencia.

Palabras clave: Categorizacin Automtica de Documentos, Algoritmos Genticos,
Computacin Evolutiva

Abstract

Automatic document clustering has been receiving increasing attention due to
the growing amount of information available in digital formats, and the importance of
finding the information required faster every day. Even though several clustering
algorithms have been developed, all of them evaluate just a small part of the solution
space. This paper presents an adaption of a genetic algorithm to the document clustering
problem. This new algoritm introduces 5 new operators, designed specifically for the
problem being solved. The obtained results show that the genetic algorithm achieves a
wider and more efficient exploration of the solution space than the previously developed
algoritms that were taken as reference.

Keywords: Automatic Document Clustering, Genetic Algorithms, Evolutionary
Computation
ALGORITMOS GENTICOS APLICADOS A LA CATEGORIZACIN AUTOMTICA DE DOCUMENTOS

Eugenio Yolis INDICE 1
Indice

CAPTULO 1 ...............................................................................................................................................................7
INTRODUCCIN......................................................................................................................................................7
1.1 CATEGORIZACIN AUTOMTICA DE DOCUMENTOS...................................................................................... 8
1.1.1 La Hiptesis del Agrupamiento.............................................................................................................8
1.1.2 Aplicaciones..............................................................................................................................................9
1.2 NATURALEZA COMBINATORIA DEL PROBLEMA DE CATEGORIZACIN..................................................... 10
1.3 ALGORITMOS GENTICOS............................................................................................................................... 11
1.4 OBJETIVO DE LA TESIS .................................................................................................................................... 11
1.5 ESTRUCTURA DE LA TESIS.............................................................................................................................. 12
CAPTULO 2 .............................................................................................................................................................15
ESTADO DEL ARTE..............................................................................................................................................15
2.1 CATEGORIZACIN DE OBJETOS...................................................................................................................... 16
2.2 REPRESENTACIN VECTORIAL....................................................................................................................... 16
2.2.1 Definicin del centroide de un grupo ............................................................................................17
2.2.2 Reduccin de la dimensionalidad del espacio de trmi nos............................................................18
2.2.2.1 Reduccin de palabras a su raz ......................................................................................................... 18
2.2.2.2 Remocin de trminos poco discriminantes ...................................................................................... 19
2.3 MEDIDAS DE SEMEJANZA............................................................................................................................... 20
2.4 MTODOS PARA CATEGORIZAR DOCUMENTOS............................................................................................ 23
2.5 MTODOS DE CATEGORIZACIN INTRNSECOS............................................................................................ 24
2.5.1 Mtodos Jerrquicos.............................................................................................................................24
2.5.1.1 Enlace simple (single link) ............................................................................................................. 27
2.5.1.2 Enlace completo (complete link).................................................................................................... 28
2.5.1.3 Enlace promedio (average link)...................................................................................................... 28
2.5.1.4 Mtodo de Ward................................................................................................................................. 29
2.5.1.5 Resumen de caractersticas ................................................................................................................ 29
2.5.2 Mtodos particionales...........................................................................................................................30
2.5.2.1 Seleccin inicial de los representantes............................................................................................... 31
2.5.2.2 Criterios de optimizacin................................................................................................................... 32
2.5.2.3 Algoritmos de optimizacin............................................................................................................... 35
2.5.2.4 Resumen de caractersticas ................................................................................................................ 37
2.6 EL ALGORITMO BISECTING K-MEANS...................................................................................................... 38
2.6.1 Algoritmo Bisecting K-Means con refinamiento..........................................................................39

2 INDICE Eugenio Yolis
2.7 INTRODUCCIN A LOS ALGORITMOS GENTICOS....................................................................................... 39
2.7.1 Representacin.......................................................................................................................................42
2.7.2 Generacin de la poblacin inicial.....................................................................................................44
2.7.3 Funcin de adaptacin..........................................................................................................................44
2.7.4 Seleccin..................................................................................................................................................45
2.7.4.1 Seleccin basada en el ranking.......................................................................................................... 45
2.7.4.2 Seleccin por ruleta............................................................................................................................ 46
2.7.4.3 Seleccin por torneo........................................................................................................................... 47
2.7.5 Reproduccin..........................................................................................................................................48
2.7.5.1 Cruza monopunto............................................................................................................................... 49
2.7.5.2 Cruza multipunto................................................................................................................................ 49
2.7.5.3 Cruza uniforme .................................................................................................................................. 50
2.7.6 Mutacin..................................................................................................................................................51
2.7.7 Insercin de los hijos en la poblacin................................................................................................51
2.7.7.1 Se generan tantos cromosomas como elementos en la poblacin...................................................... 51
2.7.7.2 Se generan ms cromosomas que elementos en la poblacin ............................................................ 52
2.7.7.3 Se generan menos cromosomas que elementos en la poblacin ........................................................ 52
2.7.8 Criterios de terminacin del algoritmo gentico..............................................................................53
2.7.8.1 Criterio de convergencia de identidad ............................................................................................... 53
2.7.8.2 Criterio de convergencia de aptitud................................................................................................... 53
2.7.8.3 Criterio de cantidad de generaciones ................................................................................................. 53
CAPTULO 3 .............................................................................................................................................................55
DESCRIPCIN DEL PROBLEMA ...................................................................................................................55
3.1 LA BSQUEDA EN EL ESPACIO DE SOLUCIONES........................................................................................... 55
3.1.1 Problemas de los algoritmos actuales................................................................................................55
3.2 UTILIZACIN DE ALGORITMOS GENTICOS.................................................................................................. 57
3.2.1 Representacin y operadores de cruza...............................................................................................58
3.2.2 Uso del conocimiento del dominio......................................................................................................58
CAPTULO 4 .............................................................................................................................................................61
SOLUCIN PROPUESTA....................................................................................................................................61
4.1 ADAPTACIONES EXISTENTES.......................................................................................................................... 61
4.1.1 Representacin.......................................................................................................................................61
4.1.1.1 Numeracin de grupo......................................................................................................................... 61
4.1.1.2 Representacin por matriz ................................................................................................................. 62
4.1.1.3 Permutacin con separadores ............................................................................................................. 62
4.1.1.4 Permutacines con bsquedas locales................................................................................................ 63
4.1.2 Generacin de la poblacin inicial.....................................................................................................64
4.1.3 Funcin de adaptacin..........................................................................................................................64

4.1.4 Seleccin..................................................................................................................................................64
4.1.5 Cruza ........................................................................................................................................................64
4.1.5.1 Cruza monopunto y multipunto......................................................................................................... 64
4.1.5.2 Cruza basada en las aristas................................................................................................................. 66
4.1.6 Mutacin..................................................................................................................................................67
4.2 ALGORITMO PROPUESTO................................................................................................................................ 67
4.2.1 Representacin.......................................................................................................................................67
4.2.2 Estructura del cromosoma....................................................................................................................68
4.2.3 Generacion de la poblacin inicial.....................................................................................................68
4.2.4 Funcion de adaptacin..........................................................................................................................69
4.2.5 Seleccion..................................................................................................................................................69
4.2.6 Cruza ........................................................................................................................................................70
4.2.6.1 Cruza Pasa Grupo............................................................................................................................... 70
4.2.6.2 Anlisis del operador Cruza Pasa Grupo........................................................................................... 72
4.2.7 Mutacin..................................................................................................................................................73
4.2.7.1 Mutacin RefinarKM......................................................................................................................... 73
4.2.7.2 Mutacin Refinar Selectivo ............................................................................................................... 74
4.2.7.3 Mutacin Join..................................................................................................................................... 74
4.2.7.4 Mutacin Split.................................................................................................................................... 75
4.2.8 Insercin de los hijos en la poblacin................................................................................................75
4.2.9 Tamao de la poblacin........................................................................................................................76
4.2.10 Criterio de terminacin.......................................................................................................................76
4.2.11 Algoritmo Gentico con refinamiento.........................................................................................77
CAPTULO 5 .............................................................................................................................................................79
PRUEBA EXPERIMENTAL................................................................................................................................79
5.1 CONJUNTO DE DATOS UTILIZADO.................................................................................................................. 79
5.2 VARIABLES A OBSERVAR................................................................................................................................ 81
5.2.1 Variables independientes......................................................................................................................81
5.2.2 Variables dependientes.........................................................................................................................82
5.2.2.1 Similitud promedio ............................................................................................................................ 82
5.2.2.2 Entropa.............................................................................................................................................. 83
5.2.2.3 Cantidad de operaciones .................................................................................................................... 85
5.3 REALIZACIN DE LOS EXPERIMENTOS.......................................................................................................... 86
5.3.1 Metodologa utilizada............................................................................................................................86
5.3.1.1 Experimentos variando la cantidad de grupos ................................................................................... 86
5.3.1.2 Experimentos variando la cantidad de documentos........................................................................... 87
5.3.2 Parmetros utilizados por el algoritmo gentico.............................................................................88
5.4 RESULTADOS.................................................................................................................................................... 89
5.4.1 Experimentos variando la cantidad de grupos.................................................................................89

5.4.2 Experimentos variando la cantidad de documentos........................................................................93
5.5 ANLISIS DE LOS RESULTADOS...................................................................................................................... 96
CAPTULO 6 .............................................................................................................................................................97
CONCLUSIONES ....................................................................................................................................................97
RESPUESTA A LAS CUEST IONES PLANTEADAS.................................................................................................... 97
REFERENCIAS..................................................................................................................................................... 101
APNDICE 1 .......................................................................................................................................................... 109
DETERMINACIN DE PARMETROS PARA EL ALGORITMO................................................... 109
A1.1 PARMETROS A DETERMINAR.................................................................................................................. 109
A1.1.1 generacionesMximo....................................................................................................................... 109
A1.1.2 poblacionTamao............................................................................................................................. 109
A1.1.3 torneoTamao................................................................................................................................... 109
A1.1.4 torneoProbMejor.............................................................................................................................. 110
A1.1.5 cruzaPasaGrupoProbMejor........................................................................................................... 110
A1.1.6 mutacionRefinarKMProb................................................................................................................ 110
A1.1.7 mutacionRefinarSelectivoProb...................................................................................................... 110
A1.2 METODOLOGA UTILIZADA....................................................................................................................... 110
A1.3 RESULTADOS............................................................................................................................................... 112
A1.3.1 generacionesMximo....................................................................................................................... 112
A1.3.2 poblacionTamao............................................................................................................................. 113
A1.3.3 torneoTamao................................................................................................................................... 115
A1.3.4 torneoProbMejor.............................................................................................................................. 116
A1.3.5 cruzaPasaGrupoProbMejor........................................................................................................... 117
A1.3.6 mutacionRefinarKMProb................................................................................................................ 118
A1.3.7 mutacionRefinarSelectivoProb...................................................................................................... 119
APNDICE 2 .......................................................................................................................................................... 121
ANLISIS ESTADSTICO DE LOS RESULTADOS................................................................................ 121
A2.1 PRUEBA DE HIPTESIS ESTADSTICAS...................................................................................................... 121
A2.2 EL TEST DE WILCOXON PARA LA COMPARACIN DE MEDIAS DE MUESTRAS APAREADAS.............. 123
A2.2.1 Introduccin...................................................................................................................................... 123
A2.2.2 Descripcin del test.......................................................................................................................... 123
A2.3 APLICACIN DEL TEST A LOS RESULTADOS............................................................................................ 125
A2.3.1 Similitud promedio........................................................................................................................... 126
A2.3.1.1 Bisecting K-Means con refinamiento contra Gentico .......................................................... 126

A2.3.1.2 Bisecting K-Means con refinamiento contra Gentico con refinamiento.............................. 126
A2.3.2 Entropa............................................................................................................................................. 127
A2.3.3 Cantidad de operaciones................................................................................................................. 128
APNDICE 3 .......................................................................................................................................................... 129
MANUAL DE USO............................................................................................................................................... 129
A3.1 ESQUEMA DE PROCESAMIENTO................................................................................................................ 130
A3.2 ESTRUCTURA DE DIRECTORIOS DEL CD.................................................................................................. 132
A3.3 CONFIGURACIN DEL ORI GEN DE DATOS ODBC................................................................................... 133
A3.3.1 Copiar el archivo MDB................................................................................................................... 133
A3.3.2 Agregar el origen de datos ODBC................................................................................................ 133
A3.4 FORMATO DE LOS ARCHIVOS DE DATOS.................................................................................................. 136
A3.5 PROGRAMA ARMAR DATASETS............................................................................................................ 137
A3.6 PROGRAMA AGDOCCLUS..................................................................................................................... 139
A3.6.1 Copia del programa al disco local ................................................................................................ 139
A3.6.2 Utilizacin del programa ................................................................................................................ 139
A3.7 PROGRAMA EVALUAR AGRUPAMIENTOS ........................................................................................... 141
APNDICE 4 .......................................................................................................................................................... 143
PROGRAMACIN DE LOS ALGORITMOS............................................................................................. 143
A4.1 DESCRIPCIN DE LOS MDULOS............................................................................................................... 143
A4.1.1 Mdulo ArchivosTexto................................................................................................................ 143
A4.1.2 Mdulo VecArchivos................................................................................................................... 144
A4.1.3 Mdulo Agrupamiento................................................................................................................ 144
A4.1.4 Mdulo K-Means......................................................................................................................... 145
A4.1.5 Mdulo Gentico......................................................................................................................... 145
A4.1.6 Mdulo Principal......................................................................................................................... 146
A4.2 CDIGO FUENTE.......................................................................................................................................... 147
A4.2.1 ArchivosTexto.h ................................................................................................................................ 147
A4.2.2 ArchivosTexto.cpp............................................................................................................................ 148
A4.2.3 VecArchivos.h ................................................................................................................................... 154
A4.2.4 VecArchivos.cpp............................................................................................................................... 156
A4.2.5 ClsAgrupamiento.h........................................................................................................................... 164
A4.2.6 ClsAgrupamiento.cpp...................................................................................................................... 165
A4.2.7 ClsAgrupImprime.h .......................................................................................................................... 171

A4.2.8 ClsAgrupImprime.cpp...................................................................................................................... 172
A4.2.9 ClsKMeans.h ..................................................................................................................................... 175
A4.2.10 ClsKMeans.cpp............................................................................................................................... 177
A4.2.11 ClsGenetico.h.................................................................................................................................. 196
A4.2.12 ClsGenetico.cpp.............................................................................................................................. 199
A4.2.13 Def.h ................................................................................................................................................. 225
A4.2.14 Sis.h................................................................................................................................................... 227
A4.2.15 SisDos.h ........................................................................................................................................... 228
A4.2.16 SisDos.cpp....................................................................................................................................... 229
A4.2.17 Ppal.cpp........................................................................................................................................... 232

Eugenio Yolis CAPITULO 1 - INTRODUCCION 7
Captulo 1
Introduccin
La Categorizacin de Documentos (Document Clustering) puede definirse como
la tarea de separar documentos en grupos. El criterio de agrupamiento se basa en las
similitudes existentes entre ellos [Kaufmann et al., 1990]. En la bibliografa consultada,
los trminos clasificacin (classification), y categorizacin o agrupamiento
(categorization clustering), son utilizados con distinto significado [Lewis, 1991;
Yang, 1997; Maarek et. al., 2000; Clerking et. al., 2001]. El concepto de clasificacin
de documentos refiere al problema de encontrar para cada documento la clase a la que
pertenece, asumiendo que las clases estn predefinidas y que se tienen documentos
preclasificados para utilizar como ejemplos. En la presente tesis, se estudia la
categorizacin o agrupamiento de documentos, entendindose por sto el proceso de
encontrar grupos dentro de una coleccin de documentos basndose en las similitudes
existentes entre ellos, sin un conocimiento a priori de sus caractersticas.
Un criterio de agrupamiento utilizado es dividir los documentos en una jerarqua
de temas. Un ejemplo de esto ltimo son las categoras que presenta el buscador
Yahoo [Rger et. al., 2000]. Un documento en particular se podra encontrar, por
ejemplo, dentro de Tecnologa ? Informtica ? Internet ? Buscadores. El problema
que presenta esta tcnica es la dificultad de encontrar la categora que mejor describa a
un documento [Hearst et. al., 1996]. Los documentos no tratan un slo tema, y aunque
lo hicieran, el enfoque con el que el tema es tratado puede hacer que el documento
encuadre en otra categora. Esto hace que la categorizacin de documentos sea una tarea
compleja y subjetiva, ya que dos personas podran asignar el mismo documento a
categoras diferentes, cada una aplicando un criterio vlido [Macskassy et.al., 2001].
Las siguientes secciones de este captulo dan una introduccin al contenido,
objetivo y estructura de esta tesis. La seccin 1.1 presenta el problema de la
categorizacin automtica de documentos, describiendo su utilidad y las causas que han
despertado el inters por resolverlo. En la seccin 1.2 se muestra la imposibilidad de
encontrar la solucin al problema de categorizacin automtica mediante una bsqueda
exhaustiva, lo que ha llevado a la creacin de algoritmos que encuentran soluciones

8 CAPITULO 1 - INTRODUCCION Eugenio Yolis

aproximadas al problema. La seccin 1.3 describe en forma breve qu son los
algoritmos genticos, y por qu se cree que pueden aplicarse al problema en estudio. La
seccin 1.4 presenta el objetivo de la tesis, y la seccin 1.5, la forma en la que se
estructura su contenido en los captulos que la componen.

1.1 Categorizacin automtica de documentos

La tarea de encontrar grupos de documentos con caractersticas comunes no slo
es compleja sino que adems consume tiempo. Un bibliotecario que tratara de clasificar
un documento tendra que leerlo para comprender su significado para luego asignarle
una categora utilizando su experiencia y sentido comn. El costo y el tiempo asociados
a la categorizacin de documentos ha llevado a la investigacin de tcnicas que
permitan automatizar la tarea [Rger et. al., 2000]. Debido al incremento en los
volmenes de informacin disponibles en forma electrnica y a la necesidad cada vez
mayor de encontrar la informacin buscada en un tiempo mnimo, stas tcnicas han
estado recibiendo creciente atencin [Hearst y Pedersen, 1996; Zamir y Etzioni, 1999;
Strehl et al., 2000; Maarek et al., 2000].

1.1.1 La Hiptesis del Agrupamiento

La categorizacin automtica de documentos se comenz a investigar dentro de
la rama de Recuperacin de Informacin (en ingls , Information Retrieval), que es
la rama de la informtica que investiga la bsqueda eficiente de informacin relativa a
un tema en particular en grandes volmenes de documentacin [ISO, 1993]. En su
forma ms simple, las consultas estn dirigidas a determinar qu documentos poseen
determinadas palabras en su contenido. Por ejemplo, la consulta buscador internet
podra tener por resultado todos los documentos que contengan las palabras buscador
e internet como parte de su contenido. El objetivo de las tcnicas de recupero de
informacin es poder resolver consultas en forma eficaz y eficiente. La eficiencia viene
dada por la rapidez con la cual se resuelve la consulta. El criterio para evaluar la

eficacia se basa en la relevancia de los resultados encontrados [Raghavan et. al., 1989];
en el ejemplo del prrafo anterior, una bsqueda eficaz debera retornar todos los
documentos que trataran sobre la bsqueda de informacin en internet, an si la palabra
buscador no estuviera en el contenido de los mismos.
En el contexto del recupero de informacin, Van Rijsbergen [Van Rijsbergen,
1979] formula la denominada Hiptesis del Agrupamiento (en ingls, Cluster
Hypothesis); bsicamente, la hiptesis del agrupamiento sostiene que los documentos
fuertemente asociados tienden a ser relevantes para la misma consulta, lo cual ha sido
verificado experimentalmente [Cutting et. al., 1992; Schtze et. al.,1997; Zamir et. al.,
1999]; basndose en dicha hiptesis, la categorizacin automtica tiene en cuenta el
contenido de los documentos para agruparlos, ya que documentos similares contendrn
palabras (trminos) similares.

1.1.2 Aplicaciones

La categorizacin automtica de documentos se investiga dentro del campo del
recupero de informacin como una herramienta capaz de mejorar la calidad de las
soluciones ofrecidas. Sus aplicaciones ms importantes son:
- Mejorar el rendimiento de los motores de bsqueda de informacin mediante la
categorizacin previa de todos los documentos disponibles [Van Rijsbergen, 1979;
Dunlop y Van Rijsbergen, 1991; Faloutsos y Oard, 1995; Zamir et. al., 1999; Rger et.
al., 2000]. Antes de comenzar a resolver las consultas, el conjunto de documentos es
separado en grupos. A cada grupo de documentos se le asigna un representante de
grupo; luego, al resolver una consulta, no se examinan todos los documentos, sino que
se busca el representante de grupo que mejor responda a la consulta. Por la hiptesis
del agrupamiento, el grupo encontrado estar compuesto de los documentos ms
relevantes para esa bsqueda.
- Facilitar la revisin de resultados por parte del usuario final, agrupando los
resultados luego de realizar la bsqueda [Croft, 1978; Cutting et al., 1992; Allen et al.,
1993; Leousky y Croft, 1996; Maarek et al., 2000]. Cuando se realizan bsquedas sobre
un gran volumen de documentos, la cantidad de resultados puede ser muy grande. Si la


lista se presenta sin ningn tipo de procesamiento previo, el usuario del sistema se ver
obligado a revisar todos los documentos descartando aquellos que no son relevantes
para l. Si los resultados se agrupan, la hiptesis del agrupamiento indica que los
documentos del mismo grupo sern relevantes para una subconsulta ms especfica que
la original. De esta forma, los documentos quedarn separados en grupos temticos (los
grupos son una divisin de los documentos originales, y cada grupo responde a una
subconsulta ms especfica dentro del tema buscado) [Rger et. al., 2000]. Asi, con slo
revisar uno o dos documentos de cada grupo, el usuario podr determinar cul es el
subtema al que responden todos los documentos del grupo, pudiendo descartar
rpidamente los documentos irrelevantes para su bsqueda.

1.2 Naturaleza combinatoria del problema de
categorizacin

Una de las caractersticas principales del problema de la categorizacin de
documentos es su naturaleza combinatoria [Duran y Odell, 1974; Pentakalos et al.,
1996]. La teora combinatoria [Liu, 1968] indica que S(n,K), la cantidad de maneras de
agrupar n objetos en K grupos, est dada por: ( ) ( )
n
K
i
i
i K
i
K
K
K n S
=0
1
!
1
) , ( .
Utilizando esta frmula puede calcularse, por ejemplo: S (25,5) = 2 x 10
16
, o,
dicho en otras palabras, que hay ms de dos mil millones de millones de formas de
agrupar 25 objetos en 5 grupos. Los 25 objetos del ejemplo, representan un problema de
dimensiones demasiado pequeas para ser de utilidad. En la prctica, se querra aplicar
la categorizacin automtica, por lo menos, a varios cientos de documentos. Sin
embargo, haciendo algunos clculos sobre este ejemplo de dimensiones pequeas,
puede comprenderse la complejidad del problema. Supngase un algoritmo que intente
probar todas las posibles categorizaciones para encontrar la mejor de ellas, asignandoles
puntajes de acuerdo a un criterio predefinido. Suponiendo que el algoritmo consiga
calcular el puntaje de 100 mil soluciones por segundo (el algoritmo tendra que ser muy
rpido, pero supngase que lo es), para probar las 2 x 10
16
posibilidades, el algoritmo
tomara ms de 6 mil aos en dar el resultado.

Un algoritmo que evale cada una de las posibles categorizaciones no es
aplicable en forma prctica a la categorizacin automtica de documentos, por lo que se
han desarrollado algoritmos que hacen uso de heursticas [Cutting et al., 1992; Zamir et.
al., 1999; Jain et.al., 1999; Estivill-Castro, 2000; Zhao et.al., 2001] para explorar una
parte de estas posibles categorizaciones buscando una solucin de calidad aceptable.

1.3 Algoritmos genticos

Los algoritmos genticos son una tcnica del rea de Sistemas Inteligentes que
constituye una abstraccin del concepto biolgico de evolucin natural y tiene
numerosas aplicaciones en problemas de optimizacin [Davis, 1991; Falkenauer, 1999].
Su funcionamiento est basado en los mecanismos de seleccin natural, combinando la
supervivencia del ms apto con un intercambio de informacin entre miembros de una
poblacin de posibles soluciones.
Se estima que el uso de algoritmos gneticos puede contribuir a acortar
significativamente los tiempos de resolucin del problema [Raghavan y Birchard, 1978;
Johnson y Fotouhi, 1996; Cole, 1998; Painho y Bao, 2000], ya que se caracterizan por
su capacidad de explorar el espacio de bsqueda amplia y eficientemente [Goldberg,
1989; Koza, 1997].

1.4 Objetivo de la tesis

En este contexto, el objetivo de esta tesis es estudiar cmo pueden aplicarse los
algoritmos genticos, que han demostrado ser tiles para ayudar a resolver problemas de
optimizacin, al problema de encontrar en forma automtica la mejor categorizacin de
documentos. Se estudiar de qu forma las caractersticas de los algoritmos genticos
pueden utilizarse para disear un algoritmo que supere el rendimiento de los algoritmos
que actualmente se aplican al problema, y se evaluarn los resultados de acuerdo a la
calidad de las soluciones obtenidas.


1.5 Estructura de la tesis

La tesis se divide en seis captulos y cuatro apndices.
El captulo 2 describe el estado actual de los campos de estudio relacionados con
esta tesis. La seccin 2.1 define formalmente el problema de la categorizacin
automtica de documentos. La categorizacin automtica de documentos se vincula con
las ciencias de la Recuperacin de Informacin y de la Minera de Datos. Del
campo de la Recuperacin de Informacin toma los conceptos y mtodos utilizados para
el procesamiento de documentos. Estas tcnicas son las que permiten transformar la
informacin no estructurada que contienen los documentos (llamados documentos de
texto libre, o en ingls free text documents), a estructuras de datos manejables
mediante algoritmos computacionales. Las secciones 2.2 y 2.3 describen estas tcnicas.
Del campo de la Minera de Datos toma las tcnicas que se ocupan de los problemas de
categorizacin de objetos. Los algoritmos utilizados para la categorizacin automtica
de documentos son adaptaciones de los que se utilizan para el problema ms general de
categorizar objetos de cualquier tipo. La seccin 2.4 muestra la ubicacin de la
categorizacin automtica de documentos dentro de este rea, y detalla los algoritmos
utilizados actualmente para categorizar documentos en forma automtica. En la seccin
2.6 se describe un algoritmo presentado recientemente, que supera a los mtodos
clsicos, y contra el cual se comparar la solucin propuesta en esta tesis. La seccin 2.7
presenta los principios bsicos de los algoritmos genticos, en los que se basar el
algoritmo de categorizacin presentado en esta tesis.
El captulo 3 plantea las cuestiones que esta tesis apunta a responder, y analiza el
trabajo previo que existe acerca de la aplicacin de los Algoritmos Genticos a este
problema. En la seccin 3.1 se exponen las limitaciones que presentan los algoritmos
actuales, relacionados con la forma en la que exploran el espacio de posibles soluciones.
La seccin 3.2 describe los problemas encontrados en los trabajos previos que aplicaron
los algoritmos genticos a la categorizacin automtica.
En el captulo 4 se presenta la solucin propuesta en esta tesis, que apunta a
responder a las cuestiones planteadas en el captulo 3. En la seccin 4.1 se describen las
tcnicas utilizadas en trabajos previos que aplican los algoritmos genticos a problemas
de categorizacin automtica. La seccin 4.2 detalla el algoritmo de categorizacin

propuesto. Este algoritmo emplea algunas de las tcnicas descriptas en la seccin 4.1,
pero su caracterstica principal es la utilizacin de los nuevos operadores que se
presentan en esta tesis.
El captulo 5 describe las pruebas que se realizaron para evaluar la efectividad de
la solucin propuesta en el captulo 4. La seccin 5.1 describe los conjuntos de datos
utilizados. Los mismos fueron extrados de una coleccin reconocida como un estndar
dentro de la comunidad de investigadores dedicados a la categorizacin automtica de
documentos. En las secciones 5.2 y 5.3 se detalla la metodologa seguida en la
experimentacin. Se enumeran las variables que intervienen en los experimentos y los
distintos tipos de experimentos realizados. La seccin 5.4 presenta los resultados de la
experimentacin. La presentacin se hace en forma de grficos y para cada variable se
incluye adems el resultado del test estadstico realizado sobre los resultados. En la
seccin 5.5 se analizan brevemente los resultados, que luego se tratan con ms detalle
en el captulo 6.
El captulo 6 presenta las conclusiones extradas a partir de la investigacin
realizada y los resultados experimentales obtenidos. En esta tesis se propone una
adaptacin de un algoritmo gentico al problema de la categorizacin automtica de
documentos, que incluye el diseo de un nuevo operador de cruza y cuatro operadores
de mutacin. Los resultados experimentales obtenidos confirman la tesis que los
algoritmos genticos son una poderosa herramienta para la resolucin de problemas en
los cuales el espacio de soluciones es amplio y la funcin de optimizacin es compleja.
En el apndice 1 se describen las pruebas realizadas para obtener los parmetros
utilizados en el algoritmo propuesto.
El apndice 2 detalla el anlisis estadstico realizado sobre los resultados que se
exponen en el captulo 5, y que soportan las afirmaciones realizadas en la seccin 5.4
(Resultados) de ese captulo.
El apndice 3 contiene la documentacin de los programas y conjuntos de datos
que se incluyen en el CD que acompaa la presente tesis. Estos programas hacen
posible la realizacin de los experimentos y la evaluacin de los resultados.
El apndice 4 detalla la forma en la que se programaron los algoritmos
comparados en la prueba experimental. Para realizar la prueba experimental, se
desarroll una aplicacin de categorizacin automtica de documentos que permite


seleccionar qu algoritmo se quiere utilizar. El desarrollo de la aplicacin se realiz en
el lenguaje C++. La seccin A4.1 contiene la descripcin de los distintos mdulos en
los que se separ la lgica del algoritmo y la interaccin que existe entre los mismos. En
la seccin A4.2 se incluye el cdigo fuente de cada mdulo.

Eugenio Yolis CAPITULO 2 - ESTADO DEL ARTE 15
Captulo 2
Estado del arte

Este captulo describe el estado actual de los campos de estudio relacionados con
esta tesis. La seccin 2.1 define formalmente el problema de la categorizacin
automtica de documentos.
La categorizacin automtica de documentos se vincula con las ciencias de la
Recuperacin de Informacin y de la Minera de Datos. Del campo de la
Recuperacin de Informacin toma los conceptos y mtodos utilizados para el
procesamiento de documentos. Estas tcnicas son las que permiten transformar la
informacin no estructurada que contienen los documentos (llamados documentos de
texto libre, o en ingls free text documents), a estructuras de datos manejables
mediante algoritmos computacionales. Las secciones 2.2 y 2.3 describen estas tcnicas.
Del campo de la Minera de Datos toma las tcnicas que se ocupan de los
problemas de categorizacin de objetos. Los algoritmos utilizados para la
categorizacin automtica de documentos son adaptaciones de los que se utilizan para el
problema ms general de categorizar objetos de cualquier tipo. La seccin 2.4 muestra
la ubicacin de la categorizacin automtica de documentos dentro de este rea, y
detalla los algoritmos utilizados actualmente para categorizar documentos en forma
automtica.
En la seccin 2.6 se describe un algoritmo presentado recientemente, que supera
a los mtodos clsicos, y contra el cual se comparar la solucin propuesta en esta tesis.
La seccin 2.7 presenta los principios bsicos de los algoritmos genticos, en los que se
basar el algoritmo de categorizacin presentado en esta tesis.


16 CAPITULO 2 ESTADO DEL ARTE Eugenio Yolis

2.1 Categorizacin de objetos

La categorizacin de documentos es un tipo de problema perteneciente a la
familia de problemas asociados a encontrar agrupamientos entre objetos de cualquier
tipo. Si bien la categorizacin de documentos tiene caractersticas particulares que
surgen de las propiedades de los documentos como objetos a agrupar, los principios
generales coinciden con los que se aplican para categorizar cualquier otro tipo de
elementos. Los algoritmos para la categorizacin automtica de documentos son los
mismos que se utilizan para agrupar otros tipos de objetos, o adaptaciones de stos [Qin
He, 1996; Cole, 1998; Fasulo, 1999; Jain et.al., 1999].
Una definicin del problema del agrupamiento de documentos (que es aplicable
al agrupamiento de cualquier tipo de elementos), puede enunciarse de la siguiente
manera [Zhao et.al., 2001]:

Dado un conjunto S, de N documentos, se quiere encontrar la
particin S
1
, S
2
, ..., S
k
, tal que cada uno de los N documentos se encuentre
slamente en un grupo S
i
, y que cada documento sea ms similar a los
documentos de su mismo grupo que a los documentos asignados a los
otros grupos.

2.2 Representacin vectorial

Para poder definir medidas de semejanza entre los objetos a agrupar, stos se
representan mediante vectores v = (a
1
, a
2
, ... , a
m
), donde cada componente del vector
es el valor de un atributo del objeto. De esta forma, cada uno de los objetos a agrupar es
un punto en un Espacio Euclideano de m dimensiones, R
m
. Los investigadores
dedicados a las ramas de la Recuperacin de Informacin adoptaron tempranamente una
representacin vectorial para el manejo de documentos [Van Rijsbergen, 1979]; en este
modelo, cada documento es considerado un vector d en el espacio de trminos (el
conjunto de palabras que aparecen en por lo menos uno de los documentos de la
coleccin).

Una forma aceptada [Van Rijsbergen, 1979; Faloutsos et.al., 1995; Jones et.al.,
1995] de representar los documentos es asignar a cada atributo del vector la presencia o
ausencia del trmino correspondiente. De esta manera, para m trminos el vector
consistira en m atributos binarios que pueden tomar valores de cero o uno, segn los
trminos que aparezcan o no en el documento. Otra manera es representar a cada
documento por su vector de frecuencia de trminos [Steinbach et.al., 2000]: d
tf
= ( tf
1
,
tf
2 , ... ,
tf
m
), donde tf
i
es la frecuencia del trmino nmero i en el documento (cantidad de
veces que aparece esa palabra en el documento). De esta forma, se considera que los
documentos quedan caracterizados por la cantidad de veces que aparece cada trmino
dentro del mismo.
Un refinamiento de este modelo consiste en multiplicar a la frecuencia de cada
trmino por su frecuencia documental inversa (en ingls, inverse document
frecuency). sta tcnica, denominada tf-idf, se basa en la premisa que si un trmino
aparece en gran parte de los documentos, es poco discriminante, y por lo tanto, debe
restrsele importancia [Faloutsos et.al., 1995; Zhao et.al., 2001]. Asi, la representacin
del documento resultara: d
t f-idf
= ( tf
1
log(N / df
1
) , tf
2
log(N / df
2
) , ... ,

tf
m
log(N / df
m
) ),
donde N es la cantidad total de documentos de la coleccin y df
i
es la cantidad de
documentos que contienen al trmino i.
La normalizacin de los vectores (|| d || = 1) asegura que los documentos se
evalen por la composicin de su contenido, sin tener en cuenta su tamao, ya que en
los documentos ms extensos, las frecuencias de aparicin de los trminos sern
mayores.

2.2.1 Definicin del centroide de un grupo

La definicin de centroide de un grupo de elementos representados
vectorialmente es utilizada en el contexto de los algoritmos de agrupamiento. Dado un
grupo de elementos S, que contiene h elementos s
i
, se define a su centroide C
s
como el
promedio de los vectores que componen el grupo:
h
s
C
h
i
i
s
=
=
1
. Cada componente del
vector centroide es el promedio del valor de esa componente para los miembros del


grupo [Steinbach et.al., 2000; Zhao et.al., 2001]; su propiedad ms importante es que la
distancia promedio desde un punto cualquiera del espacio hasta cada elemento del grupo
es igual a la distancia entre ese punto y el centroide del grupo.

2.2.2 Reduccin de la dimensionalidad del espacio de trminos

Es evidente que en una coleccin de documentos aparecern cientos o miles de
palabras distintas. Cmo la dimensin del espacio vectorial de representacin est dada
por la cantidad de palabras diferentes, cada vector contendr cientos o miles de
componentes (gran parte de ellas con valor igual a cero) [Zervas et al., 2000]. Esto es
conocido como la maldicin de la dimensionalidad (en ingls the curse of
dimensionality) [Yang et al., 1997]. Hay dos tcnicas que se utilizan para reducir la
dimensionalidad del espacio de trminos: la reduccin de palabras a su raz, y la
remocin de los trminos poco discriminantes.

2.2.2.1 Reduccin de palabras a su raz

Para reducir el nmero de trminos distintos con los que se trabaja, el primer
paso es reducir todas las palabras a su raz (en ingls steeming). Por ejemplo, las
palabras medicina, mdico y medicinal se reducen a la forma medic. Esta
tcnica es llamada remocin de sufijos (en ingls suffix stripping). Si bien es
posible que de esta manera se lleven a la misma raz palabras que en realidad tienen
significados distintos, en general las palabras que tienen la misma raz refieren al mismo
concepto, y la prdida de precisin es compensada por la reduccin de la
dimensionalidad del espacio [Van Rijsbergen, 1979].
Las aplicaciones de agrupamiento de documentos usan tcnicas de remocin de
sufijos [Krovetz, 1993; Zamir et.al., 1998; Steinbach et.al., 2000], existiendo consenso
en cuanto a la conveniencia de su aplicacin. La tcnica de remocin de sufijos ms
utilizada es la llamada regla de Porter [Porter, 1980]; esta tcnica se basa en un
algoritmo que aplica una serie de reglas que determinan si las ltimas slabas de una
palabra deben ser removidas.

2.2.2.2 Remocin de trminos poco discriminantes

Otro mtodo para reducir la dimensin del espacio de trminos (que es
complementario del anterior), es el de descartar los trminos que se consideran poco
discriminantes [Yang et al., 1997]. Un trmino es poco discriminante si el hecho de
saber que ese trmino se encuentra en un documento nos dice poco (o nada), acerca del
posible contenido o tema del documento. El ejemplo ms simple de dichos trminos son
las preposiciones, artculos y toda otra palabra auxiliar que ayude a dar forma a las
oraciones. stas palabras se consideran poco discriminantes en cualquier coleccin
documental con la cual se trabaje, por lo que se utiliza una lista de palabras irrelevantes
(en ingls, stop list) y se descartan todas las palabras que aparecen en esa lista [Van
Rijsbergen, 1979; Strehl et.al., 2000].
Existen trminos que pueden ser discriminantes dependiendo del conjunto de
documentos con los que se trabaje. Para una coleccin de documentos determinada,
entre sus trminos habr algunos ms tiles que otros para la tarea de categorizacin.
Por ejemplo, si en una serie de documentos sobre fsica cuntica, el trmino electrn
aparece en el 98% de los documentos, es evidente que la presencia o ausencia de ese
trmino no es relevante a los efectos de agrupar los mismos. De la misma forma, si
dentro de ese grupo de documentos, la palabra arcoiris aparece solamente en uno de
ellos, ese trmino tampoco ser importante para agruparlos.
En [Yang et al., 1997] se exponen diversas tcnicas orientadas a detectar, en una
coleccin de documentos, qu trminos son irrelevantes para la tarea de categorizacin.
Algunas de ellas requieren un pequeo grupo de documentos previamente
categorizados, para ser utilizados como un conjunto de entrenamiento, por lo que a
veces su aplicacin puede no ser posible. A continuacin se describe brevemente cada
una de las tcnicas analizadas.
a) Umbral de frecuencia documental
Es el mtodo ms sencillo. Se calculan las frecuencias con que aparece cada
trmino en la coleccin documental y los trminos que no superan cierto umbral
mnimo son descartados. Se asume que las palabras muy poco frecuentes no contienen
informacin sobre la categora a la que pertenece el documento, o que son trminos
ruidosos (que pueden llegar a confundir al algoritmo de agrupamiento).


b) Ganancia de informacin, Informacin mutua, Estadstica X
2

Teniendo un conjunto de documentos ya agrupados, para cada trmino se calcula
(en base a frmulas probabilsticas) qu tan bueno es para predecir la categora a la que
pertenece el documento. El puntaje ms alto es obtenido por aquellos trminos presentes
en todos los documentos de una categora y que no aparecen en ningun documento de
las dems categoras. Los trminos con puntaje ms bajo (que son aquellos que aparecen
por igual en documentos de todas las categoras) son descartados. Los tres mtodos
difieren en la forma de calcular los puntajes y normalizar los resultados.
c) Fuerza del trmino
Usando un grupo de documentos de entrenamiento, se toman aquellos pares de
documentos cuya semejanza excede un determinado valor (parmetro del mtodo). Para
cada trmino, se cuenta la cantidad de veces que el mismo aparece en ambos
documentos de cada par. En base a eso, se calcula la probabilidad de que el trmino est
en el segundo documento del par, sabiendo que est en el primero. Se asignan puntajes
ms altos cuanto mayor sea esa probabilidad, asumiendo que el trmino es descriptivo
de la categora de esos documentos.

El anlisis comparativo [Yang et al., 1997], usando cada uno de los mtodos de
remocin de trminos para diferentes algoritmos de agrupamiento, llega a la conclusin
de que las tcnicas de Umbral de frecuencia, Ganancia de informacin y Estadstica X
2

obtienen resultados similares, notando que el mtodo de Umbral de frecuencia no
requiere documentos previamente clasificados, lo que ampla el rango de situaciones en
las que puede ser aplicado.

2.3 Medidas de semejanza

En la definicin del problema de agrupamiento, se dijo: ...que cada documento
sea ms similar a los documentos de su mismo grupo, que a los documentos asignados a
los otros grupos... (los trminos similar, semejante y cercano se utilizan
indistintamente para referirse a ste concepto). Para poder evaluar esta condicin, es
necesario definir una medida cuantitativa de la similitud existente entre dos
documentos.

En el modelo de representacin ms sencillo, en el que los atibutos del vector
son valores binarios, y definiendo | v | como la cantidad de atributos de v que toman el
valor 1, las medidas ms comunes son:
- Coeficiente de Jaccard

- Coeficiente del coseno

Ambas medidas definen el concepto de semejanza de los documentos por la
cantidad de trminos en comn que contienen en relacin al tamao de los documentos.
En el modelo de representacin ms utilizado [Qin He, 1996; Maarek et.al.,
2000; Steinbach et.al., 2000], en el cual se calculan los vectores de frecuencia o de
frecuencia inversa, y siendo ||v|| la longitud (norma) del vector v, las medidas ms
comunes son [Cole, 1998; Strehl et.al., 2000; Zhao et.al., 2001]:
- Coeficiente del coseno extendido

Es una extensin del correspondiente del modelo binario para el caso de
atributos con valores reales. Esta medida tiene la propiedad de no depender del tamao
de los documentos, ya que cos(d
1
,d
2
) = cos(a.d
1
,d
2
) para a > 0. Sin embargo, los
documentos se normalizan para que tengan longitud unitaria, ya que entonces,

Y la semejanza entre los documentos se puede calcular como el producto
vectorial entre ellos.
La similitud queda comprendida en el intervalo [0,1]. Para un documento
cualquiera, el vector que lo representa es un punto en el espacio. Si se traza la recta que
definen ese punto y el eje de coordenadas, todo documento que se encuentre sobre la
2 1
2 1
d d
d d
2 1
2 1
d d
d d
2 1
2 1
2 1
) , cos(
d d
d d
d d
=
2 1 2 1
) , cos( d d d d =


recta tiene similitud 1 con el documento que la define. Si se trazan hiperconos
concntricos cuyo eje sea esa recta, la semejanza ir decreciendo a medida que se
agranda el ngulo del hipercono, y todos los documentos situados en la pared de cada
hipercono tienen la misma similitud con el documento que define el eje. La semejanza
igual a cero se alcanza cuando el hipercono se convierte en el hiperplano perpendicular
al eje que define el documento [Strehl et.al., 2000].
- Coeficiente de Jaccard extendido

Es una extensin del coeficiente de Jaccard del modelo binario para el caso de
atributos con valores reales. Los valores posibles de similitud se encuentran en el rango
[0,1]. Esta medida tiene propiedades intermedias entre el coeficiente del coseno
extendido y la distancia Euclideana, que se detalla a continuacin.
- Distancia Euclideana

Es la frmula tradicional para calcular el tamao del segmento que une dos
puntos. La semejanza de dos documentos queda definida en forma inversa, ya que los
documentos ms similares sern los que estn a menor distancia. La frmula
comunmente utilizada es:

Los posibles valores de similitud estn en el rango [0,1], pero un documento
tiene semejanza igual a 1 slamente consigo mismo. Para un documento cualquiera, el
vector que lo representa es un punto en el espacio. Si se trazan hiperesferas concntricas
alrededor del punto, todos los documentos ubicados en la superficie de una hiperesfera
tienen el mismo valor de similitud con el documento que define el centro. La semejanza
decrece a medida que aumenta el radio de las hiperesferas.

) (
) , (
2 1
2
2
2
1
2 1
2 1
d d d d
d d
d d jac
+
=
2 1 2 1
) , ( _ d d d d euc dist =
2 1
2 1
1
1
) , (
d d
d d euc

=

En el campo de la categorizacin automtica de documentos, la medida ms
utilizada es el coeficiente del coseno extendido [Cutting et.al., 1992; Qin He, 1996;
Steinbach et.al., 2000; Zhao et.al., 2001]. Se ha realizado [Strehl et.al., 2000] un
anlisis completo de las medidas expuestas anteriormente, comparando el rendimiento
de distintos algoritmos de agrupamiento utilizando cada una de las medidas de
similitud, llegando a la conclusin de que los coeficientes del coseno y Jaccard
extendidos son ms apropiados que la distancia euclideana para espacios de gran
dimensionalidad y con datos dispersos, como es el caso del agrupamiento de
documentos.

2.4 Mtodos para categorizar documentos

Las formas de clasificacin de objetos, tales como asignar clases
predeterminadas a cada elemento agruparlos en forma significativa, son susceptibles
de dividirse segn el esquema de la figura 2.1 [Qin He, 1996]:

Clasificaciones
No exclusivas Exclusivas
Extrnsecas Intrnsecas

Jerrquicas Particionales

Fig 2.1
Divisin de las formas de
clasificar objetos


- No exclusivas : Un mismo objeto puede pertenecer a varias categoras, clases o
grupos.
- Exclusivas : Cada objeto pertenece solamente a una categora, clase o grupo.

- Extrnsecas (supervisadas) : Las clases a las que pertenecen los objetos estn
predefinidas, y se conocen ejemplos de cada una, algunos de los objetos ya
estn clasificados y son utilizados por el algoritmo para aprender a clasificar a
los dems.
- Intrnsecas (no supervisadas) : La clasificacin se realiza en base a las
caractersticas propias de los objetos, sin conocimiento previo sobre las clases a
las que pertenecen.

- Jerrquicas : Los mtodos jerrquicos consiguen la categorizacin final
mediante la separacin (mtodos divisivos) o la unin (mtodos aglomerativos)
de grupos de documentos. As, estos mtodos generan una estructura en forma
de rbol en la que cada nivel representa una posible categorizacin de los
documentos [Willet, 1998]
- Particionales (no jerrquicas) : Los mtodos no jerrquicos, tambien
llamados particionales, o de optimizacin llegan a una nica categorizacin que
optimiza un criterio predefinido o funcin objetivo, sin producir una serie de
grupos anidados [Everitt, 1993].

La categorizacin automtica de documentos se encuentra en la categora
intrnseca, ya que los criterios de agrupamiento se basan en la informacin contenida
en los mismos para determinar sus similitudes

2.5 Mtodos de categorizacin intrnsecos
2.5.1 Mtodos Jerrquicos

Los algoritmos jerrquicos se caracterizan por generar una estructura de rbol
(llamada dendograma), en la que cada nivel es un agrupamiento posible de los objetos

de la coleccin [Jain et.al., 1999]. Cada vrtice (nodo) del rbol es un grupo de
elementos. La raz del rbol (primer nivel) se compone de un slo grupo que contiene
todos los elementos. Cada hoja del ltimo nivel del rbol es un grupo compuesto por un
slo elemento (hay tantas hojas como objetos tenga la coleccin). En los niveles
intermedios, cada nodo del nivel n es dividido para formar sus hijos del nivel n + 1.
Las figuras 2.2 y 2.3 ilustran estos conceptos mediante un ejemplo simple.

Los algoritmos de agrupamiento jerrquicos fueron uno de los primeros
enfoques para los problemas de categorizacin de documentos, y todava se siguen
utilizando debido a la forma simple e intuitiva en la que trabajan [Dash et.al., 2001]. De
acuerdo a la metodologa que aplican para obtener el dendograma, los algoritmos
jerrquicos pueden dividirse en aglomerativos y divisivos [Han, 2001].
A
B
C
D
E
F
Fig 2.2
Posible coleccin de objetos en
un espacio de 2 dimensiones
A B C D E F
B D A C E F
B D A C E F
A E F C B D
A E F C B D
F C A E B D
A E F C D B
Fig 2.3. Posible dendograma para la coleccin de la figura 2.2 y agrupamientos que representa
cada nivel.


Los mtodos aglomerativos parten de las hojas del rbol, ubicando a cada
elemento en su propio grupo, y en cada paso buscan los dos grupos ms cercanos para
juntarlos. Los divisivos, por su parte, hacen el camino inverso. Comenzando en la raz,
en cada paso seleccionan un grupo para dividirlo en dos, buscando que el agrupamiento
resultante sea el mejor de acuerdo a un criterio predeterminado. El anlisis necesario
para pasar de un nivel a otro (decidir qu grupo dividir o cuales juntar) es ms sencillo
para los mtodos aglomerativos [Dash et.al., 2001], y esto hace que stos sean ms
utilizados que los divisivos [Fasulo, 1999; Steinbach et.al., 2000]. En adelante, cuando
se hable de mtodos jerrquicos, se har referencia nicamente a los algoritmos de
Agrupamiento Jerrquico Aglomerativo (HAC, su sigla en ingls).
Las distintas variantes de algoritmos jerrquicos aglomerativos difieren
nicamente en la manera de determinar la semejanza entre los grupos al seleccionar los
dos grupos ms cercanos [Qin He, 1996; Willet, 1998; Cole, 1998; Jain et.al., 1999;
Fasulo 1999]. Debe notarse la diferencia entre medidas de semejanza entre documentos
y medidas de semejanza entre grupos. La similitud de dos grupos se calcula en base a
los valores de semejanza existentes entre sus documentos, pero la forma de hacer este
clculo no es nica. Dada una medida de semejanza entre documentos, que puede
considerarse la misma para todos, los distintos algoritmos jerrquicos aglomerativos se
distinguen por la medida de semejanza entre grupos que utiliza cada uno.
La figura 2.4 presenta un espacio bidimensional en el cual se han colocado 4
grupos de objetos. Los objetos de un mismo grupo se han representado mediante el
mismo smbolo (x, *, # +).

x
x
x
x
*
*
*
*
+
+
#

#
#
*
*
*
* *
*
#
#
*
+
*
Fig 2.4
Cuatro grupos de objetos en un
espacio de 2 dimensiones


Las figuras 2.5, 2.6 y 2.7 muestran cmo los mtodos pueden diferir entre ellos
al seleccionar cules son los grupos ms semejantes. En las figuras se utiliza la distancia
Euclideana como medida de semejanza entre los documentos. La disposicin presentada
de los grupos se ha elegido especialmente para provocar las diferencias, si los grupos
estn suficientemente separados y son compactos todos los mtodos coinciden en la
seleccin de los grupos ms cercanos.

2.5.1.1 Enlace simple (single link)
El mtodo de enlace simple, tambin llamado del vecino cercano (en ingls
nearest neighbour), calcula la semejanza entre dos grupos como la semejanza entre
los dos elementos ms cercanos de ambos (ver figura 2.5). Este mtodo es eficaz cuando
los grupos tienen formas irregulares, pero es muy sensible a la existencia de elementos
dispersos que no forman parte de ningn grupo definido, llevando a la creacin de
grupos alargados, compuestos de objetos dismiles [Cole, 1998; Karypis et.al., 1999].
ste efecto recibe el nombre de encadenamiento.

x
x
x
x
*
*
*
*
+
+
#

#
#
*
*
*
* *
*
#
#
*
+
*
Fig 2.5
Distancias al grupo de las x
segn el mtodo de enlace simple.
La distancia entre los grupos ms
cercanos est remarcada.


2.5.1.2 Enlace completo (complete link)
En el extremo opuesto del mtodo de enlace simple se encuentra el mtodo de
enlace completo, que calcula la semejanza entre dos grupos usando la semejanza de los
dos elementos ms lejanos (ver figura 2.6). De esta manera, el mtodo no sufre del
efecto de encadenamiento, y encuentra con eficacia grupos pequeos y compactos.
Sin embargo, cuando los grupos no estn bien definidos, puede llevar a la creacin de
grupos sin significado.

2.5.1.3 Enlace promedio (average link)
A mitad de camino entre los ds mtodos anteriores, el algoritmo de enlace
promedio define a la semejanza entre dos grupos como el promedio de las semejanzas
de cada miembro de uno con cada miembro del otro (ver figura 2.7). Al tomar
propiedades de los mtodos de enlace simple y completo, ste algoritmo obtiene
resultados aceptables en un rango de situaciones ms amplio [Cole, 1998].

x
x
x
x
*
*
*
*
+
+
#

#
#
*
*
*
* *
*
#
#
*
+
*
Fig 2.6
segn el mtodo de enlace
completo. La distancia entre los
grupos ms cercanos est
remarcada.
x
x
x
x
*
*
*
*
+
+
#

#
#
*
*
*
* *
*
#
#
*
+
*
Fig 2.7
segn el mtodo de enlace
promedio. La distancia entre los
grupos ms cercanos est
remarcada.

2.5.1.4 Mtodo de Ward
Este mtodo define la suma de errores cuadrados como la suma del cuadrado
de la distancia de cada objeto al centroide de su grupo. As, para un grupo de elementos
S, compuesto por h elementos s
i
y cuyo centroide es C
s
:

Y, para un agrupamiento de k grupos:

Al comenzar el algoritmo, la suma de errores cuadrados vale cero, ya que cada
elemento forma su propio grupo y coincide con el centroide. En cada paso, el mtodo
evala cada una de las posibles uniones y elige aquella que produce el menor
incremento del error. Este mtodo tiende a producir grupos de tamaos iguales, y su
rendimiento es comparable al del mtodo de enlace promedio [Cole, 1998].
2.5.1.5 Resumen de caractersticas

Entre las caractersticas de stos mtodos pueden destacarse las siguientes:

a) Su forma de trabajo es simple e intuitiva
El enfoque utilizado por estos mtodos es semejante al que utilizara una persona
para realizar la tarea del agrupamiento, especialmente los aglomerativos (comenzar
juntando los documentos ms similares entre si, y luego buscar similitudes entre los
grupos).

b) Su resultado es una serie de agrupamientos anidados
Esto facilita la revisin de los resultados por parte del usuario, que puede
recorrer la estructura de rbol para ver agrupamientos con diferentes niveles de
detalle [Maarek et.al., 2000].

=
=
h
i
s i s
C s W
1
2
|| ||
=
=
k
i
i
W W
1


c) Son deterministas
Al aplicar dos veces un algoritmo jerrquico a una coleccin de documentos, las
dos veces seguir el mismo camino hacia la solucin. Hay algunos agrupamientos
que el algoritmo nunca considerar, sin importar la cantidad de veces que se lo
ejecute [Steinbach et.al.,2000].

d) No revisan las decisiones que toman en los pasos anteriores
Una vez que dos documentos se han asignado al mismo grupo (o se han
colocado en distintos grupos, en los divisivos), ningn paso posterior los volver a
separar (o juntar), por lo que una mala asignacin en los primeros pasos no puede
corregirse [Cole, 1998].

e) Requieren grandes tiempos de cmputo
La forma de buscar en cada paso los grupos a unir (o dividir, en los divisivos),
hacen que las implementaciones conocidas de estos algoritmos tengan tiempos de
ejecucin del orden de n
2
(enlace simple) n
3
(enlace completo) [Zamir et.al.,
1998].

2.5.2 Mtodos particionales

Los mtodos de optimizacin o particionales, a diferencia de los jerrquicos, no
van generando distintos niveles de agrupamiento de los objetos, sino que trabajan en un
slo nivel, en el que se refina (optimiza), un agrupamiento [Everitt, 1993]. Si bien los
distintos niveles de agrupamiento generados por los algoritmos jerrquicos son ms
apropiados para la presentacin de los resultados al usuario, las tcnicas de
optimizacin se estn comenzando a utilizar con ms frecuencia en aplicaciones de
categorizacin automtica de documentos debido a requieren considerablemente menos
recursos [Zhao et.al., 2001]. Estos mtodos asumen que el valor de k (la cantidad de
grupos), est definida de antemano [Qin He, 1996].


La estructura general de stos mtodos se compone de los siguientes pasos [Han
et.al., 2001]:
1) Seleccionar k puntos representantes (cada punto representa un grupo de la
solucin).
2) Asignar cada elemento al grupo del representante ms cercano, de forma de
optimizar un determinado criterio.
3) Actualizar los k puntos representantes de acuerdo a la composicin de cada
grupo.
4) Volver al punto 2)

Este ciclo se repite hasta que no sea posible mejorar el criterio de optimizacin.

2.5.2.1 Seleccin inicial de los representantes

El mtodo ms frecuentemente utilizado para obtener los k puntos representantes
iniciales es eligindolos al azar [Bradley, 1998]. Esta tcnica es la ms rpida y simple,
pero tambin la ms riesgosa, ya que los puntos elegidos pueden ser una mala
representacin de la coleccin de objetos. Cuando se utiliza esta tcnica, se ejecuta
varias veces el algoritmo de agrupamiento para distintas selecciones aleatorias, tomando
el mejor resultado y descartando el resto [Steinbach et.al., 2000].
El resto de las tcnicas para la seleccin inicial utilizan algn algoritmo de
agrupamiento (generalmente jerrquico) para obtener la seleccin inicial [Bradley,
1998]. Lgicamente, no se realiza un agrupamiento de todos los objetos de la coleccin
ya que el objetivo no es llegar a la solucin mediante un algoritmo jerrquico, sino
solamente obtener los puntos iniciales para luego usar un algoritmo de optimizacin
(ms rpido); las tcnicas Buckshot y Fractionation [Cutting et.al., 1992] son un
ejemplo de esto ltimo.



2.5.2.2 Criterios de optimizacin

Los algoritmos particionales buscan optimizar el valor de un criterio de
optimizacin. Estos criterios deben ser funciones que den una medida cuantitativa de la
calidad de un agrupamiento. En [Zhao et.al., 2001] se analizan los criterios de
optimizacin ms frecuentemente utilizados en la categorizacin automtica de
documentos, que se detallan a continuacin.

Criterios internos

Los criterios internos dan una medida de la cohesin interna de los grupos. Para
cada grupo se calcula un valor en base a los objetos que lo componen (sin tener en
cuenta elementos de otros grupos), y luego se suman los valores de cohesin de cada
uno.

a) Maximizacin de la suma de similitudes promedio
Para cada grupo se calcula el promedio de las similitudes que existen
entre cada par de documentos que lo componen. Por ejemplo, para el grupo S, que tiene
n
s
elementos:

El valor total para el criterio se obtiene sumando las similitudes promedio
de cada grupo multiplicadas por su cantidad de elementos.

Este criterio toma valores ms altos cuando los elementos de cada grupo
son ms similares entre s.

s d
s d
s
s
d d sim
n
prom sim
'
2
) ' , (
1
_
k
k
i
k
prom sim n prom sim _ . _
1
=
=

b) Maximizacin de la suma de las similitudes con el centroide
Para cada grupo se calcula la suma de las similitudes que existen entre
cada elemento y el centroide. Por ejemplo, para el grupo S:

El valor total para el criterio se obtiene sumando las similitudes promedio
de cada grupo.

Los valores ms altos se alcanzan cuando cada objeto se encuentra cerca
del centro de su grupo.

c) Minimizacin de la suma de errores cuadrados
Este criterio es el mismo que utiliza el mtodo de Ward, que se analiza en
la seccin 2.5.1, dedicada a los mtodos jerrquicos.

=
s d
s s
C d sim cent sim ) , ( _
=
=
k
i
k
cent sim cent sim
1
_ _


Criterios externos

Los criterios externos tienen en cuenta la separacin que existe entre los
distintos grupos. Se considera que un agrupamiento es mejor que otro cuando sus
grupos estn ms separados del centro de la coleccin.

a) Minimizacin de la similitud de los centroides con centroide de la
coleccin
Este criterio calcula la similitud existente entre el centroide de cada
grupo y el centro de la coleccin, y luego suma los valores multiplicados por el tamao
de cada grupo.

b) Maximizacin de la distancia de los centroides al centroide de la
coleccin
En lugar de minimizar las similitudes, este criterio intenta maximizar las
distancias.

Evaluacin de los criterios

En [Zhao et.al., 2001] se evala cada uno de los criterios detallados, aplicados al
agrupamiento de colecciones de documentos. El criterio interno de maximizacin de la
suma de similitudes con el centroide (que es el que se utiliza ms comunmente en la
bibliografa), obtiene los mejores resultados al aplicar cada uno de los criterios en forma
individual. El trabajo propone una combinacin de ste criterio con el criterio externo
de minimizacin de la similitud de los centroides con el centro de la coleccin, que
mejora el rendimiento del algoritmo de agrupamiento, produciendo grupos de tamaos
ms balanceados.

) , ( _
1
C C sim sim ext
k
i
i
=
=
|| || _
1
C C dist ext
k
i
i
=
=

2.5.2.3 Algoritmos de optimizacin

Existen variantes de algoritmos de optimizacin en la literatura [Rasmussen,
1992; Qin He, 1996; Jain et.al., 1999; Han et.al., 2001] que implementan la estructura
bsica de cuatro pasos descripta anteriormente. Estos algoritmos son similares entre s,
por lo que se describir nicamente el algoritmo k-means, que, adems de ser el
referente ms tpico en la bibliografa, es el que ms frecuentemente se encuentra
aplicado al campo de categorizacin automtica de documentos [Steinbach et.al., 2000].

Algoritmo K-means

Este algoritmo, presentado originalmente por [McQueen, 1967], utiliza a los
centroides de cada grupo como sus puntos representantes. Partiendo de una seleccin
inicial de k centroides (que pueden ser k elementos de la coleccin seleccionados al
azar, o los que se obtengan mediante la aplicacin de alguna tcnica de inicializacin),
cada uno de los elementos de la coleccin se asigna al grupo con el centroide ms
cercano.
A continuacin, se calcula el centroide de cada uno de los grupos resultantes. En
los primeros pasos se obtienen las mayores diferencias entre los centroides originales y
los calculados luego de las reasignaciones. Los puntos de la coleccin vuelven a
asignarse al grupo del centroide ms cercano, y estos pasos se repiten hasta que los k
centroides no cambian luego de una iteracin (sto es equivalente a decir que el valor de
la funcin utilizada como criterio de optimizacin no vara). El algoritmo k-means
encuentra una categorizacin que representa un ptimo local del criterio elegido
[Bradley et.al., 1998].
Las figuras 2.8, 2.9, 2.10 y 2.11 ilustran la forma de trabajo del algoritmo. En
ellas puede verse cmo una iteracin del algoritmo refina el agrupamiento. Los objetos
de la coleccin estn representados mediante signos +, y los centroides de cada grupo
con los signos X. En la figura 2.8 se muestran los objetos de la coleccin y los
centroides que el algoritmo ha encontrado hasta el paso N. En la figura 2.9, cada objeto
de la coleccin se ha asignado al grupo con el centroide ms cercano. Los nuevos
centroides, calculados a partir de la composicin de los grupos, se grafican en la figura


2.10. En la figura 2.11 puede verse la situacin inicial para el paso N+1. En ste paso, el
algoritmo encontrar los 3 grupos claramente definidos que existen en la coleccin. La
disposicin de los objetos se ha elegido especialmente para que la mejora en el
agrupamiento sea evidente.

+
+
+
Fig 2.8
Objetos en una coleccin y los 3
centroides del paso N
+
+
+
+
+
+
+
X
X
X
+
+
+
Fig 2.9
Los objetos de la coleccin se
asignan al grupo del centroide
ms cercano
+
+
+
+
+
+
+
X
X
X
+
+
+
Fig 2.10
Se calculan los centroides para
el paso N + 1
+
+
+
+
+
+
+
X
X
X


2.5.2.4 Resumen de caractersticas

Entre las caractersticas de stos mtodos pueden destacarse las siguientes:

a) Pueden ser no deterministas.
Partiendo del mismo agrupamiento inicial, los mtodos llegarn siempre
a la misma solucin. Sin embargo, los mtodos para la seleccin inicial son no
deterministas. El algoritmo evaluar diferentes agrupamientos cada vez que se lo
ejecute, y (si los grupos no estn claramente separados) podr llegar a soluciones
distintas [Steinbach et.al., 2000].

b) Pueden corregir errores cometidos en pasos anteriores
En cada paso del algoritmo los objetos de la coleccin se asignan al
grupo ms apropiado segn el criterio de optimizacin. De esta manera, el algoritmo va
refinando el agrupamiento en cada iteracin [Qin He, 1996].

c) Pueden implementarse en forma eficiente
Las restricciones de recursos son la causa principal por la que se utilizan
este tipo de mtodos. Estos algoritmos pueden implementarse de forma que sus tiempos
de ejecucin sean del orden de n [Han et.al., 2001].

+
+
+
Fig 2.11
Situacin inicial para el paso
N+1
+
+
+
+
+
+
+
X
X
X


2.6 El algoritmo Bisecting K-Means

Se han presentado alternativas a los algoritmos tradicionales de categorizacin
automtica de documentos [Cutting et.al., 1992; Bradley et.al., 1998; Steinbach et.al.,
2000]. El algoritmo Bisecting K-Means es una de ellas [Steinbach et.al., 2000]. En
esta tesis se decidi tomar esta variante como referencia para compararla con la
solucin propuesta, por varios motivos:
- El trabajo que la presenta es uno de los ms recientes, (ao 2000), y esta
variante se analiza tambien en un trabajo del ao 2001 [Zhao et.al., 2001].
- Uno de los autores (que participa en ambos trabajos) es una personalidad
reconocida dentro del dominio del recupero de informacin y de la
categorizacin automtica, con ms de 70 trabajos publicados, y diversos
desarrollos de software relativos al tema.
- Los trabajos demuestran que la calidad de los resultados supera tanto a los
algoritmos jerrquicos aglomerativos como al K-Means, con tiempos de
cmputo lineales con la cantidad de elementos a agrupar.

El algoritmo Bisecting K-Means sigue los siguientes pasos:
1) Colocar todos los documentos en un slo grupo
2) Elegir el grupo ms grande para dividirlo.
3) Dividir el grupo en 2 subgrupos usando el algoritmo K-Means (paso de
biseccin).
4) Repetir el paso de biseccin 5 veces, y tomar la divisin que lleve a una
mayor similitud promedio.
5) Repetir los pasos 2, 3 y 4 hasta alcanzar el nmero de grupo deseado.

Al utilizar el algoritmo K-Means para formar slamente 2 grupos cada vez, y
repetir 5 veces cada divisin, se intenta atenuar la dependencia de este algoritmo con la
seleccin inicial de los representantes.


2.6.1 Algoritmo Bisecting K-Means con refinamiento

Esta variante consiste en refinar la solucin obtenida con el algoritmo Bisecting
K-Means utilizando el algoritmo K-Means estndar. El agrupamiento generado por
el algoritmo Bisecting K-Means se toma como el punto de partida para el algoritmo
K-Means. Este refinamiento apunta a corregir posibles asignaciones incorrectas de
documentos a los grupos que se podran haber realizado durante las fases de divisin del
algoritmo. Los resultados muestran que el paso de refinamiento mejora la calidad de las
soluciones obtenidas [Steinbach et.al., 2000].

2.7 Introduccin a los Algoritmos Genticos

Los algoritmos genticos fueron desarrollados por John Holland, junto a su
equipo de investigacin, en la universidad de Michigan en la dcada de 1970 [Holland,
1975]. stos combinan las nociones de supervivencia del ms apto con un intercambio
estructurado y aleatorio de caractersticas entre individuos de una poblacin de posibles
soluciones, conformando un algoritmo de bsqueda que puede aplicarse para resolver
problemas de optimizacin en diversos campos [Goldberg, 1989]. Imitando la mecnica
de la evolucin biolgica en la naturaleza, los algoritmos genticos operan sobre una
poblacin compuesta de posibles soluciones al problema. Cada elemento de la
poblacin se denomina cromosoma. Un cromosoma es el representante, dentro del
algoritmo gentico, de una posible solucin al problema. La forma en que los
cromosomas codifican a la solucin se denomina Representacin (ver figura 2.12).

Espacio de soluciones

Espacio de cromosomas
S
1
S
2
S
3
S
N
C
4
C
1
C
3
C
M
C
2
Codificacin
Fig 2.12 - Cada cromosoma codifica una posible
solucin al problema


El algoritmo gentico va creando nuevas generaciones de esta poblacin,
cuyos individuos son cada vez mejores soluciones al problema. La creacin de una
nueva generacin de individuos se produce aplicando a la generacin anterior
operadores genticos, adaptados de la gentica natural. La figura 2.13 representa el
esquema de funcionamiento del algoritmo gentico. El proceso comienza seleccionando
un nmero de cromosomas para que conformen la poblacin inicial. A continuacin se
evala la funcin de adaptacin para estos individuos. La funcin de adaptacin da una
medida de la aptitud del cromosoma para sobrevivir en su entorno. Debe estar definida
de tal forma que los cromosomas que representen mejores soluciones tengan valores
ms altos de adaptacin.
Los individuos ms aptos se seleccionan en parejas para reproducirse. La
reproduccin genera nuevos cromosomas que combinan caractersticas de ambos
padres. Estos nuevos cromosomas reemplazan a los individuos con menores valores de
adaptacin. A continuacin, algunos cromosomas son seleccionados al azar para ser
mutados. La mutacin consiste en aplicar un cambio aleatorio en su estructura. Luego,
los nuevos cromosomas deben incorporarse a la poblacin; estos cromosomas deben
reemplazar a cromosomas ya existentes. Existen diferentes criterios que pueden
utilizarse para elegir a los cromosomas que sern reemplazados. El ciclo de seleccin,
reproduccin y mutacin se repite hasta que se cumple el criterio de terminacin del
algoritmo, momento en el cual el cromosoma mejor adaptado se devuelve como
solucin (ver figura 2.13).


Mejor cromosoma
Decodificacin
Solucin
Fig. 2.13 - Esquema de funcionamiento
del algoritmo gentico
Generacin de la
poblacin inicial
Evaluacin de la
funcin de adaptacin
Seleccin de los
individuos a reproducir
Reproduccin
Mutacin
Repetir hasta que se
cumpla el criterio de
terminacin
Insercin de los hijos
en la poblacin


2.7.1 Representacin

El esquema de representacin es el que define de qu forma se corresponden los
cromosomas con las soluciones al problema. Para disear el esquema de representacin,
se buscan los parmetros que identifican a las soluciones, y luego se codifican estos
parmetros dentro del cromosoma.

La figura 2.14 muestra un posible esquema de representacin para un problema
que tiene como soluciones a los polgonos regulares. Los parmetros que identifican a
cada solucin son 2 (cantidad de lados y longitud del lado), y estos se codifican en el
cromosoma en forma binaria. El cromosoma se compone de una cadena de 10 bits, en
los que los primeros 3 son la cantidad de lados, y los siguientes 7 bits representan la
longitud de los lados en milmetros.
El esquema de representacin debera ser tal que exista al menos una posible
codificacin para cada una de las soluciones posibles. Las soluciones que no estn
dentro del espacio de cromosomas no sern exploradas por el algoritmo gentico. En el
ejemplo de la figura 2.14, el algoritmo gentico no explorar soluciones que se
compongan por polgonos de ms de 7 lados ni longitudes mayores a 127 milmetros, ya
que con 3 y 7 bits pueden codificarse solamente nmeros del 0 al 7, y del 0 al 127,
respectivamente. Por el mismo motivo (porque la bsqueda se hace sobre el espacio de
cromosomas), es deseable que no haya redundancia en la representacin; que cada
solucin sea representada por solamente un cromosoma. Si existen k cromosomas por
0 1 1 0 0 0 1 1 0 1
3 lados 13 mm
1 0 1 0 0 1 0 0 1 1
5 lados 19 mm
Fig 2.14 - Ejemplo de un esquema de
representacin para polgonos regulares

cada solucin, el espacio de bsqueda sobre el que opera el algoritmo gentico es k
veces ms grande que el espacio de soluciones, haciendo ms lento el proceso de
evolucin. La representacin ejemplificada en la figura 2.14 no tiene redundancia, cada
polgono es representado slo por un cromosoma. Otro problema que puede presentarse
es que haya cromosomas que no representan ninguna solucin. En el ejemplo de la
figura 2.14, un cromosoma que tenga todos 0 en los primeros 3 en los ltimos 7 bits
no representa un polgono vlido. En caso de que la representacin lo permita, los
operadores del algoritmo gentico deben adaptarse para tratar con este tipo de
cromosomas.
La codificacin ejemplificada en la figura 2.14 se denomina binaria, ya que
cada posicin del cromosoma contiene un bit. Esta es la representacin clsica
propuesta por los primeros autores y que todava es utilizada ampliamente [Goldberg,
1989; Cole, 1998; Falkenauer, 1999]. Sin embargo, hay problemas para los cuales esta
representacin no es la ms conveniente. El funcionamiento de los algoritmos genticos
est basado en lo que se denomina la hiptesis de los bloques constructores
[Goldberg, 1989]. Esta hiptesis requiere que los cromosomas se compongan por
bloques significativos que codifiquen las caractersticas de la solucin lo ms
independientemente posible.
El ejemplo de la figura 2.14 es un claro ejemplo de una representacin que no
cumple con esta premisa. Sera ms apropiado un esquema en el cual el cromosoma se
componga por 2 nmeros enteros, uno de los cuales codifique el nmero de lados y el
otro la longitud. La figura 2.15 muestra esta representacin.

Fig 2.15 - Ejemplo de un esquema de
representacin no binario para polgonos regulares
3 13
3 13 mm
5 19
5 19 mm


2.7.2 Generacin de la poblacin inicial

La poblacin inicial es la principal fuente (luego se ver que el operador de
mutacin tambien trabaja sobre este punto) de material gentico para el algoritmo
gentico. La poblacin inicial debe contener cromosomas que estn bien dispersos por
el espacio de soluciones. La manera ms simple de cumplir con este objetivo es elegir
cromosomas al azar. El uso de una heurstica [Bezdek et.al., 1994] puede ayudar a
generar una poblacin inicial compuesta de soluciones de mediana calidad, ahorrando
tiempo al proceso de evolucin, siempre y cuando se garantice una dispersin suficiente
para la bsqueda.

2.7.3 Funcin de adaptacin

La funcin de adaptacin cuantifica la aptitud de cada cromosoma como
solucin al problema, y determina su probabilidad de ser seleccionado para la fase de
reproduccin y poder pasar parte de su material gentico a la siguiente generacin. La
funcin de adaptacin prove la presin que hace evolucionar la poblacin hacia
cromosomas ms aptos, por lo que una buena definicin de esta funcin es fundamental
para un correcto funcionamiento del algoritmo. La funcin debe asignar el valor ms
alto al cromosoma que representa la solucin ptima al problema. Soluciones cercanas a
la ptima deben obtener valores altos, y la funcin debe ir decreciendo a medida que los
cromosomas representan soluciones cada vez ms alejadas de la ptima. Como el
proceso de evolucin tiende a retener el material gentico de los cromosomas con
valores altos de aptitud, una eleccin apropiada de la funcin de adaptacin resultar
mayor probabilidad de retener caractersticas de soluciones cercanas a la ptima.
Otro punto a tener en cuenta en el diseo de la funcin de adaptacin es la escala
[Goldberg, 1989]. Cuando la aptitud de los elementos de la poblacin es variada (por
ejemplo, al inicio del proceso de evolucin), es comn que la poblacin contenga unos
pocos cromosomas cercanos al ptimo, rodeados de cromosomas que representan
soluciones mediocres. Los cromosomas ms aptos obtendrn valores exageradamente
superiores al promedio para la funcin de adaptacin, y el algoritmo gentico elegir
solamente a estos cromosomas para la reproduccin. Esto puede ocasionar lo que se

denomina convergencia prematura: el algoritmo gentico encontrar una solucin sin
haber explorado suficientemente el espacio de bsqueda.
Sin embargo, a medida que la aptitud promedio va subiendo, el problema ser
diferente. La diferencia ir decreciendo, y los cromosomas ms aptos obtendrn valores
de adaptacin similares a los de los dems cromosomas, reduciendo la probabilidad de
que el algoritmo gentico seleccione a los mejores individuos para la reproduccin.
Los dos problemas pueden corregirse aplicando una funcin de escala a la
funcin de adaptacin. La funcin de escala lineal calcula la nueva funcin de
adaptacin f a partir de la funcin de adaptacin f usando la transformacin lineal f =
a.f + b. Las constantes a y b se eligen de forma tal que el promedio de las dos
funciones sea el mismo, y que el mximo para la funcin f asegure la diferencia de
probabilidades deseada entre los elementos ms aptos y el promedio.

2.7.4 Seleccin

La seleccin de los individuos que van a reproducirse se realiza mediante un
operador de seleccin. El operador de seleccin hace la eleccin basndose en los
valores de adaptacin de los individuos. Existen distintos operadores de seleccin que
pueden utilizarse [Miller et.al., 1995], de los cuales se describen los ms comunes.

2.7.4.1 Seleccin basada en el ranking
En el operador de seleccin basado en el ranking, los cromosomas se ordenan de
acuerdo a sus valores para la funcin de adaptacin. Luego, se seleccionan para la
reproduccin a los primeros m (la cantidad que sea necesaria) cromosomas. Como las
probabilidades de ser elegido de cada individuo dependen solamente de su posicin
relativa respecto a los dems y no del valor absoluto de aptitud, este operador no
requiere que se apliquen las tcnicas de escala de la funcin de adaptacin.



2.7.4.2 Seleccin por ruleta
El operador de seleccin por ruleta es uno de los ms simples [Goldberg, 1989].
Los cromosomas se colocan en segmentos contnuos sobre una lnea, de forma tal que el
segmento para cada individuo sea de tamao proporcional a su valor de aptitud, y que la
suma de las longitudes de los segmentos sea igual a 1. Se genera un nmero al azar
entre 0 y 1, y el individuo cuyo segmento comprende el nmero generado es
seleccionado para la reproduccin; el procedimiento se repite hasta que se obtiene el
nmero deseado de individuos. Esta tcnica es anloga a una rueda de ruleta en la que a
cada cromosoma le es asignada una parte de tamao proporcional a su valor de aptitud.
La figura 2.16 ejemplifica el funcionamiento de este operador. El tamao del
segmento asignado a cada cromosoma (y por lo tanto su probabilidad de ser
seleccionado para reproducirse) es proporcional a su aptitud.

El operador de seleccin por ruleta puede requerir la aplicacin de una funcin
de escala sobre la funcin de adaptacin, ya que los segmentos son dimensionados en
funcin del valor absoluto de aptitud de cada individuo.

Cromosoma
Aptitud
Porcentaje
C1
2,8
0,07
C2
10
0,23
C3
22,5
0,5
C4
3,1
0,07
C5
6
0,13
Totales
44,4
1
1 0 0,07
0,3 0,8
0,87
C1 C2 C3 C4 C5
Nro Azar 1 Nro Azar 2
Fig 2.16 - Seleccin de dos cromosomas
mediante el mtodo de ruleta

2.7.4.3 Seleccin por torneo
Los dos operadores de seleccin descriptos anteriormente no permiten regular la
presin selectiva. El operador de seleccin basado en el ranking siempre seleccionar a
los mejores individuos de la poblacin. La seleccin por ruleta, si no se aplica ninguna
funcin de escala, aplica una presin selectiva muy alta cuando las aptitudes de los
individuos son variadas, y muy baja cuando las aptitudes son similares [Goldberg,
1989]. El operador de seleccin por torneo permite controlar en forma efectiva la
presin selectiva del algoritmo gentico, siendo a la vez de facil implementacin. En
este esquema, se toman T individuos al azar de la poblacin (donde T es el tamao del
torneo, habitualmente 2 o 3 individuos), de los cuales se selecciona para la fase de
reproduccin, con probabilidad p (generalmente entre 0,7 y 0,8), aquel que tenga el
mayor valor de la funcin de adaptacin.
Los parmetros T y p permiten regular la presin selectiva. Cuanto ms grandes
son los valores de T y p, mayor es la presin selectiva. En el caso extremo de que p sea
igual a 1 y T igual al tamao de la poblacin, el algoritmo gentico solamente
seleccionar al mejor individuo de la poblacin. En el otro extremo, si T es igual a 1, se
logra la presin selectiva ms baja (los cromosomas se seleccionan al azar).
Manteniendo estos parmetros constantes, se logra una presin selectiva que es
independiente de los valores absolutos de aptitud de la poblacin, y sin requerir la
aplicacin de funciones de escala sobre la funcin de adaptacin.



2.7.5 Reproduccin

La fase de reproduccin se implementa por medio de un operador de
reproduccin. El operador de reproduccin es el encargado de transferir el material
gentico de una generacin a la siguiente. Es este operador el que confiere a la bsqueda
de soluciones mediante algoritmos genticos su caracterstica ms distintiva
[Falkenauer, 1999]. A diferencia de otros mtodos de optimizacin, los algoritmos
genticos no solamente exploran el vecindario de las buenas soluciones, sino que
recombinan sus partes para formar nuevas soluciones. Se ha hecho notar que el
descubrimiento de nuevas teoras combinando nociones ya conocidas es un mecanismo
que el hombre ha utilizado constantemente a lo largo de la evolucin de la ciencia
[Goldberg, 1989].
El objetivo de los operadores de reproduccin es, partiendo de dos cromosomas
padres, generar uno o ms cromosomas hijos que hereden caractersticas de ambos
padres, como se muestra en la figura 2.17. Se dice que en el hijo se recombinan las
caractersticas de los padres. Si las caractersticas se traspasan en bloques significativos,
se espera que un hijo que recombina caractersticas de buenas soluciones sea una buena
solucin, tal vez mejor que cualquiera de sus padres [Falkenauer, 1999].

Los operadores de reproduccin ms tpicos generan dos hijos a partir de dos
padres. A continuacin se describen los ms utilizados.
A
1
A
2
A
3
A
4
A
5
A
6
A
7
A
8
B
1
B
2
B
3
B
4
B
5
B
6
B
7
B
8
Padre 1
Padre 2
A
1
A
2
B
3
A
4
B
5
A
6
A
7
B
8
Hijo
Recombinacin
Fig 2.17 - En la recombinacin, el hijo
hereda caractersticas de ambos padres

2.7.5.1 Cruza monopunto
Este operador consiste en separar a los padres en dos partes para formar dos
hijos intercambiando las partes de cada padre. Si los cromosomas se componen de N
bloques, se elige un nmero al azar c, tal que 1 <= c < N, y luego se asigna al primer
hijo los primeros c bloques del primer padre y los ltimos N - c bloques del segundo
padre. Se procede en forma inversa para formar al segundo hijo. La figura 2.18 muestra
un ejemplo de la aplicacin de ste operador.

2.7.5.2 Cruza multipunto
Es evidente que en el operador de cruza monopunto, el primer y ltimo bloque
de uno de los padres no pueden pasar juntos al hijo en ningun caso. El operador de cruza
multipunto avanza un paso ms, quitando esta restriccin. En la cruza multipunto, se
eligen M puntos de corte al azar, y las secciones de cada padre se pasan a los hijos en
forma alternada. La figura 2.19 ejemplifica este procedimiento, para el caso en que M es
igual a 2.

Fig 2.18 - Ejemplo del mtodo de cruza
monopunto.
A
1
A
2
A
3
A
4
A
5
A
6
A
7
A
8
B
1
B
2
B
3
B
4
B
5
B
6
B
7
B
8
Padre 1
Padre 2
A
1
A
2
A
3
B
4
B
5
B
6
B
7
B
8
Hijo 1
Cruza monopunto
C = 3
B
1
B
2
B
3
A
4
A
5
A
6
A
7
A
8
Hijo 2


2.7.5.3 Cruza uniforme
Si bien la cruza multipunto es ms flexible que la monopunto, tiene algunos
inconvenientes. En primer lugar, para valores impares de M impide que el primer y
ltimo bloque de los padres pasen juntos a los hijos, y para valores impares obliga a que
sea asi. En segundo lugar, los bloques consecutivos tienen ms posibilidades de pasar
juntos que los que se encuentran ms distanciados. Esto no es deseable (a menos que la
codificacin elegida haga que los bloques consecutivos representen caractersticas
relacionadas).
El operador de cruza uniforme permite el intercambio de los bloques en una
manera que es independiente del orden que la codificacin impuso a cada uno dentro del
cromosoma. Para cada posicin de los cromosomas hijos, se elige al azar cul de los dos
bloques de los cromosomas padres se copia en cada uno. Esta es una generalizacin del
esquema de cruza multipunto donde la cantidad de puntos de corte M se elige al azar
para cada reproduccin.

Fig 2.19 - Ejemplo del mtodo de cruza
multipunto.
A
1
A
2
A
3
A
4
A
5
A
6
A
7
A
8
B
1
B
2
B
3
B
4
B
5
B
6
B
7
B
8
Padre 1
Padre 2
A
1
A
2
B
3
B
4
B
5
A
6
A
7
A
8
Hijo 1
Cruza multipunto
C
1
= 2
B
1
B
2
A
3
A
4
A
5
B
6
B
7
B
8
Hijo 2
C
2
= 5

2.7.6 Mutacin

La mutacin de cromosomas (junto con la generacin de la poblacin inicial) es
la encargada de proveer al sistema de material gentico. La mutacin se implementa
mediante un operador de mutacin. El operador de cruza genera nuevas soluciones
intercambiando bloques de las soluciones existentes, pero sin el operador de mutacin,
el algoritmo gentico no tendra forma de crear nuevos bloques. Este operador es el que
permite que la exploracin del espacio de bsqueda sea amplia.
El operador de mutacin trabaja a nivel de bloque dentro de los cromosomas,
haciendo cambios aleatorios de acuerdo a una probabilidad P
M
(probabilidad de
mutacin). La naturaleza del cambio depende de la composicin de los bloques de los
cromosomas. Si cada bloque es un bit (en la codificacin binaria), el nico cambio
posible es invertir su valor. Si los bloques son nmeros reales, la modificacin podra
ser la suma o sustraccin de un pequeo valor aleatorio.

2.7.7 Insercin de los hijos en la poblacin

La reinsercin de hijos consiste en incorporar los nuevos cromosomas en la
poblacin. Los mtodos de reinsercin son diferentes segn la cantidad de cromosomas
generados sea menor, igual o mayor que la cantidad de elementos existentes en la
poblacin.

2.7.7.1 Se generan tantos cromosomas como elementos en la poblacin
El esquema ms simple, denominado reinsercin pura, consiste en generar
mediante la reproduccin tantos hijos como elementos existen en la poblacin, y
reemplazar todos los cromosomas de la generacin anterior por los nuevos [Goldberg,
1989]. Cada cromosoma vive exactamente una generacin. Un inconveniente que
presenta este mtodo es que suele reemplazar buenas soluciones por soluciones de
menor calidad.



2.7.7.2 Se generan ms cromosomas que elementos en la poblacin
Este esquema es similar al de reinsercin pura. Se eligen los mejores
cromosomas entre los que se generaron, y se eliminan los cromosomas sobrantes.
Luego, se reemplaza la poblacin completa por la nueva generacin.

2.7.7.3 Se generan menos cromosomas que elementos en la poblacin
Este esquema exige seleccionar entre los cromosomas de la poblacin aquellos
que se eliminarn. A continuacin se describen los mtodos ms utilizados para hacerlo.

Insercin uniforme
Los cromosomas a ser reemplazados se eligen al azar entre los miembros de la
poblacin. Se corre el riesgo de eliminar buenas soluciones, ya que no se tiene en cuenta
la aptitud de los cromosomas.

Insercin elitista
Se eligen los cromosomas menos aptos para ser reemplazados. Este mtodo
asegura que los mejores cromosomas pasarn siempre a la siguiente generacin, pero
puede restringir la amplitud de la bsqueda que realiza el algoritmo gentico.

Insercin por torneo invertido
Se utiliza en combinacin con el mtodo de seleccin por torneo. Funciona
exactamente igual que el mtodo de seleccin por torneo pero seleccionando con
probabilidad p al peor cromosoma del torneo para ser reemplazado, y tiene las mismas
propiedades que ste, permitiendo regular la presin selectiva sin el uso de funciones de
escala.


2.7.8 Criterios de terminacin del algoritmo gentico

El criterio de terminacin del algoritmo gentico es el encargado de definir el
momento en el cual debe deternerse el ciclo de evolucin y adoptar el cromosoma ms
apto como la solucin encontrada por el algoritmo gentico. A continuacin se
describen los criterios ms comunmente utilizados.

2.7.8.1 Criterio de convergencia de identidad
Este criterio consiste en detener al algoritmo gentico cuando un determinado
porcentaje de los cromosomas de la poblacin representan a la misma solucin. Los
operadores del algoritmo gentico tienden a preservar y difundir el material gentico de
los cromosomas ms aptos, por lo que es de esperar que luego de un gran nmero de
generaciones, alguna solucin con gran valor de aptitud se imponga y domine la
poblacin.

2.7.8.2 Criterio de convergencia de aptitud
Puede suceder que existan soluciones equivalentes o cuasi equivalentes a un
problema, que obtengan valores de aptitud similares. En ese caso, es probable que no
haya una solucin que se imponga en la poblacin (y el criterio de terminacin por
convergencia de identidad nunca se cumpla). Este criterio no espera a que la poblacin
se componga mayoritariamente de una sola solucin, sino que finaliza la ejecucin del
algoritmo cuando los valores de aptitud de un determinado porcentaje de las soluciones
son iguales, o difieren en un pequeo porcentaje. Por ejemplo, cuando el 90% de l as
soluciones tenga valores de aptitud que no difieran en ms de un 1%.

2.7.8.3 Criterio de cantidad de generaciones
Los mtodos anteriores apuntan a esperar a que la evolucin de la poblacin
llegue a su fin. Cuando alguno de ellos se cumple, es probable que las soluciones no
sigan mejorando mucho ms, no importa cuantas generaciones ms se ejecuten. Sin
embargo, los algoritmos genticos pueden necesitar un nmero de generaciones muy


grande para llegar a la convergencia, dependiendo de las tasas de reproduccin y
mutacin. Utilizando cualquiera de los dos criterios anteriores no puede estimarse un
nmero mximo de generaciones, ya que esto depender no solamente de los
parmetros del algoritmo gentico sino tambien del azar.
Esto puede ser un problema, sobre todo si se quieren comparar los tiempos de
resolucin de un problema mediante algoritmos genticos con otros mtodos [Estivill-
Castro, 2000]. El criterio de terminacin por cantidad de generaciones consiste
simplemente en finalizar la ejecucin una vez que ha transcurrido un nmero
determinado de generaciones. Este mtodo permite determinar con precisin los
tiempos de ejecucin del algoritmo a costa de detener la evolucin sin la certeza de que
las soluciones no seguirn mejorando.


Eugenio Yolis CAPITULO 3 - DESCRIPCION DEL PROBLEMA 55
Captulo 3
Descripcin del problema

En este captulo se plantean las cuestiones que esta tesis apunta a responder, y se
analiza el trabajo previo que existe acerca de la aplicacin de los Algoritmos Genticos
a este problema. En la seccin 3.1 se exponen las limitaciones que presentan los
algoritmos actuales, relacionados con la forma en la que exploran el espacio de posibles
soluciones. La seccin 3.2 describe los problemas encontrados en los trabajos previos
que aplicaron los algoritmos genticos a la categorizacin automtica.

3.1 La bsqueda en el espacio de soluciones

Ante la imposibilidad de evaluar todas las posibles soluciones, los algoritmos de
categorizacin automtica exploran slo una parte del espacio de bsqueda (solamente
evaluan algunas de las posibles categorizaciones).
La diferencia fundamental entre los distintos algoritmos consiste en:
- La eleccin del punto inicial de la bsqueda.
- Las reglas para pasar de un punto del espacio de bsqueda a otro.

3.1.1 Problemas de los algoritmos actuales

Algoritmos jerrquicos aglomerativos
Si bien se acepta que los mtodos jerrquicos aglomerativos obtienen resultados
de buena calidad [Cutting et.al., 1992; Cole, 1998; Dash et.al., 2001], los tiempos de
cmputo que requieren son inaceptables para las aplicaciones prcticas, ya que son del
rden de N
2
, donde N es la cantidad de documentos a agrupar [Zamir et.al., 1998; Dash
et.al., 2001].


56 CAPITULO 3 - DESCRIPCION DEL PROBLEMA Eugenio Yolis

Algoritmo K-Means
El algoritmo K-Means es mucho ms eficiente (los tiempos de cmputo
requeridos son lineales con la cantidad documentos a agrupar [Han et.al., 2001]), pero
es dependiente de la seleccin inicial de centroides [Bradley, 1998]. Sus resultados
pueden ser bastante pobres y suelen variar mucho si se aplica varias veces a la misma
coleccin de documentos, ya que si la seleccin de centroides al azar es mala, la
solucin encontrada tambin lo ser.

Algoritmo Bisecting K-Means
Aunque este algoritmo ha demostrado obtener mejores soluciones que el
algoritmo k-means y los mtodos jerrquicos aglomerativos [Steinbach et.al., 2000], en
tiempos de cmputo lineales con la cantidad de documentos a agrupar, la forma en que
explora el espacio de bsqueda es claramente sub-ptima. Al momento de dividir un
grupo, el algoritmo Bisecting K-Means realiza 5 divisiones diferentes del grupo
(aplicando 5 veces el algoritmo K-Means con k=2 a los elementos del grupo), y luego
elige una de ellas (la que ms hace crecer el criterio de optimizacin), descartando las
dems divisiones que cre.
El siguiente anlisis muestra por qu esta forma de trabajo no es eficiente:
- Cuando el grupo es fcilmente divisible (hay 2 subgrupos claramente
definidos), las 5 corridas del algoritmo K-Means encontrarn la misma
divisin, o divisiones con muy pocas variaciones. En este caso, el algoritmo
estara repitiendo 5 veces el mismo trabajo.
- Cuando no hay dos subgrupos claramente definidos, las 5 corridas del
algoritmo K-Means encontrarn divisiones diferentes. En este caso, el
problema es que el algoritmo Bisecting K-Means no tiene ningn mecanismo
para aprovechar el trabajo realizado al armar las divisiones que son
descartadas. Es muy posible que en alguna de ellas haya encontrado un
grupo excelente y uno muy malo que en promedio hagan que descarte esa
divisin, y no tiene ningn mecanismo que le permita quedarse con la parte
buena y descartar slo lo malo.


Estos problemas de los algoritmos actuales dan lugar a las siguientes cuestiones:

Cuestin 1: Pueden ayudar los algoritmos genticos a explorar el espacio de bsqueda
en forma ms eficiente?
Cuestin 2: Pueden ayudar los algoritmos genticos a encontrar soluciones de mejor
calidad?

3.2 Utilizacin de algoritmos genticos

La aplicacin de algoritmos genticos al problema general de la categorizacin
automtica se ha investigado con inters [Jones et.al., 1991; Bezdek et.al., 1994;
Estivill-Castro et.al., 1997; Cole, 1998; Jain et.al., 1999; Hall et.al., 1999; Falkenauer,
1999; Painho et.al., 2000]. Sin embargo, son muy pocos los autores que los han
aplicado a la categorizacin automtica de documentos [Jones et.al., 1995]. Esto se debe
a que, pese a que los algoritmos genticos han demostrado capacidad de explorar el
espacio de bsqueda amplia y eficientemente [Goldberg, 1989; Koza, 1997; Falkenauer,
1999], los resultados de las investigaciones no han dado buenos resultados al aplicarlos
a la categorizacin automtica en general, ni a la categorizacin automtica de
documentos en particular.
La causa de estos fracasos radica en la aplicacin inadecuada de los algoritmos
genticos al problema. Se ha hecho notar [Falkenauer, 1999; Estivill-Castro, 2000] que
los algoritmos genticos no son una solucin universal que pueda aplicarse en forma
pura a cualquier problema, sino un paradigma que debe adaptarse a los problemas
concretos a los que se aplica. Los fracasos no se deben a que los algoritmos genticos no
puedan aplicarse en forma efectiva en el dominio de la categorizacin automtica de
documentos sino a la falta de una correcta adaptacin del esquema de representacin y
los operadores del algoritmo gentico a este problema.


58 CAPITULO 3 - DESCRIPCION DEL PROBLEMA Eugenio Yolis

3.2.1 Representacin y operadores de cruza

La hiptesis principal en la que descansa la teora de los algoritmos genticos es
la hiptesis de los bloques constructores (en ingls building blocks) [Goldberg,
1989]; esto es, que el operador de cruza intercambiar caractersticas entre los
individuos de la poblacin en bloques significativos. Al combinarse bloques de buenas
soluciones, se espera que la solucin resultante tambin lo sea. Para que los principios
de la hiptesis se cumplan (y el algoritmo gentico opere de acuerdo a la misma), la
representacin y el operador de cruza deben ser definidos en forma cuidadosa e
interdependiente, para evitar lo que se conoce como operadores de cruza insensibles al
contexto [Cole, 1998]. La inconsistencia ms importante que puede surgir al definir
incorrectamente estos operadores es que la cruza de dos individuos que representan la
misma solucin puede dar como resultado una solucin diferente, con poca relacin con
aquella a partir de la cual se gener.
Debe remarcarse que al operar el algoritmo gentico por fuera de la hiptesis de
los bloques constructores, es altamente probable que los resultados sean incorrectos, o al
menos insatisfactorios.

Esto lleva a plantear la cuestin:
Cuestin 3: De qu manera puede definirse la representacin de las soluciones y el
operador de cruza para que el algoritmo gentico pueda ser aplicado a la categorizacin
automtica de documentos de acuerdo a la hiptesis de los bloques constructores?

3.2.2 Uso del conocimiento del dominio

Otro punto importante es la posibilidad de incorporar en los operadores del
algoritmo gentico conocimiento especfico del problema al cual se est aplicando el
mismo. De esta manera, los operadores no trabajan en forma totalmente aleatoria sobre
los individuos de la poblacin, sino que tienden a realizar cambios que apunten a buenas
soluciones para el problema a resolver. Esto ayuda a que el algoritmo gentico no tenga

que explorar todo el espacio de bsqueda, ya que lo gua por aquellos sectores en los
cuales las soluciones son significativas.
Sin la aplicacin de conocimiento especfico del problema que se est
resolviendo en los operadores, es casi imposible que el algoritmo gentico supere en
trminos de eficiencia a los algoritmos diseados ad hoc para el problema [Goldberg,
1989; Estivill-Castro, 2000]. Sin embargo, solamente un trabajo hace uso de este
conocimiento [Estivill-Castro, 2000], aunque falla en reconocer la importancia de la
sensibilidad al contexto del operador de cruza.

Lo expuesto en esta seccin da lugar a la siguiente cuestin:
Cuestin 4: De qu manera pueden disearse los operadores del algoritmo gentico
para hacer uso del conocimiento especfico del dominio?


Eugenio Yolis CAPITULO 4 - SOLUCION PROPUESTA 61
Captulo 4
Solucin propuesta

En este captulo se presenta la solucin propuesta en esta tesis, que apunta a
responder a las cuestiones planteadas en el captulo 3. En la seccin 4.1 se describen las
tcnicas utilizadas en trabajos previos que aplican los algoritmos genticos a problemas
de categorizacin automtica. La seccin 4.2 detalla el algoritmo de categorizacin
propuesto. Este algoritmo emplea algunas de las tcnicas descriptas en la seccin 4.1,
pero su caracterstica principal es la utilizacin de los nuevos operadores que se
presentan en esta tesis.

4.1 Adaptaciones existentes

En esta seccin se describen los esquemas de representacin y operadores que se
han utilizado en los trabajos previos que aplicaron los algoritmos genticos a problemas
de categorizacin automtica.

4.1.1 Representacin

Los mtodos ms comunes para codificar un agrupamiento en un cromosoma
son los siguientes:

4.1.1.1 Numeracin de grupo
El cromosoma representa un agrupamiento de n objetos como una cadena de n
nmeros enteros. En cada posicin i, la cadena contiene el nmero de grupo en que se
encuentra el objeto nmero i [Jones et.al., 1991]. Por ejemplo, para una coleccin de 5
objetos, el siguiente cromosoma representa un agrupamiento que contiene los grupos
{1,2,4} y {3,5}:


62 CAPITULO 4 SOLUCION PROPUESTA Eugenio Yolis

1 1 2 1 2

Pero en un agrupamiento no importa el nmero de cada grupo, sino slamente
cules objetos contiene cada uno, por lo que el siguiente cromosoma representa el
mismo agrupamiento:

2 2 1 2 1

4.1.1.2 Representacin por matriz
Este mtodo utiliza una matriz de n x k posiciones para representar un
agrupamiento de n objetos y k grupos. Cada celda i,j de la matriz contiene el valor 1 si
el elemento i se encuentra en el grupo j, o 0 en caso contrario [Bezdek et.al., 1994]. El
mismo agrupamiento utilizado en el ejemplo anterior estara representado por el
cromosoma
1 1 0 1 0
0 0 1 0 1

Y tambin por el cromosoma

0 0 1 0 1
1 1 0 1 0

4.1.1.3 Permutacin con separadores
En este esquema, un agrupamiento de n objetos en k grupos se representa por
una cadena de enteros en la que los valores de cada posicin representan el nmero de
objeto, y el grupo al que pertenece est dado por el orden en el que los objetos aparecen
en la cadena. Los objetos que pertenecen al mismo grupo se encuentran juntos, y se
utilizan los nmeros (n+1) al (n+k-1), que no son vlidos como nmeros de objetos,
para indicar la separacin entre los grupos. El agrupamiento del ejemplo se podra
codificar con cualquiera de los siguientes cromosomas (donde el nmero 6 actua como
separador):


1 2 4 6 3 5

3 5 6 1 2 4

4 1 2 6 3 5

4.1.1.4 Permutacines con bsquedas locales
Al igual que el mtodo de Permutacin con separadores, estos mtodos utilizan
una cadena de enteros, en el que cada valor representa el nmero de objeto, pero en este
caso no se utiliza ningn separador. Un agrupamiento de n objetos en k grupos se
representa mediante una cadena que contiene los n nmeros de elemento, ordenados
adecuadamente. Cuando se utilizan estas codificaciones, los cromosomas no representan
agrupamientos en forma directa, sino que debe emplearse un algoritmo de bsqueda
local para encontrar el agrupamiento representado. Estos algoritmos encuentran un
agrupamiento que es el mximo local para algn criterio determinado.
El ms simple de estos algoritmos, denominado Permutacin ambiciosa,
supone que los primeros k objetos son los centroides iniciales de los k grupos, y va
asignando cada uno de los elementos siguientes al grupo con el centroide ms cercano,
en forma similar a como funciona el algoritmo k-means. El agrupamiento del ejemplo
podra ser codificado por el cromosoma:

1 3 4 5 2

Suponiendo que el agrupamiento usado como ejemplo sea el mximo local para
esa bsqueda.
Estos mtodos tienen ciertas particularidades que deben tenerse en cuenta:
- Puede suceder que haya agrupamientos imposibles de codificar con estos
esquemas (que no se pueda encontrar una permutacin para la cual ese
agrupamiento sea el mximo local).
- Los algoritmos de bsqueda local ms comunes son del orden de (nk) o de
(n
2
k) [Cole, 1998].


4.1.2 Generacin de la poblacin inicial

Los cromosomas de la generacion inicial pueden ser agrupamientos al azar
[Jones et.al., 1991], o agrupamientos generados mediante alguna heurstica que aplique
conocimiento del dominio para formar grupos con algn criterio [Bezdek et.al., 1994].

4.1.3 Funcin de adaptacin

La funcin de adaptacin debe dar una medida de la calidad del agrupamiento
que representa el cromosoma, por lo que normalmente se usan las mismas funciones que
utilizan los algoritmos tradicionales como criterios de optimizacin [Cole, 1998].

4.1.4 Seleccin

En el captulo 2 (Estado del arte), seccin 2.7.4, se describen los distintos
operadores de seleccin que utilizan los algoritmos genticos. No se encuentran
operadores de seleccin especialmente adaptados al problema, en los trabajos previos
que aplicaron los algoritmos genticos a la categorizacin automtica.

4.1.5 Cruza

Se detallan los operadores de cruza utilizados habitualmente para la
representacin Numeracin de grupo (que es la que se utilizar en el algoritmo
propuesto).

4.1.5.1 Cruza monopunto y multipunto

Estos son los operadores de cruza clsicos, que suelen aplicarse a los
cromosomas que usan representacin binaria en los algoritmos genticos ms sencillos
[Goldberg, 1989]. Sin embargo, aplicados a la representacin de Numeracin de grupo,

estos mtodos presentan un problema denominado insensibilidad al contexto
[Falkenauer, 1999] . Este problema surge del hecho de que la cruza opera sobre los
cromosomas sin tener en cuenta qu es lo que estos cromosomas representan. Asi, el
cromosoma hijo tiene elementos de los cromosomas padres, pero el agrupamiento
representado por el hijo tiene muy poco (o nada) en comn con los agrupamientos
representados por los padres, como muestra el ejemplo siguiente:

Como los dos padres representan el mismo agrupamiento, con los grupos {1,2,4}
y {3,5}, se esperara que el hijo represente el mismo agrupamiento. Sin embargo
representa un agrupamiento distinto, que contiene los grupos {1,2,3,5} y {4}.
Una forma de intentar resolver el problema es renumerar los grupos de cada
padre en forma cannica (por ejemplo, de forma ascendente, de izquierda a derecha)
antes de realizar la cruza [Jones et.al., 1991]. En ese caso, los dos cromosomas padres
del ejemplo anterior seran idnticos. Sin embargo, hay casos en los cuales esto no es
suficiente:

1 1 2 1 2

2 2 1 2 1

1 1 1 2 1

1 2 3 3 3 3 1

1 1 2 2 2 2 3

1 2 3 3 2 2 3



En este caso, los cromosomas padres ya estn numerados en forma cannica. El
grupo {3,4,5,6} se repite en los dos padres, por lo que se esperara que pase al hijo sin
cambios. Sin embargo, en el agrupamiento resultante el grupo se ha dividido.

4.1.5.2 Cruza basada en las aristas
Este operador trabaja a nivel de agrupamiento, en lugar de hacerlo a nivel de
cromosoma [Jones et.al., 1991; Cole, 1998]. Por lo tanto, no sufre el problema de la
insensibilidad al contexto.
El algoritmo de cruza basada en las aristas sigue los siguientes pasos:
- Buscar las intersecciones no vacas de los grupos de cada padre. Estas
intersecciones son los grupos del agrupamiento hijo.
- Juntar estas intersecciones al azar hasta que el hijo tenga k grupos.

Por ejemplo, si uno de los padres es
1 2 3 3 3 3 1
Que contiene los grupos : { 1, 7 } , { 2 } , { 3, 4, 5, 6 }
Y el otro es
1 1 2 2 2 2 3
Que contiene los grupos : { 1, 2 } , { 3, 4, 5, 6 } , { 7 }

Las intersecciones no vacas entre los grupos sern:
{ 1 } , { 2 } , { 3, 4, 5, 6 } , { 7 }
Como son 4 intersecciones, y el hijo debe tener 3 grupos (al igual que los
padres), deben juntarse 2 de las intersecciones. Puede verse que en ningn caso el grupo
que es comn entre los dos padres puede dividirse.
Si juntamos las intersecciones { 2 } y { 7 }, el hijo ser
1 2 3 3 3 3 2

Sin embargo, si bien el operador es sensible al contexto, no aplica informacin
especfica del dominio para mejorar la calidad del hijo que est creando (por ejemplo,
no intenta juntar las intersecciones que contienen elementos ms similares entre si).

4.1.6 Mutacin

Los operadores de mutacin utilizados en la literatura funcionan en forma
anloga a los operadores de mutacin clsicos, cambiando elementos de grupo en forma
aleatoria en base a alguna probabilidad de mutacin [Jones et.al., 1991; Bezdek et.al.,
1994].

4.2 Algoritmo propuesto

En esta seccin se describe el algoritmo gnetico de categorizacin automtica
de documentos propuesto. Este algoritmo presenta un nuevo operador de cruza y cuatro
nuevos operadores de mutacin diseados especficamente para el problema de la
categorizacin automtica de documentos.
Para el diseo de los operadores se tuvieron en cuenta los siguientes puntos,
basados en las cuestiones planteadas en el captulo 3 (Descripcin del problema):
- Los operadores deben ser eficientes
- Los operadores deben ayudar a explorar el espacio de bsqueda
- Los operadores deben aplicar informacin del dominio para ayudar al
algoritmo a obtener soluciones de buena calidad

4.2.1 Representacin

La representacin elegida fue la Numeracin de grupo; este mtodo es el ms
frecuentemente utilizado en la literatura [Falkenauer, 1999].
Para elegir el mtodo de representacin se evaluaron los siguientes puntos:
- Que la representacin fuera sencilla e intuitiva,
- Que se pudiera implementar eficientemente la funcin de evaluacin,
- Que se pudieran implementar eficientemente los operadores.



Vector de elementos (1..N) : es el vector que contiene, para cada elemento, el
nmero de grupo al que pertenece
CantGrupos : es la cantidad de grupos que tiene el agrupamiento

Vector de
grupos
CantElementos : es la cantidad de
elementos que tiene el grupo
NroGrupo : es el nmero que identifica al
grupo
VecCentroide : es el centroide del grupo
4.2.2 Estructura del cromosoma

La estructura del cromosoma utilizado en el algoritmo propuesto es la siguiente:

La cantidad de grupos (CantGrupos) y el Vector de grupos no son estrictamente
necesarios, ya que todos los datos que contienen pueden obtenerse realizando
operaciones a partir de la informacin del vector de elementos. Sin embargo, como
estos datos se acceden muy frecuentemente, se incluyen en el cromosoma por razones
de eficiencia.

4.2.3 Generacion de la poblacin inicial

Para seleccionar el mtodo de generacin de la poblacin inicial se hicieron
diversas pruebas y se extrajeron las siguientes observaciones:
- El tamao de la poblacin requerido para que el algoritmo gentico
encuentre buenas soluciones es ms chico cuanto mejores sean los
agrupamientos de la poblacin inicial.
- Generar la poblacin inicial al azar es lo ms rpido, pero los agrupamientos
generados son de muy baja calidad, y lleva demasiadas generaciones al
algoritmo gentico llegar a buenas soluciones.
- Utilizando el algoritmo k-means (el ms rpido de los algoritmos conocidos
que dan soluciones aceptables) se obtienen buenas soluciones en
relativamente pocas generaciones, pero el proceso de generacin de la
poblacin inicial exige demasiado tiempo (an teniendo en cuenta que el

tamao de la poblacin inicial puede reducirse), ya que el algoritmo k-means
es del orden de (n.k).

Buscando una solucin intermedia, se decidi aplicar el algoritmo k-means para
generar los agrupamientos de la poblacin inicial, pero en lugar de formar k grupos, se
generan agrupamientos de log(k) grupos. De esta forma, la generacin de la poblacin
inicial lleva tiempos del orden de (n.log(k)). El algoritmo gentico tiene operadores que
se ocupan de ir dividiendo a los grupos para llegar a soluciones que tengan k grupos,
que se detallan ms adelante.

4.2.4 Funcion de adaptacin

Para el algoritmo propuesto se eligi la Similitud promedio del agrupamiento
como funcin de adaptacin. Esta funcin se detalla en el captulo 5 (Prueba
Experimental), seccin 5.2.2.1.

4.2.5 Seleccion

Para el algoritmo propuesto se utiliza el mtodo de Torneo, por los siguientes
motivos:
- Es independiente de la escala de la funcin de adaptacin,
- No requiere ordenar los valores de adaptacin de cada cromosoma,
- Permite regular la presin de seleccin.



4.2.6 Cruza

Dado que ninguno de los operadores de cruza encontrados en la literatura daba
solucin a las cuestiones planteadas en el captulo 3 (Descripcin del problema), se
dise un nuevo operador de cruza que cumpliera con las caractersticas buscadas.
El operador fue diseado con los siguientes lineamientos:
- La implementacin deba ser eficiente,
- El operador deba ser sensible al contexto,
- El operador deba aplicar informacin especfica del dominio para generar
agrupamientos de buena calidad.

4.2.6.1 Cruza Pasa Grupo

El operador diseado se denomina Cruza Pasa Grupos. El operador genera 2
hijos a partir de los padres. Primero asigna un rol a cada padre para generar el primer
hijo, y luego invierte los roles para generar el otro. La figura 4.1 muestra el esquema
bsico de funcionamiento del operador para generar uno de los hijos.

El agrupamiento de uno de los padres es copiado al hijo sin modificaciones, y
luego uno de los grupos del segundo padre se pasa al hijo, reacomodando los elementos
que hagan falta.

Padre que pasa
agrupamiento base
Padre que pasa grupo
Hijo
1 - Pasa agrupamiento 2 - Pasa grupo
Fig 4.1 - Esquema bsico del funcionamiento
del operador Cruza Pasa Grupo

Los pasos que sigue el algoritmo para generar cada uno de los hijos son:
1. Crear un cromosoma con el mismo agrupamiento que el primer padre (el
padre que pasa el agrupamiento),
2. Seleccionar un grupo fuente del segundo padre (el padre que pasa el grupo),
3. Seleccionar un grupo destino en el hijo, que va a transformarse en el grupo
del padre,
4. Reacomodar los elementos del hijo segn sea necesario para que el grupo
destino contenga los elementos que contiene el grupo fuente.

Paso 1 - Crear el cromosoma hijo
Este paso consiste simplemente en crear un cromosoma copiando los mismos
valores que contiene el padre que pasa el agrupamiento.

Paso 2 - Seleccin del grupo fuente
En este paso se selecciona un grupo del padre que pasa el grupo. Hay un
parmetro del algoritmo gentico que controla la probabilidad de que se elija el mejor
grupo (aquel con mayor similitud promedio) para pasarlo al hijo. En caso contrario, se
elige un grupo al azar para pasarlo al hijo. Este parmetro vara entre los valores 0,8 y
0,9 durante la ejecucin del algoritmo gentico, lo que quiere decir que en ms del 80%
de los casos, se elegir el grupo con mayor similitud promedio para pasarlo al hijo.

Paso 3 - Seleccin del grupo destino
En este paso se selecciona un grupo del hijo, al que se le quitarn y agregarn
elementos para que contenga los mismos elementos que contiene el grupo fuente. Hay
cuatro formas de seleccionar este grupo, cada una de ellas con cierta probabilidad:
a) El grupo ms similar (probabilidad 0,56): se busca en el hijo el grupo con el
centroide ms cercano al centroide del grupo fuente.
b) El grupo con ms elementos en comn (probabilidad 0,40): se busca en el
hijo el grupo con ms elementos en comn con el grupo fuente.
c) Menor similitud promedio (probabilidad 0,02): se busca en el hijo el grupo
que tenga la menor similitud promedio.
d) Al azar (probabilidad 0,02): se selecciona un grupo al azar del hijo.


Paso 4 - Reacomodamiento de los elementos del hijo
En este paso, se agregan y quitan elementos del grupo destino para que resulte
igual al grupo fuente. Los elementos que estn en el grupo fuente (en el padre) pero que
no estn en el grupo destino (en el hijo), se sacan del grupo en el que estn en el hijo, y
se agregan al grupo destino. Los elementos que estn en el grupo destino (en el hijo)
pero que no estn en el grupo fuente (en el padre), se quitan del grupo destino del hijo,
y se colocan en otro grupo. El grupo al que se reasigna cada uno de estos elementos se
elige de la siguiente forma:
a) Con probabilidad 0,95, se busca, dentro de los 2 grupos del hijo ms
similares al grupo fuente del padre, aquel que tenga el centroide ms cercano
al elemento que se est reasignando.
b) Con probabilidad del 0,05, se elige al azar el grupo al cual se mover el
elemento a reasignar.

4.2.6.2 Anlisis del operador Cruza Pasa Grupo

Sensibilidad al contexto
El operador copia el agrupamiento de uno de los padres al hijo, y despus le pasa
un grupo del otro padre. El hijo siempre heredar grupos de ambos padres. En el caso
de que ambos padres sean iguales, la forma de seleccionar el grupo destino asegura que
en el 96% de los casos el grupo destino ser el mismo que el grupo origen, y el hijo ser
igual a los padres. En las pruebas realizadas se observ que si no se dejaba ningn caso
librado al azar, el algoritmo exploraba el espacio de bsqueda en forma incompleta,
convergiendo en forma demasiado rpido a soluciones subptimas.

Utilizacin de informacin especfica del dominio
El operador no elige al azar qu grupo del padre pasar al hijo, sino que elige en
ms del 80% de los casos el grupo con mayor similitud promedio. As, durante la cruza
no slo se heredan caractersticas de los padres, sino que se intenta que estas
caractersticas sean deseables. En forma similar, cuando hay que reasignar un elemento
a otro grupo, en un 95% de los casos se busca una alternativa mejor que la eleccin al
azar del grupo destino, tratando de que el agrupamiento resultante sea de buena calidad.

4.2.7 Mutacin

Durante las pruebas realizadas se observ que los operadores de mutacin
clsicos retrasaban considerablemente la convergencia del algoritmo gentico, ya que lo
obligaban a explorar regiones del espacio de bsqueda al azar, donde la mayor parte de
las veces no se encontraban mejores soluciones. Al disear un algoritmo gentico que
pueda competir en trminos de eficiencia con los algoritmos especficos del dominio,
debe sacrificarse en parte la amplitud de la exploracin, restringindola a aquellas
regiones donde es ms probable que haya buenas soluciones.
Esto puede lograrse diseando operadores de mutacin que no hagan cambios
totalmente aleatorios, sino que, de la misma forma que el operador de cruza, tiendan a
hacer cambios que aumenten la calidad de las soluciones, dejando algunas pocas
decisiones libradas al azar. Estos operadores se aplicarn luego con probabilidades
bastante altas comparadas con las de los operadores de mutacin estndar, ya que son
necesarios no slo para la exploracin del espacio de bsqueda, sino tambien para el
aumento de la calidad de la poblacin. A continuacin se describen los 4 nuevos
operadores de mutacin diseados para el algoritmo propuesto.

4.2.7.1 Mutacin RefinarKM
Este operador de mutacin se aplica con una probabilidad que vara durante la
ejecucin del algoritmo gentico entre los valores 0,1 y 0,25. Cuando se muta un
cromosoma mediante este operador, se aplica al agrupamiento lo que se denomina
Refinamiento ligero, que es una modificacin del algoritmo k-means. El refinamiento
ligero consiste en una sla iteracin del algoritmo k-means. Pero para cada elemento, en
lugar de buscar entre los k grupos del agrupamiento aquel cuyo centroide sea ms
cercano al del elemento, la bsqueda se realiza entre 2*log(k) grupos seleccionados al
azar. De esta forma, en lugar de ser del orden de (n.k), la aplicacin del operador tiene
una complejidad del orden de (n.2.log(k)). El operador cumple con el doble propsito de
mejorar la calidad de la solucin, pero al mismo tiempo incluir el azar en las decisiones
para ampliar la exploracin del espacio de bsqueda.



4.2.7.2 Mutacin Refinar Selectivo
Este operador de mutacin se aplica con una probabilidad que vara durante la
ejecucin del algoritmo gentico entre los valores 0 y 0,3. Al aplicar este operador a un
cromosoma, se intenta mejorar la calidad de los mejores grupos del agrupamiento. Lo
que se busca es que el agrupamiento mutado tenga algunos grupos de muy buena
calidad que luego, si el cromosoma es seleccionado como padre, pasen al hijo. El
operador identifica los grupos con mayor y menor similitud promedio y luego recorre
los mejores grupos en busca de los elementos que estn ms alejados del centroide del
grupo. Esos elementos son removidos del grupo (lo que aumenta su similitud
promedio), y son reasignados a alguno de los grupos con menor similitud promedio (lo
que disminuye an ms su similitud promedio). El cromosoma resultante luego de la
mutacin puede no ser una buena solucin, pero va a tener algunos grupos de muy
buena calidad que podrn pasar a sus hijos en caso de ser seleccionado para la cruza.

4.2.7.3 Mutacin Join
Este operador de mutacin se aplica con probabilidad 1 a todos los cromosomas
que tengan ms de k grupos, y con una probabilidad que vara durante la ejecucin del
algoritmo gentico entre los valores 0,05 y 0,15 a los cromosomas que tengan k grupos.
La aplicacin de este operador a un cromosoma que tenga k grupos har que en la
iteracin siguiente se aplique el operador de mutacin Split, que se describe en la
seccin 4.2.7.4 (ya que el agrupamiento tendr k-1 grupos). El operador apunta a juntar
en un solo grupo dos grupos de mediana o mala calidad, con la esperanza de que el
operador de mutacin Split pueda armar grupos de mejor calidad, mejorando la
solucin. El operador elige dos grupos del agrupamiento, y junta en un slo grupo los
elementos de ambos.
El primero de los grupos puede ser seleccionado con alguno de estos criterios:
- Menor tamao (probabilidad 0,7): se selecciona el grupo con menor cantidad
de elementos.
- Menor similitud promedio (probabilidad 0,3): se selecciona el grupo con
menor similitud promedio.


El otro grupo se puede seleccionar con alguno de estos criterios:
- Ms similar (probabilidad 0,95): se selecciona el grupo con el centroide ms
cercano al del primer grupo elegido.
- Al azar (probabilidad 0,05): el segundo grupo se selecciona al azar.

4.2.7.4 Mutacin Split
Este operador de mutacin se aplica con probabilidad 1 a todos los cromosomas
que tengan menos de k grupos, y con una probabilidad que vara durante la ejecucin
del algoritmo gentico entre los valores 0,05 y 0,15 a los cromosomas que tengan k
grupos. Como en la generacin de la poblacin inicial los agrupamientos se generan con
log(k) grupos, este operador es necesario para que los agrupamientos lleguen a tener k
grupos. El operador selecciona un grupo y lo divide en 2. Si al cromosoma se le aplic
anteriormente el operador de mutacin Join, el grupo formado por este operador es el
que se divide. En caso contrario, el grupo a dividir puede ser seleccionado con alguno
de los siguientes criterios:
- Mayor tamao (probabilidad 0,90): se selecciona el grupo con la mayor
cantidad de elementos.
- Menor similitud promedio (probabilidad 0,05): se selecciona el grupo con la
menor similitud promedio.
- Al azar (probabilidad 0,05): el grupo a dividir es seleccionado al azar.
Una vez que se tiene el grupo a dividir, se lo divide en 2 aplicando a los
elementos del grupo la primera iteracin (fase inicial) del algoritmo k-means, con k = 2.

4.2.8 Insercin de los hijos en la poblacin

Se utiliza el mtodo de torneo invertido. Cada vez que se realiza la reproduccin,
se busca mediante ste mtodo dos cromosomas de la poblacin que son reemplazados
por los hijos recin generados.



4.2.9 Tamao de la poblacin

Los tamaos de poblacin utilizados en trabajos previos varan entre valores de
40 a 1000 individuos [Cole, 1998]. Se ha hecho notar [Estivill-Castro, 2000] que
tamaos de poblacin excesivamente grandes retrasan la convergencia del algoritmo
gentico, impidindole competir con otro tipo de mtodos. En las pruebas realizadas se
observ que partiendo de una poblacin de individuos de calidad medianamente
aceptable, y utilizando los operadores ya descriptos, al agrandar el tamao de la
poblacin se aumentaba la cantidad de generaciones requeridas para obtener buenas
soluciones, sin obtener mejoras apreciables en la calidad de las mismas. En el algoritmo
propuesto, se comienza con una poblacin inicial de 12 individuos, que luego
disminuye a 10 cuando se han completado el 40% de las generaciones previstas.

4.2.10 Criterio de terminacin

En las pruebas realizadas se observ que la calidad de la mejor solucin
aumentaba con cierto ritmo hasta un punto, para luego crecer muy lentamente hasta
alcanzar la convergencia. Esto es, una vez que se llegaba a una buena solucin, el
algoritmo requera una cantidad importante de generaciones hasta que todos los
cromosomas alcanzaban niveles cercanos de la funcin de adaptacin. Para evitar esa
espera, se decidi terminar la ejecucin del algoritmo gentico luego de una cantidad
fija de iteraciones. Experimentalmente se encontr el valor GEN_MAX = (N / 20) + 25.
Esto es, dada la cantidad de documentos a categorizar, se calcula la cantidad de
iteraciones que debe ejecutar el algoritmo gentico. Luego de llegar al nmero de
generaciones mximo, se selecciona como solucin al cromosoma con el mayor valor
de la funcin de adaptacin.


4.2.11 Algoritmo Gentico con refinamiento

Al igual que en el caso del algoritmo Bisecting K-Means con refinamiento,
esta variante consiste en refinar la solucin obtenida con el algoritmo gentico
propuesto utilizando el algoritmo K-Means estndar. El algoritmo propuesto no
garantiza que la solucin obtenida sea un mximo local para la funcin de optimizacin,
por lo que probablemente el refinamiento mejore la calidad de la solucin, ya que
encontrar el mximo local ms prximo al agrupamiento obtenido por el algoritmo
gentico.

Eugenio Yolis CAPITULO 5 - PRUEBA EXPERIMENTAL 79
Captulo 5
Prueba experimental

Este captulo describe las pruebas que se realizaron para evaluar la efectividad
de la solucin propuesta en el captulo 4. La seccin 5.1 describe los conjuntos de datos
utilizados. Los mismos fueron extrados de una coleccin reconocida como un estndar
dentro de la comunidad de investigadores dedicados a la categorizacin automtica de
documentos. En las secciones 5.2 y 5.3 se detalla la metodologa seguida en la
experimentacin. Se enumeran las variables que intervienen en los experimentos y los
distintos tipos de experimentos realizados. La seccin 5.4 presenta los resultados de la
experimentacin. La presentacin se hace en forma de grficos y para cada variable se
incluye adems el resultado del test estadstico realizado sobre los resultados. En la
seccin 5.5 se analizan brevemente los resultados, que luego se tratan con ms detalle
en el captulo 6.

5.1 Conjunto de datos utilizado

Para la realizacin de los experimentos, se utilizaron datos de la Coleccin de
Prueba para Categorizacin de Documentos Reuters 21578 [Lewis, 1997]. sta
coleccin se ha convertido en un estndar de facto dentro del dominio de la
categorizacin automtica de documentos y es utilizada por numerosos autores de la
materia [Joachims, 1998; Yang et.al., 2000; Steinbach et.al., 2000; Zhao et.al., 2001].
La bsqueda de Reuters 21578 en el ndice de recursos ResearchIndex/Citeseer
[Citeseer] (un sitio que se dedica a la publicacin on-line de bibliografa especializada
en las ciencias de la computacin), arroja alrededor de 80 documentos que la mencionan
o utilizan. Si se repite la bsqueda en el motor de bsqueda Google [Google], los
resultados traen cerca de 1.000 pginas web, entre las cuales se encuentran pginas de
productos comerciales que realizan categorizacin de documentos y que utilizan esta
coleccin para sus pruebas.

80 CAPITULO 5 PRUEBA EXPERIMENTAL Eugenio Yolis

Los documentos en la coleccin son noticias reales que aparecieron en cables de
la agencia Reuters durante 1987. Los documentos fueron recopilados y categorizados
manualmente por personal de la agencia y de la compaa Carnegie Group, Inc., en
1987. En 1990, la agencia entreg los documentos al Laboratorio de Recupero de
Informacin (Information Retrieval Laboratory) de la Universidad de Massachusetts.
Desde 1991 hasta 1996, la coleccin se distribuy bajo la denominacin Reuters
22173. En 1996, durante la conferencia ACM SIGIR (una de las reuniones ms
importantes en el campo de recupero de informacin y categorizacin de documentos),
un grupo de investigadores realiz un trabajo sobre esta coleccin con el objetivo de que
los resultados de distintos trabajos que utilizaran la coleccin fueran ms fciles de
comparar entre s [ACM SIGIR, 1996]. El resultado fue la distribucin 21578, que es la
que actualmente se utiliza en los trabajos sobre categorizacin automtica de
documentos para asegurar una metodologa de prueba uniforme. La coleccin se
compone de 21.578 documentos (cantidad que le da nombre a la misma), distribuidos en
22 archivos. Cada documento tiene 5 campos de categorizacin distintos: Valor
Bursatil, Organizacin, Persona, Lugar y Tema. En cada campo, el documento puede
tener un slo valor, varios, o ninguno.
Los criterios utilizados en esta tesis para medir la calidad de un agrupamiento
requieren que cada documento tenga solamente una categora asignada, por lo que para
los experimentos se decidi utilizar dos subconjuntos extraidos de esta coleccin
previamente utilizados por otros investigadores [Zhao et.al., 2001]. El procedimiento
seguido para extraer los subconjuntos fue tomar solamente los documentos que tenan
slamente un valor en el campo Tema, luego dividir los posibles valores del campo en
dos subconjuntos y asignar a cada documento al subconjunto correspondiente. Esto di
lugar a dos conjuntos de datos (re0 y re1), de 1504 y 1657 documentos respectivamente.
Las principales razones para usar estos documentos para las pruebas
experimentales fueron:
- La coleccin Reuters 21578 es un estndar para la prueba de algoritmos de
categorizacin, por lo que los resultados obtenidos tendrn mucha ms
validez que si los experiementos se realizaran sobre un conjunto de datos
recopilado sin seguir una metodologa estndar.

- En los subconjuntos re0 y re1 extraidos de esta coleccin [Zhao et.al., 2001]
ya se han filtrado aquellos documentos sin clasificar, o con ms de una
clasificacin (que complican innecesariamente la evaluacin de los
resultados) y son ms fciles de manipular que la coleccin completa.
- Los documentos de los subconjuntos re0 y re1 ya se han preprocesado
utilizando tcnicas estndar. Primero, se han removido de cada documento
las palabras comunes que no sirven para el proceso de categorizacin,
utilizando una stop list, y el resto de las palabras fueron llevadas a su raz
utilizando el algoritmo de Porter [Porter, 1980].

5.2 Variables a observar

Una vez que se obtienen los agrupamientos de documentos que arroja cada
algoritmo como salida, debe medirse cuantitativamente la calidad de cada uno para
poder compararlos.

5.2.1 Variables independientes

Los siguientes son los parmetros que pueden variarse con cada muestra de
datos y cada corrida de los algoritmos:
- Cantidad de documentos (N): es la cantidad de documentos que contiene la
muestra, y que se van a categorizar.
- Cantidad de grupos (K): es la cantidad de grupos que va a formar cada
algoritmo con los documentos de la muestra.



5.2.2 Variables dependientes

A continuacin se detallan las diversas medidas que se utilizaron para evaluar
los agrupamientos.

5.2.2.1 Similitud promedio
Esta es una medida interna, ya que puede evaluarse sin conocimentos externos
(no hace falta conocer la categorizacin real de los documentos). En el captulo 2
(Estado del arte), seccin 2.3, se describen las distintas formas de medir la similitud
entre dos documentos. Tal como se explica en esa seccin, el uso del coeficiente del
coseno extendido es uno de los ms difundidos, y es el que se utilizar para medir la
similitud entre dos documentos dados.
La similitud promedio (sim_prom) de un grupo es, justamente, la que surge de
promediar la similitud existente entre todos los documentos (d) del grupo tomados de a
pares. Por ejemplo, para el grupo j, que tiene n
j
elementos, utilizando el coeficiente del
coseno extendido como medida de similitud,

La similitud promedio de todo el agrupamiento se obtiene sumando la similitud
promedio de cada grupo multiplicada por la cantidad de elementos del grupo, y
dividiendo el total por la cantidad total de elementos de la muestra,

De esta manera se pondera la similitud promedio de cada grupo asignndole un
peso acorde con la cantidad de elementos que contiene. Esta ponderacin permite que
un grupo grande con baja similitud promedio impacte negativamente en la evaluacin
del agrupamiento y no sea compensado tan fcilmente por un grupo pequeo. Si no se
=
=
j
n
j
i
j i
j i
j
j
d d
d d
n
prom sim
1
1
2
*
1
_
N
prom sim n
prom sim
k
i j
j j
=
=
_ *
_

realizara esta ponderacin, una muestra de 1.000 documentos que se dividiera en un
grupo de 900 elementos con muy baja similitud promedio y 10 grupos compactos de 10
elementos cada uno, podra sumar mejor similitud promedio que un agrupamiento
balanceado de 11 grupos con buena similitud promedio en cada uno.
Esta medida da cuenta de cunto tienen en comn los elementos de cada grupo.
Cuanto ms homogeneo sea cada grupo, mayor valor tendr este parmetro. Valores
ms grandes de similitud promedio indican una mejor calidad del agrupamiento.

5.2.2.2 Entropa
La entropa es una medida externa (para calcularla es necesario conocer a qu
categora real pertenece cada documento). El concepto de entropa tiene su origen en
el campo de la fsica (ms especificamente, en el area de la termodinmica), y es
utilizada como medida del grado de desorden de un sistema [Carter, 2000]. En 1948,
Shannon [Shannon, 1948] incorpora el trmino a la teora de la informacin como una
funcin que mide la cantidad de informacin generada por un proceso.
Un ejemplo simple permitir entender qu es lo que mide la entropa y cmo
puede utilizarse para medir la calidad de un agrupamiento dado. Supngase que se tiene
un grupo con 1000 documentos de 8 categoras distintas. Una persona debe tomar cada
documento, y escribir un cdigo (en forma binaria) para describir la categora a la cual
pertenece. La forma ms simple de hacerlo sera escribir, para cada documento, el
nmero de la categora (de 0 a 7), en base 2. Para esto, necesitara 3 bits por cada
documento (en base 2 se requieren 3 bits para codificar los nmeros 0 a 7).
Supngase ahora que los documentos del grupo no pertenecen a cada categora
en cantidades iguales, sino que el 42% de los documentos son de la primer categora, el
40% son de la segunda categora, y el 18% restante pertenece a las otras 6 categoras en
cantidades iguales. La persona encargada de anotar la categora de cada documento
podra desarrollar una codificacin ms eficiente (la forma simple, descrita
anteriormente le insuma 3 bits por cada uno). Por ejemplo, podra adoptar el siguiente
cdigo:



CATEGORA
CDIGO PROBABILIDAD
0 00 42%
1 01 40%
2 1000 3%
3 1001 3%
4 1010 3%
5 1011 3%
6 1100 3%
7 1101 3%

Puede calcularse fcilmente, que, al utilizar solamente 2 bits en el 82% de los
casos, y 4 bits en el 18% de los casos restantes, estar utilizando en promedio 2,36 bits
por cada documento. Aplicada a una situacin como la descrita anteriormente, la
entropa mide justamente la mnima cantidad de bits promedio para codificar la
categora de cada documento del grupo.
Si se tienen h categoras y p
i
es la probabilidad de que un documento sea de la
categora i, la formula para calcular la entropa en una situacin como sta es,
=
=
h
i
i i
p p H
0
) log( * . La mxima entropa se obtiene cuando los documentos
pertenecen en cantidades iguales a las categoras (en ese caso, H = 3, que es el caso de
la codificacin en base 2 del nmero de categora). En el caso que se describe en la
tabla, el valor de H es aproximadamente 1,96, lo que indica que la codificacin elegida
no es la ptima. Cuanto ms desparejas sean las probabilidades, el valor de la entropa
ir disminuyendo. Si todos los documentos del grupo fueran de una sla categora, el
sistema estar totalmente ordenado, y la entropa ser igual a 0 (no har falta escribir de
qu categora es cada documento).
Para medir la calidad de un agrupamiento utilizando la entropa, primero se
calcula entropa de cada grupo. Para cada categora real i, se calcula la probabilidad
p
ij
de que un miembro del grupo j sea de la categora i,
j
ij
ij
n
n
p = , donde n
ij
es la
cantidad de documentos de la categora i que se encuentran en el grupo j y n
j
es la
cantidad de documentos del grupo j. La entropa de cada grupo se calcula usando la

frmula:
=
i
ij ij j
p p H ) log( * , donde i recorre todas las categoras reales de los
documentos.
La entropa total del agrupamiento se calcula luego ponderando la entropa de
cada grupo de acuerdo a su tamao,

La entropa tendr un valor mximo cuando los documentos de cada categora
estn distribuidos uniformemente entre los grupos, y un valor igual a 0 cuando cada
categora tenga sus documentos en un slo grupo. Valores ms chicos de entropa
indican una mejor calidad del agrupamiento.

5.2.2.3 Cantidad de operaciones
Esta medida no se relaciona con la calidad del agrupamiento obtenido, sino con
la eficiencia del algoritmo. La cantidad de operaciones da una medida de la complejidad
computacional del algoritmo [Wilf, 1986], ya que mide el esfuerzo computacional que
llev al algoritmo obtener el agrupamiento, en una escala que es independiente de los
recursos de hardware sobre los cuales se realizaron las pruebas (velocidad del
procesador, memoria, velocidad del disco, etc).
Las tres operaciones bsicas que se repiten en los algoritmos evaluados son:
- Multiplicacin de 2 vectores (para calcular la similitud entre los
documentos),
- Clculo de la norma de un vector (para calcular la similitud promedio de un
grupo se calcula la norma del centroide),
- Sumas de vectores (cuando se cambia un elemento de un grupo a otro deben
actualizarse los centroides).
Para simplificar las mediciones, se supuso que las 3 operaciones eran
equivalentes (multiplicar dos vectores lleva el mismo esfuerzo computacional que
sumar dos vectores o calcular la norma de un vector). Por la naturaleza de las
operaciones (todas iteran sobre los elementos de un vector realizando operaciones
N
H n
H
k
j
j j
=
=
1
*


algebraicas), es una aproximacin razonable. De todas maneras, alrededor del 90% de
las operaciones que realizan los algoritmos son multiplicaciones de vectores, por lo que
el error es despreciable. Lgicamente, un menor nmero de operaciones realizadas (para
resultados similares) indica una mayor eficiencia del algoritmo.

5.3 Realizacin de los experimentos

Los algoritmos que se compararon fueron:
- Bisecting K-Means con refinamiento (captulo 2, seccin 2.6).
- Algoritmo Gentico (captulo 4, seccin 4.2).
- Algoritmo Gentico con refinamiento (captulo 4, seccin 4.2.11)

5.3.1 Metodologa utilizada

Se realizaron dos tipos de experimentos. El primero consisti en tomar muestras
de datos con una cantidad de documentos fija, y realizar corridas de los algoritmos
variando la cantidad de grupos a formar. La segunda clase de experimentos consisti en
tomar muestras de datos con diferentes cantidades de documentos, y realizar corridas de
los algoritmos formando una cantidad fija de grupos. El anlisis estadstico de los
resultados (aplicando el test de Wilcoxon, que se detalla en el apndice 2) se realiz
sobre los resultados del primer tipo de experimentos, ya que sus valores son ms
facilmente comparables por provenir de corridas sobre muestras con la misma cantidad
de documentos. El segundo tipo de experimentos se utiliz para comprobar y validar las
conclusiones que se extrajeron del anlisis de los resultados del primer tipo de
experimentos.

5.3.1.1 Experimentos variando la cantidad de grupos
La forma ms simple de realizar los experimentos hubiera sido tomar cada
subconjunto (re0 y re1) como una muestra de datos, aplicar cada uno de los algoritmos a
evaluar, y comparar los resultados. Sin embargo, se hubieran obtenido slamente dos

conjuntos de resultados, lo que hubiera hecho muy dificil un anlisis estadstico de los
mismos. El rendimiento de los algoritmos se hubiera comparado basndose solamente
en la categorizacin de dos muestras, que podran haber sido casos favorables para
alguno de ellos, quitndole validez a las conclusiones.
Con el objetivo de obtener resultados que fueran vlidos desde un punto de vista
estadstico, tratando de minimizar las probabilidades de que un caso particular favorable
a uno u otro algoritmo influyera en los resultados en forma excesiva, se prepararon las
muestras de datos de la siguiente manera: de cada subconjunto de datos (re0 y re1) se
extrajeron 10 muestras de 500 documentos al azar, y se realizaron 5 corridas de cada
algoritmo sobre cada muestra. De esta manera, los resultados particulares que no
reflejan el comportamiento estadstico de los algoritmos tienen menos posibilidades de
distorsionar los resultados.
Para cada una de las muestras de datos, se obtuvieron agrupamientos de 5, 10, 15
y 20 grupos con cada algoritmo y se calcularon las medidas de evaluacin para cada
uno. El procedimiento se repiti 5 veces, yse promediaron las medidas de evaluacin de
las 5 iteraciones. Esto di como resultado 20 tablas (una para cada muestra de datos),
con las medidas de evaluacin de cada algoritmo para los agrupamientos de 5, 10, 15 y
20 grupos. Promediando los valores de las 20 tablas, se construy una tabla de
promedios generales, con el valor promedio de cada medida de evaluacin para cada
algoritmo, para los agrupamientos de 5, 10, 15 y 20 grupos.
Para la confeccin de los grficos, se utiliz la tabla de promedios generales.
Para la realizacin del test de Wilcoxon, se utilizaron los valores cada una de las 20
tablas, ya que cada una de ellas se corresponde a una muestra de datos.

5.3.1.2 Experimentos variando la cantidad de documentos
Se tomaron muestras al azar de 400, 700, 1000 y 1300 documentos del primer
conjunto de datos (re0). Para cada tamao se tomaron 3 muestras de datos, y se
realizaron 5 corridas de cada algoritmo, formando agrupamientos de 10 grupos. Para la
confeccin de los grficos se promediaron los valores para las 5 corridas de cada
algoritmo sobre cada muestra de datos.



5.3.2 Parmetros utilizados por el algoritmo gentico

En el Apndice 1 se detallan las experiencias realizadas para obtener todos los
valores de los parmetros utilizados por el algoritmo.
Los valores utilizados para los parmetros ms importantes son:
- Generaciones: se vari la cantidad de generaciones de acuerdo con la
cantidad de documentos a categorizar segn la formula descripta en el
captulo 4 (Solucin Propuesta). Para un tamao de muestra de 500
documentos, esta frmula indica que deben ejecutarse 50 generaciones.
- Tamao de poblacin:
- Generacin 1 a 20: 12 individuos
- Generacin 20 a 50: 10 individuos
- Probabilidad de aplicar el operador de mutacin Refinar KM:
- Generacin 1 a 40: 10%
- Generacin 40 a 50: 25%
- Tamao y presin selectiva del torneo:
- Generacin 1 a 10: tamao 2, presin 75%


5.4 Resultados
5.4.1 Experimentos variando la cantidad de grupos

En esta seccin se presentan los resultados que se obtuvieron en los
experimentos realizados variando la cantidad de grupos. Para seguir el comportamiento
de cada una de las variables independientes al ir variando la cantidad de grupos, se
confeccionaron grficos con los promedios generales para cada algoritmo. En cada
grfico, el eje x representa la cantidad de grupos en que se fueron dividiendo las
muestras de datos con los algoritmos. El eje y representa la variable independiente
que se mide en cada grfico. El ttulo del grfico lleva el nombre de la variable
independiente. Los valores que se grafican son los promedios generales para cada
algoritmo.
Adems, se utiliz el test de Wilcoxon sobre cada una de las variables para
obtener un anlisis estadstico de los resultados.


Similitud Promedio
0,08
0,1
0,12
0,14
0,16
0,18
0,2
5 10 15 20
Cant. Grupos
Bisecting KM Ref
Genetico
Genetico Ref

La figura 5.1 muestra la similitud promedio de los agrupamientos encontrados
en funcin de la cantidad de grupos armados. La curva de resultados del algoritmo
Gentico se encuentra ligeramente por encima de la curva del algoritmo Bisecting K-
Means con refinamiento, mientras que la curva para el algoritmo Gentico con
refinamiento supera claramente a la del algoritmo Bisecting K-Means con
refinamiento. Esta apreciacin es consistente con los resultados que arroja el test de
Wilcoxon para esta variable (que se detalla en el apndice 2). Tomando en cuenta los
resultados de las 20 muestras, el test permite afirmar con un margen de confianza del
95% que el promedio de valores de similitud promedio para el algoritmo Bisecting K-
Means con refinamiento es inferior al de los otros 2 algoritmos.
Fig 5.1
Similitud promedio de los agrupamientos encontrados en funcin de la cantidad de grupos.

Entropa
1,2
1,3
1,4
1,5
1,6
1,7
1,8
1,9
5 10 15 20
Cant. Grupos
Bisecting KM Ref
Genetico
Genetico Ref

La figura 5.2 muestra la entropa de los agrupamientos encontrados en funcin
de la cantidad de grupos armados. Las curvas de resultados de los algoritmos
Gentico y Bisecting K-Means con refinamiento son bastante similares, y tienen
diferencias en uno y otro sentido que no permiten afirmar que una sea mejor que la otra,
mientras que la curva para el algoritmo Gentico con refinamiento est claramente
por debajo de ambas. Esta apreciacin es consistente con los resultados que arroja el test
de Wilcoxon para esta variable. Tomando en cuenta los resultados de las 20 muestras, el
test no puede distinguir si los valores de entropa son diferentes para los algoritmos
Gentico y Bisecting K-Means con refinamiento, mientras que permite afirmar con
un grado de confianza de 95% que los valores para el algoritmo Gentico con
refinamiento son menores que para el algoritmo Bisecting K-Means con
refinamiento.
Fig 5.2
Entropa de los agrupamientos encontrados en funcin de la cantidad de grupos.


Cant. Operaciones
60000
80000
100000
120000
140000
160000
180000
200000
5 10 15 20
Cant. Grupos
Bisecting KM Ref
Genetico
Genetico Ref

La figura 5.3 muestra la cantidad de operaciones realizada por los algoritmos en
funcin de la cantidad de grupos armados. Se ve claramente que los valores para el
algoritmo Gentico estn muy por debajo que los del algoritmo Bisecting K-Means
con refinamiento, mientras que para el algoritmo Gentico con refinamiento se
encuentran en una posicin intermedia, tambien claramente por debajo del algoritmo
Bisecting K-Means con refinamiento. Esta apreciacin es consistente con los
resultados que arroja el test de Wilcoxon para esta variable. Tomando en cuenta los
resultados de las 20 muestras, el test permite afirmar con un margen de confianza del
95% que el promedio de operaciones realizadas por el algoritmo Bisecting K-Means
con refinamiento es superior en ms de un 40% a las realizadas por el algoritmo
Gentico y en ms de un 15% a las realizadas por el algoritmo Bisecting K-Means
con refinamiento.

Fig 5.3
Cantidad de operaciones realizadas por los algoritmos en funcin de la cantidad de grupos.

5.4.2 Experimentos variando la cantidad de documentos

Se grafic la evolucin de las variables independientes para cada algoritmo al
variar la cantidad de documentos a agrupar con el fin de comprobar si su
comportamiento segua las tendencias encontradas durante la realizacin del primer tipo
de experimento. En cada grfico, el eje x representa la cantidad de documentos de las
muestras que se agruparon. El eje y representa los valores de la variable
independiente que se est graficando. Cada grfico lleva como ttulo el nombre de la
variable independiente que se grafica.

Similitud promedio
0,154
0,156
0,158
0,16
0,162
0,164
0,166
0,168
0,17
0,172
300 500 700 900 1100 1300
Bisecting KM Ref
Genetico Ref
Genetico

La figura 5.4 muestra la evolucin de la similitud promedio de los
agrupamientos encontrados al variar la cantidad de documentos. Puede observarse que
se confirma la tendencia encontrada. La curva de similitud promedio para el algoritmo
Bisecting K-Means con refinamiento se encuentra por debajo de las curvas para los
algoritmos Gentico y Gentico con refinamiento.

Fig 5.4
Similitud promedio de los agrupamientos encontrados en funcin de la cantidad de documentos.


Entropa
1,36
1,38
1,4
1,42
1,44
1,46
1,48
1,5
1,52
1,54
1,56
300 500 700 900 1100 1300
Bisecting KM Ref
Genetico Ref
Genetico

La evolucin de la entropa con la cantidad de grupos (figura 5.5) muestra el
mismo comportamiento observado en el primer tipo de experimento, aunque en este
grfico la entropa para los agrupamientos encontrados por el algoritmo Gentico es
menor que para el algoritmo Bisecting K-Means con refinamiento, aunque esto puede
deberse a particularidades de las muestras utilizadas, ya que el anlisis estadstico
realizado con los resultados del primer tipo de experimento no permitan afirmar esto.

Fig 5.5
Entropa de los agrupamientos encontrados en funcin de la cantidad de documentos.

Cant. Operaciones
50000
100000
150000
200000
250000
300000
350000
400000
450000
500000
550000
300 500 700 900 1100 1300
Bisecting KM Ref
Genetico Ref
Genetico

La cantidad de operaciones en funcin de los documentos a agrupar (figura 5.6)
sigue la tendencia esperada, siendo el algoritmo Bisecting K-Means con refinamiento
el que requiere mayor cantidad de operaciones, seguido por el algoritmo Gentico con
refinamiento y quedando el algoritmo Gentico en tercer lugar.

Fig 5.6
Cantidad de operaciones realizadas por los algoritmos en funcin de la cantidad de documentos.


5.5 Anlisis de los resultados

A partir de los grficos y el anlisis estadstico de los resultados, pueden
responderse en base a los resultados experimentales las cuestiones 1 y 2 planteadas en el
captulo 3 (Descripcin del problema).

Los resultados experimentales demuestran que si, ya que los algoritmos
Gentico y Gentico con refinamiento encuentran soluciones de igual o mayor
calidad que el algoritmo Bisecting K-Means con refinamiento tomado como
referencia, requiriendo una menor cantidad de operaciones para lograrlo.

calidad?
Los resultados muestran que las soluciones encontradas por los algoritmos
Gentico y Gentico con refinamiento son de mayor calidad que las halladas con el
algoritmo Bisecting K-Means con refinamiento tomado como referencia, para las
medidas de calidad definidas.

Eugenio Yolis CAPITULO 6 - CONCLUSIONES 97
Captulo 6
Conclusiones

En esta tesis se propone una adaptacin de un algoritmo gentico al problema de
la categorizacin automtica de documentos, que incluye el diseo de un nuevo
operador de cruza y cuatro operadores de mutacin. Los resultados experimentales
obtenidos confirman la tesis que los algoritmos genticos son una poderosa herramienta
para la resolucin de problemas en los cuales el espacio de soluciones es amplio y la
funcin de optimizacin es compleja.
Se ha encontrado tambien que, tal como lo han afirmado otros autores
[Falkenauer, 1999; Estivill-Castro, 2000], los algoritmos genticos no son un mtodo de
solucin universal de problemas, sino un paradigma que debe adaptarse correctamente
al problema a resolver. El algoritmo propuesto logra resultados efectivos porque en el
diseo del mismo se han adaptado los conceptos que aplican los algoritmos genticos y
se han creado nuevos operadores especficos para el problema a resolver.

Respuesta a las cuestiones planteadas

Los resultados presentados en el captulo 5 muestran que el algoritmo gentico
propuesto encuentra soluciones de mejor calidad que el algoritmo Bisecting K-Means
con refinamiento, requiriendo una menor cantidad de operaciones para lograrlo. La
explicacin a este hecho debe buscarse en la forma que tienen de explorar el espacio de
posibles agrupamientos tanto el algoritmo Bisecting K-Means como el algoritmo
gentico propuesto. Se ha mostrado en el captulo 3 (Descripcin del problema), por
qu la forma de explorar el espacio de soluciones del algoritmo Bisecting K-Means es
subptima.

98 REFERENCIAS Eugenio Yolis

El algoritmo Gentico, al crear nuevos grupos (o modificar los existentes) con
cualquiera de sus operadores, no descarta de inmediato ninguno de ellos, aunque sean
malas soluciones. Los malos agrupamientos se van eliminando ms tarde mediante el
operador de seleccin. Mientras tanto, esos agrupamientos pueden ser seleccionados
para su cruza con otros, momento en el cual tienen la oportunidad de pasar alguna de
sus caractersticas positivas a uno de sus hijos. Es el operador de cruza el que permite al
algoritmo Gentico obtener su solucin en forma ms eficiente, ya que puede
aprovechar las buenas caractersticas de cada una de las variaciones que se fue
realizando, por lo que prcticamente ningn trabajo es desperdiciado.

calidad?
Las soluciones halladas por el algoritmo gentico propuesto son de mayor
calidad (de acuerdo a las medidas definidas) que las del algoritmo Bisecting K-Means
con refinamiento, segn lo muestran los resultados expuestos en el captulo 5. El
algoritmo Bisecting K-Means no puede llegar a ninguna solucin que le obligue a
pasar por un punto en el que disminuya el criterio de optimizacin (siempre elige la
divisin que ms hace crecer el criterio de optimizacin). Esto hace que haya regiones
del espacio de bsqueda a las que le pueda resultar difcil llegar.
Por otra parte, el algoritmo Gentico es capaz de generar soluciones de menor
calidad como parte del proceso, y extraer caractersticas positivas de ellas. De esta
manera, el algoritmo gentico nunca se encuentra restringido a una regin del espacio
de bsqueda. Los elementos de azar que intervienen en la cruza y la mutacin pueden
llegar a generar agrupamientos en cualquier punto del espacio de bsqueda. La figura
6.1 ilustra ste concepto. La figura muestra un espacio de bsqueda unidimensional
(simplificacin necesaria para que se lo pueda graficar en forma simple), en la que la
curva representa el valor del criterio de optimizacin para cada punto.

Eugenio Yolis CAPITULO 6 - CONCLUSIONES 99
La figura muestra con smbolos cuadrados dos posibles agrupamientos entre los
cuales debe elegir el algoritmo Bisecting K-Means. Este algoritmo elegir la solucin
con mayor valor para el criterio de optimizacin, y esto puede tener como consecuencia
que se encuentre una solucin subptima, ya que tal vez la regin con el mximo ms
alto nunca se explore. Los smbolos triangulares representan los posibles miembros de
la poblacin del algoritmo gentico. Si los operadores del algoritmo gentico generaran
el agrupamiento graficado con lnea punteada, este agrupamiento pasara a formar parte
de la poblacin (an cuando existan soluciones mejores), dndole al algoritmo gentico
la posibilidad de explorar esa regin.

Cuestin 3: De qu manera puede definirse la representacin de las soluciones y el
operador de cruza para que el algoritmo gentico pueda ser aplicado a la categorizacin
automtica de documentos de acuerdo a la hiptesis de los bloques constructores?
Esta cuestin se responde en las secciones 4.2.1 y 4.2.6.1, que detallan la
representacin utilizada en el algoritmo propuesto y el operador de cruza Cruza Pasa
Grupo diseado para trabajar sobre esa representacin. Este operador de cruza asegura
que se transfieran caractersticas significativas entre los miembros de la poblacin,
llevando a que el algoritmo gentico opere dentro de la hiptesis de los bloques
constructores.
Fig 6.1
Comparacin de la exploracin de los algoritmos Bisecting K-Means con refinamiento y Gentico.



Cuestin 4: De qu manera pueden disearse los operadores del algoritmo gentico
para hacer uso del conocimiento especfico del dominio?
Los 5 nuevos operadores presentados como parte de la solucin propuesta (el
operador de cruza y los 4 operadores de mutacin, que se detallan en las secciones
4.2.6.1 y 4.7) dan respuesta a esta cuestin. Estos operadores hacen uso de esta
informacin para guiar la bsqueda del algoritmo gentico por regiones donde haya ms
posibilidades de encontrar soluciones de buena calidad.

Eugenio Yolis REFERENCIAS 101
Referencias

ACM SIGIR. (1996). Proceedings of the 19th annual international ACM SIGIR
conference on Research and development in information retrieval, ACM
Press, New York, USA.

Allen, R. B., Obry, P. y Littman, M. (1993). An interface for navigating clustered
document sets returned by queries, Proceedings of the ACM Conference on
Organizational Computing Systems.

Anderberg, Michael R. (1973). Cluster analysis for Applications. Academic Press, New
York.

Bezdeck, J. C., Boggavaparu, S., Hall, L. O. y Bensaid, A. (1994). Genetic algorithm
guided clustering, in Proc. of the First IEEE Conference on Evolutionary
Computation, 3440.

Boley, D., Gini, M., Gross, R., Eui Hong, H., Hastings, K., Karypis, G., Kumar, V.,
Mobasher, B., Moore, J. (1999). Partitioning-based clustering for Web
Document Categorization. Decision Support Systems, volumen 27, nmero
3, pginas 329-341.

Box, G.E.P., Hunter, W.G., Hunter, J.S. (1978). Statistics for experimenters: An
introduction to design, data analysis and model building. John Wiley and
Sons, New York.

Bradley, P.S. y Fayyad, U.M. (1998). Refining initial points for k-means clustering. In
J. Shavlik, editor, Proceedings of the Fifteenth International Conference on
Machine Learning (ICML '98), pages 91--99, San Francisco, CA, 1998.
Morgan Kaufmann

Canavos, G.C. (1984). Probabilidad y estadstica, Aplicaciones y Mtodos. McGraw-
Hill.

Carter, T. (2000). An introduction to information theory and entropy. Complex Systems
Summer School.

Clerking, P., Cunningham, P., Hayes, C. (2001). Ontology Discovery for the Semantic
Web Using Hierarchical Clustering. Department of Computer Science,
Trinity College, Dublin.

Citeseer (Research Index). The NEC Research Institute Digital Library. Sitio dedicado a
la difusin de literatura cientfica. http://citeseer.nj.nec.com/.



Cole, Rowena M. (1998). Clustering with Genetic Algorithms. Thesis for the degree of
Master of Science, Department of Computer Science, University of Western
Australia.

Croft, W. B. (1978). Organizing and searching large files of documents, Ph.D. Thesis,
University of Cambridge.

Cutting, D. R., Karger, D. R., Pedersen, J. O. y Tukey, J. W. (1992). Scatter/Gather: A
cluster-based approach to browsing large document collections,
Proceedings of the 15
th
International ACM SIGIR Conference on Research
and Development in Information Retrieval, Pginas 318-29.

Dash, M., y Liu, H. (2001). Efficient Hierarchical Clustering Algorithms Using
Partially Overlapping Partitions. Pacific-Asia Conference on Knowledge
Discovery and Data Mining, pginas 495-506.

Davis, L. (1991). Handbook of Genetic Algorithms. New York. Van Nostrand Reihold.

De Jong, K.A. (1975). An analysis of the behavior of a class of genetic adaptive
systems. Dissertation Abstracts International 36 (10), 514B. University of
Michigan, Microfilm No. 76-9381.

Dunlop, M.D. y Van Rijsbergen, C. J. (1991). Hypermedia and free text retrieval.
RIA091 Conference, Barcelona.

Duran, B. S. y Odell, P. L. (1974). Cluster Analysis: A survey. Berlin. Springer-Verlag.

Estivill-Castro, V. (2000). Hybrid Genetic Algorithms Are Better for Spatial Clustering.
Pacific Rim International Conference on Artificial Intelligence, pages 424-
434.

Estivill-Castro, V. y Murray, A. (1997). Spatial Clustering for Data Mining with
Genetic Algorithms. FIT, Technical Report, 97-10.

Everitt, Brian S. (1993). Cluster analysis. Halsted Press, 3ra edicin.

Falkenauer, Emanuel. (1999). Evolutionary Algorithms: Applying Genetic Algorithms to
Real-World Problems. Springer, New York, Pag 65--88.

Faloutsos, Christos y Oard, Douglas W. (1995). A survey of Information Retrieval and
Filtering Methods. Technical Report CS-TR3514, Dept. of Computer
Science, Univ. of Maryland.

Fasulo, Daniel. (1999). An analysis of recent work on clustering algorithms. Technical
Report #01-03-12, Dept. of Computer Science & Engineering, University of
Washington.


Goldberg, David E. (1989). Genetic Algorithms - in Search, Optimization and Machine
Learning. Addison-Wesley Publishing Company, Inc.

Google. Motor de bsqueda de pginas en internet. http://www.google.com/.

Guha, S., Rastogi, R., y Shim, K. (1998). CURE: An efficient clustering algorithm for
large databases. In Proceedings of 1998 ACM-SIGMOD International
Conference on Management of Data.

Hall, L.O., Ozyurt, B. y Bezdek, J.C. (1999). Clustering with a genetically optimized
approach. IEEE Trans. On Evolutionaty Computation, 3, 2, 103-112.

Han, J., Kamber, M. y Tung, A.K.H. (2001). Spatial clustering methods in data mining:
A survey. Geographic Data Mining and Knowledge Discovery, H. Miller
and J. Han, editors, Taylor and Francis.

Hearst, Marti A. y Pedersen, Jan O. (1996). Reexaminig the Cluster Hypothesis:
Scatter/Gather on Retrieval Results. Proceedings of ACM SIGIR 96,
Zurich.

Hilera, J.R. y Martnez, V.J., (1995). Redes Neuronales Artificiales. Fundamentos,
Modelos y Aplicaciones. Editorial Ra-Ma, Serie Paradigma, Madrid.

Holland, J. H. (1975). Adaptation in natural and artificial systems. Ann Arbor: The
University of Michigan Press.

Honkela, T., Kaski, S., Lagus, K., y Kohonen, T. (1996). Newsgroup exploration with
WEBSOM method and browsing interface. Technical Report A32, Helsinky
University of Technology, Laboratory of Computer and Information
Science.

ISO/IEC 2382-1:1993 Information technology -- Vocabulary --. Part 1: Fundamental
terms

Jain, A. K., Murty, M.N., y Flinn, P.J. (1999). Data Clustering: A review. ACM
Computing Surveys, Vol. 31, Nro 3, Septiembre 1999.

Joachims, T. (1998). Text Categorization with Support Vector Machines: Learning with
Many Relevant Features. Proceedings of ECML-98, 10th European
Conference on Machine Learning, Springer Verlag, Heidelberg, DE.

Johnson, A., Fotouhi, F. (1996). Adaptive Clustering of Hypermedia Documents.
Information Systems, Vol. 21, No. 6, pp. 459.

Jones, D. R. y Beltramo, M. A. (1991) Solving partitioning problems with genetic
algorithms. Proceedings of the fourth International Conference on Genetic
Algorithms, pages 442-449.



Jones, G., Robertson, A.M., Santimetvirul, C. y Willet, P. (1995). Non-hierarchical
document clustering using a genetic algorithm. Information Research, an
electronic journal, Vol 1, No 1, April, 1995.

Kaufmann, Leonard y Rousseeuw, Peter J. (1990). Finding Groups in data: An
introduction to Cluster Analysis, John Wiley & Sons, Inc., NY.

Karipys, G., Han, E.H., Kumar, V. (1999). CHAMELEON: A hierarchical clustering
algorithm using dynamic modeling, IEEE Computer: Special Issue on Data
Analysis and Mining, 32(8), 68-75.

Kohonen, T. (1982). Self-organized formation of topologically correct feature maps,
Biological Cybernetics, 43 : 59-69.

Koza, John R. (1997). Genetic Programming. Cambridge : M.I.T. Press.

Krovetz, R. (1993). Viewing morphology as an inference process. In Proceedings of
ACM-SIGIR93, pages 191--203

Leousky, A. V. y Croft, W. B. (1996). An evaluation of techniques for clustering search
results, Technical Report IR-76, Department of Computer Science,
University of Massachusetts, Amherst.

Lewis, D. (1991). Evaluating text categorization, Proceedings of the Speech and
Natural Language Workshop, Asilomar, Morgan.

Lewis, D. (1997). Reuters-21578 text categorization test collection,
http://www.daviddlewis.com/resources/testcollections/reuters21578/
http://kdd.ics.uci.edu/databases/reuters21578/reuters21578.html.

Liu, G.L. (1968). Introduction to combinatorial mathematics, McGraw Hill.

Maarek, Yoelle S., Fagin, Ronald, Ben-Shaul, Israel Z. y Pelleg, Dan. (2000).
Ephemeral Document Clustering for Web Applications. IBM Research
Report RJ 10186.

Macskassy, S.A., Banerjee, A., Davison, B.D., Hirsh, H. (2001). Human performance
on clustering web pages. Technical Report DCS-TR-355, Department of
computer Science, Rutgers, State University of New Jersey.

Mahfouz, S.Y., Toropov, V.V., Westbrook, R.K. (2000). Modification, tunning and
testing of a GA for structural optimization problems. Department of Civil
and Environmental Engineering, University of Bradford, UK.

Miller, B.L., Goldberg, D.E. (1995). Genetic algorithms, Selection Schemes and the
Varying Effects of Noise, IlliGAL report No. 95009.


McQueen, J. (1967). Some methods for classification and analysis of multivariate
observations, 5-th Berkeley Symposium on mathematics, Statistics and
Probability, 1, S. 281-298.

Myers, R.H., Montgomery, D.C. (1995). Response surface methodology: process and
product optimization using designed experiments. John Wiley and Sons,
New York.

Painho, M. y Bao, F. (2000). Using Genetic Algorithms in Clustering Problems.
Proceedings of the 5th International Conference on GeoComputation,
University of Greenwich, United Kingdom.

Pentakalos, O., Menasc, D. y Yesha, Y. (1996). Automated Clustering-Based
Workload Characterization. 5th NASA Goddard Mass Storage Systems and
Technologies Conference.

Porter, M. F., (1980). An Algorithm for Suffix Stripping, Program, vol.14, no. 3, 130-
137, 1980

Qin He, (1996). A review of clustering algorithms as applied in IR, UIUCLIS-
1996/6+IGR, University of Illinois at Urbana-Champaign.

Raghavan, V. V. y Birchard, K. (1978). A clustering strategy based on a formalism of
the reproductive process in natural systems. Proceedings of the 2
nd

International Conference on Research and Development in Information
Retrieval. 10-22.

Raghavan, V., Bollmann, P., y Jung, G. (1989). A critical investigation of recall and
precision as measures of retrieval system performance. ACM Transactions
on Information Systems, 7(3):205--229.

Rasmussen, E. (1992). Clustering Algorithms, W. B. Frakes and R. Baeza-Yates,
editors, Information Retrieval, Pginas 419-442. Prentice Hall, Eaglewood
Cliffs, N. J.

Rger, S. M. R. y Gauch, S. E. (2000). Feature reduction for document clustering and
classification. Technical report, Computing Department, Imperial College,
London, UK.

Sarle, W.S., ed. (1997) Neural Network FAQ, part 1 of 7: Introduction, actualizacin
peridica al grupo de noticias de Usenet comp.ai.neural-nets,
ftp://ftp.sas.com/pub/neural/FAQ.html

Schtze, Hinrich y Silverstein Craig (1997) Projections for Efficient Document
Clustering, in Proceedings of ACM/SIGIR97, pp.74-81.

Shannon, C.E. (1948) A mathematical theory of communication, Bell System Technical
Journal, vol. 27, pp. 379-423 and 623-656, July and October.


Steinbach, M., Karypis, G., y Kumar, V. (2000). A comparison of Document Clustering
Techniques. Technical Report #00-034. University of Minnesota. In KDD
Workshop on Text Mining.

Strehl, A., Ghosh, J. y Mooney, R. (2000). Impact of Similarity Measures on Web-page
Clustering. AAAI-2000: Workshop of Artificial Inteligence for Web
Search.

Trocine, L., Malone, L.C. (2000). Finding important independent variables through
screening designs: a comparison of methods. Proceedings of the 2000
Winter Simulation Conference, University of Central Florida, Orlando,
U.S.A.

Unal, R., Dean E.B. (1991). Taguchi approach to design optimization for quality and
cost: an overview, 1991 International Conference of the International
Society of Parametric Analysts.

Van Rijsbergen, C. J. (1979). Information Retrieval, Butterworths, London, 2da edicin.

Webster, P.G. (2002). Design of experiments in the Mbius Modeling Framework,
Thesis presented for the degree of Master of Science in Electrical
Engineering, University of Illinois.

Wilf, H.S. (1986). Algorithms and Complexity, Prentice Hall.

Willet, P. (1998). Recent trends in hierarchical document clustering: a critical review.
Information Processing and Management. 24:577-97.

Yang, Y. (1997). An evaluation of statistical approaches to text categorization. School
of Computer Science, Carnegie Mellon University, CMU-CS-97-127.

Yang, Y. y Liu, Xin, (1999). A re-examination of text categorization methods. 22nd
Annual International SIGIR.

Yang, Y. y Pedersen J., (1997). A comparative study on feature selection in text
categorization. Proc. of the 14th International Conference on Machine
Learning ICML97, pginas 412 - 420.

Zamir, Oren y Etzioni, Oren. (1998). Web Document Clustering: A feasibility
demonstration. Proceedings of ACM/SIGIR98.

Zamir, Oren y Etzioni, Oren. (1999). Grouper: A Dynamic Clustering Interface to Web
Search Results. Proceedings of the Eighth International World Wide Web
Conference, Computer Networks and ISDN Systems.


Zhao, Y. y Karypis, G., (2001). Criterion Functions for Document Clustering.
Technical Report #01-40, Department of Computer Science, University of
Minnesota.

Zervas, Giorgio y Rger, Stefan. (2000).The curse of dimensionality and document
clustering. Dept. of Computing, Imperial College, England.


Eugenio Yolis APNDICE 1 - DETERMINACIN DE PARMETROS 109
Apndice 1
Determinacin de parmetros para el algoritmo

Este apndice detalla las pruebas realizadas para determinar los valores de cada
uno de los parmetros utilizados por el algoritmo gentico.

A1.1 Parmetros a determinar

En esta seccin se enumeran los parmetros del algoritmo gentico, con la
descripcin de la funcin que cada uno cumple en el mismo. Para cada parmetro se
indica el rango de valores posibles que puede tomar. El rango de variacin de cada
parmetro se defini tomando en cuenta la naturaleza del mismo, o en base a pruebas
preliminares realizadas durante el diseo del algoritmo gentico.

A1.1.1 generacionesMximo
Este parmetro especifica el nmero fijo de generaciones que se ejecutar el
algoritmo gentico. El valor de este parmetro debe ser dependiente de la cantidad de
documentos que se van a agrupar. Lo que debe determinarse es la frmula para calcular
el nmero de generaciones en funcin de la cantidad de documentos.
A1.1.2 poblacionTamao
Este parmetro indica el nmero de cromosomas en la poblacin. El posible
rango de valores es de 10 a 50 cromosomas.
A1.1.3 torneoTamao
Este parmetro determina el tamao del torneo para el operador de seleccin.
Los valores para este parmetro pueden variar entre 2 y 4.

110 APNDICE 1 - DETERMINACIN DE PARMETROS Eugenio Yolis

A1.1.4 torneoProbMejor
Este parmetro especifica la probabilidad con la cual se elige al mejor individuo
del torneo en el operador de seleccin. Su valor puede variar entre 0.6 y 1.
A1.1.5 cruzaPasaGrupoProbMejor
Este parmetro indica la probabilidad de que, en el operador de cruza, el grupo
con mayor similitud promedio del padre que pasa el grupo se incluya en el hijo. Su
valor puede variar entre 0.6 y 1.
A1.1.6 mutacionRefinarKMProb
Este parametro especifica la probabilidad de aplicar el operador de mutacin
Refinar KM a cada hijo generado por el operador de cruza. El posible rango de
valores es de 0 a 0.15.
A1.1.7 mutacionRefinarSelectivoProb
Este parametro especifica la probabilidad de aplicar el operador de mutacin
Refinar Selectivo a cada hijo generado por el operador de cruza. El posible rango de
valores es de 0 a 0.1.

A1.2 Metodologa utilizada

Existen numerosas tcnicas para la realizacin de experimentos tendientes a la
determinacin de parmetros de un sistema [De Jong, 1975; Box et.al., 1978; Unal
et.al., 1991; Mahfouz et.al., 2000; Trocine et.al., 2000; Webster, 2002]. A continuacin
se describe la metodologa adoptada en esta tesis. Para poder observar la variacin del
rendimiento del algoritmo gentico cuando se modifica el valor de alguno de sus
parmetros, se realizaron pruebas sobre muestras de datos seleccionadas al azar. Todas
las muestras utilizadas (excepto las utilizadas para determinar la cantidad de
generaciones) fueron de 500 documentos. En todos los experimentos realizados se
formaron conjuntos de 10 grupos.


Los experimentos para cada parmetro consistieron en hacer que el parmetro
estudiado tomara distintos valores, dejando fijo el valor de los otros parmetros. Los
parmetros que no se estaban evaluando se fijaron en un valor igual al promedio de los
extremos de sus rangos de valores. Esta metodologa se denomina un factor a la vez
(en ingls: one factor at a time) y suele usarse para observar cmo afecta a un sistema
la modificacin de uno de sus parmetros [Myers et.al., 1995; Webster, 2002]. Si bien
no permite percibir los efectos de comportamiento causados por la variacin combinada
de ms de un parmetro, da una buena nocin de la sensibilidad del sistema con
respecto a cada uno de sus parmetros.
Durante la ejecucin del algoritmo gentico, se tom el promedio de la funcin
de adaptacin para los cromosomas de la poblacin cada 5 generaciones, y se
confeccionaron curvas con la evolucin de la aptitud promedio de la poblacin en
funcin del nmero de generacin. En cada grfico se incluy una curva para cada valor
del parmetro evaluado.
A continuacin se listan los valores utilizados para cada parmetro en los
experimentos que no lo involucraban:
- poblacionTamao : 30
- torneoTamao : 3
- torneoProbMejor : 0.8
- cruzaPasaGrupoProbMejor : 0.8
- mutacionRefinarKMProb : 0.1
- mutacionRefinarSelectivoProb : 0.05



A1.3 Resultados

A1.3.1 generacionesMximo
Se realizaron experimentos con muestras de datos tomadas al azar conteniendo
400, 700, 1000 y 1300 documentos, y se grafic la evolucin de la aptitud promedio de
la poblacin en funcin del nmero de generacin para cada tamao de muestra.

Cantidad de documentos
0,05
0,07
0,09
0,11
0,13
0,15
0,17
0 50 100 150 200
Generacin
A
p
t
i
t
u
d

p
r
o
m
e
d
i
o
400 700 1000 1300 generacionesMximo

Puede observarse que la evolucin de las curvas es similar. Todas presentan un
crecimiento relativamente rapido en las primeras generaciones. Luego, la tasa de
crecimiento decrece paulatinamente y la aptitud promedio de la poblacin tiende a
estabilizarse (la poblacin converge). Como se describe en el captulo 4 (Solucin
propuesta), seccin 4.2.10, se busca detener al algoritmo gentico antes de la
Fig A1.1
Aptitud promedio en funcin del nmero de generacin para distintas cantidades de documentos.

convergencia, ya que esta toma demasiado tiempo. En el grfico se incluye una lnea
que corta a cada curva en el punto donde se observa que el crecimiento comienza a ser
lento. Se encuentra experimentalmente que la funcin:
generacionesMaximo = (N / 20) + 25
donde N es la cantidad de documentos a categorizar, es una buena aproximacin
de esta lnea.

A1.3.2 poblacionTamao

poblacionTamao
0,06
0,08
0,1
0,12
0,14
0,16
0,18
0 50 100 150 200
Generacin
A
p
t
i
t
u
d

p
r
o
m
e
d
i
o
10 20 30 40

Se observa que la evolucin de la aptitud promedio no presencia variaciones
significativas para los distintos tamaos de poblacin en el primer tramo de la curva.
Cuando la velocidad de evolucin decrece, la mayor diversidad de material gentico
presente en las poblaciones ms grandes hace que stas continen evolucionando
Fig A1.2
Aptitud promedio en funcin del nmero de generacin para distintos tamaos de poblacin.


(aunque muy lentamente), mientras que las poblaciones de pocos individuos convergen
rapidamente.
Para elegir el tamao de la poblacin a utilizar, se tuvieron en cuenta los
siguientes puntos:
- El algoritmo gentico se detendr antes de la convergencia de la poblacin, y
en esa parte de la curva la evolucin es similar para todos los tamaos de
poblacin.
- El tamao de la poblacin impacta significativamente en la cantidad de
operaciones que requiere el algoritmo para llegar a una solucin, ya que la
generacin de cada individuo de la poblacin inicial insume una cantidad de
operaciones considerable.
En el algoritmo propuesto, se comienza con un tamao de poblacin de 12
individuos, que se reduce a 10 una vez que han transcurrido el 40% de las generaciones
previstas. Se encontr experimentalmente que esta reduccin en el tamao de la
poblacin aceleraba ligeramente la convergencia del algoritmo sin afectar la calidad de
la solucin obtenida.


A1.3.3 torneoTamao

torneoTamao
0,06
0,08
0,1
0,12
0,14
0,16
0,18
0 50 100 150 200
Generacin
A
p
t
i
t
u
d

p
r
o
m
e
d
i
o
2 3 4

El comportamiento observado es el que podra esperarse a travs de un anlisis
terico del impacto de este parmetro. Tamaos de torneo ms grandes resultan en una
presin selectiva mayor, que acelera la evolucin de la poblacin hasta cierto punto,
pero provoca una convergencia prematura de la poblacin hacia una solucin
subptima. En el algoritmo propuesto se utiliza un tamao de torneo igual a 2 hasta que
transcurre el 20% de las generaciones previstas, que luego se cambia al valor 3. De esta
forma, se asegura que la presin selectiva al inicio (cuando hay ms peligro de que
soluciones mediocres dominen la poblacin) sea pequea, para luego acelerar la
velocidad de evolucin en forma moderada.
Fig A1.3
Aptitud promedio en funcin del nmero de generacin para distintos tamaos de torneo.


A1.3.4 torneoProbMejor

torneoProbMejor
0,06
0,08
0,1
0,12
0,14
0,16
0,18
0 50 100 150 200
Generacin
A
p
t
i
t
u
d

p
r
o
m
e
d
i
o
0.6 0.8 1

Se observa que este parmetro tiene un impacto sobre la presin selectiva, que es
an mayor que el del parmetro anterior (tamao del torneo). Una presin selectiva
demasiado pequea (valor igual a 0.6) no hace evolucionar a la poblacin, mientras que
si es demasiado alta (valor igual a 1), se produce la convergencia prematura. El valor de
0.8 produce los mejores resultados. El algoritmo propuesto utiliza para este parmetro
un valor igual a 0.75 hasta que transcurre el 40% de las generaciones previstas, luego se
aumenta el valor a 0.8 hasta llegar al 80% de las generaciones, donde se vuelve a
aumentar a 0.85 para las generaciones restantes. De esta manera, se va acelerando
progresivamente la velocidad de evolucin del algoritmo.
Fig A1.4
Aptitud promedio en funcin del nmero de generacin para distintos valores del parmetro
probTorneoMejor.

A1.3.5 cruzaPasaGrupoProbMejor

cruzaPasaGrupoProbMejor
0,06
0,08
0,1
0,12
0,14
0,16
0,18
0 50 100 150 200
Generacin
A
p
t
i
t
u
d

p
r
o
m
e
d
i
o
0.6 0.8 1

Un valor de 0.6 para este parmetro resulta demasiado pequeo y provoca una
involucin de la poblacin, ya que en un 40% de los casos el grupo que pasa al hijo es
seleccionado al azar, lo que puede ocasionar que los hijos sean soluciones de peor
calidad que los padres. Los valores de 0.8 y 1 presentan curvas de evolucin similares.
En el algoritmo propuesto se utiliza un valor de 0.8 hasta que transcurre el 80% de las
generaciones previstas, y luego se aumenta este valor a 0.9, para acelerar la
convergencia en la fase final.
Fig A1.5
cruzaPasaGrupoProbMejor.


A1.3.6 mutacionRefinarKMProb

mutacionRefinarKMProb
0,06
0,08
0,1
0,12
0,14
0,16
0,18
0 50 100 150 200
Generacin
A
p
t
i
t
u
d

p
r
o
m
e
d
i
o
0.05 0.1 0.15

Puede observarse que el operador de mutacin Refinar KM es de suma
importancia para la evolucin de la poblacin, ya que (como se detalla en el captulo 4)
utiliza conocimiento especfico del dominio para mejorar la calidad de las soluciones.
Una probabilidad de 0.05 es demasiado baja para este operador, y la poblacin no
alcanza soluciones de buena calidad. Con probabilidades de 0.1 0.15 se obtienen
buenos resultados. En el algoritmo propuesto se utiliza un valor de 0.1 para este
parmetro hasta que transcurre el 80% de las generaciones previstas, y luego se aumenta
el valor a 0.25. De esta forma, en la fase final del algoritmo, cuando la evolucin es ms
lenta, se apunta a mejorar la calidad de las soluciones utilizando este operador.
Fig A1.6
mutacionRefinarKMProb.

A1.3.7 mutacionRefinarSelectivoProb

mutacionRefinarSelectivoProb
0,06
0,08
0,1
0,12
0,14
0,16
0,18
0 50 100 150 200
Generacin
A
p
t
i
t
u
d

p
r
o
m
e
d
i
o
0 0.05 0.1

Puede observarse que la aplicacin de este operador puede ser nociva para la
evolucin de la poblacin. Para un valor de probabilidad de 0.1, el algoritmo gentico
no alcanza soluciones aceptables. Tal como se describe en el captulo 4 este operador
suele formar unos pocos grupos con gran similitud promedio, aunque reduciendo la
calidad general de la solucin mutada. Si se lo utiliza desde el inicio de la evolucin,
cada vez que se aplica reduce la calidad del agrupamiento que muta, impidiendo que el
algoritmo alcance soluciones de buena calidad. En el algoritmo propuesto, se lo utiliza
solamente sobre el final del algoritmo (en el ltimo 20% de las generaciones) con
probabilidad 0.3. En esta fase, casi todas las soluciones son de la misma calidad y este
operador permite obtener material gentico no presente en las soluciones.

Fig A1.7
mutacionRefinarSelectivoProb.

Eugenio Yolis APNDICE 2 - ANLISIS ESTADSTICO 121
Apndice 2
Anlisis estadstico de los resultados

Este apndice detalla el anlisis estadstico hecho sobre los resultados que se
exponen en el captulo 5, y que soportan las afirmaciones realizadas en la seccin 5.4
(Resultados) de ese captulo. Las nociones tericas de probabilidad y estadstica
fueron extradas principalmente de [Canavos, 1984], pero son las mismas que pueden
encontrarse en cualquier texto relativo al tema.

A2.1 Prueba de hiptesis estadsticas

En todas las ramas de la ciencia, cuando un investigador hace una afirmacin
con respecto a un fenmeno (que puede estar basada en su intuicin, o en algn
desarrollo terico que parece demostrarla), debe luego probar la misma mediante la
realizacin de experimentos. La experimentacin consiste en armar un ambiente de
prueba en el que ocurra el fenmeno (o buscarlo en el ambiente real), y tomar
mediciones de las variables involucradas. Luego, se realizan anlisis estadsticos de los
resultados para determinar si los mismos confirman la afirmacin realizada.
Una hiptesis estadstica es una afirmacin con respecto a una caracterstica
desconocida de una poblacin de inters. La esencia de probar una hiptesis estadstica
es el decidir si la afirmacin se encuentra apoyada por la evidencia experimental que se
obtiene a travs de una muestra aleatoria. Supngase, por ejemplo, que los fabricantes
de tubos de luz marca ACME estn teniendo problemas en el mercado debido a algunos
casos de mala calidad de sus productos. Para recuperar su prestigio, hacen la siguiente
afirmacin: El promedio de vida til de los tubos de luz marca ACME es de 500
horas. Y encargan a una firma independiente que haga una serie de experimentos para
contrastar esta afirmacin con esta otra: El promedio de vida til de los tubos de luz
marca ACME es menor a 500 horas.

122 APNDICE 2 - ANLISIS ESTADSTICO Eugenio Yolis

A la afirmacin promedio = 500 se la llama hiptesis nula, y se escribe como:
H
0
: promedio = 500
A la afirmacin promedio < 500 se la llama hiptesis alternativa, y se escribe
como:
H
1
: promedio < 500
La hiptesis nula debe considerarse verdadera a menos que exista suficiente
evidencia en su contra. Es decir, se rechazar la afirmacin de que la vida til promedio
es de 500 horas slo si la evidencia experimental se encuentra muy en contra de sta
afirmacin. En caso contrario, no se podr rechazar la afirmacin basndose en la
evidencia experimental. Debe notarse que no poder rechazar la afirmacin no es lo
mismo que aceptarla. El caso es anlogo al de un juicio, donde hay un sospechoso
acusado de un crimen: si la evidencia es suficiente, se lo declarar culpable. De lo
contrario, se dir que la evidencia no alcanza para demostrar su culpabilidad.
Existen entonces dos posibles decisiones con respecto a la hiptesis nula:
rechazarla no poder rechazarla. A su vez, la hiptesis nula puede ser verdadera o falsa.
Esto deja cuatro posibles escenarios:
Se denomina a a la probabilidad de cometer un error de tipo I, y a la
probabilidad de cometer un error de tipo II. Los valores de a y son interdependientes.
Para cada experimento, al disminuir uno de ellos, aumenta el otro. El error de tipo I se
considera ms grave que el de tipo II (volviendo a la analoga con el juicio, se prefiere
dejar ir a un culpable y no condenar a un inocente), por lo que el procedimiento seguido
habitualmente consiste en fijar un valor pequeo para a (por ejemplo, 5%), y luego
tratar de minimizar lo ms que se pueda.

Rechazar H
0
Cuando H
0
es
verdadera
(error Tipo I)

Cuando H
0

es falsa
No poder
Rechazar H
0
Cuando H
0
es
verdadera
Cuando H
0

es falsa (error
Tipo II)

A2.2 El test de Wilcoxon para la comparacin de
medias de muestras apareadas

A2.2.1 Introduccin

Existen numerosos mtodos para la prueba de hiptesis estadsticas. El hecho de
que cada uno de ellos pueda aplicarse a una situacin en particular depende de los
siguientes factores:
- La cantidad de mediciones realizadas;
- La naturaleza de los valores a analizar (si son valores en un intervalo
numrico, si son categoras cualitativas, si son del tipo SI/NO, etc);
- El grado de dependencia existente entre las mediciones.
Los experimentos realizados para comparar los algoritmos de categorizacin
automtica de documentos, son un caso que se denomina de muestras apareadas, en el
cual se miden variables numricas. Para estos casos, el test de Wilcoxon es el ms
apropiado [Canavos, 1984]. El trmino muestras apareadas se refiere a que las
mediciones realizadas no son independientes, sino que son tomadas de a pares (la
muestra de datos 1 es categorizada con los algoritmos 1 y 2). Esto hace que lo que deba
analizarse sean las diferencias que existen en cada par de valores, que es precisamente
lo que hace el test de Wilcoxon.

A2.2.2 Descripcin del test

Los experimentos para comparar dos algoritmos de categorizacin, con respecto
a una medida de calidad, se realizan de la siguiente forma:
- Se toman N muestras de datos,
- Se categorizan las muestras de datos con ambos algoritmos,
- Se mide una variable numrica que indica la calidad del agrupamiento.


Luego de la realizacin de los experimentos, se confecciona una tabla que tiene
la siguiente forma (ejemplo para 4 muestras):

Muestra Algoritmo 1 Algoritmo 2 Diferencia
(1 -2)
Ranking Ranking con
signo
1 0,79 0,80 -0,01 1 -1
2 0,46 0,51 -0,05 4 -4
3 0,91 0,87 0,04 3 3
4 0,23 0,25 -0,02 2 -2

Como se ve, los valores pueden tener grandes variaciones de muestra a muestra,
pero lo que importa es la diferencia entre los valores de cada algoritmo para cada
muestra, ya que eso es lo que indicar el mejor o peor rendimiento de cada uno.
La hiptesis nula que es puesta a prueba es que el promedio de los valores es
igual para los dos algoritmos (es decir, que las calidades de los agrupamientos
producidos es equivalente). Se plantean dos hiptesis alternativas, una de ellas afirma
que el promedio de los valores es mayor para el algoritmo 1, y la otra que el promedio
de los valores es mayor para el algoritmo 2.
La metodologa del test es la siguiente:
- Se calculan las diferencias de los valores para cada muestra,
- Luego, se asigna a cada diferencia un valor en un ranking (de menor a
mayor) en base a su valor absoluto,
- Por ltimo, a cada valor del ranking se le asigna el signo de la diferencia que
le di origen.
Se denomina T+ a la suma de los valores positivos y T- a la suma de los
negativos. Si no hubiera diferencias entre los algoritmos, es de esperar que T+ resulte
igual a T- (en valor absoluto). Para muestras lo suficientemente grandes (N > 15), la
variable T+ puede aproximarse por medio de una distribucin normal con media E(T+)
y varianza Var(T+), donde
4
) 1 (
) (
+
= +
N N
T E
24
) 1 2 )( 1 (
) (
+ +
= +
N N N
T Var

Luego, si se define la transformacin

La variable zT+ tiene una distribucin normal estndar (media igual a 0 y
varianza igual a 1). El valor del parmetro a determina los lmites mnimo y mximo
para el valor observado de zT+, ms all de los cuales se rechaza la hiptesis nula. Si el
valor de zT+ es superior al lmite mximo, se aceptar la hiptesis alternativa de que el
promedio de valores para el algoritmo 1 es mayor que para el algoritmo 2. Si el valor de
zT+ es inferior al lmite mnimo, se aceptar la hiptesis alternativa de que el promedio
de valores para el algoritmo 2 es mayor que para el algoritmo 1.

A2.3 Aplicacin del test a los resultados

Tal como se describe en el captulo 5, seccin 5.3.1 (Metodologa Utilizada),
se utilizaron 20 muestras de datos. Cada una de ellas se proces con cada algoritmo para
producir agrupamientos de 5, 10, 15 y 20 grupos. Esto da un total de 20 * 4 = 80
mediciones realizadas, por lo que N = 80. El valor de a utilizado es de 5%, a = 0,05.
Esto quiere decir que, en los casos en que rechazemos la hiptesis nula y aceptemos
alguna hiptesis alternativa, el test nos dar un 95% de confianza.
Teniendo N y a, quedan definidos los lmites mnimo y mximo para zT+, que
son respectivamente -1,645 y 1,645. Para cada variable se compar al algoritmo
Bisecting K-Means con refinamiento con los algoritmos Gentico y Gentico con
refinamiento.

) (
) ( ) (
+
+ +
= +
T Var
T E T
zT


A2.3.1 Similitud promedio

Debe recordarse que valores ms grandes para la similitud promedio indican una
mejor calidad del agrupamiento.

A2.3.1.1 Bisecting K-Means con refinamiento contra Gentico
Valor de zT+ observado: -4,812
Consecuencia: Debe rechazarse la hiptesis nula y aceptarse la hiptesis
alternativa de que los valores para el algoritmo Gentico son mayores que para el
algoritmo Bisecting K-Means con refinamiento.

A2.3.1.2 Bisecting K-Means con refinamiento contra Gentico con
refinamiento
alternativa de que los valores para el algoritmo Gentico con refinamiento son
mayores que para el algoritmo Bisecting K-Means con refinamiento.


A2.3.2 Entropa

Debe recordarse que valores ms chicos para la entropa indican una mejor
calidad del agrupamiento.

Consecuencia: No puede rechazarse la hiptesis nula de que los valores son
iguales para los dos algoritmos.

refinamiento
Valor de zT+ observado: 4,713
alternativa de que los valores para el algoritmo Gentico con refinamiento son
menores que para el algoritmo Bisecting K-Means con refinamiento.



A2.3.3 Cantidad de operaciones

Para la variable Cantidad de operaciones se cambi la hiptesis nula, ya que el
objetivo no es demostrar slamente que la cantidad de operaciones es menor (esto es
evidente viendo las grficas del captulo 5), sino que la diferencia es considerable.

La hiptesis nula se reformul de la siguiente forma: La cantidad de
operaciones para el algoritmo Bisecting K-Means con refinamiento es un 40% mayor
que para el algoritmo Gentico. Las hiptesis alternativas se reformularon para
afirmar que la diferencia era todava mayor que el 40%, que no llegaba a ser del 40%.
Para realizar el test en estas condiciones, slamente se requiri multiplicar la cantidad
de operaciones del algoritmo Gentico por 1,4 y realizar el test de la forma habitual.
alternativa de que la diferencia es todava mayor que el 40%.

refinamiento
La hiptesis nula se reformul de la siguiente forma: La cantidad de
operaciones para el algoritmo Bisecting K-Means con refinamiento es un 15% mayor
que para el algoritmo Gentico con refinamiento. Las hiptesis alternativas se
reformularon para afirmar que la diferencia era todava mayor que el 15%, que no
llegaba a ser del 15%. Para realizar el test en estas condiciones, slamente se requiri
multiplicar la cantidad de operaciones del algoritmo Gentico con refinamiento por
1,15 y realizar el test de la forma habitual.
alternativa de que la diferencia es todava mayor que el 15%.

Eugenio Yolis APNDICE 3 - MANUAL DE USO 129
Apndice 3
Manual de Uso

Este apndice contiene la documentacin de los programas y conjuntos de datos
que se incluyen en el CD que acompaa el presente trabajo. Estos programas hacen
posible la realizacin de los experimentos y la evaluacin de los resultados.
La seccin A3.1 describe el esquema de procesamiento, explicando la funcin de
cada componente en el proceso de experimentacin. La seccin A3.2 identifica la
ubicacin de cada uno de los componentes en la estructura de directorios del CD. La
seccin A3.3 explica cmo debe configurarse el origen de datos ODBC para que los
programas puedan acceder a la base de datos de datasets. La seccin A3.4 detalla el
formato de los archivos que contienen los conjuntos de datos utilizados. En la seccin
A3.5 se explica cmo utilizar el programa que genera subconjuntos de datos a partir de
los archivos que contienen la coleccin completa. La seccin A3.6 contiene la
documentacin del programa de agrupamiento. ste programa es el que implementa los
algoritmos de agrupamiento descriptos durante el trabajo y permite utilizarlos para
agrupar los documentos de los subconjuntos de datos. La seccin A3.7 describe el
programa que, a partir de la salida generada por el programa de agrupamiento, evala
las soluciones generadas y proporciona los valores para las distintas medidas de calidad.


130 APNDICE 3 - MANUAL DE USO Eugenio Yolis

A3.1 Esquema de procesamiento

La figura A3.1 muestra grficamente la forma en la que interacta cada uno de
los componentes del proceso. Los archivos re0 y re1 son los conjuntos de datos
extrados de la coleccin Reuters 21578, que se describe en el captulo 5. El formato de
estos archivos se detalla en la seccin A3.3.

Conjuntos de
datos (re0 y re1)
Base de datos de
datasets (MDB)
Programa
Armar Datasets
Subconjuntos de
datos (re0_1,
re0_2, etc)
Programa
AGDocClus
Agrupamientos
Programa
Evaluar Agrupamientos
Planilla excel con
los resultados
Fig. A3.1: Esquema de procesamiento

El primer paso consiste en generar subconjuntos de datos que contengan
elementos (elegidos al azar) de estos archivos. Estos subconjuntos de datos se generan
en la forma de archivos con el mismo formato que los conjuntos originales, y adems se
guardan en la base de datos de datasets. El programa Armar Datasets es el que hace
este trabajo. Luego, los archivos conteniendo cada subconjunto son procesados por el
programa que realiza los agrupamientos (AGDocClus). Este programa genera
archivos de salida que contienen la informacin de los agrupamientos. A continuacin,
el programa Evaluar Agrupamientos toma como entrada los agrupamientos generados
y los datos de cada subconjunto de la base de datos de datasets para armar una planilla
excel con los resultados (los valores de las medidas de calidad para cada agrupamiento).



A3.2 Estructura de directorios del CD

A continuacin se describe el contenido de cada uno de los directorios que se
encuentran en el CD.

Directorio Raiz
Tesis
Este directorio contiene los documentos que componen el presente
trabajo.
Conjuntos de datos
Este directorio contiene los archivos de los conjuntos re0 y re1.
Subconjuntos de datos
Este directorio contiene subdirectorios para cada uno de los subconjuntos
utilizados. En cada subdirectorio se encuentran los archivos del
subconjunto, y los agrupamientos encontrados por cada uno de los
algoritmos evaluados.
Base de datos
Este directorio contiene la base de datos de datasets.
Armar Datasets
Este directorio contiene el cdigo fuente y el ejecutable compilado del
programa que genera los subconjuntos de datos al azar.
AGDocClus
programa que implementa los algoritmos de agrupamiento estudiados en
el trabajo.
Evaluar Agrupamientos
programa que calcula las medidas de calidad para los agrupamientos
generados.
Resultados
Este directorio contiene las planillas excel con los resultados de los
experimentos realizados.

A3.3 Configuracin del origen de datos ODBC

Para que los programas Armar Datasets y Evaluar Agrupamientos puedan
acceder a la base de datos de datasets, debe configurarse un origen de datos ODBC en el
sistema. A continuacin se explica cmo realizar esta configuracin en Windows 98. La
configuracin para otras versiones de Windows puede variar levemente.

A3.3.1 Copiar el archivo MDB

El archivo bdDataSets.mdb, ubicado en el directorio Base de datos del CD,
debe copiarse al disco rgido de la PC. El archivo puede copiarse en cualquier directorio
del disco. Como ejemplo, se supondr que se copia en el directorio C:\Tesis\BD.

A3.3.2 Agregar el origen de datos ODBC

Para completar este paso, debe abrirse el Panel de Control de Windows, y
seleccionar la opcin ODBC Data Sources (32bit), como se muestra en la figura A3.2.

Fig. A3.2: Panel de
control de Windows


Luego debe seleccionarse la solapa System DNS y presionar el botn Add...,
como se muestra en la figura A3.3.

Debe seleccionarse el driver de conexin Microsoft Access Driver (*.mdb),
como se muestra en la figura A3.4.

Fig. A3.3: Agregar
un DNS de sistema
Fig. A3.4: Seleccin
del driver a utilizar

Luego debe configurarse el origen de datos ODBC para utilizar el archivo MDB
que se copi al disco en el paso descripto en la seccin A3.3.1, de la forma que muestra
la figura A3.5. En la figura se utiliza el nombre bdReuters2 para el origen de datos. Se
recomienda el uso de este nombre, ya que es el que tienen configurado por defecto los
programas que acceden a la base de datos.

Fig. A3.5:
Configuracin del
origen de datos


A3.4 Formato de los archivos de datos

Como se describe en el captulo 5, los archivos de datos utilizados no son
documentos de texto sino dos conjuntos de datos preprocesados extrados de la
coleccin Reuters 21578. Cada uno de los conjuntos de datos (llamados re0 y re1), se
compone de 3 archivos, que llevan como nombre de archivo el nombre del conjunto de
datos, con extensiones .mat, .mat.clabel y .mat.rclass. Para el conjunto de datos
re0, por ejemplo, los 3 archivos son:
- re0.mat
El archivo .mat contiene 1 linea de encabezado, y luego 1 lnea por
cada documento del conjunto de datos.
La lnea de encabezado tiene 3 nmeros. El primero de ellos es la
cantidad de documentos que tiene el conjunto de datos. El segundo es la
cantidad de trminos distintos que aparecen en los documentos del
conjunto. El tercer nmero es la cantidad de entradas distintas de cero
que hay en la matriz que conforman las lneas siguientes del archivo.
Cada una de las siguientes lneas representa un documento del conjunto
de datos. En cada linea hay tantos pares de nmeros como trminos
distintos haya en el documento. El primer nmero del par es el nmero
del trmino, y el segundo nmero es la cantidad de veces que aparece ese
trmino en el documento.
- re0.mat.clabel
El archivo .mat.clabel enumera todos los trminos que aparecen en los
documentos, uno en cada lnea. El orden de los trminos se corresponde
con la numeracin mediante la cual se referencian en el archivo .mat.
- re0.mat.rclass
El archivo .mat.rclass contiene una lnea por cada documento del
conjunto de datos. Cada lnea del archivo contiene la categora a la que
pertenece ese documento.


A3.5 Programa Armar Datasets

Este programa es el que se utiliza para extraer muestras de datos al azar a partir
de los conjuntos de datos re0 y re1. En la realizacin de los experimentos, este
programa se utiliz para generar las 10 muestras de datos re0_1 a re0_10 con 500
documentos al azar del conjunto de datos re0, y las 10 muestras de datos re1_1 a
re1_10, con 500 documentos al azar del conjunto de datos re1.
Al ejecutar el programa, se presenta la siguiente pantalla:

En esta pantalla deben configurarse los parmetros del programa. A
continuacin se detalla el significado de cada uno de ellos:
- Nombre del origen ODBC : Este parmetro es utilizado para identificar la
base de datos MDB de datasets. Debe colocarse el mismo nombre que se
utiliz al configurar el origen de datos ODBC de la forma en que se describe
en la seccin A3.3.
- Ubicacin archivos datasets : Este parmetro indica la ruta a los archivos
.mat, .mat.clabel y .mat.rclass correspondientes a los conjuntos de
Fig. A3.6:
Configuracin del
programa Armar
Datasets


datos re0 y re1. En este directorio se ubicarn tambien los archivos de las
nuevas muestras de datos generadas por el programa.
- Dataset fuente : Este parmetro permite seleccionar el conjunto de datos del
cual se quiere extraer la muestra de datos al azar. Este parmetro puede
tomar los valores re0 y re1.
- Cantidad elementos dataset fuente : En este parmetro debe colocarse la
cantidad de documentos que contiene el conjunto de datos ingresado en el
parmetro anterior. Los conjuntos de datos re0 y re1 contienen 1504 y 1657
documentos, respectivamente.
- Cantidad elementos nuevos datasets : Este parmetro indica la cantidad de
documentos que van a contener las muestras de datos extradas. Debe ser
menor o igual a la cantidad de documentos del conjunto de datos origen.
- Nuevos datasets, desde : Este parmetro indica el nmero de la primera
muestra de datos a generar. Si el parmetro tiene el valor 1, y el conjunto
de datos origen es re0, la primera muestra de datos ser re0_1.
- Nuevos datasets, hasta : Este parmetro indica el nmero de la ltima
muestra de datos a generar. Si el conjunto de datos origen es re0, el
parmetro Nuevos datasets, desde toma el valor 1, y el parmetro
Nuevos datasets, hasta toma el valor 3, las muestras de datos generadas
sern re0_1, re0_2 y re0_3.

Una vez configurados los valores de los parmetros, debe presionarse el botn
Procesar. El programa generar los archivos correspondientes a las muestras de datos,
y guardar tambien la informacin de los mismos en la base de datos de datasets.


A3.6 Programa AGDocClus

Este programa implementa los algoritmos de agrupamiento estudiados en el
trabajo. El programa permite seleccionar la muestra de datos que se quiere categorizar,
seleccionar la cantidad de grupos y el algoritmo a utilizar, y generar el agrupamiento.
A3.6.1 Copia del programa al disco local

El programa AGDocClus no puede ejecutarse desde el CD, ya que intentar
escribir la salida en un subdirectorio del CD, generando un error. Debe copiarse el
contenido de la carpeta AGDocClus del CD en un directorio del disco rgido de la PC,
por ejemplo, en el directorio C:\Tesis\AGDocClus. Luego debe crearse un
subdirectorio llamado salida en el subdirectorio en el cual se copi el programa. En
caso del ejemplo, debe crearse el subdirectorio C:\Tesis\AGDocClus\salida. En este
subdirectorio se generar la salida del programa.

A3.6.2 Utilizacin del programa

Debe ejecutarse el archivo AGDocClus.exe.

El programa comenzar preguntando por el directorio en el cual se encuentran
ubicados los archivos de muestras de datos.
Directorio donde se encuentran los archivos (ej: 'd:\Tesis_Docs') :
Debe ingresarse el mismo directorio que se indic como salida en el programa
Armar Datasets, ya que en ese directorio se habrn generado los archivos de muestras
de datos.

Luego, el programa preguntar el nombre de la muestra de datos a categorizar.
Nombre del .mat (ej : 're0_1') o 'txt' para leer archivos .txt :
Debe ingresarse el nombre de la muestra de datos que se quiere categorizar, por
ejemplo, re0_1.


A continuacin, el programa presentar un men de opciones.
(1) Cambiar cantidad grupos (15)
(2) Cambiar cantidad corridas (5)
(3) Cambiar generaciones del genetico (50)
(a) Bisecting K-Means (con refinamiento)
(b) Algoritmo Genetico (con y sin refinamiento)
(x) Salir
?

Las opciones (1) a (3) permiten cambiar parmetros que afectarn la realizacin
de los experimentos.
La opcin (1) permite cambiar la cantidad de grupos que se formarn.
La opcin (2) permite cambiar la cantidad de corridas del algoritmo
seleccionado que se realizarn.
La opcin (3) permite cambiar la cantidad de generaciones que se ejecutarn en
el algoritmo gentico.
Las opciones (a) y (b) permiten realizar los agrupamientos con cada uno de los
algoritmos.
Al seleccionar la opcin (a) se agruparn los elementos de la muestra de datos
utilizando el algoritmo Bisecting K-Means con refinamiento.
Al seleccionar la opcin (b) se agruparn los elementos de la muestra de datos
utilizando los algoritmos Gentico y Gentico con refinamiento.

El programa generar los archivos de salida para cada corrida de los algoritmos
en el subdirectorio salida. Estos archivos de salida son utilizados por el programa
Evaluar Agrupamientos.


A3.7 Programa Evaluar Agrupamientos

Este programa toma los agrupamientos generados como salida por el programa
AGDocClus y calcula las medidas de calidad utilizadas en el trabajo.

Al ejecutar el programa se presenta la siguiente pantalla:

En esta pantalla deben configurarse los parmetros del programa. A
continuacin se detalla el significado de cada uno de ellos:
- Nombre del origen ODBC : Este parmetro es utilizado para identificar la
base de datos MDB de datasets. Debe colocarse el mismo nombre que se
utiliz al configurar el origen de datos ODBC de la forma en que se describe
en la seccin A3.3.
- Dataset a evaluar : Este parmetro indica el dataset para el cual se desea
evaluar la salida generada.
- Ubicacin del programa AGDocClus : En este parmetro debe colocarse el
directorio en el cual se copi el programa AGDocClus. El programa
Evaluar Agrupamiento buscar los archivos de salida en el subdirectorio
salida del directorio indicado en este parmetro
Fig. A3.7: Configuracin del programa Evaluar Agrupamientos


Una vez configurados los valores de los parmetros, debe presionarse el botn
Procesar. El programa buscar los archivos de salida generados por el programa
AGDocClus, obtendr la informacin del dataset de la base de datos de datasets, y
generar una planilla en el programa Microsoft Excel con las medidas de calidad para
cada uno de los agrupamientos procesados.

La planilla generada tendr un formato similar al siguiente:

CORRIDA SIMIL.PROM. ENTROPIA OPERACIONES
salida_re0_1_BisKM(ref)2_15_0.txt 0,188 1,464 145758
PROM. BisKM(ref)2_15 0,1854 1,4796 156254,4
salida_re0_1_Gen(ref)_15_0.txt 0,19 1,446 119230
PROM. Gen(ref)_15 0,19 1,3786 126969
salida_re0_1_Gen_15_0.txt 0,189 1,478 96207
salida_re0_1_Gen_15_1.txt 0,18 1,523 76086
salida_re0_1_Gen_15_2.txt 0,19 1,37 112203
salida_re0_1_Gen_15_3.txt 0,183 1,274 97150
salida_re0_1_Gen_15_4.txt 0,184 1,432 85483
PROM. Gen_15 0,1852 1,4154 93425,8

Para cada corrida de cada uno de los algoritmos se muestran sus medidas de
calidad, con los promedios agrupados para las corridas de cada algoritmo.


Eugenio Yolis APNDICE 4 - PROGRAMACION 143
Apndice 4
Programacin de los algoritmos

En ste apndice se detalla la forma en la que se programaron los algoritmos
comparados en la prueba experimental. Para realizar la prueba experimental, se
desarroll una aplicacin de categorizacin automtica de documentos que permite
seleccionar qu algoritmo se quiere utilizar. El desarrollo de la aplicacin se realiz en
el lenguaje C++. La seccin A4.1 contiene la descripcin de los distintos mdulos en
los que se separ la lgica del algoritmo y la interaccin que existe entre los mismos. En
la seccin A4.2 se incluye el cdigo fuente de los mdulos ms significativos.

A4.1 Descripcin de los mdulos

Para facilitar la codificacin y el seguimiento de la lgica de la aplicacin, la
misma se dividi en mdulos conceptuales. Cada mdulo implementa una parte de la
funcionalidad necesaria para la aplicacin. A su vez, cada mdulo est compuesto de
uno o ms archivos de cdigo fuente.

A4.1.1 Mdulo ArchivosTexto

Este mdulo implementa las funciones necesarias para leer los subconjuntos de
documentos que se categorizarn con la aplicacin. Los subconjuntos de documentos
deben estar compuestos por archivos con el formato que se describe en el apndice 3
(Manual de uso), seccin A3.4. Este mdulo se compone de los siguientes archivos de
cdigo fuente:
ArchivosTexto.h: Declaracin de las funciones para leer los
subconjuntos de documentos.
ArchivosTexto.cpp: Implementacin de las funciones que leen los
subconjuntos de documentos.

144 APNDICE 4 - PROGRAMACION Eugenio Yolis

A4.1.2 Mdulo VecArchivos

Este mdulo implementa un tipo de objeto VecArchivo. La utilizacin de este
objeto permite al resto de los mdulos abstraerse de la forma en la cual se manejan las
estructuras utilizadas para la representacin vectorial de los documentos a agrupar. El
mdulo incluye funciones para agregar elementos al vector, calcular su norma y
multiplicar, sumar y restar vectores. Este mdulo se compone de los siguientes archivos
de cdigo fuente:
VecArchivos.h: Declaracin de la clase c_VecArchivo, que es la que
encapsula la representacin vectorial de los documentos.
VecArchivos.cpp: Implementacin de los mtodos de la clase
c_VecArchivo.
A4.1.3 Mdulo Agrupamiento

Este mdulo implementa un tipo de objeto agrupamiento. La utilizacin de
este objeto permite al resto de los mdulos abstraerse de la forma en la cual se manejan
las estructuras necesarias para representar los agrupamientos. El mdulo incluye
funciones para crear grupos, asignar elementos a cada grupo y mover los elementos
entre los grupos del agrupamiento. Este mdulo se compone de los siguientes archivos
de cdigo fuente:
ClsAgrupamiento.h: Declaracin de la clase c_Agrupamiento, que es la
que encapsula la representacin del objeto de tipo agrupamiento.
ClsAgrupamiento.cpp: Implementacin de los mtodos de la clase
c_Agrupamiento. Estos mtodos permiten inicializar el agrupamiento,
crear y eliminar grupos, y agregar y quitar elementos de los grupos.
ClsAgrupImprime.h: Declaracin de la clase c_Agrup_Imprime. Esta
clase implementa funciones para imprimir en un archivo de texto la
composicin de un agrupamiento. Estas funciones son utilizadas por la
aplicacin para preparar los archivos de salida.
ClsAgrupImprime.cpp: Implementacin de los mtodos de la clase
c_Agrup_Imprime.

A4.1.4 Mdulo K-Means

Este mdulo implementa el algoritmo de categorizacin automtica Bisecting
K-Means con refinamiento. El mdulo incluye la implementacin de las funciones del
algoritmo K-Means, que es utilizado por el algoritmo Bisecting K-Means con
refinamiento en el paso de biseccin. Este mdulo se compone de los siguientes
archivos de cdigo fuente:
ClsKMeans.h: Declaracin de la clase c_KMeans, que implementa
todas las funciones que requiere el algoritmo Bisecting K-Means con
refinamiento.
ClsKMeans.cpp: Implementacin de los mtodos de la clase
c_KMeans.

A4.1.5 Mdulo Gentico

Este mdulo implementa el algoritmo propuesto para la categorizacin
automtica de documentos. Este algoritmo (que se describe en detalle en el captulo 4)
es una adaptacin de un algoritmo gentico al problema de la categorizacin automtica
de documentos, e incluye nuevos operadores diseados especficamente para el
problema a resolver. Este mdulo se compone de los siguientes archivos de cdigo
fuente:
ClsGenetico.h: Declaracin de la clase c_Genetico. Esta clase
implementa todos los operadores del algoritmo gentico, incluyendo los
nuevos operadores diseados como parte de la solucin propuesta.
ClsGenetico.cpp: Implementacin de los operadores del algoritmo
gentico. Este archivo contiene el constructor de la clase c_Genetico,
donde se fijan todos los parmetros que utiliza el algoritmo gentico
(tamao de la poblacin, tamao del torneo, y probabilidades con las que
se aplica cada operador).



A4.1.6 Mdulo Principal

Este mdulo implementa la interfaz con el usuario, que permite seleccionar qu
subconjunto de datos se quiere agrupar, qu algoritmo se desea utilizar, y cuntos
grupos se van a formar. El mdulo contiene procedimientos que, utilizando las
funciones y clases definidas en los otros mdulos, ejecutan las acciones seleccionadas.
Este mdulo se compone de los siguientes archivos de cdigo fuente:
Def.h: Definicin de tipos de datos y de constantes utilizadas en la
aplicacin.
Sis.h, SisDos.h y SisDos.cpp: Declaracin e implementacin de
funciones auxiliares.
Ppal.cpp: Implementacin de las funciones de interfaz con el usuario, y
de los procedimientos que ejecutan las acciones seleccionadas.


A4.2 Cdigo fuente

A4.2.1 ArchivosTexto.h

#ifndef __ArchivosTextoH__
#define __ArchivosTextoH__

uent CargarListaArchivos(char *dir, c_SkipList &ltxt);

uent CargarListaArchivosMAT(char *szMat, c_SkipList &ltxt);

uent ProcesarArchivosTexto(c_SkipList &ltxt, c_SkipList &lexico,
uent tbufftxt, uent &cantlex, c_SkipList *lLexArchivos[]);

uent ProcesarArchivosTextoMAT(char *szMat, c_SkipList &lexico,
uent &cantlex, c_SkipList *lLexArchivos[]);

uent ArmarVectoresArchivos(c_SkipList &lexico, uword cantArchivos,
c_SkipList *lLexArchivos[], c_VecArchivo *vVecArchivos[]);

#endif



A4.2.2 ArchivosTexto.cpp

#include "def.h"
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "skipl.h"
#include "archtxt.h"
#include "filtrarpalabras.h"
#include "steeming.h"
#include "vecArchivos.h"

uent CargarListaArchivos(char *dir, c_SkipList &ltxt)
/*
carga en ltxt los archivos de texto "*.txt" del directorio dir
devuelve la cantidad de archivos de texto que se cargaron
En vecfh va poniendo la fecha y hora de cada archivo txt
*/
{
t_dir d;
char arch[MAX_LONG_NOMARCH], archlwr[MAX_LONG_NOMARCH];
/* empiezo a contar desde 1 */
uent cant=1;
uword auxlong;

d = PrimeroDir(dir,arch);
while (d!=-1)
/* mientras haya archivos en el directorio */
{
strcpy(archlwr,arch);
strlwr(archlwr);
if (strstr(archlwr,".txt"))
/* si es un .txt */
{
/* paso cant a long */
auxlong = (long)cant;
ltxt.Buscar_Insertar((ubyte*)arch,auxlong);
cant++;
//xxxdebug
//printf("Arch : %d - %s\n",cant-1,arch);
}
d = SiguienteDir(d,arch);
}
return (cant-1);
}

uent CargarListaArchivosMAT(char *szMat, c_SkipList &ltxt)
/*
carga en ltxt los nombres de archivos de texto del .mat.
devuelve la cantidad de archivos de texto que se cargaron
(en realidad, el nombre de archivo va a ser _D_nro.txt y la cantidad
de archivos la sacamos de la primera linea del .mat)
*/
{

char arch[MAX_LONG_NOMARCH];
/* empiezo a contar desde 1 */
uent cant,i;
uword auxlong;
FILE *fMat;

/* leemos el primer numero del .mat */
fMat = fopen(szMat,"r");
fscanf(fMat,"%d",&cant);
fclose(fMat);

/* cargamos la lista */
for (i=1;i <= cant; i++)
/* para cada "archivo" */
{
sprintf((char*)&arch,"_D_%d.txt",i);
/* paso "i" a long */
auxlong = (long)i;
ltxt.Buscar_Insertar((ubyte*)arch,auxlong);
//xxxdebug
//printf("Arch : %d - %s\n",i,arch);
}

return cant;
}

uent ProcesarArchivosTexto(c_SkipList &ltxt, c_SkipList &lexico,
uent tbufftxt, uent &cantlex, c_SkipList *lLexArchivos[])
/*
Devuelve la tabla de lexico en lexico
Utiliza el tamanio de buffer especificado en tbufftxt para los
archivos de texto
devuelve en cantlex la cantidad de terminos del lexico
Devuelve OK o el error que corresponda
*/
{
uent nropal;
uword nroarch;
ubyte nomtxt[MAX_LONG_NOMARCH], pal[MAX_LONG_PALABRA];
c_ArchTexto atxt;
uword auxlong;
c_SkipList *lLexA;
uword nroTerm;
uent frecTerm;
uent codRet;

cantlex = 1;
if (ltxt.MoverPrimero() == ERROR)
/* la lista estaba vacia, no hay archivos */
return OK;
if (atxt.CrearBuffer(tbufftxt) == ERROR_MEMORIA)
return ERROR_MEMORIA;
do
{
ltxt.ObtenerClave(nomtxt);
nroarch = ltxt.ObtenerValor();
lLexArchivos[nroarch] = new c_SkipList();
if (lLexArchivos[nroarch] == NULL)


/* obtenemos los datos del archivo de texto */
if (atxt.Abrir((char*)nomtxt) == ERROR_ARCHIVO)
return ERROR_ARCHIVO;
lexico.ResetFrecs();
/* reseteamos las frecuencias de la lista de lexico */
while (atxt.LeerPalabra(pal))
/* leemos todas las palabras y las metemos en el lexico si
es que no estan */
{
/* procesamos la palabra */
codRet = ProcesarPalabra(pal);
if (codRet != ERROR)
/* Hay que guardar esta palabra */
{
/* le aplicamos las reglas de steeming */
steeming_porter((char*)pal);

nropal = cantlex;
/* pasamos el nropal a long */
auxlong = nropal;
if (lexico.Buscar_Insertar(pal,auxlong) == ERROR_MEMORIA)
nropal = (uent)auxlong;
if (nropal == cantlex)
{
cantlex++;
}
}
}
atxt.Cerrar();
/* no hay mas palabras, completemos la lista de ese archivo */
if (lexico.MoverPrimero() == OK)
{
/* vamos a trabajar con la lista de ese archivo */
lLexA = lLexArchivos[nroarch];
do
{
if (lexico.ObtenerFrec() != 0)
/* si la palabra estaba en el archivo que procesamos */
{
/* la insertamos en la lista del archivo */
lexico.ObtenerClave(pal);
nroTerm = lexico.ObtenerValor();
frecTerm = lexico.ObtenerFrec();
if (lLexA->Buscar_Insertar(pal,nroTerm) ==
ERROR_MEMORIA)
/* seteamos la frecuencia del termino */
lLexA->SetearFrecuencia(frecTerm);
}
} while (lexico.MoverSiguiente() == OK);
}
} while (ltxt.MoverSiguiente() == OK);
/* cantlex habia quedado con 1 de mas */
cantlex--;
return OK;

}

uent ProcesarArchivosTextoMAT(char *szMat, c_SkipList &lexico,
uent &cantlex, c_SkipList *lLexArchivos[])
/*
Devuelve la tabla de lexico en lexico
devuelve en cantlex la cantidad de terminos del lexico
*/
{
ubyte pal[MAX_LONG_PALABRA];
c_SkipList *lLexA;
uword nroTerm;
uent frecTerm;
uent cantArchivos, iArchivo;
FILE *fp;
char szCLabel[200],dummyChar;
float fNroTerm,fFrecTerm;

/* la cantidad de archivos es el primer nro del .mat
y la cantidad de trminos es el segundo */
fp = fopen(szMat,"r");
fscanf(fp,"%d %d",&cantArchivos,&cantlex);
fclose(fp);

/* abrimos el archivo de palabras (.mat.clabel) y las vamos
ingresando el la lista de lexico */
sprintf((char*)&szCLabel,"%s.clabel",szMat);
fp = fopen((char*)&szCLabel,"r");
for (nroTerm = 1; nroTerm <= cantlex; nroTerm++)
{
fscanf(fp,"%s",(char*)&pal);
fscanf(fp,"%c",&dummyChar);
if (lexico.Buscar_Insertar(pal,nroTerm) == ERROR_MEMORIA)
}
fclose(fp);

/* ahora abrimos el .mat y leemos los archivos
(cada linea del .mat, excepto la primera, se corresponde
con un archivo) */
fp = fopen(szMat,"r");

/* la primera linea la salteamos */
while (fgetc(fp) != '\n');

for (iArchivo = 1; iArchivo <= cantArchivos; iArchivo++)
{
/* creamos una nueva lista para ese archivo */
lLexArchivos[iArchivo] = new c_SkipList();
/* la ordenamos por numero */
lLexArchivos[iArchivo]->SetearOrden(1);
if (lLexArchivos[iArchivo] == NULL)
lLexA = lLexArchivos[iArchivo];

/* vamos leyendo los pares (palabra,frecuencia) de ese archivo */


do
{
fscanf(fp,"%f %f",&fNroTerm,&fFrecTerm);
nroTerm = (uword)fNroTerm;
frecTerm = (uent)fFrecTerm;
/* buscamos esa palabra en el lexico */
lexico.Buscar(pal,nroTerm);
/* la insertamos el la lista del archivo */
if (lLexA->Buscar_Insertar(pal,nroTerm) == ERROR_MEMORIA)
/* asignamos la frecuencia en ambas listas */
lexico.SetearFrecuencia(frecTerm);
lLexA->SetearFrecuencia(frecTerm);
/* leemos un caracter, a ver si viene el fin de linea */
fscanf(fp,"%c",&dummyChar);
} while (dummyChar != '\n');

}

fclose(fp);

return OK;
}

uent ArmarVectoresArchivos(c_SkipList &lexico, uword cantArchivos,
c_SkipList *lLexArchivos[], c_VecArchivo *vVecArchivos[])
/* arma los vectores de terminos de los archivos */
/* devuelve OK o el error que corresponda */
{
uent codRet,iArch, iPal, frec, countFrecs;
ubyte pal[MAX_LONG_PALABRA],pal2[MAX_LONG_PALABRA];
uent nroPalEnt;
uword nroPalWord;
real tfIdf;

/* para cada archivo */
for (iArch=1; iArch <= cantArchivos; iArch++) {
/* creamos el vector con la cantidad de entradas que necesitamos */
vVecArchivos[iArch] = new c_VecArchivo();
if (vVecArchivos[iArch] == NULL)
codRet = vVecArchivos[iArch]->CrearVector((uent)lLexArchivos[iArch]-
>ObtenerCantElementos());
if (codRet != OK)
return codRet;
/* las entradas en el vector empiezan en 0 */
iPal = 0;
if (0 < lLexArchivos[iArch]->ObtenerCantElementos())
{
lLexArchivos[iArch]->MoverPrimero();
do {
/* para cada palabra del archivo */
/* buscamos la palabra y la frecuencia en el archivo */
lLexArchivos[iArch]->ObtenerClave(pal);
frec = lLexArchivos[iArch]->ObtenerFrec();
nroPalWord = lLexArchivos[iArch]->ObtenerValor();
/* buscamos el nuevo numero de palabra y la cantidad

de archivos en la que aparece */
strcpy((char *)pal2,(char *)pal);
lexico.Buscar(pal,nroPalWord);
nroPalEnt = (uent)nroPalWord;
countFrecs = lexico.ObtenerCountFrecs();
/* calculamos el valor tf-idf */
tfIdf = (real)frec *
((real)log((double)cantArchivos/(double)countFrecs) / (real)log(2.0));
/* insertamos la entrada en el vector */
vVecArchivos[iArch]-
>ModificarEntrada(iPal,nroPalEnt,tfIdf,false);
iPal++;
} while (lLexArchivos[iArch]->MoverSiguiente() == OK);
}
/* ahora lo normalizamos */
vVecArchivos[iArch]->Normalizar();
/* y calculamos las palabras claves */
vVecArchivos[iArch]->ActualizarPalabrasClave();
}
return OK;
}



A4.2.3 VecArchivos.h

/*
Clase de vector de archivos

El vector contiene entradas compuestas de dos valores :
un valor entero y un valor real

El vector se crea con un tamao y luego no se puede cambiar

*/

#ifndef __vecArchivosH__

#define __vecArchivosH__

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "def.h"
#include "sis.h"

#define NRO_ENT_KEYWORDS 5

typedef struct _t_RegVecArchivo {
uent valEnt;
real valReal;
} t_RegVecArchivo;

class c_VecArchivo {
private:
uent cantEntradas; /* numero de entradas en el vector */
t_RegVecArchivo *entradas; /* vector con una entrada por cada palabra del
archivo */
t_RegVecArchivo keywords[NRO_ENT_KEYWORDS]; /* palabras clave que
describen al archivo */
real normaValor; /* valor de la norma del vector */
bool normaActualizada; /* true si el valor de la norma est actualizado */
uent SumarPriv(c_VecArchivo &otroVec, real signo, bool
soloEntradasEnComun);
public:
static uword contMultiplicaciones; /* cuenta las veces que se llam a la funcion
multiplicacion */
static uword contCalculoNorma; /* cuenta la cantidad de veces que se llam a la
funcion calcular norma */
c_VecArchivo();
uent CrearVector(uent parCantEntradas);
uent Duplicar(c_VecArchivo &otroVec);
void ModificarEntrada(uent nroEntrada, uent parValEnt, real parValReal, bool
usarKeywords);
void ConseguirEntrada(uent nroEntrada, uent &parValEnt, real &parValReal, bool
usarKeywords);

uent ConseguirCantEntradas(bool usarKeywords);
real Multiplicar(c_VecArchivo &otroVec, bool usarKeywords);
uent EnComun(c_VecArchivo &otroVec, bool usarKeywords);
uent Sumar(c_VecArchivo &otroVec);
uent Restar(c_VecArchivo &otroVec);
real CalcularNorma(bool incContador);
void MultiplicarPorReal(real nroReal);
~c_VecArchivo();
void Normalizar();
void ActualizarPalabrasClave();
};

#endif



A4.2.4 VecArchivos.cpp


uword c_VecArchivo::contMultiplicaciones = 0;
uword c_VecArchivo::contCalculoNorma = 0;

c_VecArchivo::c_VecArchivo()
/* constructor */
{
cantEntradas = 0;
entradas = NULL;
normaValor = (real)0.0;
normaActualizada = false;
}

c_VecArchivo::~c_VecArchivo()
/* destructor */
{
if (cantEntradas != 0)
free((void*)entradas);
}

uent c_VecArchivo::CrearVector(uent parCantEntradas)
/* reserva espacio para la cantidad de entradas pedida */
{
uent i;

cantEntradas = parCantEntradas;

/* inicializamos el vector de palabras claves */
for (i=0; i < NRO_ENT_KEYWORDS; i++)
{
keywords[i].valEnt = 0;
keywords[i].valReal = 0.0;
}

if (cantEntradas == 0)
return OK;

entradas = (t_RegVecArchivo*)malloc(cantEntradas * sizeof(t_RegVecArchivo));
if (entradas == NULL)

return OK;
}

uent c_VecArchivo::Duplicar(c_VecArchivo &otroVec)
{
/* copia el vector otroVec en el actual
el actual no debe estar inicializado
devuelve OK o el error que corresponda */

/* copiamos las keywords */

memcpy((void*)keywords,(void*)otroVec.keywords,NRO_ENT_KEYWORDS *
sizeof(t_RegVecArchivo));

/* copiamos las entradas */
cantEntradas = otroVec.cantEntradas;
entradas = (t_RegVecArchivo*)malloc(cantEntradas * sizeof(t_RegVecArchivo));
if (entradas == NULL)
memcpy((void*)entradas,(void*)otroVec.entradas,cantEntradas *
sizeof(t_RegVecArchivo));

/* copiamos el valor de la norma y el flag que marca si est actualizada */
normaValor = otroVec.normaValor;
normaActualizada = otroVec.normaActualizada;

return OK;
}

void c_VecArchivo::ModificarEntrada(uent nroEntrada,uent parValEnt,real parValReal, bool
usarKeywords)
/* modifica la entrada */
/* si el valor "parValReal" le permite a la palabra ser una de las
keywords del archivo, la incluye en el vector y saca una de ellas */
{
if (usarKeywords)
{
keywords[nroEntrada].valEnt = parValEnt;
keywords[nroEntrada].valReal = parValReal;
}
else
{
entradas[nroEntrada].valEnt = parValEnt;
entradas[nroEntrada].valReal = parValReal;
}
/* la norma no est actualizada porque cambi una entrada */
normaActualizada = false;
}

void c_VecArchivo::ConseguirEntrada(uent nroEntrada,uent &parValEnt,real &parValReal, bool
usarKeywords)
/* devuelve los valores de la entrada */
{
if (usarKeywords)
{
if (nroEntrada < NRO_ENT_KEYWORDS) {
parValEnt = keywords[nroEntrada].valEnt;
parValReal = keywords[nroEntrada].valReal;
} else {
parValEnt = 0;
parValReal = 0;
}
}
else
{
if (nroEntrada < cantEntradas) {
parValEnt = entradas[nroEntrada].valEnt;
parValReal = entradas[nroEntrada].valReal;
} else {


parValEnt = 0;
parValReal = 0;
}
}
}

uent c_VecArchivo::ConseguirCantEntradas(bool usarKeywords)
{
if (usarKeywords)
return NRO_ENT_KEYWORDS;
else
return cantEntradas;
}

real c_VecArchivo::Multiplicar(c_VecArchivo &otroVec, bool usarKeywords)
/* multiplica el vector por el que viene como parametro */
/* producto interno */
/* devuelve el resultado */
{
real rAux,valReal1,valReal2;
uent i1,i2,valEnt1,valEnt2;
uent ent1,ent2;

contMultiplicaciones++;

ent1 = ConseguirCantEntradas(usarKeywords);
ent2 = otroVec.ConseguirCantEntradas(usarKeywords);

i1 = 0;
i2 = 0;

ConseguirEntrada(i1,valEnt1,valReal1,usarKeywords);
otroVec.ConseguirEntrada(i2,valEnt2,valReal2,usarKeywords);

rAux = 0;

while (i1 < ent1 && i2 < ent2) {
if (valEnt1 == valEnt2) {
rAux += valReal1 * valReal2;
i1++;
i2++;
} else if (valEnt1 < valEnt2) {
i1++;
} else {
i2++;
}
}

return rAux;
}

uent c_VecArchivo::EnComun(c_VecArchivo &otroVec, bool usarKeywords)
/* devuelve la cantidad de elementos en comun */
{

real valReal1,valReal2;
uent i1,i2,valEnt1,valEnt2,entAux;
uent ent1,ent2;


i1 = 0;
i2 = 0;


entAux = 0;

entAux++;
i1++;
i2++;
i1++;
} else {
i2++;
}
}

return entAux;
}

uent c_VecArchivo::Sumar(c_VecArchivo &otroVec)
{
return SumarPriv(otroVec,(real)1.0,false);
}

uent c_VecArchivo::Restar(c_VecArchivo &otroVec)
{
return SumarPriv(otroVec,(real)-1.0,true);
}

uent c_VecArchivo::SumarPriv(c_VecArchivo &otroVec, real signo, bool
soloEntradasEnComun)
/* suma al vector las entradas del otro vector, multiplicandolas
por el valor "signo"
Si "soloEntradasEnComun" es true, se ignoran todas las entradas que
estn en el otro vector y no en este
Si "soloEntradasEnComun" es false, si es necesario, le agrega entradas al vector
{
real valReal1,valReal2;
uent i1,i2,iNuevo,valEnt1,valEnt2;
uent ent1,ent2,entComun,nuevoTam;
t_RegVecArchivo *nuevasEntradas;
bool usarKeywords;


real normaVec; /* vamos a aprovechar para calcular la norma */
bool ignoramosEntrada;

usarKeywords = false;


if (soloEntradasEnComun == false)
{
entComun = EnComun(otroVec,usarKeywords);

/* el nuevo tamao es la suma menos la interseccion */
nuevoTam = ent1 + ent2 - entComun;

nuevasEntradas =
(t_RegVecArchivo*)malloc(nuevoTam*sizeof(t_RegVecArchivo));
if (nuevasEntradas == NULL)
}
else
{
nuevasEntradas = entradas;
}

i1 = 0;
i2 = 0;
iNuevo = 0;
normaVec = (real)0.0;


ignoramosEntrada = false;
nuevasEntradas[iNuevo].valEnt = valEnt1;
nuevasEntradas[iNuevo].valReal = valReal1 + (signo * valReal2);
i1++;
i2++;
/* esta entrada solo est en este vector */
nuevasEntradas[iNuevo].valReal = valReal1;
i1++;
} else {
/* esta entrada solo est en el otro vector */
{
nuevasEntradas[iNuevo].valReal = signo * valReal2;
}
else
{
ignoramosEntrada = true;

}
i2++;
}
if (ignoramosEntrada == false)
{
normaVec += nuevasEntradas[iNuevo].valReal *
nuevasEntradas[iNuevo].valReal;
iNuevo++;
}
}
/* alguno de los vectores se termin */
while (i1 < ent1) {
/* se termin el otro vector */
nuevasEntradas[iNuevo].valReal = valReal1;
i1++;
iNuevo++;
}
while ((i2 < ent2) && (soloEntradasEnComun == false)) {
/* se termin este vector */
nuevasEntradas[iNuevo].valReal = signo * valReal2;
i2++;
iNuevo++;
}

{
/* liberamos el viejo vector de entradas */
free((void*)entradas);
/* asignamos el nuevo vector de entradas */
entradas = nuevasEntradas;
}

cantEntradas = iNuevo;
/* guardamos la norma y marcamos que est actualizada */
normaValor = (real)sqrt((double)normaVec);
normaActualizada = true;
return OK;

}

real c_VecArchivo::CalcularNorma(bool incContador)
{
/* calculamos la norma (raiz del vector multiplicado por si mismo */

real normaVec;
uent i;

if (incContador)
contCalculoNorma++;


if (normaActualizada == false)
{
/* la norma no est actualizada, hay que calcularla */
normaVec = (real)0.0;
for (i=0; i < cantEntradas; i++)
{
normaVec += entradas[i].valReal * entradas[i].valReal;
}
normaVec = (real)sqrt((double)normaVec);
/* la guardamos, y marcamos que est actualizada */
normaValor = normaVec;
normaActualizada = true;
}
else
{
normaVec = normaValor;
}

return normaVec;
}

void c_VecArchivo::Normalizar()
{
/* divide las entradas del vector por su norma, de forma tal
que la norma del vector sea igual a 1 */
real normaVec,unoSobre;

normaVec = CalcularNorma(false);
/* dividimos los valores de todas las entradas por la norma */
unoSobre = (real)1.0 / normaVec;
MultiplicarPorReal(unoSobre);
}

void c_VecArchivo::MultiplicarPorReal(real nroReal)
{
/*
Multiplica las entradas del vector por el numero real
*/
uent i;

{
entradas[i].valReal *= nroReal;
}
/* si la norma estaba actualizada, va a quedar bien si la multiplicamos tambien por el
real */
normaValor *= nroReal;
}

void c_VecArchivo::ActualizarPalabrasClave()
{
/* actualiza la lista de palabras clave del vector
*/

uent iEntradas,i,j;

for (j=0; j < NRO_ENT_KEYWORDS; j++)

{
keywords[j].valReal = (real)0.0;
keywords[j].valEnt = 0;
}

for (iEntradas=0; iEntradas < cantEntradas; iEntradas++)
{

i = 0;

for (j=0; j < NRO_ENT_KEYWORDS; j++)
if (entradas[iEntradas].valReal > keywords[j].valReal)
i++;
if (i > 0)
/* la palabra entra en las keywords, en la posicion i-1 */
{
i--;
for (j = 0; j < i; j++)
{
keywords[j].valEnt = keywords[j+1].valEnt;
keywords[j].valReal = keywords[j+1].valReal;
}
keywords[i].valEnt = entradas[iEntradas].valEnt;
keywords[i].valReal = entradas[iEntradas].valReal;
}
}
}



A4.2.5 ClsAgrupamiento.h

/*
Clase que implementa un agrupamiento

*/

#ifndef __clsAgrupamiento__

#define __clsAgrupamiento__

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "def.h"

#define AGRUP_MIN_GRUPOS 5
#define AGRUP_INC_CANT_GRUPOS 5

typedef struct _t_RegVecGrupos {
uent nroGrupo; /* identificador del grupo */
uent menorNroElem; /* menor numero de elemento del grupo */
c_VecArchivo *vecCentroide; /* centroide del grupo */
uent cantElementos; /* cantidad de elementos del grupo */
} tRegVecGrupos;

class c_Agrupamiento {
friend class c_KMeans;
friend class c_Agrup_Imprime;
friend class c_Genetico;
private:
tRegVecGrupos *vecGrupos;
uent *vecElementos;
uent capacidadVecGrupos;
void CopiarRegVecGrupos(uent i, uent j, tRegVecGrupos *nuevoVecGrupos);
public:
uent cantGrupos;
uent cantElementos;
uent IndiceDeGrupo(uent nroGrupo, bool puedeNoEstar);
uent SiguienteNroGrupo();
c_Agrupamiento();
~c_Agrupamiento();
uent Inicializar(uent parCantElementos);
uent Duplicar(c_Agrupamiento &agrup);
uent AgruparAlAzar(uent cantGrupMin, uent cantGrupMax);
uent AgregarGrupos(uent cantidad);
void RenumerarGrupos();
void MoverElemento(uent nroElem, uent indGrupNuevo, uent indGrupAnterior);
void EliminarRegVecGrupos(uent indGrupo);
};

#endif


A4.2.6 ClsAgrupamiento.cpp

#include "clsAgrupamiento.h"

c_Agrupamiento::c_Agrupamiento()
{
cantElementos = 0;
capacidadVecGrupos = 0;
cantGrupos = 0;
}

c_Agrupamiento::~c_Agrupamiento()
{
uent i;
for (i=0 ; i < cantGrupos ; i++)
{
if (vecGrupos[i].vecCentroide != NULL)
delete(vecGrupos[i].vecCentroide);
}
if (vecGrupos != NULL)
free((void*)vecGrupos);
if (vecElementos != NULL)
free((void*)vecElementos);

}

uent c_Agrupamiento::SiguienteNroGrupo()
{
/* devuelve el siguiente nmero de grupo que se puede
utilizar para un grupo nuevo
*/
uent i;
uent max;

max = 1;
for (i=0; i < cantGrupos; i++)
if (vecGrupos[i].nroGrupo > max)
max = vecGrupos[i].nroGrupo;
/* veamos si no hay un numero mayor, en ese caso,
devolvemos 0 */
if (max >= MAX_UENT)
return 0;
return (max + 1);
}

uent c_Agrupamiento::IndiceDeGrupo(uent nroGrupo,bool puedeNoEstar)
{
/* devuelve el indice en el vector de grupos del grupo
cuyo nmero es "nroGrupo"
si "puedeNoEstar" es true, quiere decir que no es error si no
est el nro de grupo buscado. en ese caso, devolvemos el
indice de un grupo al azar
*/
uent i = 0;
while ((i < cantGrupos) && (vecGrupos[i].nroGrupo != nroGrupo))
i++;
if (i >= cantGrupos) /* no lo encontramos */


{
if (puedeNoEstar)
return RANDOM(cantGrupos);
else
return MAX_UENT; /* para que de error y detectemos el problema */
}
else
return i;
}

uent c_Agrupamiento::Inicializar(uent parCantElementos)
{
/* inicializa el agrupamiento para que contenga "parCantElementos"
elementos */
uent i;

vecElementos = (uent*)malloc(parCantElementos * sizeof(uent));
if (vecElementos == NULL)
cantElementos = parCantElementos;
for (i=0; i < cantElementos; i++)
vecElementos[i] = 0;
return OK;
}

uent c_Agrupamiento::Duplicar(c_Agrupamiento &agrup)
{
/* el agrupamiento copia exactamente al agrupamiento agrup
el agrupamiento no debe estar inicializado (agrup si)
uent i, codRet;

/* copiamos el vector de elementos */
cantElementos = agrup.cantElementos;
vecElementos = (uent*)malloc(cantElementos * sizeof(uent));
if (vecElementos == NULL)
memcpy((void*)vecElementos,(void*)agrup.vecElementos,cantElementos *
sizeof(uent));
/* copiamos el vector de grupos */
capacidadVecGrupos = agrup.capacidadVecGrupos;
cantGrupos = agrup.cantGrupos;
vecGrupos = (tRegVecGrupos*)malloc(capacidadVecGrupos * sizeof(tRegVecGrupos));
if (vecGrupos == NULL)
memcpy((void*)vecGrupos,(void*)agrup.vecGrupos,capacidadVecGrupos *
sizeof(tRegVecGrupos));
/* duplicamos los centroides */
for (i = 0; i < cantGrupos; i++)
{
if (agrup.vecGrupos[i].vecCentroide != NULL)
{
vecGrupos[i].vecCentroide = new c_VecArchivo();
codRet = vecGrupos[i].vecCentroide-
>Duplicar(*(agrup.vecGrupos[i].vecCentroide));
if (codRet != OK)
return codRet;

}
else
{
vecGrupos[i].vecCentroide = NULL;
}
}

return OK;
}

uent c_Agrupamiento::AgruparAlAzar(uent cantGrupMin, uent cantGrupMax)
{
/* Agrupa los elementos al azar */
/* Debe llamarse luego de ::Inicializar() */
/* Devuelve OK o el error que corresponda */
uent i;
uent nroElemRand;
uent grupAsig;

/* la cantidad de grupos debe estar entre cantGrupMin y cantGrupMax */
cantGrupos = RANDOM(1 + cantGrupMax - cantGrupMin) + cantGrupMin;
vecGrupos = (tRegVecGrupos*)malloc(cantGrupos * sizeof(tRegVecGrupos));
if (vecGrupos == NULL)
capacidadVecGrupos = cantGrupos;
/* inicializamos cada grupo */
{
vecGrupos[i].cantElementos = 0;
vecGrupos[i].nroGrupo = i+1;
/* en el campo menorNroElem ponemos el numero "cantElementos"
del agrupamiento, para que sea mayor a cualquier
nmero de elemento */
vecGrupos[i].menorNroElem = cantElementos;
vecGrupos[i].vecCentroide = NULL;
}
/* ahora nos aseguramos de poner 1 elemento por grupo */
{
/* elegimos un elemento al azar */
nroElemRand = RANDOM(cantElementos);
/* si ya est asignado, buscamos otro */
while (vecElementos[nroElemRand] != 0)
nroElemRand = RANDOM(cantElementos);
/* le asignamos el grupo */
vecElementos[nroElemRand] = vecGrupos[i].nroGrupo;
}
/* ahora recorremos el vector y vamos asignando grupos al azar */
for (i=0; i < cantElementos; i++)
{
/* veamos si ese elemento no tiene grupo */
if (vecElementos[i] == 0)
{
/* le asignamos uno */
grupAsig = RANDOM(cantGrupos);
vecElementos[i] = vecGrupos[grupAsig].nroGrupo;
}
else


{
/* buscamos el grupo del elemento */
grupAsig = IndiceDeGrupo(vecElementos[i],false);
}
/* sumamos un elemento al grupo */
vecGrupos[grupAsig].cantElementos++;
/* vemos si este elemento es el menor nro de elementos del grupo */
if (vecGrupos[grupAsig].menorNroElem > i)
vecGrupos[grupAsig].menorNroElem = i;
}
return OK;
}

void c_Agrupamiento::CopiarRegVecGrupos(uent i, uent j, tRegVecGrupos *nuevoVecGrupos)
{
/* copia la entrada "i" del vector de grupos a la entrada j
del nuevo vector de grupos */
nuevoVecGrupos[j].cantElementos = vecGrupos[i].cantElementos;
nuevoVecGrupos[j].menorNroElem = vecGrupos[i].menorNroElem;
nuevoVecGrupos[j].nroGrupo = vecGrupos[i].nroGrupo;
nuevoVecGrupos[j].vecCentroide = vecGrupos[i].vecCentroide;
}

uent c_Agrupamiento::AgregarGrupos(uent cantidad)
{
/* agrega "cantidad" grupos al agrupamiento, alocando ms memoria
si es necesario */
/* los grupos se crean vacos, por lo que el agrupamiento queda en
un estado inconsistente */
uent capacidadAgregar, incrementosAgregar;
tRegVecGrupos *nuevoVecGrupos;
uent i;
uent siguienteNro;
uent cantGrupOld;

/* veamos cuanto tenemos que agrandar el vector */
if (capacidadVecGrupos < (cantGrupos+cantidad))
{
capacidadAgregar = (cantGrupos+cantidad) - capacidadVecGrupos;
incrementosAgregar = 1 + (capacidadAgregar /
AGRUP_INC_CANT_GRUPOS);
capacidadVecGrupos +=
(incrementosAgregar*AGRUP_INC_CANT_GRUPOS);
nuevoVecGrupos = (tRegVecGrupos*)malloc(capacidadVecGrupos *
sizeof(tRegVecGrupos));
if (nuevoVecGrupos == NULL)
/* copiamos el vector anterior al nuevo */
{
CopiarRegVecGrupos(i, i, nuevoVecGrupos);
}
/* damos de baja el viejo vector y usamos el nuevo */
free((void*)vecGrupos);
vecGrupos = nuevoVecGrupos;
}
/* veamos si quedan suficientes numeros de grupo para agregar */

siguienteNro = SiguienteNroGrupo();
if ((siguienteNro + cantidad) > MAX_UENT) /* renumeramos los grupos */
{
RenumerarGrupos();
siguienteNro = SiguienteNroGrupo();
}
/* agregamos los nuevos grupos al vector */
cantGrupOld = cantGrupos;
for (i=0; i < cantidad; i++)
{
vecGrupos[cantGrupOld + i].cantElementos = 0;
/* en el campo "menorNroElemento" ponemos la cantidad de elementos
del agrupamiento, para que sea mayor a cualquier numero de elemento */
vecGrupos[cantGrupOld + i].menorNroElem = cantElementos;
vecGrupos[cantGrupOld + i].nroGrupo = siguienteNro;
vecGrupos[cantGrupOld + i].vecCentroide = NULL;
siguienteNro++;
cantGrupos++;
}
return OK;
}

void c_Agrupamiento::RenumerarGrupos()
{
/* renumera los grupos */
/* esta funcin debe utilizarse en el improbable caso de que se
hayan usado ms de 65536 nmeros de grupo, por agregar y borrar
grupos muchas veces */
uent i,j, nroAnterior;

{
nroAnterior = vecGrupos[i].nroGrupo;
vecGrupos[i].nroGrupo = i + 1;
for (j=0; j < cantElementos; j++)
if (vecElementos[j] == nroAnterior)
vecElementos[j] = vecGrupos[i].nroGrupo;
}
}

void c_Agrupamiento::EliminarRegVecGrupos(uent indGrupo)
{
/*
Elimina la entrada con ndice "indGrupo" del vector de grupos
*/
uent i;
if (vecGrupos[indGrupo].vecCentroide != NULL)
delete(vecGrupos[indGrupo].vecCentroide);
for (i = indGrupo; i < cantGrupos - 1; i++)
CopiarRegVecGrupos(i+1, i, vecGrupos);
cantGrupos--;
}

void c_Agrupamiento::MoverElemento(uent nroElem, uent indGrupNuevo, uent
indGrupAnterior)
{
/*


Mueve el elemento "nroElem" del grupo con ndice "indGrupAnterior"
al grupo con ndice "indGrupNuevo"
Si el grupo anterior queda vaco, lo elimina
*/
uent i;

if (indGrupNuevo != indGrupAnterior)
{

vecElementos[nroElem] = vecGrupos[indGrupNuevo].nroGrupo;
vecGrupos[indGrupNuevo].cantElementos++;
/* veamos si el que agregamos al nuevo grupo es el menor nro de elemento */
if (nroElem < vecGrupos[indGrupNuevo].menorNroElem)
vecGrupos[indGrupNuevo].menorNroElem = nroElem;

if (vecGrupos[indGrupAnterior].cantElementos <= 1)
EliminarRegVecGrupos(indGrupAnterior);
else
{
vecGrupos[indGrupAnterior].cantElementos--;
/* veamos si el que le sacamos era el menor numero de elemento */
if (nroElem == vecGrupos[indGrupAnterior].menorNroElem)
{
/* buscamos el nuevo menor numero de elemento */
i = nroElem + 1;
while (i < cantElementos)
{
if (vecElementos[i] ==
vecGrupos[indGrupAnterior].nroGrupo)
break;
i++;
}
vecGrupos[indGrupAnterior].menorNroElem = i;
}
}
}
}


A4.2.7 ClsAgrupImprime.h

/*
Clase que imprime agrupamientos, grupos y documentos
para ser desplegados al usuario

*/

#ifndef __clsAgrupImprime__

#define __clsAgrupImprime__

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "def.h"
#include "sis.h"
#include "skipl.h"
#include "clsKMeans.h"

class c_Agrup_Imprime {
private:

public:
static bool salidaCompacta;
c_Agrup_Imprime() {};
~c_Agrup_Imprime() {};
static uent ImprimirVecArchivo(FILE *fp, c_VecArchivo &vecArchivo, c_SkipList
&lexico);
static uent ImprimirTodo(FILE *fp, c_Agrupamiento &agrup, c_VecArchivo
*vVecArchivos[], c_SkipList &lexico, c_SkipList &ltxt);
static uent ImprimirGrupo(FILE *fp, uent indGrupo, c_Agrupamiento &agrup,
c_VecArchivo *vVecArchivos[], c_SkipList &lexico, c_SkipList &ltxt);
static uent ImprimirDocumento(FILE *fp, uent nroElem, c_VecArchivo
*vVecArchivos[], c_SkipList &lexico);
};

#endif



A4.2.8 ClsAgrupImprime.cpp

#include "clsAgrupImprime.h"

/* si se setea salidaCompacta en true, la salida va a estar preparada
para ser procesada en forma automtica por otro programa */
bool c_Agrup_Imprime::salidaCompacta = false;

uent c_Agrup_Imprime::ImprimirVecArchivo(FILE *fp, c_VecArchivo &vecArchivo, c_SkipList
&lexico)
{
/* En "fp" recibe un archivo de texto abierto */
/* Imprime las palabras claves del vector */
uent i, cantKeywords;
ubyte palabra[MAX_LONG_PALABRA];
uent nroPalEnt;
uword nroPalLong;
real auxReal;

cantKeywords = vecArchivo.ConseguirCantEntradas(true);
/* recorremos la lista de atras para adelante porque las ultimas
entradas son las de mayor peso */
for (i=cantKeywords; i > 0; i--)
{
vecArchivo.ConseguirEntrada(i-1,nroPalEnt,auxReal,true);
if (nroPalEnt > 0)
{
/* la buscamos en la lista de lexico */
nroPalLong = (uword)nroPalEnt;
lexico.Buscar(palabra,nroPalLong);
/* la imprimimos */
fprintf(fp,"%s",(char*)palabra);
}
if (i > 1)
fprintf(fp," ; ");
}

return OK;
}

uent c_Agrup_Imprime::ImprimirDocumento(FILE *fp, uent nroElem, c_VecArchivo
*vVecArchivos[], c_SkipList &lexico)
{
/* En "fp" recibe un archivo de texto abierto */
/* Imprime las palabras claves del documento */
uent codRet;

if (salidaCompacta)
{
fprintf(fp,"%d",nroElem);
}
else
{
codRet = ImprimirVecArchivo(fp,*(vVecArchivos[nroElem]),lexico);
if (codRet != OK)
return codRet;

}
return OK;
}

uent c_Agrup_Imprime::ImprimirGrupo(FILE *fp,uent indGrupo,c_Agrupamiento
&agrup,c_VecArchivo *vVecArchivos[],c_SkipList &lexico, c_SkipList &ltxt)
{
/* en fp recibe un archivo abierto */
/* imprime el numero del grupo, sus palabras claves, y cada uno de los
documentos que lo componen */

uent j;
uword jLong;
ubyte nomArch[MAX_LONG_NOMARCH];
real similPromGrupo;
real simElemCent;

/* calculamos la similitud promedio de los elementos del grupo
(es igual al cuadrado de la norma del centroide) */
if (agrup.vecGrupos[indGrupo].vecCentroide != NULL)
similPromGrupo = agrup.vecGrupos[indGrupo].vecCentroide-
>CalcularNorma(false);
else
similPromGrupo = 0;
similPromGrupo *= similPromGrupo; /* al cuadrado */

/* imprimimos el numero del grupo */
if (salidaCompacta)
{
fprintf(fp,"_G_%d[%f]=",indGrupo,similPromGrupo);
}
else
{
fprintf(fp,"Grupo %d (%d). Elementos=%d. Similitud Promedio=%f :
",indGrupo+1,agrup.vecGrupos[indGrupo].nroGrupo,agrup.vecGrupos[indGrupo].cantElementos
,similPromGrupo);
if (agrup.vecGrupos[indGrupo].vecCentroide != NULL)
{
agrup.vecGrupos[indGrupo].vecCentroide->ActualizarPalabrasClave();

ImprimirVecArchivo(fp,*(agrup.vecGrupos[indGrupo].vecCentroide),lexico);
}
//xxxdebug
else

ImprimirVecArchivo(fp,*(vVecArchivos[agrup.vecGrupos[indGrupo].menorNroElem +
1]),lexico);
fprintf(fp,"\n");
}
/* imprimimos los elementos del grupo */
for (j=0; j < agrup.cantElementos; j++)
if (agrup.vecElementos[j] == agrup.vecGrupos[indGrupo].nroGrupo)
if (salidaCompacta)
{
jLong = (uword)j + 1;
ltxt.Buscar(nomArch,jLong);
fprintf(fp,"%s;",(char*)nomArch);


//ImprimirDocumento(fp,j+1,vVecArchivos,lexico);
//fprintf(fp,";");
}
else
{
jLong = (uword)j + 1;
ltxt.Buscar(nomArch,jLong);
simElemCent =
c_KMeans::ValorCriterioActual(agrup,vVecArchivos,j,indGrupo);
fprintf(fp,"\t%s (%f)\n",(char*)nomArch,simElemCent);
fprintf(fp,"\t\t");
ImprimirDocumento(fp,j+1,vVecArchivos,lexico);
fprintf(fp,"\n");
}
fprintf(fp,"\n");
return OK;
}

uent c_Agrup_Imprime::ImprimirTodo(FILE *fp,c_Agrupamiento &agrup,c_VecArchivo
*vVecArchivos[],c_SkipList &lexico, c_SkipList &ltxt)
{
/* imprime el agrupamiento */
uent i, codRet;

for (i=0; i < agrup.cantGrupos ; i++)
{
codRet = ImprimirGrupo(fp,i,agrup,vVecArchivos,lexico,ltxt);
if (codRet != OK)
return codRet;
}

return OK;
}


A4.2.9 ClsKMeans.h

/*
Clase que implementa las funciones del algoritmo kmeans

*/

#ifndef __clsKMeans__

#define __clsKMeans__

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "def.h"
#include "sis.h"

//xxxdebug
#include "skipl.h"

class c_KMeans {
private:
static uent ElegirKCentroides(c_Agrupamiento &agrup, uent nroGrupo, uent
*indGrupos, c_VecArchivo *vVecArchivos[], bool bOptimizarSeparacion, uent cantMuestras);
public:
static uword contMoverYRecalcular; /* cuenta las veces que se llam a la
funcin de mover y recalcular */
static uent k;
static uent codCriterio; /* el criterio de optimizacion que se utiliza para refinar */
/* 1 : minima distancia de cada elemento al centroide del grupo */
/* 2 : ... */
c_KMeans() {};
~c_KMeans() {};
static uent FaseInicial(c_Agrupamiento &agrup, uent nroGrupo, c_VecArchivo
*vVecArchivos[], uent *indGrupos, bool bOptimizarSeparacion, uent cantMuestras);
static uent FaseInicialLite(c_Agrupamiento &agrup, uent nroGrupo,
c_VecArchivo *vVecArchivos[], uent *indGrupos, bool bOptimizarSeparacion, uent
cantMuestras);
static uent CalcularCentroides(c_Agrupamiento &agrup,c_VecArchivo
*vVecArchivos[],uent cantGrup,uent *vecIndGrupos);
static uent FaseRefinar(c_Agrupamiento &agrup, c_VecArchivo
*vVecArchivos[], uent *indGrupos,bool iteracionesFijas, uent &cantIteraciones, uent
&cantCambiosTotal);
static uent FaseRefinarLite(c_Agrupamiento &agrup, c_VecArchivo
*vVecArchivos[], uent *indGrupos,bool iteracionesFijas, uent &cantIteraciones, uent
&cantCambiosTotal);
static bool NroGrupoEstaEnVectorIndices(uent nro, uent *vector,uent
cantEntradas, c_Agrupamiento &agrup, uent &indGrupo);
static real ValorCriterioActual(c_Agrupamiento &agrup, c_VecArchivo
*vVecArchivos[], uent nroElemAnalisis, uent indGrupoAnalisis);
static real ValorCriterioAlternativa(c_Agrupamiento &agrup, c_VecArchivo
*vVecArchivos[], uent nroElemAnalisis, uent indGrupoCandidato, real valCriterioActual);


static uent MoverElementoyRecalcular(c_Agrupamiento &agrup,c_VecArchivo
*vVecArchivos[],uent nroElem,uent indGrupoOrig,uent indGrupoGanador, bool
restarACentroide);
static uent BisectingKMeans(c_Agrupamiento* &agrup, uent nroGrupo,
c_VecArchivo *vVecArchivos[], uent kBisect, bool refinar);
};

#endif


A4.2.10 ClsKMeans.cpp


#define MAX_VALOR_CRITERIO (real)1000000.0
/* maximo valor que va a tomar cualquiera de los criterios de
optimizacion */
#define MARGEN_CRITERIO (real)0.1

/* por defecto k = 5 */
uent c_KMeans::k = 5;
uword c_KMeans::contMoverYRecalcular = 0;

/* por defecto criterio = 1 */
uent c_KMeans::codCriterio = 1;

uent c_KMeans::ElegirKCentroides(c_Agrupamiento &agrup, uent nroGrupo, uent *indGrupos,
c_VecArchivo *vVecArchivos[], bool bOptimizarSeparacion, uent cantMuestras)
{
/* elige K centroides al azar
los K centroides al azar los toma del grupo "nroGrupo"
En el campo "menorNroElem" del grupo "nroGrupo"
pone el nro de elemento de uno de los centroides.
Tambien crea (k - 1) grupos ms en el agrupamiento
y al campo "menorNroElem" de cada uno de esos grupos
le asigna su respectivo centroide
Deja el agrupamiento en un estado inconsistente,
ya que se usa el campo de menor grupo de elemento
para designar al centroide elegido.
(solo es inconsistente para el grupo "nroGrupo",
para los nuevos grupos, el centroide es el nico elemento
En el vector "indGrupos" (que se recibe con memoria alocada para k
nmeros) devuelve un vector con los ndices del grupo original
y los grupos que se crearon
En el caso particular de que haya que elegir 2 centroides, si el
parmetro bOptimizarSeparacion es true, toma "cantMuestras" elementos
al azar y elige los 2 que estn ms distantes el uno del otro
*/
uent *nrosAzar, *vNroElem;
uent indGrupo, cantElemGrupo, cantGruposAnterior;
uent codRet;
uent i, j, indElem, indElemGrupo;
uent parejaMasDistante[2];
real menorSimProm, simProm;
c_VecArchivo *vArch1, *vArch2;

indGrupo = agrup.IndiceDeGrupo(nroGrupo,false);
cantElemGrupo = agrup.vecGrupos[indGrupo].cantElementos;
cantGruposAnterior = agrup.cantGrupos;

/* generamos los numeros al azar */
if ((bOptimizarSeparacion == false) || (k != 2))
{
/* deben generarse k numeros al azar */
cantMuestras = k;
}


/* generamos cantMuestras nmeros que esten entre 1 y la cantidad de elementos
del grupo */
nrosAzar = kNumerosRandom(cantMuestras,1,cantElemGrupo,true);
if (nrosAzar == NULL)
vNroElem = (uent*)malloc(cantMuestras * SINT);
if (vNroElem == NULL)
/* asignamos el numero de elemento que corresponde a cada uno */
indElem = 0;
indElemGrupo = 0;
for (i=0; i < cantMuestras; i++)
{
while(indElemGrupo < nrosAzar[i])
{
if (agrup.vecElementos[indElem] == nroGrupo)
indElemGrupo++;
indElem++;
}
vNroElem[i] = indElem - 1;
}

if ((bOptimizarSeparacion == true) && (k == 2))
{
/* tenemos que elegir los 2 elementos mas distantes */
menorSimProm = (real)10000.0;
/* vamos del primero al anteultimo */
for (i = 0; i < cantMuestras - 1; i++)
{
vArch1 = vVecArchivos[vNroElem[i]+1];
/* vamos desde el siguiente a i hasta el ultimo */
for (j=i+1; j < cantMuestras; j++)
{
vArch2 = vVecArchivos[vNroElem[j]+1];
/* calculamos la similitud */
simProm = vArch1->Multiplicar(*vArch2,false);
if (simProm < menorSimProm)
{
menorSimProm = simProm;
parejaMasDistante[0] = vNroElem[i];
parejaMasDistante[1] = vNroElem[j];
}
}
}
vNroElem[0] = parejaMasDistante[0];
vNroElem[1] = parejaMasDistante[1];
}

/* creamos k - 1 grupos mas */
codRet = agrup.AgregarGrupos(k - 1);
if (codRet != OK)
return codRet;
/* ahora, al campo "menorNroElem" de cada grupo le asignamos el
nmero de elemento elegido al azar */
indElem = 0;
indElemGrupo = 0;
for (i=0; i < k; i++)
{

if (i == 0) /* el primero es el grupo original */
{
agrup.vecGrupos[indGrupo].menorNroElem = vNroElem[i];
indGrupos[i] = indGrupo;
}
else /* los siguientes son los que se agregaron */
{
agrup.vecGrupos[cantGruposAnterior - 1 + i].menorNroElem =
vNroElem[i];
indGrupos[i] = cantGruposAnterior - 1 + i;
}
}

free((void*)nrosAzar);
free((void*)vNroElem);

return OK;
}

uent c_KMeans::FaseInicial(c_Agrupamiento &agrup, uent nroGrupo, c_VecArchivo
*vVecArchivos[], uent *indGrupos, bool bOptimizarSeparacion, uent cantMuestras)
{
/* Fase inicial del algoritmo kmeans
Se supone que el agrupamiento "agrup" se ha inicializado
y contiene al menos 1 grupo
En "nroGrupo" recibe el numero de grupo a separar
En la fase inicial, se arma un agrupamiento de la siguiente forma:
- se eligen k elementos como los centroides
- se asigna cada elemento al grupo del centroide ms cercano
En el vector "indGrupos" (que se recibe con memoria alocada para k
nmeros) devuelve un vector con los ndices de los
grupos en los que se separaron los elementos
*/
uent grupGanador, indGrupo, cantGruposAnterior;
real similGanador, similAux;
uent codRet;
uent *ordenProceso, *nrosElementos;
uent cantElemGrupo, i, j, indElemGrupo, nroElem;
c_VecArchivo *vecArchivoElem;
bool esCentroide,ganoEmpate;
uent empates;

/* tomamos el ndice del grupo y la cantidad de grupos */

/* elegimos los k centroides de los elementos del grupo */
codRet =
ElegirKCentroides(agrup,nroGrupo,indGrupos,vVecArchivos,bOptimizarSeparacion,cantMuestr
as);
if (codRet != OK)
return codRet;

/* elegimos un orden al azar para procesar los elementos del grupo */
ordenProceso = kNumerosRandom(cantElemGrupo,1,cantElemGrupo,false);


if (ordenProceso == NULL)
/* armamos un vector con los numeros de elemento del grupo */
nrosElementos = (uent*)malloc(cantElemGrupo * SINT);
indElemGrupo = 0;
for (i = 0; i < agrup.cantElementos; i++)
{
if (agrup.vecElementos[i] == nroGrupo)
{
//xxxdebug
//printf("c_KMeans::FI::orAzar : %d ;; nroElem :
%d\n",ordenProceso[indElemGrupo]-1,i);
nrosElementos[ordenProceso[indElemGrupo]-1] = i;
indElemGrupo++;
}
}
/* el centroide de cada grupo es el elemento que figura en el campo "menorNroElem" */
for (i = 0; i < k; i++)
{
if (i == 0)
j = indGrupo;
else
j = cantGruposAnterior + i - 1;
if (agrup.vecGrupos[j].vecCentroide != NULL)
delete(agrup.vecGrupos[j].vecCentroide);
agrup.vecGrupos[j].vecCentroide = new c_VecArchivo;
agrup.vecGrupos[j].vecCentroide-
>Duplicar(*(vVecArchivos[agrup.vecGrupos[j].menorNroElem + 1]));
}

/* los procesamos en el orden al azar, buscando su nuevo grupo */
for (i = 0; i < cantElemGrupo; i++)
{
empates = 0;
esCentroide = false;
nroElem = nrosElementos[i];
vecArchivoElem = vVecArchivos[nroElem + 1];
/* veamos la similitud con el centroide del grupo original */
if (nroElem == agrup.vecGrupos[indGrupo].menorNroElem)
{
esCentroide = true;
grupGanador = indGrupo;
}
else
{
similGanador = vecArchivoElem-
>Multiplicar(*(agrup.vecGrupos[indGrupo].vecCentroide),false);
grupGanador = indGrupo;
}
/* ahora con los otros */
for (j = 0; j < k-1; j++)
{
if (!esCentroide)
{
if (nroElem == agrup.vecGrupos[cantGruposAnterior +
j].menorNroElem)
{
esCentroide = true;

grupGanador = cantGruposAnterior + j;
}
else
{
similAux = vecArchivoElem-
>Multiplicar(*(agrup.vecGrupos[cantGruposAnterior + j].vecCentroide),false);
ganoEmpate = false;
if (similAux == similGanador)
{
empates++;
ganoEmpate = (RANDOM(empates+1)==0);
}
if ((similAux > similGanador) || ganoEmpate)
{
similGanador = similAux;
grupGanador = cantGruposAnterior + j;
}
}
}
}
if (bOptimizarSeparacion)
{

c_KMeans::MoverElementoyRecalcular(agrup,vVecArchivos,nroElem,indGrupo,grupGa
nador,false);
}
else
{
/* si hace falta, lo movemos */
if (grupGanador != indGrupo)
{
agrup.MoverElemento(nroElem, grupGanador, indGrupo);
}
}
//xxxdebug
//if (esCentroide)
//printf("c_KMeans:FI: Elem : %d ;; Es centroide de :
%d\n",nroElem,grupGanador + 1);
//else
//printf("c_KMeans:FI: Elem : %d ;; SimGan : %f ;; GrupGan :
%d\n",nroElem,similGanador,grupGanador + 1);
}

free((void*)ordenProceso);
free((void*)nrosElementos);

return OK;
}

uent c_KMeans::FaseInicialLite(c_Agrupamiento &agrup, uent nroGrupo, c_VecArchivo
*vVecArchivos[], uent *indGrupos, bool bOptimizarSeparacion, uent cantMuestras)
{
/*
Igual que la fase inicial pero version "Lite"
*/
uent grupGanador, indGrupo, cantGruposAnterior;
real similGanador, similAux;
uent codRet;


uent *ordenProceso, *nrosElementos;
uent cantElemGrupo, i, j, indElemGrupo, nroElem;
c_VecArchivo *vecArchivoElem;
bool esCentroide,ganoEmpate;
uent empates;
uent cantGruposMuestra;
uent *vecIndGruposMuestra;

/* tomamos el ndice del grupo y la cantidad de grupos */

/* elegimos los k centroides de los elementos del grupo */
codRet =
ElegirKCentroides(agrup,nroGrupo,indGrupos,vVecArchivos,bOptimizarSeparacion,cantMuestr
as);
if (codRet != OK)
return codRet;

/* elegimos un orden al azar para procesar los elementos del grupo */
ordenProceso = kNumerosRandom(cantElemGrupo,1,cantElemGrupo,false);
/* armamos un vector con los numeros de elemento del grupo */
nrosElementos = (uent*)malloc(cantElemGrupo * SINT);
indElemGrupo = 0;
for (i = 0; i < agrup.cantElementos; i++)
{
if (agrup.vecElementos[i] == nroGrupo)
{
//xxxdebug
//printf("c_KMeans::FI::orAzar : %d ;; nroElem :
%d\n",ordenProceso[indElemGrupo]-1,i);
nrosElementos[ordenProceso[indElemGrupo]-1] = i;
indElemGrupo++;
}
}
/* la cantidad de grupos muestra es del orden de log k */
cantGruposMuestra = (uent)(log(k)/log(2))*2;
/* los procesamos en el orden al azar, buscando su nuevo grupo */
for (i = 0; i < cantElemGrupo; i++)
{
/* armamos el vector de muestra de grupos */
vecIndGruposMuestra = kNumerosRandom(cantGruposMuestra,0,k-1,true);
if (vecIndGruposMuestra == NULL)
empates = 0;
esCentroide = false;
nroElem = nrosElementos[i];
vecArchivoElem = vVecArchivos[nroElem + 1];
/* veamos la similitud con el centroide del grupo original */
if (nroElem == agrup.vecGrupos[vecIndGruposMuestra[0]].menorNroElem)
{
esCentroide = true;
grupGanador = vecIndGruposMuestra[0];
}
else

{
similGanador = vecArchivoElem-
>Multiplicar(*(vVecArchivos[agrup.vecGrupos[vecIndGruposMuestra[0]].menorNroElem +
1]),false);
grupGanador = vecIndGruposMuestra[0];
}
/* ahora con los otros */
for (j = 1; j < cantGruposMuestra-1; j++)
{
if (!esCentroide)
{
if (nroElem ==
agrup.vecGrupos[vecIndGruposMuestra[j]].menorNroElem)
{
esCentroide = true;
grupGanador = vecIndGruposMuestra[j];
}
else
{
similAux = vecArchivoElem-
>Multiplicar(*(vVecArchivos[agrup.vecGrupos[vecIndGruposMuestra[j]].menorNroElem +
1]),false);
ganoEmpate = false;
if (similAux == similGanador)
{
empates++;
ganoEmpate = (RANDOM(empates+1)==0);
}
if ((similAux > similGanador) || ganoEmpate)
{
similGanador = similAux;
grupGanador = vecIndGruposMuestra[j];
}
}
}
}
/* si hace falta, lo movemos */
if (grupGanador != indGrupo)
{
agrup.MoverElemento(nroElem, grupGanador, indGrupo);
}

free((void*)vecIndGruposMuestra);

//xxxdebug
//if (esCentroide)
//printf("c_KMeans:FI: Elem : %d ;; Es centroide de :
%d\n",nroElem,grupGanador + 1);
//else
//printf("c_KMeans:FI: Elem : %d ;; SimGan : %f ;; GrupGan :
%d\n",nroElem,similGanador,grupGanador + 1);
}

free((void*)nrosElementos);

return OK;
}


uent c_KMeans::CalcularCentroides(c_Agrupamiento &agrup,c_VecArchivo
*vVecArchivos[],uent cantGrup,uent *vecIndGrupos)
{
/* calcula los centroides de los grupos */
/* si cantGrup es 0, calcula los centroides de todos los grupos
si no, calcula solamente los centroides de los grupos que estan
en vecIndGrupos */
uent i,codRet,indAux;
uent j, cantElemGrup;
real unoSobre;
c_VecArchivo *centroide;

for (i=0; i < agrup.cantGrupos; i++)
{
if ((cantGrup == 0) ||
NroGrupoEstaEnVectorIndices(agrup.vecGrupos[i].nroGrupo,vecIndGrupos,cantGrup,agrup,ind
Aux))
{
/* si tena el centroide creado, lo reinicializamos */
if (agrup.vecGrupos[i].vecCentroide != NULL)
{
delete(agrup.vecGrupos[i].vecCentroide);
}
centroide = new c_VecArchivo;
agrup.vecGrupos[i].vecCentroide = centroide;
codRet = centroide->CrearVector(0);
if (codRet != OK)
return codRet;
cantElemGrup = agrup.vecGrupos[i].cantElementos;
/* sumamos los elementos de ese grupo */
for (j=0; j < agrup.cantElementos; j++)
if (agrup.vecElementos[j] == agrup.vecGrupos[i].nroGrupo)
centroide->Sumar(*(vVecArchivos[j+1]));
/* dividimos cada entrada por la cantidad de elementos del grupo */
unoSobre = (real)1.0 / (real)cantElemGrup;
centroide->MultiplicarPorReal(unoSobre);
/* actualizamos las palabras clave */
centroide->ActualizarPalabrasClave();
}
}

return OK;
}

uent c_KMeans::FaseRefinar(c_Agrupamiento &agrup, c_VecArchivo *vVecArchivos[], uent
*indGrupos,bool iteracionesFijas, uent &cantIteraciones, uent &cantCambiosTotal)
{
/* ejecuta la fase de refinamiento del algoritmo k-means
en el vector indGrupos recibe los indices de los grupos entre los
cuales puede mover documentos
en agrup recibe un agrupamiento que ya tiene calculados
los centroides de sus grupos
el parametro iteracionesFijas indica si el algoritmo debe ejecutarse
hasta un numero mximo de iteraciones. en caso de que sea verdadero,
el parametro cantIteraciones indica este nmero mximo

la funcin itera hasta que no se producen cambios en los grupos o
hasta alcanzar el mximo nmero de iteraciones (si corresponde)
en el parametro cantIteraciones se devuelve la cantidad de iteraciones
que se realizaron
*/
uent iIteraciones,iElem,iGrupos,cantCambios, indGrupoOrig;
uent cantElementos, nroElem, nroGrupoElem, indGrupoGanador;
uent *ordenProceso;
real valorActual, valorAux, incGanador;
uent codRet;
bool bParar;

iIteraciones = 0;
cantCambiosTotal = 0;
bParar = false;

while (!bParar)
{
cantCambios = 0;
/* buscamos un orden al azar para procesar los elementos */
ordenProceso = kNumerosRandom(cantElementos,0,cantElementos-1,false);
/* vamos iterando por todos los elementos pero procesamos
solamente los de los grupos que nos interesan */
for (iElem=0; iElem<cantElementos; iElem++)
{
/* tomamos el elemento */
nroElem = ordenProceso[iElem];

///xxxdebug
//printf("KMRefinar:Proc.Elem=%d\n",nroElem);

nroGrupoElem = agrup.vecElementos[nroElem];
/* veamos si esta en uno de los grupos que nos interesan */
if
(NroGrupoEstaEnVectorIndices(nroGrupoElem,indGrupos,k,agrup,indGrupoOrig))
{
///xxxdebug
//printf(" nos interesa(grupo=%d)\n",nroGrupoElem);

/* calculamos el valor actual, y decimos que el ganador es el
grupo
actual */
indGrupoGanador = indGrupoOrig;
valorActual =
ValorCriterioActual(agrup,vVecArchivos,nroElem,indGrupoOrig);
incGanador = 0.0;
/* evaluamos el movimiento a cada uno de los otros
grupos */
//xxxdebug
//printf(" increm:[%f];;;",valorActual);
for (iGrupos=0; iGrupos < k; iGrupos++)
{
if (iGrupos != indGrupoGanador) /* no
evaluamos 2 veces el grupo original */


{
valorAux =
ValorCriterioAlternativa(agrup,vVecArchivos,nroElem,iGrupos,valorActual);
if ((valorAux - valorActual) > incGanador)
{
/* este incremento va ganando por
ahora */
indGrupoGanador = iGrupos;
incGanador = (valorAux - valorActual);
}
//xxxdebug
//printf("%f;;;",valorAux - valorActual);
}
}
//xxxdebug
//printf("\n");
/* veamos si hubo un ganador */
if (indGrupoGanador != indGrupoOrig)
{
/* hay que mover el elemento */
codRet =
MoverElementoyRecalcular(agrup,vVecArchivos,nroElem,indGrupoOrig,indGrupoGanador,true)
;
if (codRet != OK)
return codRet;
cantCambios++; /* sumamos un cambio esta vuelta */
//xxxdebug
//printf("KMRefinar::Cambio.Iter=%d
Elem=%d;Orig=%d;Dest=%d\n",iIteraciones,nroElem,indGrupoOrig,indGrupoGanador);
}
}
}

cantCambiosTotal += cantCambios;

//xxxdebug
//printf("KMRefinar::FinIter=%d Cambios=%d\n",iIteraciones,cantCambios);

/* liberamos el vector de orden aleatorio */
/* si no hubo ningun cambio tenemos que parar */
if (cantCambios == 0)
bParar = true;
/* sumamos una iteracion mas y vemos si ya tenemos que parar */
iIteraciones++;
if (iIteraciones >= cantIteraciones)
bParar = true;
}

/* devolvemos la cantidad de iteraciones */
cantIteraciones = iIteraciones;

//xxxdebug
printf("KMRefinar::Fin TotalIter=%d
TotalCambios=%d\n",iIteraciones,cantCambiosTotal);

return OK;

}

uent c_KMeans::FaseRefinarLite(c_Agrupamiento &agrup, c_VecArchivo *vVecArchivos[], uent
*indGrupos,bool iteracionesFijas, uent &cantIteraciones, uent &cantCambiosTotal)
{
/*
Igual que la fase inicial pero version "Lite"
*/
uent iIteraciones,iElem,iGrupos,cantCambios, indGrupoOrig;
uent cantElementos, nroElem, nroGrupoElem, indGrupoGanador;
uent *ordenProceso;
real valorActual, valorAux, incGanador;
uent codRet;
bool bParar;
uent cantGruposMuestra;
uent *vecIndGruposMuestra;
uent h;

iIteraciones = 0;
cantCambiosTotal = 0;
bParar = false;

/* la cantidad de grupos muestra es del orden de log k */
cantGruposMuestra = (uent)(log(k)/log(2))*2;

while (!bParar)
{
cantCambios = 0;
/* buscamos un orden al azar para procesar los elementos */
ordenProceso = kNumerosRandom(cantElementos,0,cantElementos-1,false);
/* vamos iterando por todos los elementos pero procesamos
solamente los de los grupos que nos interesan */
for (iElem=0; iElem<cantElementos; iElem++)
{
/* tomamos el elemento */
nroElem = ordenProceso[iElem];

///xxxdebug
//printf("KMRefinar:Proc.Elem=%d\n",nroElem);

nroGrupoElem = agrup.vecElementos[nroElem];
/* veamos si esta en uno de los grupos que nos interesan */
if
(NroGrupoEstaEnVectorIndices(nroGrupoElem,indGrupos,k,agrup,indGrupoOrig))
{
///xxxdebug
//printf(" nos interesa(grupo=%d)\n",nroGrupoElem);

/* armamos el vector de muestra de grupos */
vecIndGruposMuestra =
kNumerosRandom(cantGruposMuestra,0,k-1,true);
if (vecIndGruposMuestra == NULL)
{
//xxxdebug
perror("Null vecIndGruposMuestra...");


getchar(); getchar();
}

/* calculamos el valor actual, y decimos que el ganador es el
grupo
actual */
indGrupoGanador = indGrupoOrig;
valorActual =
ValorCriterioActual(agrup,vVecArchivos,nroElem,indGrupoOrig);
incGanador = 0.0;
/* evaluamos el movimiento a cada uno de los otros
grupos */
//xxxdebug
//printf(" increm:[%f];;;",valorActual);
for (h=0; h < cantGruposMuestra; h++)
{
iGrupos = vecIndGruposMuestra[h];
if (iGrupos != indGrupoGanador) /* no
evaluamos 2 veces el grupo original */
{
valorAux =
ValorCriterioAlternativa(agrup,vVecArchivos,nroElem,iGrupos,valorActual);
if ((valorAux - valorActual) > incGanador)
{
/* este incremento va ganando por
ahora */
indGrupoGanador = iGrupos;
incGanador = (valorAux - valorActual);
}
//xxxdebug
//printf("%f;;;",valorAux - valorActual);
}
}
free((void*)vecIndGruposMuestra);
//xxxdebug
//printf("\n");
/* veamos si hubo un ganador */
if (indGrupoGanador != indGrupoOrig)
{
/* hay que mover el elemento */
codRet =
MoverElementoyRecalcular(agrup,vVecArchivos,nroElem,indGrupoOrig,indGrupoGanador,true)
;
if (codRet != OK)
return codRet;
cantCambios++; /* sumamos un cambio esta vuelta */
//xxxdebug
//printf("KMRefinar::Cambio.Iter=%d
Elem=%d;Orig=%d;Dest=%d\n",iIteraciones,nroElem,indGrupoOrig,indGrupoGanador);
}
}
}

cantCambiosTotal += cantCambios;

//xxxdebug
//printf("KMRefinar::FinIter=%d Cambios=%d\n",iIteraciones,cantCambios);


/* liberamos el vector de orden aleatorio */
/* si no hubo ningun cambio tenemos que parar */
if (cantCambios == 0)
bParar = true;
/* sumamos una iteracion mas y vemos si ya tenemos que parar */
iIteraciones++;
if (iIteraciones >= cantIteraciones)
bParar = true;
}

/* devolvemos la cantidad de iteraciones */
cantIteraciones = iIteraciones;

//xxxdebug
printf("KMRefinarLite::Fin TotalIter=%d
TotalCambios=%d\n",iIteraciones,cantCambiosTotal);

return OK;
}

bool c_KMeans::NroGrupoEstaEnVectorIndices(uent nro, uent *vector,uent cantEntradas,
c_Agrupamiento &agrup, uent &indGrupo)
{
/* busca si el numero de grupo "nro" tiene un indice que est dentro
del vector "vector", que tiene "cantEntradas" entradas
si est, en el parametro "indGrupo" devuelve el indice del grupo
*/

uent i;

if (agrup.vecGrupos[vector[i]].nroGrupo == nro)
{
indGrupo = vector[i];
return true;
}

return false;

}

real c_KMeans::ValorCriterioActual(c_Agrupamiento &agrup, c_VecArchivo *vVecArchivos[],
uent nroElemAnalisis, uent indGrupoAnalisis)
{
/*
calcula el valor actual del criterio que se optimiza con el algoritmo
en "nroElemAnalisis" recibe el nro de elemento que est siendo analizado
para ver si se mueve a otro grupo (para algunos criterios va a hacer falta)
en "indGrupoAnalisis" recibe el indice del grupo al cual pertenece el
elemento que se est analizando (para algunos criterios va a hacer falta)
*/

/* antes que nada, veamos si el elemento es el ultimo que queda
en el grupo. En ese caso, devolvemos el maximo valor, ya que
no se deben eliminar grupos */


if (agrup.vecGrupos[indGrupoAnalisis].cantElementos <= 1)
return MAX_VALOR_CRITERIO;

real valorCriterio;
real normaCent;

switch (codCriterio)
{
case 1 :
{
c_VecArchivo *vecCent, *vecElem;
real simil;
/* este criterio es igual a la similitud entre
el centroide del grupo y el elemento */
vecCent = agrup.vecGrupos[indGrupoAnalisis].vecCentroide;
vecElem = vVecArchivos[nroElemAnalisis+1];
simil = vecCent->Multiplicar(*vecElem,false);
normaCent = vecCent->CalcularNorma(false);
valorCriterio = simil / normaCent;
break;
}
default :
{
/* error : no estaba definido el criterio */
valorCriterio = 0.0;
}
}

/* siempre tenemos que devolver algo menor que el maximo */
if (valorCriterio >= MAX_VALOR_CRITERIO)
valorCriterio = MAX_VALOR_CRITERIO - MARGEN_CRITERIO;

return valorCriterio;
}

real c_KMeans::ValorCriterioAlternativa(c_Agrupamiento &agrup, c_VecArchivo
*vVecArchivos[], uent nroElemAnalisis, uent indGrupoCandidato, real valCriterioActual)
{
/*
calcula el valor del criterio para la alternativa de mover el
elemento "nroElem" al grupo de indice "indGrupoCandidato"
en "nroElemAnalisis" recibe el nro de elemento que est siendo analizado
en "indGrupoCandidato" recibe el indice del grupo al cual se est
evaluando mover el elemento
en "valCriterioActual" recibe el valor actual del criterio
(para algunos criterios puede hacer falta)
*/
real valorCriterio;
real normaCent;

{
case 1 :
{
c_VecArchivo *vecCent, *vecElem;
real simil;
/* este criterio es igual a la similitud entre

el centroide del grupo y el elemento */
vecCent = agrup.vecGrupos[indGrupoCandidato].vecCentroide;
vecElem = vVecArchivos[nroElemAnalisis+1];
simil = vecCent->Multiplicar(*vecElem,false);
normaCent = vecCent->CalcularNorma(false);
valorCriterio = simil / normaCent;
break;
}
default :
{
valorCriterio = 0.0;
}
}

/* siempre tenemos que devolver algo menor que el maximo */
if (valorCriterio >= MAX_VALOR_CRITERIO)
valorCriterio = MAX_VALOR_CRITERIO - MARGEN_CRITERIO;

return valorCriterio;

}

uent c_KMeans::MoverElementoyRecalcular(c_Agrupamiento &agrup,c_VecArchivo
*vVecArchivos[],uent nroElem,uent indGrupoOrig,uent indGrupoGanador, bool
restarACentroide)
{
/* mueve el elemento "nroElem" del grupo con indice "indGrupoOrig"
al grupo con indice "indGrupoGanador"
recalcula todo lo que haga falta dentro del agrupamiento
(ej : centroides) que sea necesario de acuerdo a cada criterio
*/

uent codRet;

contMoverYRecalcular++;

{
case 1 :
{
c_VecArchivo *vecCentOrig, *vecCentGanador, *vecElem;
real unoSobre;
uent cantElemOrig, cantElemGanador;
/* recalculamos los centroides de los 2 grupos */
vecCentOrig = agrup.vecGrupos[indGrupoOrig].vecCentroide;
vecCentGanador = agrup.vecGrupos[indGrupoGanador].vecCentroide;
vecElem = vVecArchivos[nroElem+1];
cantElemOrig = agrup.vecGrupos[indGrupoOrig].cantElementos;
cantElemGanador =
agrup.vecGrupos[indGrupoGanador].cantElementos;
/* al original le restamos el elemento que le sacamos */
/* primero lo multiplicamos por la cantidad de elementos anterior */
if (restarACentroide == true)
{
vecCentOrig->MultiplicarPorReal((real)cantElemOrig);
codRet = vecCentOrig->Restar(*vecElem);
if (codRet != OK)


return codRet;
unoSobre = (real)1.0 / (real)(cantElemOrig - 1);
vecCentOrig->MultiplicarPorReal(unoSobre);
}
/* al ganador le sumamos el elemento que le agregamos */
/* primero lo multiplicamos por la cantidad de elementos anterior */
vecCentGanador->MultiplicarPorReal((real)cantElemGanador);
codRet = vecCentGanador->Sumar(*vecElem);
if (codRet != OK)
return codRet;
unoSobre = (real)1.0 / (real)(cantElemGanador + 1);
vecCentGanador->MultiplicarPorReal(unoSobre);
/* movemos el elemento de un grupo al otro */
agrup.MoverElemento(nroElem,indGrupoGanador,indGrupoOrig);
break;
}
default :
{

}
}

return OK;

}

uent c_KMeans::BisectingKMeans(c_Agrupamiento* &agrup, uent nroGrupo, c_VecArchivo
*vVecArchivos[], uent kBisect, bool refinar)
/*
Divide al grupo "nroGrupo" en k grupos usando el algoritmo
bisecting kmeans (Steinbach et al, 2000)
Se divide el grupo en "kBisect" grupos usando el algoritmo kmeans basico, luego
se toma el grupo mas grande y se lo vuelve a dividir en "kBisect", etc
Para que esto funcione, debe cumplirse que
k = 1 + (n * (kBisect-1)) con "n" cualquier entero mayor a 0
Si refinar es "true", cuando termina, corre la fase de refinacion
sobre el agrupamiento
*/
{
uent codRet;
uent *vec2Ind, *vecIndices, indiceAux;
uent kOriginal, cantCambiosTotal = 0;
uent iCantGrupos, i, cantIter;
uent nroADividir, cantElemMax;

uent j, cantCandidatosKMeans = 5; /* cantidad de veces que se hace el KMeans
basico */
real normaCent, simProm, maxSimProm;
uent indMejor;
c_Agrupamiento **vecAgrups;

/* creamos un vector de punteros a los agrupamientos candidatos */
vecAgrups = (c_Agrupamiento**)malloc(cantCandidatosKMeans *
sizeof(c_Agrupamiento*));

if (vecAgrups == NULL)

kOriginal = k; /* guardamos la variable de clase k */
k = kBisect; /* seteamos k = kBisect */

/* este vector va a contener los kBisect indices de los grupos que vamos
a ir refinando */
vec2Ind = (uent*)malloc(k * SINT);
if (vec2Ind == NULL)

/* en este vector vamos a tener los indices de los grupos que vamos
generando */
vecIndices = (uent*)malloc(kOriginal * SINT);
if (vecIndices == NULL)

iCantGrupos = 1; /* ahora tenemos 1 solo grupo */
vecIndices[0] = agrup->IndiceDeGrupo(nroGrupo,false); /* es el grupo original */

while (iCantGrupos < kOriginal) /* hasta que no tengamos la cantidad de grupos que
queremos */
{
/* buscamos el grupo que tenga la mayor cantidad de elementos */
cantElemMax = 0;
for (i=0; i < agrup->cantGrupos; i++)
{
if (NroGrupoEstaEnVectorIndices(agrup-
>vecGrupos[i].nroGrupo,vecIndices,iCantGrupos,*agrup,indiceAux))
{
if (agrup->vecGrupos[i].cantElementos > cantElemMax)
{
nroADividir = agrup->vecGrupos[i].nroGrupo;
cantElemMax = agrup->vecGrupos[i].cantElementos;
}
}
}

/* vamos a buscar candidatos usando el kmeans basico */
/* creamos los candidatos */
maxSimProm = -1; /* inicializamos el maximo como negativo */
for (i=0; i < cantCandidatosKMeans; i++)
{
/* creamos un agrupamiento y lo hacemos igual al que tenemos
hasta ahora */
vecAgrups[i] = new c_Agrupamiento();
if (vecAgrups[i] == NULL)
codRet = vecAgrups[i]->Duplicar(*agrup);
if (codRet != OK)
return codRet;

/* dividimos el nro de grupo que tenia mas elementos */
codRet =
FaseInicial(*(vecAgrups[i]),nroADividir,vVecArchivos,vec2Ind,false,0);
if (codRet != OK)
return codRet;


/* calculamos los centroides */
codRet = CalcularCentroides(*(vecAgrups[i]),vVecArchivos,k,vec2Ind);
if (codRet != OK)
return codRet;
/* refinamos */
cantIter = 100;
codRet =
FaseRefinar(*(vecAgrups[i]),vVecArchivos,vec2Ind,true,cantIter,cantCambiosTotal);
if (codRet != OK)
return codRet;

/* calculamos la similitud promedio de los nuevos grupos */
simProm = 0;
for (j = 0; j < k; j++)
{
/* buscamos la norma del centroide */
normaCent = ((vecAgrups[i]-
>vecGrupos[vec2Ind[j]]).vecCentroide)->CalcularNorma(false);
simProm += normaCent * normaCent;
//xxxdebug
printf("BisKM:NormaCent[%d,%d] = %f\n",i,j,normaCent *
normaCent);
}

if (simProm > maxSimProm)
{
/* este es el mejor que tenemos hasta el momento */
maxSimProm = simProm;
indMejor = i;
}

//xxxdebug
printf("BisKM:SimProm[%d] = %f\n",i,simProm / k);
//c_Agrup_Imprime::salidaCompacta = false;
//c_Agrup_Imprime::ImprimirTodo(stdout,agrup,vVecArchivos,lLex,lTxt);
//printf ("Otra Iter \n");
}

//xxxdebug
printf("BisKM:SimPromGanador[%d] = %f\n",indMejor,maxSimProm / k);

/* nos quedamos con el mejor candidato y destruimos el resto */
for (i=0; i < cantCandidatosKMeans; i++)
{
if (i!=indMejor)
delete(vecAgrups[i]);
}
delete agrup;
agrup = vecAgrups[indMejor];

/* ingresamos los nuevos grupos en el vector */
for (i=1; i < k; i++)
vecIndices[iCantGrupos + i - 1] = vec2Ind[i];
iCantGrupos += k - 1;
}

/* restauramos el valor de k */
k = kOriginal;


/* veamos si hay que refinar */
if (refinar)
{
cantIter = 100;
FaseRefinar(*agrup,vVecArchivos,vecIndices,true,cantIter,cantCambiosTotal);
}

/* liberamos los vectores que creamos */
free((void*)vecIndices);
free((void*)vec2Ind);
free((void*)vecAgrups);

return OK;
}



A4.2.11 ClsGenetico.h

/*
Clase que implementa las funciones del algoritmo genetico

*/

#ifndef __clsGenetico__

#define __clsGenetico__

#include <malloc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "def.h"
#include "sis.h"

//xxxdebug
#include "skipl.h"

typedef struct _t_RegConfigGenetico {
FILE *fpSalidaDebug; /* puntero a un archivo al que se enva la salida de depuracion */
uent generacionesMaximo; /* maximo numero de generaciones */
uent poblacionTamanio; /* tamao de la poblacion */
uent poblacionTamanioDeseado; /* el tamao de la poblacion tiene que llegar a ser
este */
uent torneoTamanio; /* tamao del torneo */
real torneoProbMejor; /* probabilidad que tiene de ser elegido el mejor del torneo */
uent fitnessCriterio; /* criterio para calcular el fitness
1 : similitud promedio de los elementos
de cada grupo
2 : promedio de las normas de los
centroides
3 : .. (no definido todavia)
*/
uent cruzaOperador; /* operador de cruza a utilizar
1 : pasar un grupo del padre al hijo
2 : ... (no definido todavia)
*/
real cruzaPasaGrupoProbMejor; /* probabilidad de que la cruza que pasa grupos pase
el de mayor similitud promedio */
real cruzaPasaGrupoProbMasElemComun; /* probabilidad de que el grupo destino sea
el que tiene mas elementos en comun */
real cruzaPasaGrupoProbMasSimilar; /* probabilidad de que el grupo destino sea el
mas similar */
real cruzaPasaGrupoProbMenorSimilProm; /* probabilidad de que el grupo destino sea
el que tiene menor similitud promedio */
real cruzaPasaGrupoProbAzar; /* probabilidad de que el grupo destino se elija por azar
*/

real cruzaPasaGrupoProbMejorDestino; /* probabilidad de el elemento que se saca del
grupo destino pase al grupo mas similar */
uent k; /* cantidad de grupos */
uent mutacionRefinarKMCantIter; /* cantidad de iteraciones de refinamiento en la
mutacion que refina */
real mutacionRefinarKMProb; /* probabilidad de que se aplique la mutacion que refina
*/
uent generacionInicialModo; /* forma de generar la poblacion inicial :
1 : al azar
2 : con la fase inicial
(lite) del kmeans
3 : fase inicial del
kmeans pero solo log k grupos
*/
real mutacionJoinProb; /* probabilidad de que se aplique la mutacion que junta 2
grupos */
real mutacionJoinProbMasSimilar; /* probabilidad de que el grupo destino sea el mas
similar */
real mutacionJoinProbMenorSimilProm; /* probabilidad de que el grupo origen sea el
que tiene menor similitud promedio */
real mutacionJoinProbMasChico; /* probabilidad de que el grupo origen sea el mas
chico */
real mutacionJoinProbAzar; /* probabilidad de que los grupos se elijan por azar */
real mutacionSplitProb; /* probabilidad de que se aplique la mutacion que separa 1
grupo */
real mutacionSplitProbMasGrande; /* probabilidad de que el grupo sea el que tiene ms
elementos */
real mutacionSplitProbMenorSimilProm; /* probabilidad de que el grupo origen sea el
que tiene menor similitud promedio */
real mutacionSplitProbAzar; /* probabilidad de que los grupos se elijan por azar */
uent mutacionSplitCantMuestras; /* cantidad de muestras a tomar para buscar los
elementos mas distantes del grupo */
real mutacionRefinarSelectivoProb; /* probabilidad de que se aplique la mutacion de
refinacion selectiva */
} tRegConfigGenetico;

typedef struct _t_Cromosoma {
c_Agrupamiento *agrup;
real fitness;
bool disponible;
ent ultimoJoin; //indice del ultimo grupo en el cual se hizo un join (o -1)
} tCromosoma;

class c_Genetico {
private:
uent AsignarFormaElegirGrupoDestino();
uent AsignarFormaElegirGrupoSplit();
tCromosoma **poblacion;
real FitnessDeCromosoma(tCromosoma &cromosoma);
uent privCruzaPasaGrupo(tCromosoma *padre1, tCromosoma *padre2,
tCromosoma **hijo1, c_VecArchivo *vVecArchivos[]);
void ActualizarParametros(uent genActual,uent genLimite);
FILE *DebugFP();
public:
uent ElegirPorTorneo(uent &indElegido, bool invertido);
tRegConfigGenetico RegConfig;
c_Genetico();
~c_Genetico();


uent GenerarPoblacionInicial(uent cantElemAAgrupar, c_VecArchivo
*vVecArchivos[]);
uent Evolucionar(c_VecArchivo *vVecArchivos[],bool generacionesFijas, uent
&cantGeneraciones);
uent DevolverMejorSolucion(c_Agrupamiento **solucion);
uent CruzaPasaGrupo(tCromosoma *padre1, tCromosoma *padre2,
tCromosoma **hijo1, tCromosoma **hijo2, c_VecArchivo *vVecArchivos[]);
uent OperadorCruza(c_VecArchivo *vVecArchivos[]);
uent UbicarEnPoblacion(tCromosoma *hijo1, tCromosoma *hijo2);
uent MutacionRefinarKM(tCromosoma *cromosoma, c_VecArchivo
*vVecArchivos[]);
uent MutacionJoin(tCromosoma *cromosoma, c_VecArchivo *vVecArchivos[]);
uent MutacionSplit(tCromosoma *cromosoma, c_VecArchivo *vVecArchivos[]);
uent MutacionRefinarSelectivo(tCromosoma *cromosoma, c_VecArchivo
*vVecArchivos[]);
};

#endif


A4.2.12 ClsGenetico.cpp

#include "clsGenetico.h"

c_Genetico::c_Genetico()
/* constructor */
{
/* seteos por defecto */
RegConfig.generacionesMaximo = 200;
RegConfig.k = 5; /* por defecto k=5 */
RegConfig.generacionInicialModo = 3;
RegConfig.fitnessCriterio = 1;
RegConfig.poblacionTamanio = 12;
RegConfig.poblacionTamanioDeseado = RegConfig.poblacionTamanio;
RegConfig.torneoTamanio = 2;
RegConfig.torneoProbMejor = (real)0.7;
RegConfig.cruzaOperador = 1;
RegConfig.cruzaPasaGrupoProbMejor = (real)0.7;
RegConfig.cruzaPasaGrupoProbMejorDestino = (real)0.95;
/* las siguientes 4 probabilidades deben sumar 1 */
RegConfig.cruzaPasaGrupoProbMasElemComun = (real)0.4;
RegConfig.cruzaPasaGrupoProbMasSimilar = (real)0.56;
RegConfig.cruzaPasaGrupoProbMenorSimilProm = (real)0.02;
RegConfig.cruzaPasaGrupoProbAzar = (real)0.02;
/* */
RegConfig.mutacionRefinarKMCantIter = 1;
RegConfig.mutacionRefinarKMProb = (real)0.3;
RegConfig.fpSalidaDebug = NULL;
RegConfig.mutacionJoinProb = (real)0.1;
RegConfig.mutacionJoinProbAzar = (real)0.00;
RegConfig.mutacionJoinProbMenorSimilProm = (real)0.30;
RegConfig.mutacionJoinProbMasChico = (real)0.70;
/* */
RegConfig.mutacionJoinProbMasSimilar = (real)0.95;
RegConfig.mutacionSplitProb = (real)0.1;
RegConfig.mutacionSplitProbAzar = (real)0.05;
RegConfig.mutacionSplitProbMasGrande = (real)0.9;
RegConfig.mutacionSplitProbMenorSimilProm = (real)0.05;
RegConfig.mutacionSplitCantMuestras = 6;
/* */
RegConfig.mutacionRefinarSelectivoProb = (real)0.0;
}

void c_Genetico::ActualizarParametros(uent genActual,uent genLimite)
/* actualiza los parmetros de RegConfig de acuerdo a la fase del
algoritmo en que nos encontramos
genActual es el nmero de generacion actual
genLimite es el lmite de generaciones
*/
{
real pctCompleto;

pctCompleto = (real)((real)genActual / (real)genLimite);


/*
RegConfig.torneoProbMejor = (real)(0.6 + (0.2 * pctCompleto));
RegConfig.cruzaPasaGrupoProbMejor = (real)(0.60 + (0.3 * pctCompleto));
RegConfig.mutacionRefinarKMProb = (real)(0.4 - (0.35 * sin((PI/2)*pctCompleto)));
*/
if (pctCompleto == 0.0) {
RegConfig.poblacionTamanioDeseado =
RegConfig.poblacionTamanioDeseado;
}
if (pctCompleto < 0.2) /* 0 a 20% */ {
RegConfig.torneoProbMejor = (real)(0.75);
RegConfig.cruzaPasaGrupoProbMejor = (real)(0.8);
RegConfig.mutacionRefinarKMProb = (real)(0.1);
} else if (pctCompleto < 0.4) /* 20 a 40% */ {
RegConfig.poblacionTamanioDeseado = 10;
} else /* 90 a 100% */ {
}
}

FILE* c_Genetico::DebugFP()
{
return (RegConfig.fpSalidaDebug ? RegConfig.fpSalidaDebug : stdout);
}

c_Genetico::~c_Genetico()
/* destructor */
{
uent i;
for (i=0; i < RegConfig.poblacionTamanio; i++)
{
if (poblacion[i] != NULL)
{

if (poblacion[i]->agrup != NULL)
{
delete (poblacion[i]->agrup);
}
free((void*)poblacion[i]);
}
}
free((void*)poblacion);
}

real c_Genetico::FitnessDeCromosoma(tCromosoma &cromosoma)
/* calcula el fitness del cromosoma "cromosoma" */
{
uent iGrupos, cantGrupos, cantElemGrupo;
real simSuma, normaCent, penalizacion;
c_VecArchivo *vecCent;

switch (RegConfig.fitnessCriterio)
{
case 1:
/* este criterio evalua el promedio de similitudes entre
los elementos de cada grupo */
simSuma = (real)0.0;

/* tomamos el agrupamiento del cromosoma */
agrup = cromosoma.agrup;
cantGrupos = agrup->cantGrupos;
/* vamos recorriendo los grupos */
for (iGrupos = 0; iGrupos < cantGrupos; iGrupos++)
{
/* tomamos el centroide del grupo y la cantidad de elementos */
vecCent = agrup->vecGrupos[iGrupos].vecCentroide;
cantElemGrupo = agrup->vecGrupos[iGrupos].cantElementos;
/* calculamos la norma del centroide al cuadrado */
normaCent = vecCent->CalcularNorma(true);
normaCent *= normaCent;
/* sumamos la norma multiplicada por la cantidad de elementos del
grupo */
simSuma += (real)(cantElemGrupo * normaCent);
}
/* penalizamos a los que se apartan de k grupos */
//penalizacion = (real)abs(RegConfig.k - agrup->cantGrupos)/(real)RegConfig.k;
//penalizacion = (real)1.0 - penalizacion;
penalizacion = (real)1.0;
/* el criterio a devolver es la suma dividida la cantidad total de elementos */
return ((simSuma / agrup->cantElementos) * penalizacion);
break;
case 2:
/* este criterio evalua el promedio de la norma de los centroides */
simSuma = (real)0.0;
/* tomamos el agrupamiento del cromosoma */
agrup = cromosoma.agrup;
cantGrupos = agrup->cantGrupos;
/* vamos recorriendo los grupos */
for (iGrupos = 0; iGrupos < cantGrupos; iGrupos++)
{
/* tomamos el centroide del grupo */


vecCent = agrup->vecGrupos[iGrupos].vecCentroide;
/* calculamos la norma del centroide al cuadrado */
normaCent = vecCent->CalcularNorma(true);
normaCent *= normaCent;
/* sumamos la norma */
simSuma += (real)(normaCent);
}
/* el criterio a devolver es la suma dividida la cantidad total de grupos */
return ((simSuma / cantGrupos));
break;
default: /* criterio desconocido ... */
return((real)0.0);
break;
}

}

uent c_Genetico::GenerarPoblacionInicial(uent cantElemAAgrupar, c_VecArchivo
*vVecArchivos[])
/* inicializa la poblacion del algoritmo genetico
eso incluye alocar memoria para los cromosomas,
agrupar al azar los elementos en el agrupamiento de cada
cromosoma, calcular los centroides para el agrupamiento de
cada cromosoma y calcular el fitness de cada cromosoma */
{
uent i, j, codRet;
uent *vecIndGruposAux;

/* inicializamos el vector de grupos auxiliar (lo necesita
la funcion que calcula los centroides */
vecIndGruposAux = (uent*)malloc(RegConfig.k * SINT);
if (vecIndGruposAux == NULL)

/* creamos el vector de punteros a cromosomas */
poblacion = (tCromosoma**)malloc(RegConfig.poblacionTamanio *
sizeof(tCromosoma*));
if (poblacion == NULL)
/* inicializamos cada puntero a cromosoma */
for (i = 0; i < RegConfig.poblacionTamanio; i++)
{
/* creamos un cromosoma */
poblacion[i] = (tCromosoma*)malloc(sizeof(tCromosoma));
if (poblacion[i] == NULL)
/* creamos el agrupamiento del cromosoma */
poblacion[i]->agrup = new c_Agrupamiento;
if (poblacion[i]->agrup == NULL)
/* inicializamos el agrupamiento */
codRet = poblacion[i]->agrup->Inicializar(cantElemAAgrupar);
if (codRet != OK)
return codRet;

switch (RegConfig.generacionInicialModo)
{

case 1:
/* lo agrupamos al azar */
codRet = poblacion[i]->agrup-
>AgruparAlAzar(RegConfig.k,RegConfig.k);
if (codRet != OK)
return codRet;
break;
case 2:
/* lo inicializamos con la fase inicial (lite) del kmeans */
codRet = poblacion[i]->agrup->AgruparAlAzar(1,1);
if (codRet != OK)
return codRet;
c_KMeans::k = RegConfig.k;
codRet = c_KMeans::FaseInicialLite(*(poblacion[i]-
>agrup),1,vVecArchivos,vecIndGruposAux,false,0);
if (codRet != OK)
return codRet;
break;
case 3:
/* fase inicial, pero solamente log k grupos */
codRet = poblacion[i]->agrup->AgruparAlAzar(1,1);
if (codRet != OK)
return codRet;
c_KMeans::k = (uent)(log(RegConfi g.k)/log(2));
codRet = c_KMeans::FaseInicial(*(poblacion[i]-
>agrup),1,vVecArchivos,vecIndGruposAux,false,0);
if (codRet != OK)
return codRet;
break;
}
for (j=0; j<RegConfig.k; j++)
vecIndGruposAux[j] = j;
codRet = c_KMeans::CalcularCentroides(*(poblacion[i]-
>agrup),vVecArchivos,RegConfig.k,vecIndGruposAux);
if (codRet != OK)
return codRet;
/* le asociamos el fitness */
poblacion[i]->fitness = FitnessDeCromosoma(*(poblacion[i]));
/* esta disponible para ser seleccionado */
poblacion[i]->disponible = true;
/* no hubo un join */
poblacion[i]->ultimoJoin = -1;
fprintf(DebugFP(),"GenInic : %d; Fitness : %f \n",i,poblacion[i]->fitness);
}

free((void*)vecIndGruposAux);

return OK;
}

uent c_Genetico::DevolverMejorSolucion(c_Agrupamiento **solucion)
/* devuelve un puntero al agrupamiento del cromosoma
que tiene fitness mas alto */
{
uent iPob, iMax;
real fitMax;


iMax = 0;
fitMax = (real)-1.0;

for (iPob = 0; iPob < RegConfig.poblacionTamanio; iPob++)
{
if (poblacion[iPob]->fitness > fitMax)
{
fitMax = poblacion[iPob]->fitness;
iMax = iPob;
}
}

*solucion = poblacion[iMax]->agrup;

return OK;
}

uent c_Genetico::ElegirPorTorneo(uent &indElegido, bool invertido)
/* elige un cromosoma mediante el mtodo del torneo
los parametros son las variables de configuracion:
- torneoTamanio : cantidad de cromosomas que se examinan
- torneoProbMejor : probabilidad de que se seleccione al mejor
si "invertido" es true, se busca al reves (intentando elegir al
peor), esto se usa para elegir a quien se reemplaza
en "indElegido", devuelve el numero del cromosoma seleccionado
*/
{
uent *elemAzar;
uent *ordenTorneo;
uent iElemTorneo,iElem,j;
bool bSalir;

if (invertido == false)
fprintf(DebugFP(),"Torneo : ");
else
fprintf(DebugFP(),"Torneo invertido : ");

/* "ordenTorneo" es un vector de tamao "torneoTamanio" */
ordenTorneo = (uent*)malloc(RegConfig.torneoTamanio * SINT);

/* en "elemAzar" generamos un vector de numeros de cromosoma
ordenados al azar. Lo hacemos un poco mas grande que el
tamao del torneo por las dudas de que alguno est marcado
como no disponible */
elemAzar = kNumerosRandom(RegConfig.torneoTamanio +
3,0,RegConfig.poblacionTamanio - 1,false);
if (elemAzar == NULL)

/* iElem avanza mas rapido que iElemTorneo cuando hay cromosomas no disponibles
*/
iElem = 0;
for (iElemTorneo=0;iElemTorneo<RegConfig.torneoTamanio;iElemTorneo++)
{
/* iElem saltea los cromosomas no disponibles */
while(poblacion[elemAzar[iElem]]->disponible == false)
iElem++;

fprintf(DebugFP(),"(%d) %f ; ",elemAzar[iElem],poblacion[elemAzar[iElem]]-
>fitness);
/* ahora veamos en que posicion del vector "ordenTorneo" tiene que ir */
/* empezamos a evaluar por el ultimo del vector (el de mas fitness) */
j = iElemTorneo;
while (j > 0)
{
/* veamos si el que acabamos de elegir tiene mas fitness */
if (poblacion[elemAzar[iElem]]->fitness < poblacion[ordenTorneo[j-1]]-
>fitness)
{
/* movemos el elemento del vector hacia arriba */
ordenTorneo[j] = ordenTorneo[j-1];
}
else
{
break; /* salimos del while */
}
j--;
}
/* el elemento va en la posicion j */
ordenTorneo[j] = elemAzar[iElem];
iElem++;
}
fprintf(DebugFP()," --> ");
/* ya tenemos los elementos en el vector "ordenTorneo" ordenados
por fitness (primero el de menor fitness) */
/* ahora elegimos al elemento con la probabilidad que corresponde */
bSalir = false;
j = 0;
while ((j < RegConfig.torneoTamanio) && (bSalir == false))
{
if (TirarMonedaCargada(RegConfig.torneoProbMejor))
{
bSalir = true;
}
else
{
fprintf(DebugFP()," salteo - ");
j++;
}
}
if (bSalir == false) /* j se pas 1 */
j--;
/* de acuerdo al valor de "invertido" devolvemos el que corresponde */
if (invertido == true)
indElegido = ordenTorneo[j];
else
indElegido = ordenTorneo[RegConfig.torneoTamanio - 1 - j];

fprintf(DebugFP(),"[%f]\n",poblacion[indElegido]->fitness);

free((void*)elemAzar);
free((void*)ordenTorneo);

return (0);
}



uent c_Genetico::CruzaPasaGrupo(tCromosoma *padre1, tCromosoma *padre2, tCromosoma
**hijo1, tCromosoma **hijo2, c_VecArchivo *vVecArchivos[])
/* Operador de cruza. Recibe punteros a los 2 padres.
Crea 2 cromosomas nuevos (que devuelve en los 2 punteros a los hijos)
Para generar el hijo 1 hace lo siguiente :
- crea el agrupamiento para el hijo 1 igual al del padre 2
- busca en el padre 1 un grupo para pasar al hijo. Con cierta probabilidad
el grupo a pasar es el que tiene mejor promedio de similitud entre sus
elementos
- busca en el hijo 1 (que por ahora es igual al padre 2), el grupo que
tenga mas elementos en comun con el grupo que eligio para pasarle
- saca de ese grupo los elementos que no estan en el grupo que le va
a pasar, y agrega a ese grupo los elementos que le faltan
- si algun grupo del hijo se queda sin elementos, lo borra
Para generar el hijo 2 es el mismo procedimiento pero tomando los padres
al revs
*/
{
uent codRet;

/* generamos el hijo 1 */
fprintf(DebugFP(),"Cruza PasaGrup 1 : fitness padre1(%d) = %f ; fitness padre2(%d) =
%f\n",padre1->agrup->cantGrupos,padre1->fitness,padre2->agrup->cantGrupos,padre2-
>fitness);
codRet = privCruzaPasaGrupo(padre1,padre2,hijo1,vVecArchivos);
if (codRet != OK)
return codRet;
/* generamos el hijo 2 */
fprintf(DebugFP(),"Cruza PasaGrup 2 : fitness padre1 = %f ; fitness padre2 =
%f\n",padre2->fitness,padre1->fitness);
codRet = privCruzaPasaGrupo(padre2,padre1,hijo2,vVecArchivos);
return codRet;
return OK;
}

uent c_Genetico::AsignarFormaElegirGrupoDestino()
/* calcula la forma de elegir el grupo destino de acuerdo a las probabilidades
(usado por el operador de cruza)
Devuelve : 1 = Mas elementos en comun
2 = Mas similar
3 = Menor similitud promedio
4 = Al Azar
*/
{
real totalProbRestante;

totalProbRestante = (real)1.0;
if (TirarMonedaCargada(RegConfig.cruzaPasaGrupoProbMasElemComun * (real)(1.0 /
totalProbRestante)))
{
return 1;
}
totalProbRestante -= RegConfig.cruzaPasaGrupoProbMasElemComun;
if (TirarMonedaCargada(RegConfig.cruzaPasaGrupoProbMasSimilar * (real)(1.0 /
{
return 2;

}
totalProbRestante -= RegConfig.cruzaPasaGrupoProbMasSimilar;
if (TirarMonedaCargada(RegConfig.cruzaPasaGrupoProbMenorSimilProm * (real)(1.0 /
{
return 3;
}
/* si llegamos hasta aca, es al azar */
return 4;
}

uent c_Genetico::privCruzaPasaGrupo(tCromosoma *padre1, tCromosoma *padre2,
tCromosoma **hijo1, c_VecArchivo *vVecArchivos[])
/* implementa el operador de cruza "CruzaPasaGrupo", para generar uno de
los dos hijos.
Para generar el otro, se deben pasar los padres en orden inverso */
{
uent codRet;
c_Agrupamiento *agrupHijo, *agrupPadre;
uent indGrupoPasar, indGrupoDestino, i, nroGrupoPasar, nroGrupoDestino;
uent nroGrupoElemHijo, maxElemComun, cantGruposHijo, indGrupoAux;
real maxSimProm, simProm, maxSimPromDest;
uent *vecNroElemComun, j;
real valorActual, valorAlternativa;
uent formaElegirGrupoDestino, h;
c_VecArchivo *vecCent1,*vecCent2;
real vMaxSimProm[3]; /* para buscar los 2 grupos mas similares en el segundo padre
*/
uent vIndGrupoDestino[3], vNroGrupoDestino[3];

/* creamos el cromosoma */
*hijo1 = (tCromosoma*)malloc(sizeof(tCromosoma));
if (*hijo1 == NULL)
/* creamos el agrupamiento del cromosoma */
(*hijo1)->agrup = new c_Agrupamiento();
if ((*hijo1)->agrup == NULL)
agrupHijo = (*hijo1)->agrup;
/* hacemos el agrupamiento del hijo igual al del padre 2 */
codRet = agrupHijo->Duplicar(*(padre2->agrup));
if (codRet != OK)
return codRet;
/* le tenemos que pasar un grupo del padre 1 */
agrupPadre = padre1->agrup;
/* veamos si tenemos que pasar el mejor grupo */
if (TirarMonedaCargada(RegConfig.cruzaPasaGrupoProbMejor))
{
/* buscamos el grupo del padre con mejor similitud promedio */
maxSimProm = (real)-1.0;
for (i=0; i < agrupPadre->cantGrupos; i++)
{
simProm = agrupPadre->vecGrupos[i].vecCentroide-
{
indGrupoPasar = i;


}
}
}
else
{
/* el grupo a pasar se elige al azar */
indGrupoPasar = RANDOM(agrupPadre->cantGrupos);
maxSimProm = 0;
}
nroGrupoPasar = agrupPadre->vecGrupos[indGrupoPasar].nroGrupo;

/* buscamos los 2 grupos mas similares del otro padre */
for (i=0; i < 2; i++)
{
vMaxSimProm[i] = (real)-1.0;
vIndGrupoDestino[i] = 0;
}
vecCent1 = agrupPadre->vecGrupos[indGrupoPasar].vecCentroide;
for (i=0; i < agrupHijo->cantGrupos; i++)
{
vecCent2 = agrupHijo->vecGrupos[i].vecCentroide;
simProm = vecCent1->Multiplicar(*vecCent2,false);
j=0;
while ((j<2) && (simProm > vMaxSimProm[j]))
{
vMaxSimProm[j] = vMaxSimProm[j+1];
vIndGrupoDestino[j] = vIndGrupoDestino[j+1];
j++;
}
if (j > 0) /* entra en el vector, en la posicion j-1 */
{
vMaxSimProm[j-1] = simProm;
vIndGrupoDestino[j-1] = i;
}
}
for (i=0; i<2; i++)
{
vNroGrupoDestino[i] = agrupHijo->vecGrupos[vIndGrupoDestino[i]].nroGrupo;
}

/* ahora elegimos el grupo destino */
formaElegirGrupoDestino = AsignarFormaElegirGrupoDestino();
switch (formaElegirGrupoDestino)
{
case 1: /* mas elementos en comun */
/* creamos un vector para contar los elementos en comun de cada grupo */
vecNroElemComun = (uent*)malloc(agrupHijo->cantGrupos * SINT);
if (vecNroElemComun == NULL)
{
vecNroElemComun[i] = 0;
}
/* buscamos en el hijo el grupo con mas elementos en comun */
for (i=0; i < agrupPadre->cantElementos; i++)
{
/* si el elemento es del grupo a pasar */
if (agrupPadre->vecElementos[i] == nroGrupoPasar)

{
/* sumamos uno al grupo del hijo que tiene ese elemento */
nroGrupoElemHijo = agrupHijo->vecElementos[i];
vecNroElemComun[agrupHijo-
>IndiceDeGrupo(nroGrupoElemHijo,false)]++;
}
}
/* buscamos la mayor entrada en el vector */
maxElemComun = 0;
{
if (vecNroElemComun[i] > maxElemComun)
{
maxElemComun = vecNroElemComun[i];
indGrupoDestino = i;
}
}
free((void*)vecNroElemComun);
maxSimPromDest = (real)maxElemComun;
break;
case 2: /* mas similar */
maxSimPromDest = vMaxSimProm[1];
indGrupoDestino = vIndGrupoDestino[1];
break;
case 3: /* menor similitud promedio */
maxSimPromDest = (real)-10000.0;
{
vecCent2 = agrupHijo->vecGrupos[i].vecCentroide;
simProm = (real)-1.0 * vecCent2->CalcularNorma(false);
if (simProm > maxSimPromDest)
{
maxSimPromDest = simProm;
}
}
break;
case 4: /* al azar */
maxSimPromDest = (real)0.0;
indGrupoDestino = RANDOM(agrupHijo->cantGrupos);
break;
}
nroGrupoDestino = agrupHijo->vecGrupos[indGrupoDestino].nroGrupo;

fprintf(DebugFP()," Grupos : fuente=(%d) [%d] %f, destino=(%d) [%d] Sim :
%f\n",nroGrupoPasar,agrupPadre-
>vecGrupos[indGrupoPasar].cantElementos,maxSimProm,nroGrupoDestino,agrupHijo-
>vecGrupos[indGrupoDestino].cantElementos,maxSimPromDest);

/* ahora reacomodamos los elementos para que el grupo pase al hijo */
for (i=0; i < agrupPadre->cantElementos; i++)
{
if (agrupPadre->vecElementos[i] == nroGrupoPasar)
{
/* si en el hijo el elemento no est en el grupo destino, hay que
agregarlo */
if (agrupHijo->vecElementos[i] != nroGrupoDestino)
{


/* guardamos la cantidad actual de grupos del hijo para saber si
cambia */
cantGruposHijo = agrupHijo->cantGrupos;
/* pasamos el elemento al grupo destino */
indGrupoAux = agrupHijo->IndiceDeGrupo(agrupHijo-
>vecElementos[i],false);
codRet =
c_KMeans::MoverElementoyRecalcular(*agrupHijo,vVecArchivos,i,indGrupoAux,indGrupoDesti
no,true);
if (codRet != OK)
return codRet;
/* veamos si cambio la cantidad de grupos */
if (cantGruposHijo != agrupHijo->cantGrupos)
{
/* tomamos el nuevo indice del grupo */
indGrupoDestino = agrupHijo-
>IndiceDeGrupo(nroGrupoDestino,true);
for (h=0; h<2; h++)
vIndGrupoDestino[h] = agrupHijo-
>IndiceDeGrupo(vNroGrupoDestino[h],true);
}
}
}
else
{
/* si en el hijo el elemento est en el grupo destino, hay que sacarlo */
if (agrupHijo->vecElementos[i] == nroGrupoDestino)
{
/* veamos si tenemos que buscar el mejor grupo */
if
(TirarMonedaCargada(RegConfig.cruzaPasaGrupoProbMejorDestino))
{
/* hay que buscar el mejor grupo (solo entre los 2 mas
similares) */
valorActual =
c_KMeans::ValorCriterioActual(*agrupHijo,vVecArchivos,i,indGrupoDestino);
indGrupoAux = indGrupoDestino;
for (h=0; h < 2; h++)
{
j = vIndGrupoDestino[h];
if (j != indGrupoDestino) /* no evaluamos 2
veces el mismo */
{
valorAlternativa =
c_KMeans::ValorCriterioAlternativa(*agrupHijo,vVecArchivos,i,j,valorActual);
if (valorAlternativa > valorActual)
{
valorActual = valorAlternativa;
indGrupoAux = j;
}
}
}
}
else
{
indGrupoAux = RANDOM(agrupHijo->cantGrupos);

}

/* lo pasamos al otro grupo */
if (indGrupoAux != indGrupoDestino)
{
cantGruposHijo = agrupHijo->cantGrupos; /* para ver si
cambia la cantidad de grupos */
codRet =
c_KMeans::MoverElementoyRecalcular(*agrupHijo,vVecArchivos,i,indGrupoDestino,indGrupoA
ux,true);
if (codRet != OK)
return (codRet);
if (cantGruposHijo != agrupHijo->cantGrupos)
{ /* buscamos los nuevos indices */
indGrupoDestino = agrupHijo-
for (h=0; h<2; h++)
vIndGrupoDestino[h] = agrupHijo-
>IndiceDeGrupo(vNroGrupoDestino[h],true);
}
}
}
}
}

return OK;
}

uent c_Genetico::OperadorCruza(c_VecArchivo *vVecArchivos[])
/* elige 2 cromosomas mediante el metodo del torneo
los cruza generando 2 hijos
elige 2 cromosomas mediante el metodo del torneo para ser reemplazados
los reemplaza por los 2 hijos generados
*/
{
tCromosoma *hijo1, *hijo2;
uent indPadre1, indPadre2;
uent codRet;

/* elegimos los padres */
codRet = ElegirPorTorneo(indPadre1,false);
if (codRet != OK)
return (codRet);
poblacion[indPadre1]->disponible = false; /* lo marcamos para no elegirlo de nuevo */
codRet = ElegirPorTorneo(indPadre2,false);
if (codRet != OK)
return (codRet);
/* desmarcamos el padre 1 */
poblacion[indPadre1]->disponible = true;

if (RegConfig.cruzaOperador == 1)
{
codRet =
CruzaPasaGrupo(poblacion[indPadre1],poblacion[indPadre2],&hijo1,&hijo2,vVecArchivos);
if (codRet != OK)
return (codRet);
}
else
{
/* ... no definido aun */


}

hijo1->ultimoJoin = -1;

/* ahora calculamos el fitness del hijo 1 */
hijo1->fitness = FitnessDeCromosoma(*hijo1);

fprintf(DebugFP(),"Hijo 1 = %f ; Hijo 2 = %f\n",hijo1->fitness,hijo2->fitness);

/* veamos si tenemos que mutar (operador split) al hijo 1 */
if ((hijo1->agrup->cantGrupos < RegConfig.k) ||
(TirarMonedaCargada(RegConfig.mutacionSplitProb)))
{
fprintf(DebugFP(),"MutarSplit 1 : ");
codRet = MutacionSplit(hijo1,vVecArchivos);
if (codRet != OK)
return (codRet);
}
/* veamos si tenemos que mutar (operador split) al hijo 2 */
if ((hijo2->agrup->cantGrupos < RegConfig.k) ||
(TirarMonedaCargada(RegConfig.mutacionSplitProb)))
{
fprintf(DebugFP(),"MutarSplit 2 : ");
codRet = MutacionSplit(hijo2,vVecArchivos);
if (codRet != OK)
return (codRet);
}

/* veamos si tenemos que mutar (operador join) al hijo 1 */
if ((hijo1->agrup->cantGrupos > RegConfig.k) ||
(TirarMonedaCargada(RegConfig.mutacionJoinProb)))
{
fprintf(DebugFP(),"MutarJoin 1 : ");
codRet = MutacionJoin(hijo1,vVecArchivos);
if (codRet != OK)
return (codRet);
}
/* veamos si tenemos que mutar (operador join) al hijo 2 */
if ((hijo2->agrup->cantGrupos > RegConfig.k) ||
(TirarMonedaCargada(RegConfig.mutacionJoinProb)))
{
fprintf(DebugFP(),"MutarJoin 2 : ");
codRet = MutacionJoin(hijo2,vVecArchivos);
if (codRet != OK)
return (codRet);
}

/* veamos si tenemos que mutar (operador refinar) al hijo 1 */
if (TirarMonedaCargada(RegConfig.mutacionRefinarKMProb))
{
fprintf(DebugFP(),"MutarRef 1 : ");
codRet = MutacionRefinarKM(hijo1,vVecArchivos);
if (codRet != OK)
return (codRet);
}

if (TirarMonedaCargada(RegConfig.mutacionRefinarKMProb))
{
fprintf(DebugFP(),"MutarRef 2 : ");
codRet = MutacionRefinarKM(hijo2,vVecArchivos);
if (codRet != OK)
return (codRet);
}
/* veamos si tenemos que mutar (operador refinar selectivo) al hijo 1 */
if (TirarMonedaCargada(RegConfig.mutacionRefinarSelectivoProb))
{
fprintf(DebugFP(),"MutarRefSelectivo 1 : ");
codRet = MutacionRefinarSelectivo(hijo1,vVecArchivos);
if (codRet != OK)
return (codRet);
}
if (TirarMonedaCargada(RegConfig.mutacionRefinarSelectivoProb))
{
fprintf(DebugFP(),"MutarRefSelectivo 2 : ");
codRet = MutacionRefinarSelectivo(hijo2,vVecArchivos);
if (codRet != OK)
return (codRet);
}


hijo1->disponible = true;
hijo2->disponible = true;

fprintf(DebugFP(),"Hijo 1 = %f ; Hijo 2 = %f\n",hijo1->fitness,hijo2->fitness);

/* los insertamos en la poblacion */
codRet = UbicarEnPoblacion(hijo1,hijo2);
if (codRet != OK)
return (codRet);

return OK;
}

uent c_Genetico::UbicarEnPoblacion(tCromosoma *hijo1, tCromosoma *hijo2)
/* Ubica los dos hijos en la poblacion */
{
uent codRet;
uent indReemp1, indReemp2;
uent i;
tCromosoma **pobAux;
tCromosoma *hijoAux;

/* seleccionamos 2 para ser reemplazados */
codRet = ElegirPorTorneo(indReemp1,true);
if (codRet != OK)
return (codRet);


poblacion[indReemp1]->disponible = false; /* lo marcamos */
codRet = ElegirPorTorneo(indReemp2,true);
if (codRet != OK)
return (codRet);
poblacion[indReemp1]->disponible = true; /* desmarcamos al primero */

/* veamos si la poblacion tiene que crecer o disminuir */
if (RegConfig.poblacionTamanio < RegConfig.poblacionTamanioDeseado)
{
/* la poblacion tiene que crecer */
/* alocamos lugar para uno mas */
pobAux = (tCromosoma**)malloc((RegConfig.poblacionTamanio + 1) *
sizeof(tCromosoma*));
/* pasamos la poblacion al nuevo vector */
for (i=0; i < RegConfig.poblacionTamanio; i++)
pobAux[i] = poblacion[i];
/* el ultimo lo ponemos en null */
pobAux[RegConfig.poblacionTamanio] = NULL;
/* cambiamos los vectores */
free((void*)poblacion);
poblacion = pobAux;
RegConfig.poblacionTamanio++;
/* solamente vamos a reemplazar al peor de los 2 elegidos */
if (poblacion[indReemp1]->fitness < poblacion[indReemp2]->fitness)
indReemp2 = RegConfig.poblacionTamanio;
else
indReemp1 = RegConfig.poblacionTamanio;
}
else if (RegConfig.poblacionTamanio > RegConfig.poblacionTamanioDeseado)
{
/* la poblacion tiene que disminuir */
/* nos quedamos solamente con el mejor hijo */
/* ponemos el mejor hijo en hijo1 y el otro en hijo2 */
if (hijo1->fitness < hijo2->fitness)
{
hijoAux = hijo2;
hijo2 = hijo1;
hijo1 = hijoAux;
}
/* eliminamos el hijo2 */
if (hijo2->agrup != NULL)
delete(hijo2->agrup);
free((void*)hijo2);
hijo2 = NULL;
/* sacamos uno de los elegidos y disminuimos el tamao de la poblacion */
if (indReemp1 > indReemp2)
{
i = indReemp1;
indReemp1 = indReemp2;
}
else
{
i = indReemp2;
indReemp2 = indReemp1;
}
if (poblacion[i]->agrup != NULL)
delete(poblacion[i]->agrup);
free((void*)poblacion[i]);

for (; i < (RegConfig.poblacionTamanio - 1); i++)
poblacion[i] = poblacion[i+1];
RegConfig.poblacionTamanio--;
}
/* los reemplazamos */
if (poblacion[indReemp1] != NULL)
{
delete (poblacion[indReemp1]->agrup);
free((void*)poblacion[indReemp1]);
poblacion[indReemp1] = NULL;
}
if (poblacion[indReemp2] != NULL)
{
delete (poblacion[indReemp2]->agrup);
free((void*)poblacion[indReemp2]);
poblacion[indReemp2] = NULL;
}

if (hijo1 != NULL)
poblacion[indReemp1] = hijo1;
if (hijo2 != NULL)
poblacion[indReemp2] = hijo2;

return OK;
}

uent c_Genetico::Evolucionar(c_VecArchivo *vVecArchivos[],bool generacionesFijas, uent
&cantGeneraciones)
/* Implementa el ciclo de evolucion del algoritmo genetico
Antes de llamarse a esta funcion debe llamarse a "GenerarPoblacionInicial"
Despues de esta funcion, puede llamarse a "DevolverMejorSolucion"
*/
{
uent codRet, iGeneraciones, limiteGeneraciones;

if (generacionesFijas == true)
limiteGeneraciones = cantGeneraciones;
else
limiteGeneraciones = RegConfig.generacionesMaximo;

iGeneraciones = 0;
while (iGeneraciones < limiteGeneraciones)
{
//xxxdebug
printf("Gcion : %d\n",iGeneraciones);
fprintf(DebugFP(),"Gcion : %d\n",iGeneraciones);

ActualizarParametros(iGeneraciones,limiteGeneraciones);

codRet = OperadorCruza(vVecArchivos);
if (codRet != OK)
return (codRet);

iGeneraciones++;
}

cantGeneraciones = iGeneraciones;



return OK;
}

uent c_Genetico::MutacionRefinarKM(tCromosoma *cromosoma, c_VecArchivo
*vVecArchivos[])
/* operador de mutacion que consiste en realizar una iteracion de
la refinacion KMeans sobre el agrupamiento del cromosoma */
{
uent codRet,i;
uent *indGrupos;
uent cantIteraciones, cantCambiosTotal = 0;

/* creamos un vector para poner los indices de los grupos */
indGrupos = (uent*)malloc(cromosoma->agrup->cantGrupos * SINT);
if (indGrupos == NULL)
for (i=0; i < cromosoma->agrup->cantGrupos; i++)
indGrupos[i] = i;

cantIteraciones = RegConfig.mutacionRefinarKMCantIter;
c_KMeans::k = cromosoma->agrup->cantGrupos;
codRet = c_KMeans::FaseRefinarLite(*(cromosoma-
>agrup),vVecArchivos,indGrupos,true,cantIteraciones,cantCambiosTotal);
if (codRet != OK)
return codRet;

fprintf(DebugFP()," %d\n",cantCambiosTotal);

free((void*)indGrupos);

return OK;
}

uent c_Genetico::MutacionRefinarSelectivo(tCromosoma *cromosoma, c_VecArchivo
*vVecArchivos[])
/* operador de mutacion que consiste en refinar solamente los
mejores grupos, con la esperanza de aislar los elementos "ruidosos"
en 1 o 2 grupos de baja similitud promedio */
{
uent i,j,h;
uent *vecOrdenTamano, *vecOrdenSimilProm, *vecPuntaje;
real *vecSimilPromAux;
uent *vecPeores, *vecMejores;
uent cantMejores;
uent cantPeores;
real desvioSim, simProm, simDestino, simDestinoAux;
uent indGrupoOrigen, indGrupoDestino;
uent cantCambios;

real pctMejores = (real)0.25;
real pctPeores = (real)0.25;
real factorDesvioTolerado = (real)0.8;

agrup = cromosoma->agrup;

cantMejores = (int)(agrup->cantGrupos * pctMejores);

cantPeores = (int)(agrup->cantGrupos * pctPeores);

/* creamos los vectores que vamos a usar */
vecMejores = (uent*)malloc(cantMejores * sizeof(uent));
if (vecMejores == NULL)
vecPeores = (uent*)malloc(cantPeores * sizeof(uent));
if (vecPeores == NULL)
vecOrdenTamano = (uent*)malloc(agrup->cantGrupos * sizeof(uent));
if (vecOrdenTamano == NULL)
vecOrdenSimilProm = (uent*)malloc(agrup->cantGrupos * sizeof(uent));
if (vecOrdenSimilProm == NULL)
vecPuntaje = (uent*)malloc(agrup->cantGrupos * sizeof(uent));
if (vecPuntaje == NULL)
vecSimilPromAux = (real*)malloc(agrup->cantGrupos * sizeof(real));
if (vecSimilPromAux == NULL)

/* vamos a armar 2 vectores
en uno vamos a ordenar los grupos por tamao (descendentemente)
en el otro, por similitud promedio (descendentemente) */
for (i=0; i<agrup->cantGrupos; i++)
{
/* calculamos la similitud promedio del grupo y lo ubicamos en el vector */
vecSimilPromAux[i] = agrup->vecGrupos[i].vecCentroide-
vecSimilPromAux[i] *= vecSimilPromAux[i]; // al cuadrado
//fprintf(DebugFP(),"Grupo : %d, Sim : %f, Tam :
%d\n",i,vecSimilPromAux[i],agrup->vecGrupos[i].cantElementos);
j = 0;
while ((j < i) && (vecSimilPromAux[i] <
vecSimilPromAux[vecOrdenSimilProm[j]]))
j++;
/* va en la posicion j, hay que correr al resto */
for (h = (agrup->cantGrupos - 1); h > j; h--)
vecOrdenSimilProm[h] = vecOrdenSimilProm[h-1];
vecOrdenSimilProm[j] = i;
/* ahora hacemos lo mismo pero con el tamao del grupo */
j = 0;
while ((j < i) && (agrup->vecGrupos[i].cantElementos < agrup-
>vecGrupos[vecOrdenTamano[j]].cantElementos))
j++;
/* va en la posicion j, hay que correr al resto */
for (h = (agrup->cantGrupos - 1); h > j; h--)
vecOrdenTamano[h] = vecOrdenTamano[h-1];
vecOrdenTamano[j] = i;
}
/* ahora calculamos un puntaje para cada grupo
mayor el puntaje -> peor el grupo */
/* primero inicializamos el vector de puntajes en 0 */
vecPuntaje[i] = 0;
{


h = vecOrdenTamano[i];
if (vecPuntaje[h] == 0)
{
vecPuntaje[h] = i + 1;
}
else
{
if (vecPuntaje[h] < (i+1))
{
vecPuntaje[h] *= 2;
vecPuntaje[h] += i + 1;
}
else
{
vecPuntaje[h] += 2 * (i+1);
}
// fprintf(DebugFP(),"Grupo : %d, Puntaje : %d\n",h,vecPuntaje[h]);
}

h = vecOrdenSimilProm[i];
if (vecPuntaje[h] == 0)
{
vecPuntaje[h] = i + 1;
}
else
{
if (vecPuntaje[h] < (i+1))
{
vecPuntaje[h] *= 2;
vecPuntaje[h] += i + 1;
}
else
{
vecPuntaje[h] += 2 * (i+1);
}
// fprintf(DebugFP(),"Grupo : %d, Puntaje : %d\n",h,vecPuntaje[h]);
}
}

/* armamos los vectores de mejores y peores */
for (i=0; i<cantMejores; i++)
vecMejores[i] = agrup->cantGrupos;
for (i=0; i<cantPeores; i++)
vecPeores[i] = agrup->cantGrupos;

{
/* veamos si este grupo entra en el vector de mejores */
j = 0;
while (j < cantMejores)
{
if (vecMejores[j] == agrup->cantGrupos)
j++;
else if (vecPuntaje[i] < vecPuntaje[vecMejores[j]])
j++;
else
break;
}

if (j > 0)
{
/* va en la posicion j - 1 */
/* hay que correr los demas */
j--;
for (h=0; h < j; h++)
vecMejores[h] = vecMejores[h+1];
vecMejores[j] = i;
}
/* ahora en el de peores */
j = 0;
while (j < cantPeores)
{
if (vecPeores[j] == agrup->cantGrupos)
j++;
else if (vecPuntaje[i] > vecPuntaje[vecPeores[j]])
j++;
else
break;
}
if (j > 0)
{
/* va en la posicion j - 1 */
/* hay que correr los demas */
j--;
for (h=0; h < j; h++)
vecPeores[h] = vecPeores[h+1];
vecPeores[j] = i;
}
}

/* ahora vamos a buscar en los mejores grupos los elementos
que tengan baja similitud con el centroide y los vamos a pasar
a los peores grupos */
cantCambios = 0;
for (i=0; i < agrup->cantElementos; i++)
{
if (c_KMeans::NroGrupoEstaEnVectorIndices(agrup-
>vecElementos[i],vecMejores,cantMejores,*agrup,indGrupoOrigen))
{
/* veamos si la similitud de este elemento con el centroide es peor que
el promedio */
simProm = agrup->vecGrupos[indGrupoOrigen].vecCentroide-
>Multiplicar(*(vVecArchivos[i+1]),false);
//fprintf(DebugFP(),"Elemento : %d, Grupo : %d, Sim :
%f\n",i,indGrupoOrigen,simProm);
if (simProm < vecSimilPromAux[indGrupoOrigen])
{
/* es menos similar que el promedio */
desvioSim = vecSimilPromAux[indGrupoOrigen] - simProm;
/* buscamos entre los peores grupos al mas similar */
simDestino = (real)0.0;
for (h=0; h < cantPeores; h++)
{
simDestinoAux = agrup-
>vecGrupos[vecPeores[h]].vecCentroide->Multiplicar(*(vVecArchivos[i+1]),false);
if (simDestinoAux > simDestino)
{


indGrupoDestino = vecPeores[h];
simDestino = simDestinoAux;
}
}
/* veamos si la mejor similitud esta dentro de lo tolerado */
//fprintf(DebugFP()," Mejor Sim Alternativa : %f, Grupo :
%d, Desvio : %f\n",simDestino,indGrupoDestino,desvioSim);
if (simDestino > (simProm - (desvioSim *
factorDesvioTolerado)))
{
cantCambios++;

c_KMeans::MoverElementoyRecalcular(*agrup,vVecArchivos,i,indGrupoOrigen,indGrup
oDestino,true);
}
}
}
}

fprintf(DebugFP()," %d\n",cantCambios);

free((void*)vecMejores);
free((void*)vecPeores);
free((void*)vecOrdenSimilProm);
free((void*)vecOrdenTamano);
free((void*)vecPuntaje);
free((void*)vecSimilPromAux);

return OK;
}

uent c_Genetico::MutacionJoin(tCromosoma *cromosoma, c_VecArchivo *vVecArchivos[])
/* operador de mutacion que consiste en juntar 2 grupos */
{
uent codRet,i;
uent formaElegirGrupoOrigen, formaElegirGrupoDestino;
real probAux, probRestante;
uent indGrupoOrigen, indGrupoDestino, nroGrupoOrigen, nroGrupoDestino;
real maxSimProm, simProm, simPromDest, maxSimPromDest;
uent cantElem, minCantElem;
c_VecArchivo *vecCent2, *vecCent1;
uent cantGrupos;


/* veamos de que forma elegimos al grupo origen */
probRestante = (real)1.0;
probAux = (real)(RegConfig.mutacionJoinProbAzar / probRestante);
if (TirarMonedaCargada(probAux))
formaElegirGrupoOrigen = 4; /* al azar */
else
{
probRestante -= probAux;
probAux = (real)(RegConfig.mutacionJoinProbMasChico / probRestante);
formaElegirGrupoOrigen = 2; /* el mas chico */

else
formaElegirGrupoOrigen = 3; /* menor similitud promedio */
}

switch (formaElegirGrupoOrigen)
{
case 2: /* mas chico */
minCantElem = MAX_UENT;
{
cantElem = agrup->vecGrupos[i].cantElementos;
if (cantElem < minCantElem)
{
minCantElem = cantElem;
indGrupoOrigen = i;
}
}
maxSimProm = (real)(0 - minCantElem);
break;
{
vecCent2 = agrup->vecGrupos[i].vecCentroide;
{
indGrupoOrigen = i;
}
}
break;
maxSimProm = (real)0.0;
indGrupoOrigen = RANDOM(agrup->cantGrupos);
break;
}
nroGrupoOrigen = agrup->vecGrupos[indGrupoOrigen].nroGrupo;

/* veamos de que forma elegimos al grupo destino */
probAux = (real)(RegConfig.mutacionJoinProbAzar / (RegConfig.mutacionJoinProbAzar
+ RegConfig.mutacionJoinProbMasSimilar));
formaElegirGrupoDestino = 4;
else
formaElegirGrupoDestino = 2;

switch (formaElegirGrupoDestino)
{
case 2: /* mas similar */
maxSimPromDest = (real)-1.0;
vecCent1 = agrup->vecGrupos[indGrupoOrigen].vecCentroide;
{
if (i != indGrupoOrigen)
{


simPromDest = vecCent1->Multiplicar(*vecCent2,false);
if (simPromDest > maxSimPromDest)
{
maxSimPromDest = simPromDest;
}
}
}
break;
maxSimPromDest = (real)0.0;
indGrupoDestino = RANDOM(agrup->cantGrupos);
break;
}
nroGrupoDestino = agrup->vecGrupos[indGrupoDestino].nroGrupo;

cromosoma->ultimoJoin = indGrupoDestino;

fprintf(DebugFP(),"Join Grupos : fuente=(%d) [%d] %f, destino=(%d) [%d] Sim :
%f\n",nroGrupoOrigen,agrup-
>vecGrupos[indGrupoOrigen].cantElementos,maxSimProm,nroGrupoDestino,agrup-
>vecGrupos[indGrupoDestino].cantElementos,maxSimPromDest);

if (indGrupoDestino != indGrupoOrigen)
/* puede pasar que sean iguales cuando se elige al azar */
{
/* juntamos los 2 grupos */
for (i=0; i < agrup->cantElementos; i++)
{
if (agrup->vecElementos[i] == nroGrupoOrigen)
{
/* lo pasamos al otro */
cantGrupos = agrup->cantGrupos; /* para ver si cambia */
codRet =
c_KMeans::MoverElementoyRecalcular(*agrup,vVecArchivos,i,indGrupoOrigen,indGrupoDestin
o,true);
if (codRet != OK)
return codRet;
if (cantGrupos != agrup->cantGrupos)
{
indGrupoOrigen = agrup-
>IndiceDeGrupo(nroGrupoOrigen,false);
indGrupoDestino = agrup-
}
}
}
}

return OK;
}

uent c_Genetico::AsignarFormaElegirGrupoSplit()
/* calcula la forma de elegir el grupo a partir de acuerdo a las probabilidades
(usado por el operador de mutacion split)
Devuelve : 1 = (... no definido)
2 = Mas grande
3 = Menor similitud promedio

4 = Al Azar
*/
{
real totalProbRestante;

totalProbRestante = (real)1.0;
if (TirarMonedaCargada(RegConfig.mutacionSplitProbMasGrande * (real)(1.0 /
{
return 2;
}
totalProbRestante -= RegConfig.mutacionSplitProbMasGrande;
if (TirarMonedaCargada(RegConfig.mutacionSplitProbMenorSimilProm * (real)(1.0 /
{
return 3;
}
/* si llegamos hasta aca, es al azar */
return 4;
}

uent c_Genetico::MutacionSplit(tCromosoma *cromosoma, c_VecArchivo *vVecArchivos[])
/* operador de mutacion que consiste en tomar un grupo y separarlo en 2 */
{
uent codRet,i;
uent formaElegirGrupoOrigen;
uent indGrupoOrigen, nroGrupoOrigen;
real maxSimProm, simProm;
c_VecArchivo *vecCent2;
uent cantElem, maxCantElem;
uent kAux;
uent *vec2Ind;


if (cromosoma->ultimoJoin == -1)
{

/* veamos de que forma elegimos al grupo a partir */
formaElegirGrupoOrigen = AsignarFormaElegirGrupoSplit();

switch (formaElegirGrupoOrigen)
{
case 2: /* mas grande */
maxCantElem = 0;
{
cantElem = agrup->vecGrupos[i].cantElementos;
if (cantElem > maxCantElem)
{
maxCantElem = cantElem;
indGrupoOrigen = i;
}
}
maxSimProm = (real)maxCantElem;
break;


{
{
indGrupoOrigen = i;
}
}
break;
maxSimProm = (real)0.0;
indGrupoOrigen = RANDOM(agrup->cantGrupos);
break;
}
}
else //tomamos el grupo donde se hizo el ultimo join
{
indGrupoOrigen = cromosoma->ultimoJoin;
}
nroGrupoOrigen = agrup->vecGrupos[indGrupoOrigen].nroGrupo;

fprintf(DebugFP(),"Split Grupos : fuente=(%d) [%d] %f\n",nroGrupoOrigen,agrup-
>vecGrupos[indGrupoOrigen].cantElementos,maxSimProm);

/* lo partimos */
/* guardamos el valor actual de k de la clase kmeans */
kAux = c_KMeans::k;
/* seteamos el k del kmeans igual a 2 */
c_KMeans::k = 2;
/* creamos un vector para contener el indice del nuevo grupo */
vec2Ind = (uent*)malloc(SINT * 2);
if (vec2Ind == NULL)
/* separamos el grupo en 2 usando la fase inicial del kmeans */
codRet =
c_KMeans::FaseInicial(*agrup,nroGrupoOrigen,vVecArchivos,vec2Ind,true,RegConfig.mutacion
SplitCantMuestras);
if (codRet != OK)
return codRet;
codRet = c_KMeans::CalcularCentroides(*agrup,vVecArchivos,2,vec2Ind);
if (codRet != OK)
return codRet;
/* reponemos el valor de k de la clase kmeans */
c_KMeans::k = kAux;

free((void*)vec2Ind);

return OK;
}


A4.2.13 Def.h

/*
En este archivo se hacen las definiciones generales
que se utilizaran en el resto del programa
*/

#ifndef __NuestraDefH__
/* si no esta definido todo esto... */
/* lo definimos ahora */
#define __NuestraDefH__

#include "limits.h"

/* estamos en windows */
#define midefDOS

typedef char byte;
typedef unsigned char ubyte;
#define SBYTE sizeof(char)
#define MAX_UBYTE UCHAR_MAX
/* 8 bits, 1 byte */

typedef short int ent;
typedef unsigned short int uent;
#define SINT sizeof(short int)
#define MAX_UENT USHRT_MAX
/* 16 bits, 2 bytes */

typedef long int word;
typedef unsigned long int uword;
#define SWORD sizeof(long int)
#define MAX_UWORD ULONG_MAX
/* 32 bits, 4 bytes */

typedef float real;
#define SREAL sizeof(float);

#define BITS_A_BYTES(b) ((b & 7) ? ((b>>3)+1) : (b>>3))
/* devuelve la cantidad de bytes necesarias para almacenar b bits */
/* si b es divisible por 8, devuelve b/8, sino, (b/8)+1 */

#define TRUE 1
#define FALSE 0

#define MAX_LONG_PALABRA 250
/* cantidad maxima de caracteres que puede tener el nombre de un archivo */
#define MAX_LONG_NOMARCH 350

/* definimos el tamanio de los buffers */
#define TBUFFTXT 1000

#define OK 0
#define ERROR 1
#define ERROR_MEMORIA 2
#define ERROR_ARCHIVO 3
#define ERROR_DIRECTORIO 4


#define MODO_LECTURA 0
#define MODO_ESCRITURA 1

#endif


A4.2.14 Sis.h

/*
En vez de incluir sisdos o sislinux debe incluirse
este archivo para poder tener definidas las funciones de sistema
*/

#include "def.h"

#ifdef midefDOS
/* dos */
#ifndef __SisDosH__
#include "sisdos.h"
#endif
#endif

#ifndef midefDOS
/* linux */
#ifndef __SisLinuxH__
#include "sislinux.h"
#endif
#endif



A4.2.15 SisDos.h

/*
Va a contener las rutinas que dependen del sistema operativo en
version DOS
*/
#include <io.h>
#include <malloc.h>
#include "def.h"
#include <string.h>
#include <stdlib.h>

#define __SisDosH__

#define RANDOM(n) (random(n))
/* esta macro devuelve un nro random entre 0 y n-1 */

#define PI (real)3.14159

/* para hora y fecha voy a usar el formato DOS */
/* el puntero a directorio lo presento como puntero a unsigned, total...*/
typedef long t_dir;

t_dir PrimeroDir(char *path, char *nomarch);
/*
Abre el directorio "path" y devuelve en dir un puntero a la estructura
de directorio
Si devuelve NULL, el directorio no se pudo abrir o esta vacio
En nomarch devuelve el nombre del primer archivo del directorio
En f y h, fecha y hora de ultima modificacion
*/

t_dir SiguienteDir(t_dir d, char *nomarch);
/*
Obtiene el siguiente archivo del directorio
Si devuelve NULL, el directorio no tiene mas archivos
En nomarch devuelve el nombre del siguiente archivo del directorio
*/

ent random(int n);
/* Devuelve un nro aleatorio entre 0 y n-1 */

uent *kNumerosRandom(uent k, uent minimo, uent maximo, bool ordenados);
/* Devuelve k numeros al azar que esten entre minimo y maximo
(incluyendo el minimo y el mximo */

bool TirarMonedaCargada(real probabilidadTrue);
/* esta funcin devuelve "true" con probabilidad "probabilidadTrue"
"probabilidadTrue" debe estar comprendida entre 0 y 1 */


A4.2.16 SisDos.cpp

/*
Va a contener las rutinas que dependen del sistema operativo en
version DOS
*/
#include "sisdos.h"

static struct _finddata_t blkarch;
static char ruta[255];
/* necesitamos que esto sea global */

t_dir PrimeroDir(char *path, char *nomarch)
/*
Abre el directorio "path" y devuelve en dir un puntero a la estructura
de directorio
Si devuelve NULL, el directorio no se pudo abrir o esta vacio
En nomarch devuelve el nombre del primer archivo del directorio
*/
{
char path2[256];
t_dir codRet;
strcpy(ruta,path);
strcpy(path2,path);
strcat(path2,"\\*.*");
if ((codRet = _findfirst(path2,&blkarch)) == -1)
/* no se pudo abrir */
return -1;
strcpy(nomarch,ruta);
strcat(nomarch,"\\");
strcat(nomarch,blkarch.name);
/* devolvemos un puntero no nulo */
return codRet;
}

t_dir SiguienteDir(t_dir d, char *nomarch)
/*
Obtiene el siguiente archivo del directorio
Si devuelve NULL, el directorio no tiene mas archivos
En nomarch devuelve el nombre del siguiente archivo del directorio
*/
{
if (_findnext(d, &blkarch) == -1)
return -1;
strcpy(nomarch,ruta);
strcat(nomarch,"\\");
strcat(nomarch,blkarch.name);
/* devolvemos no nulo */
return d;
}

ent random(int n)


{
/*
float f;

//conseguimos un nro entre 0 y 1
f = (float)(rand() - 1) / RAND_MAX;
f = f * n;

return (int)f;
*/

return (rand() % n);
}

uent *kNumerosRandom(uent k, uent minimo, uent maximo, bool ordenados)
{
uent *punt;
uent i,j,h,nroAzar,nroAzar2;

if (((maximo - minimo) + 1) < k)
return NULL;
/* creamos un vector de k numeros */
punt = (uent*)malloc(k * SINT);
if (punt==NULL)
return NULL;
/* vamos generando los numeros */
/* los generamos siempre ordenados, y si se necesitan desordenados,
los desordenamos despues */
if (((maximo - minimo) + 1) == k)
{
/* caso trivial */
for (i=0; i < k; i++)
punt[i] = minimo + i;
}
else
{
for (i=0; i < k; i++)
{
/* generamos un numero al azar en el intervalo que corresponde */
/* la primera vez va entre el minimo y el maximo
pero luego el intervalo se va achicando */
nroAzar = RANDOM(1 + (maximo - minimo) - i);
nroAzar += minimo;
/* veamos en que posicion del vector debe ingresarse */
j = 0;
while ((punt[j] <= nroAzar) && (j < i))
{
nroAzar++;
j++;
}
/* corremos las posiciones del vector hacia arriba */
for (h = i; h > j; h--)
{
punt[h] = punt[h-1];
}
/* lo insertamos */
punt[j] = nroAzar;
}

}

if (!ordenados)
{
/* los desordenamos */
for (i=0; i < k; i++)
{
nroAzar = RANDOM(k);
nroAzar2 = RANDOM(k);
j = punt[nroAzar];
punt[nroAzar] = punt[nroAzar2];
punt[nroAzar2] = j;
}
}

return punt;
}

bool TirarMonedaCargada(real probabilidadTrue)
{
uent nroAzar;

nroAzar = RANDOM(100);

return (nroAzar < (probabilidadTrue * 100));
}



A4.2.17 Ppal.cpp

#include "def.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <conio.h>
#include "skipl.h"
#include "archtxt.h"

#include "archivostexto.h"
#include "filtrarpalabras.h"
#include "clsGenetico.h"

/* VARIABLES GLOBALES */
uent generacionesGenetico;
char szSalida[300] = "salida\\salida_clustering.txt";
c_SkipList **lLexArchivos;
c_SkipList lTxt;
c_SkipList lLex;
c_VecArchivo **vVectoresArchivos;
time_t startTime, elapsedTime, endTime;
uent codRet;
uent kBisect;
char szMat[300] = "";
uent cantGrupos;
char szAlgoritmo[300];
uent iCorridas;

void ImprimirAgrupamiento(c_Agrupamiento &agrup)
/* imprime el agrupamiento en el archivo szSalida */
{
FILE *fpSalida;

fpSalida = fopen(szSalida,"wt");
fprintf(fpSalida,"CantMultip=%d\n",c_VecArchivo::contMultiplicaciones);
fprintf(fpSalida,"CantCalcNorma=%d\n",c_VecArchivo::contCalculoNorma);
fprintf(fpSalida,"CantMovimientos=%d\n",c_KMeans::contMoverYRecalcular);
c_Agrup_Imprime::salidaCompacta = true;
c_Agrup_Imprime::ImprimirTodo(fpSalida,agrup,vVectoresArchivos,lLex,lTxt);
fclose(fpSalida);
//xxxdebug
fpSalida = fopen("salida_no_compacta.txt","wt");
c_Agrup_Imprime::salidaCompacta = false;
c_Agrup_Imprime::ImprimirTodo(fpSalida,agrup,vVectoresArchivos,lLex,lTxt);
fclose(fpSalida);
}

/* Las funciones "Agrupar...." realizan un agrupamiento
y lo imprimen en szSalida
*/


uent AgruparRandom(uent k)
/* Realiza un agrupamiento al azar de los documentos en
k grupos */
{
c_Agrupamiento agrup;
uent codRet;

startTime = time(NULL);

codRet = agrup.Inicializar((uent)lTxt.ObtenerCantElementos());
if (codRet != OK)
return codRet;
codRet = agrup.AgruparAlAzar(k,k);
if (codRet != OK)
return codRet;

codRet = c_KMeans::CalcularCentroides(agrup,vVectoresArchivos,0,NULL);
if (codRet != OK)
return codRet;

endTime = time(NULL);
elapsedTime = endTime - startTime;
printf("Fin agrupar al azar : %d segundos\n",elapsedTime);

ImprimirAgrupamiento(agrup);

return OK;
}

uent AgruparKMeansComun(uent k)
/* realiza un agrupamiento k-means en k grupos */
{
c_Agrupamiento agrup;
uent codRet;
uent *vecIndGrupos;
uent cantIteraciones = 100, cantCambiosTotal = 0;


c_KMeans::k = k;

vecIndGrupos = (uent *)malloc(k * SINT);
if (vecIndGrupos == NULL)

codRet = agrup.Inicializar((uent)lTxt.ObtenerCantElementos());
if (codRet != OK)
return codRet;

codRet = agrup.AgruparAlAzar(1,1);
if (codRet != OK)
return codRet;

codRet = c_KMeans::FaseInicial(agrup,1,vVectoresArchivos,vecIndGrupos,false,0);
if (codRet != OK)
return codRet;



printf("Fin fase inicial : %d segundos\n",elapsedTime);

c_KMeans::CalcularCentroides(agrup,vVectoresArchivos,0,NULL);
//c_Agrup_Imprime::ImprimirTodo(stdout,agrup,vVectoresArchivos,lLex,lTxt);

printf("Fin calcular centroides : %d segundos\n",elapsedTime);

printf("Vamos a refinar...\n");
c_KMeans::FaseRefinar(agrup,vVectoresArchivos,vecIndGrupos,true,cantIteraciones,c
antCambiosTotal);
printf("Refinar : %d iteraciones.\n",cantIteraciones);

printf("Fin refinar : %d segundos\n",elapsedTime);

/* liberamos el vector de k indices */
free((void*)vecIndGrupos);

ImprimirAgrupamiento(agrup);

return OK;
}

uent AgruparBisectingKMeans(uent k, bool refinar)
/* realiza un agrupamiento bisecting k-means en k grupos */
{
uent codRet;

agrup = new c_Agrupamiento();


printf("Empezando bisecting k-means ...\n");

c_KMeans::k = k;

codRet = agrup->Inicializar((uent)lTxt.ObtenerCantElementos());
if (codRet != OK)
return codRet;

codRet = agrup->AgruparAlAzar(1,1);
if (codRet != OK)
return codRet;

codRet = c_KMeans::BisectingKMeans(agrup,1,vVectoresArchivos,kBisect,refinar);
if (codRet != OK)
return codRet;


printf("Fin bisecting k-means : %d segundos\n",elapsedTime);

ImprimirAgrupamiento(*agrup);

delete(agrup);
return OK;
}

uent AgruparBisectingKMeansSinRef(uent k)
{
return AgruparBisectingKMeans(k,false);
}

uent AgruparBisectingKMeansConRef(uent k)
{
return AgruparBisectingKMeans(k,true);
}

uent AgruparGenetico(uent k)
/* Realiza un agrupamiento de los documentos en k grupos
usando el algoritmo genetico */
{
c_Genetico objGenetico;
uent codRet;
c_Agrupamiento *agrup = NULL;
uent cantGeneraciones, i, cantIteraciones, cantCambiosTotal;
FILE *fp;
uent *vecIndGrupos;
char szDebug[255];

//fp = NULL;
sprintf(szAlgoritmo,"Gen");
sprintf(szSalida,"salida\\salida_%s_%s_%d_%d.txt",szMat,szAlgoritmo,cantGrupos,iCor
ridas);

sprintf(szDebug,"%s_d.asc",szSalida);
fp = fopen(szDebug,"wt");

objGenetico.RegConfig.fpSalidaDebug = fp;

uent a = 0;


objGenetico.RegConfig.k = k;

codRet =
objGenetico.GenerarPoblacionInicial((uent)lTxt.ObtenerCantElementos(),vVectoresArchivos);
if (codRet != OK)
return codRet;

printf("Fin generar poblacion inicial : %d segundos\n",elapsedTime);


cantGeneraciones = generacionesGenetico;
codRet = objGenetico.Evolucionar(vVectoresArchivos,true,cantGeneraciones);
if (codRet != OK)
return codRet;

printf("Fin evolucion : %d segundos\n",elapsedTime);

codRet = objGenetico.DevolverMejorSolucion(&agrup);
if (codRet != OK)
return codRet;

if (fp != NULL)
fclose(fp);

/* lo imprimimos sin refinar */

/* ahora lo refinamos con el KMeans */
c_KMeans::k = agrup->cantGrupos;
vecIndGrupos = (uent*)malloc(agrup->cantGrupos * SINT);
vecIndGrupos[i] = i;
cantIteraciones = 100;
codRet =
c_KMeans::FaseRefinar(*agrup,vVectoresArchivos,vecIndGrupos,true,cantIteraciones,cantCam
biosTotal);

printf("Fin refinar : %d segundos\n",elapsedTime);
/* lo imprimimos refinado */
sprintf(szAlgoritmo,"Gen(ref)");
ridas);

return OK;
}

int main(void)
{
int i;
//int j;
//uent valEnt;
//real valReal;
char szDir[300] = "d:\\Tesis_Docs";
char szPathMat[300] = "";
uent cantLex;
uent cantArchivos;
char opcion;
uent codRet;
bool bCorrerAlgoritmo;
uent (*funcionAgrupar)(uent); /* puntero a la funcion */

uent cantCorridas;
uent cantGruposLoc;

/* inicializamos la serie de numeros al azar */
srand( (unsigned)time( NULL ) );

/* preguntamos por el directorio de los archivos */
printf ("Directorio donde se encuentran los archivos (ej: 'd:\\Tesis_Docs') : ");
scanf("%s",&szDir); getchar();
/* veamos si hay que leer archivos txt del disco
o si se debe cargar un dataset .mat */
printf ("Nombre del .mat (ej : 're0_1') o 'txt' para leer archivos .txt : ");
scanf("%s",&szMat); getchar();

if (strcmp((char*)&szMat,"txt") == 0)

{

/* ***************************************** */
/* LEEMOS LOS ARCHIVOS .TXT DEL DISCO */
/* Se leen los archivos y se arman las listas de
palabras */


lTxt.SetearOrden(1); /* los ordenamos por numero */
cantArchivos = CargarListaArchivos(szDir,lTxt);

/* creamos los vectores de listas y vectores de palabras */
lLexArchivos = (c_SkipList**)malloc((cantArchivos+1)*sizeof(c_SkipList*));
if (lLexArchivos == NULL)
vVectoresArchivos =
(c_VecArchivo**)malloc((cantArchivos+1)*sizeof(c_VecArchivo*));
if (vVectoresArchivos == NULL)

codRet = ProcesarArchivosTexto(lTxt,lLex,TBUFFTXT,cantLex,lLexArchivos);
if (codRet != OK)
return codRet;

printf("Fin leer archivos : %d segundos\n",elapsedTime);

/* FIN DE LEER LOS ARCHIVOS */
/*********************************************/

/* ******************************************** */
/* VAMOS A FILTRAR LAS LISTAS DE LEXICO */

codRet =
FiltrarListasDeLexico(lLex,lLexArchivos,lTxt.ObtenerCantElementos());
if (codRet != OK)
return codRet;

/* al renumerar los valores, la lista de lexico queda ordenada tanto


por numero de palabra como por orden alfabtico */
lLex.RenumerarValores();

/* FIN FILTRAR LISTAS DE LEXICO */
/************************************/

}
else
{
/* Leemos un dataset en formato .mat */

sprintf((char*)&szPathMat,"%s\\%s.mat",szDir,szMat);


lTxt.SetearOrden(1); /* los ordenamos por numero */

cantArchivos = CargarListaArchivosMAT(szPathMat,lTxt);

/* creamos los vectores de listas y vectores de palabras */
lLexArchivos = (c_SkipList**)malloc((cantArchivos+1)*sizeof(c_SkipList*));
if (lLexArchivos == NULL)
vVectoresArchivos =
(c_VecArchivo**)malloc((cantArchivos+1)*sizeof(c_VecArchivo*));
if (vVectoresArchivos == NULL)

lLex.SetearOrden(1); /* lo ordenamos por numero */

codRet = ProcesarArchivosTextoMAT(szPathMat,lLex,cantLex,lLexArchivos);
if (codRet != OK)
return codRet;

printf("Fin leer .mat : %d segundos\n",elapsedTime);

}

/* ******************************************** */
/* VAMOS A CREAR LOS VECTORES DE ARCHIVOS */

codRet =
ArmarVectoresArchivos(lLex,lTxt.ObtenerCantElementos(),lLexArchivos,vVectoresArchivos);
if (codRet != OK)
return codRet;

/* a partir de aca no vamos a volver a buscar por orden
alfabetico en la lista de lexico */
lLex.SetearOrden(1);

/* no necesitamos ms las listas de palabras de los archivos */
for (i=1; i <= cantArchivos; i++)
delete(lLexArchivos[i]);
free((void*)lLexArchivos);


printf("Fin inicializacion : %d segundos\n",elapsedTime);

/* FIN DE ARMAR VECTORES DE ARCHIVOS */
/* ************************************************* */

/* Ahora vamos a mostrar un menu para que se pueda
elegir que hacer */

opcion = 0;
/* valores por default */
cantGrupos = 15;
cantCorridas = 5;
kBisect = 2;
generacionesGenetico = 50;

while (opcion != 'x')
{
bCorrerAlgoritmo = false;
printf("(1) Cambiar cantidad grupos (%d)\n",cantGrupos);
printf("(2) Cambiar cantidad corridas (%d)\n",cantCorridas);
printf("(3) Cambiar generaciones del genetico (%d)\n",generacionesGenetico);
// printf("(4) Cambiar k de bisecting K-Means (%d)\n",kBisect);
printf("(a) Bisecting K-Means (con refinamiento)\n");
printf("(b) Algoritmo Genetico (con y sin refinamiento)\n");
// printf("(c) Al Azar\n");
// printf("(d) K-Means Comun\n");
// printf("(e) Bisecting K-Means (sin refinar)\n");
printf("(x) Salir\n");
printf("\n");
printf ("? ");
opcion = (char)getchar(); getchar();

switch (opcion)
{
case 'a':
funcionAgrupar = &AgruparBisectingKMeansConRef;
sprintf(szAlgoritmo,"BisKM(ref)%d",kBisect);
bCorrerAlgoritmo = true;
break;
case 'b':
funcionAgrupar = &AgruparGenetico;
sprintf(szAlgoritmo,"Gen");
break;
case 'c':
funcionAgrupar = &AgruparRandom;
sprintf(szAlgoritmo,"Azar");
break;
case 'd':
funcionAgrupar = &AgruparKMeansComun;
sprintf(szAlgoritmo,"KMCom");
break;


case 'e':
funcionAgrupar = &AgruparBisectingKMeansSinRef;
sprintf(szAlgoritmo,"BisKM%d",kBisect);
break;
case '1':
printf("Grupos : ");
scanf("%d",&cantGruposLoc); getchar();
cantGrupos = cantGruposLoc;
break;
case '2':
printf("Corridas : ");
scanf("%d",&cantCorridas); getchar();
break;
case '3':
printf("Generaciones : ");
scanf("%d",&generacionesGenetico); getchar();
break;
case '4':
printf("K de bisecting k-means : ");
scanf("%d",&kBisect); getchar();
break;
}

if (bCorrerAlgoritmo)
{
for (iCorridas = 0; iCorridas < cantCorridas; iCorridas++)
{
/* reseteamos los contadores de las clases */
c_KMeans::contMoverYRecalcular = 0;
c_VecArchivo::contCalculoNorma = 0;
c_VecArchivo::contMultiplicaciones = 0;

ridas);
codRet = (*funcionAgrupar)(cantGrupos);
if (codRet != OK)
return codRet;
}
}

}

/* liberamos los vectores de los archivos */
for (i=1; i <= cantArchivos; i++)
delete(vVectoresArchivos[i]);
free((void*)vVectoresArchivos);

return 0;
}

Yolis Tesisingenieriainformatica

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Yolis Tesisingenieriainformatica

Cargado por

Copyright:

Formatos disponibles

ALGORITMOS GENTICOS APLICADOS A

También podría gustarte