Algoritmo P

ANALISIS INTELIGENTE
DE DATOS
TRABAJO FINAL
IMPLEMENTACION MÉTODO
CLUSTER EN WEKA: P-MEDIAN
Profesores:
Dra. Ana Haedo
Daniel Vázquez V.
Alumno:
Jorge Beyoglonian
Diciembre 2008
AID - Trabajo Final
Implementación P-Median
Índice
RESUMEN ........................................................................................................................................................................ 3
INTRODUCCIÓN ............................................................................................................................................................. 3
IMPLEMENTACIÓN ........................................................................................................................................................ 5
ALGORITMO P-MEDIAN ............................................................................................................................................... 5
INTEGRACIÓN CON WEKA ......................................................................................................................................... 6
REGISTRACIÓN DEL NUEVO ALGORITMO ......................................................................................................................... 6
DETALLES DE INTEGRACIÓN.......................................................................................................................................... 10
ESTANDARIZACIÓN DE VARIABLES................................................................................................................................ 10
P-MEDIAN PASO A PASO ................................................................................................................................................ 11
EJEMPLOS .................................................................................................................................................................... 15
PROBLEMAS CON MUCHAS INSTANCIAS ......................................................................................................................... 18
IDEAS PARA FUTURAS INVESTIGACIONES ........................................................................................................ 18
CONCLUSIONES .......................................................................................................................................................... 19
DETALLES DE INSTALACIÓN .................................................................................................................................. 19
DISPONIBILIDAD PÚBLICA ....................................................................................................................................... 19
BIBLIOGRAFÍA Y REFERENCIAS ............................................................................................................................ 20
Diciembre 2008
Página 2 de 20
AID - Trabajo Final
Implementación P-Median
Resumen
El presente trabajo consiste en la presentación del método de agrupamiento P-Median, su comparación
con el algoritmo K-Means, y el desarrollo de una implementación a través de la cual se pueda realizar
comparaciones de los resultados, y analizar las métricas del consumo de recursos empleado por cada
método de agrupamiento.
La implementación del algoritmo será realizada como un módulo adicional del sistema Weka, incorporando
a este informe todos los detalles de su implementación y los pasos a seguir para poder emplear de forma
libre el módulo desarrollado.
Introducción
El análisis cluster, también conocido como análisis de conglomerados, es una técnica estadística
multivariante cuya finalidad es formar grupos a partir de un conjunto de elementos de tal forma que estos
grupos estén formados por elementos los más parecidos que sea posible (homogéneos) y a su vez lo más
diferentes (heterogéneos) que sea posible entre los grupos. Los elementos en cada grupo (conglomerado)
tienden a ser similares entre sí (alta homogeneidad interna, dentro del cluster) y diferentes a los objetos de
los otros grupos (alta heterogeneidad externa, entre clusters) con respecto a algún criterio de selección
predeterminado.
El análisis de cluster se utiliza en marketing para diversos propósitos, entre los que podemos destacar:
segmentación del mercado, comprensión del comportamiento del comprador, identificación de
oportunidades para productos nuevos, selección de mercados de prueba, reducción de datos, etc.
El objetivo del análisis de cluster es la de agrupar a los individuos por su grado de homogeneidad. Existen
distintas clasificaciones de este tipo de modelos, siendo la más usada los modelos jerárquicos frente a los
no jerárquicos.
El análisis cluster jerárquico es una herramienta exploratoria diseñada para revelar las agrupaciones
naturales (o los conglomerados o clusters) dentro de un conjunto de datos que no sería de otra manera
evidente. Es el más útil cuando se desea agrupar un número pequeño (menos que algunos cientos) de
objetos. Este método comienza separando cada objeto en un cluster por sí mismo. En cada etapa del
análisis, el criterio por el que los objetos son separados se relaja en orden a enlazar los dos conglomerados
más similares hasta que todos los objetos sean agrupados en un árbol de clasificación completo.
El criterio básico para cualquier agrupación es la distancia. Los objetos que estén cerca uno del otro
pertenecerían al mismo conglomerado o cluster, y los objetos que estén lejos uno del otro pertenecerán a
distintos clusters.
Los resultados de agrupamientos jerárquicos se muestran en un diagrama conocido como dendrograma, en
el que se pueden observar las uniones y/o divisiones que se van realizando. Las ramas del árbol
representan los conglomerados. Las ramas se unen en un nodo cuya ubicación sobre el eje de distancias
indica el nivel en el cual ocurre la fusión. El nodo en el que todas los objetos forman un solo conglomerado
se llama nodo raíz.
Diciembre 2008
Página 3 de 20
AID - Trabajo Final
Implementación P-Median
Figure 1. Ejemplo de un dendograma
El análisis de cluster no jerárquico es especialmente indicado para grandes tablas de datos. El
objetivo de este análisis es realizar una sola partición de los elementos en K grupos.
El número de grupos puede ser especificado de antemano o ser determinado en el procedimiento. Estos
métodos pueden comenzar con un agrupamiento inicial o con un grupo de puntos semilla (centroides) que
formarán los centros de los grupos.
El método de tipo no jerárquico mas comúnmente usado es el algoritmo K-means. Este separa un grupo de
objetos en una cantidad elegida de grupos haciendo máxima la variación entre conglomerados y
minimizando la variación dentro de cada conglomerado. Asigna cada objeto al grupo que tiene el centroide
(media) más cercano. La distancia comúnmente usada es la Euclídea, tanto en observaciones
estandarizadas como en las no estandarizadas. La partición lograda es aquella tal que la suma de la suma de
las distancias al cuadrado de los miembros del grupo respecto a su centroide es mínima.
Dado que este algoritmo, en cada iteración de su proceso, utiliza la media de su población para recalcular el
potencial nuevo centroide, la existencia de elementos alejados (que puedan ser outliers o no) logran
producir una distorsión tal que lleva a que el algoritmo retorne soluciones erróneas, tanto en la
composición de los grupos conformados como en la elección de los centroides de cada uno de ellos.
Diciembre 2008
Página 4 de 20
AID - Trabajo Final
Implementación P-Median
Un algoritmo de tipo no jerárquico inmune a este problema descripto en el párrafo anterior es el conocido
bajo el nombre P-Median.
Este algoritmo se diferencia del K-means en la postulación de nuevos centroides que hace en cada
iteración, ya que en lugar de utilizar la media considera la mediana de la población del grupo. De esta
manera la existencia de valores lejanos y/o utliers no afectan la ubicación de los nuevos centroides ni la
conformación de nuevos grupos que minimicen la variación interna al conglomerado y maximice la
variación intra los diferentes grupos.
Implementación
El objetivo de este trabajo es presentar el algoritmo P-Median, realizar comprobaciones en cuanto a su
desempeño, y proveer una implementación que pueda ser utilizada de la manera más simple posible por
quién la requiera.
La idea fue integrar este método en algunos de los paquetes de software que se emplean comúnmente
para hacer análisis exploratorio y de tipo multivariado, por tal razón la implementación del algoritmo fue
realizada en lenguaje Java, previendo cumplir todos los requisitos para poder ser integrado al software
Weka.
Algoritmo P-Median
A grandes rasgos el algoritmo P-Median se comporta de igual manera que el K-Means, diferenciándose en
que en lugar de utilizar la función estadística media utiliza la mediana para generar nuevos centroides en
cada iteración.
Los pasos del algoritmo, en lenguaje natural, son los siguientes:
1) Plantear una solución inicial eligiendo de manera aleatoria instancias para ser utilizadas como
centroides de cada grupo. La cantidad de grupos debe ser configurada por el usuario.
2) Para cada instancia considerar la distancia euclidea que tiene contra cada centroide y asignarlo al
grupo cuya distancia al centroide sea menor.
3) Para cada grupo calcular por medio de la mediana la nueva ubicación del centroide de cada grupo.
4) Repetir los pasos 2 y 3 hasta que la conformación de los grupos converja, y ya no haya más
reasignación de instancias a grupos entre iteraciones.
El aspecto característico, y que da nombre al algoritmo, es el que se realiza en el paso 3), en el cálculo de la
mediana para cada dimensión de todos los componentes del grupo.
Para llevar a cabo esta tarea la implementación tradicional es ordenar los valores de cada dimensión y
acceder al elemento, o a los dos elementos en caso que la cantidad sea par, que se encuentra en la mitad
Diciembre 2008
Página 5 de 20
AID - Trabajo Final
Implementación P-Median
de la totalidad que conforman el grupo, y tomar este valor como medida para conformar el nuevo
centroide.
Esta tarea tiene un costo computacional importante, ya que en cada iteración se debe ordenar la colección
de valores de cada dimensión de todos los grupos. Como podrá apreciarse más adelante en este informe, al
momento de realizar las pruebas este punto no resulta impedimento para poder ejecutar el algoritmo,
considerando una computadora personal configuración promedio del año 2008 y dimensión de problemas
acotados a pocos miles de instancias y pocas dimensiones.
Si puede ser un problema importante para realizar análisis sobre problemas de cantidad de muestras muy
importantes y/o de muchas dimensiones.
Integración con Weka
Weka cuenta con una jerarquía de clases específica para cada funcionalidad que brinda. Esta jerarquía y
otras cuestiones internas de implementación pueden modificarse con el advenimiento de nuevas versiones
de Weka, no obstante es poco común que surjan cambios tan importantes que puedan causar que el nuevo
algoritmo P-Median no pueda ser integrado al resto del sistema.
Se tomó como base la versión Weka Developer 3.5.8.
Los algoritmos de agrupamiento (clustering) extienden una clase base llamada RandomizableClusterer,
quién provee la especificación de los puntos de entrada y los enlaces por los cuales este modulo deberá
comunicarse con el resto del sistema.
Asimismo las clases de este tipo también pueden implementar ciertas interfaces que simplifican las tareas
comunes, por ejemplo NumberOfClustersRequestable.
Registración del nuevo algoritmo
Se generó una nueva clase siguiendo estos mismos lineamientos llamada PMedian, donde se encontrará
toda la lógica de la implementación del algoritmo, así como todas las funcionalidades auxiliares para que
este módulo coexista dentro del mismo paquete de software Weka, integrándose y proveyendo las mismas
funcionalidades que el resto de los algoritmos disponibles.
Diciembre 2008
Página 6 de 20
AID - Trabajo Final
Implementación P-Median
La creación de la nueva clase se llevo a cabo con el siguiente código Java:
public class PMedian
extends RandomizableClusterer
implements NumberOfClustersRequestable, WeightedInstancesHandler {
/**
* the default constructor
*/
public PMedian() {
super();
m_SeedDefault = 10;
setSeed( m_SeedDefault );
}
…
}
El texto descriptivo para la ventana de configuración de los parámetros:
/**
* Returns a string describing this clusterer
*
* @return a description of the evaluator suitable for displaying in the
*
explorer/experimenter gui
*/
public String globalInfo() {
return "Cluster data using the PMedian algorithm";
}
La definición de las capacidades del algoritmo, donde se especifica que el mismo no soporta valores
perdidos:
/**
* Returns default capabilities of the clusterer.
*
* @return the capabilities of this clusterer
*/
public Capabilities getCapabilities() {
Capabilities result = super.getCapabilities();
// attributes
result.enable( Capability.NOMINAL_ATTRIBUTES );
result.enable( Capability.NUMERIC_ATTRIBUTES );
// disable MISSING VALUES
result.disable( Capability.MISSING_VALUES );
return result;
}
Diciembre 2008
Página 7 de 20
AID - Trabajo Final
Implementación P-Median
Especificación de los parametros que deberán ser proporcionados para llevar a cabo un ciclo de ejecución:
/**
* Gets the current settings of PMedian
*
* @return an array of strings suitable for passing to setOptions()
*/
public String[] getOptions() {
int i;
Vector result;
String[] options;
result = new Vector();
if( m_displayStdDevs ) {
result.add( "-V" );
}
if( m_standardizeAttributes ) {
result.add( "-M" );
}
result.add( "-N" );
result.add( "" + getNumClusters() );
options = super.getOptions();
for( i = 0; i < options.length; i++ )
result.add( options[i] );
return (String[]) result.toArray( new String[result.size()] );
}
Ajuste de las opciones configuradas por el usuario para llevar a cabo la ejecución del algoritmo:
public void setOptions(String[] options) throws Exception {
m_displayStdDevs = Utils.getFlag( "V", options );
m_standardizeAttributes = Utils.getFlag( "M", options );
String optionString = Utils.getOption( 'N', options );
if( optionString.length() != 0 ) {
setNumClusters( Integer.parseInt( optionString ) );
}
super.setOptions( options );
}
Diciembre 2008
Página 8 de 20
AID - Trabajo Final
Implementación P-Median
El código expuesto en parrafos anteriores hace posible que el algoritmo PMedian se integre como un
modulo nativo al sistema Weka, el mismo puede observarse como una opción mas de algoritmos de
clustering, como se ve en la siguiente captura de pantalla:
Y al ingresar al algoritmo pueden verse y configurarse las opciones, de la siguiente manera:
Diciembre 2008
Página 9 de 20
AID - Trabajo Final
Implementación P-Median
Detalles de integración
Una vez registrado el nuevo algoritmo en el sistema Weka el usuario lo verá disponible y podrá utilizarlo de
la misma manera que utiliza el resto de funcionalidades que otorga el resto del sistema.
Al emplear el PMedian Weka realizará primero una invocación al método setOptions (función descripta
en párrafos anteriores) con el fin que el algoritmo pueda obtener las opciones seleccionadas por el usuario,
luego invocará al punto de entrada del algoritmo indicándole las datos en los cuales debe ejecutarse.
El punto de entrada al algoritmo de agrupamiento (definido dentro de la jerarquía de algoritmos de
agrupamiento, mas específicamente en la clase AbstractClusterer) es el siguiente:
/**
* Generates a clusterer. Has to initialize all fields of the clusterer that
* are not being set via options.
*
* @param data
*
set of instances serving as training data
* @throws Exception
*
if the clusterer has not been generated successfully
*/
public void buildClusterer(Instances data) throws Exception {
…
En el cuadro anterior puede apreciarse la función que invoca Weka para realizar la generación del
agrupamiento. En la misma pasa por parámetro los datos en los cuales debe llevar a cabo el algoritmo.
El tipo de dato Instances es original de Weka y contiene dentro de sí toda la información del dataset con el
cual se esta operando, tanto la información de nombres de campos, tipos de datos, etc, como los datos
específicos de las instancias.
El primer paso a llevar a cabo es verificar que se cumplan los requisitos impuestos, en nuestro caso se debe
verificar que los datos no contengan valores faltantes, esto se lleva a cabo con la siguiente instrucción:
// can clusterer handle the data?
getCapabilities().testWithFail( data );
…
Esta invocación realizará la comprobación que los datos no contengan datos faltantes, y que los atributos
sean de tipo numérico o nominal. La definición de las capacidades del algoritmo PMedian están definidos
en el método getCapabilities que ya fue expuesto en un punto anterior dentro de este informe (bajo
la sección Registración del nuevo Algoritmo).
Estandarización de variables
Para implementar la opción de estandarizacion de los variables como paso previo al proceso de
agrupamiento se utilizo una clase provista por Weka llamada Standardize.
En caso de ser necesario (por solicitud del usuario mediante la ventana de configuración) se procederá a
instanciar un objeto de esta clase, e invocar a un filtro no supervisado que llevará a cabo la estandarización
de los valores en las instancias previamente cargadas en la aplicación. Puede verse esta secuencia en el
siguiente código:
Diciembre 2008
Página 10 de 20
AID - Trabajo Final
Implementación P-Median
m_Standardize = new Standardize();
Instances instances = new Instances( data );
instances.setClassIndex( -1 );
if( m_standardizeAttributes ) {
m_Standardize.setInputFormat( instances );
instances = Filter.useFilter( instances, m_Standardize );
}
P-Median paso a paso
El primer paso en el algoritmo de agrupamiento es crear tantos centroides como haya especificado el
usuario, para luego poder plantear una solución inicial.
m_ClusterCentroids = new Instances( instances, m_NumClusters );
int[] clusterAssignments = new int[instances.numInstances()];
…
Random RandomO = new Random( getSeed() );
for( int j = instances.numInstances() - 1; j >= 0; j-- ) {
int instIndex = RandomO.nextInt( j + 1 );
m_ClusterCentroids.add( instances.instance( instIndex ) );
instances.swap( j, instIndex );
if( m_ClusterCentroids.numInstances() == m_NumClusters ) {
break;
}
}
Aquí puede apreciarse la elección aleatoria de los centroides para conformar luego la solución inicial.
A través de un ciclo se itera tantas veces como centroides deban elegirse, y en cada paso se selecciona a
través de un numero aleatorio (con la semilla seleccionada por el usuario) el número de instancia que será
elegida como centroide inicial. Luego esta instancia se la coloca al final de todas para que no vuelva a ser
elegida en la próxima iteración.
Como resultado de este conjunto de instrucciones los centroides ya han sido prefijados, y resta asignar
cada instancia a su centroide mas cercano para conformar así la solución inicial del algoritmo.
La selección y asignación de cada instancia a su centroide mas cercano, y por consiguiente al grupo al cual
pertenece este centroide se realiza con la siguiente función:
Diciembre 2008
Página 11 de 20
AID - Trabajo Final
Implementación P-Median
/**
* clusters an instance that has been through the filters
*
* @param instance
*
the instance to assign a cluster to
* @param updateErrors
*
if true, update the within clusters sum of errors
* @return a cluster number
*/
private int clusterProcessedInstance(Instance instance) {
double minDist = Integer.MAX_VALUE;
int bestCluster = 0;
for( int i = 0; i < m_NumClusters; i++ ) {
double dist = distance( instance, m_ClusterCentroids.instance(i) );
if( dist < minDist ) {
minDist = dist;
bestCluster = i;
}
}
return bestCluster;
}
Considerando únicamente la instancia recibida por parámetro recorre todos los centroides y calcula la
distancia que lo separa a cada uno de ellos. Luego selecciona el centroide/grupo al cual la distancia haya
sido menor, y lo asigna al mismo. La distancia utilizada es la distancia Euclidea provista por el sistema
Weka.
En este momento el algoritmo ya cuenta con una solución inicial; a partir de ahora buscará nuevas
soluciones que mejoren en cada iteración, y se detendrá cuando la solución converja y se estabilice, es
decir que como resultado de la iteración ninguna instancia se haya desplazado de un grupo a otro.
for( i = 0; i < m_NumClusters; i++ ) {
double[] vals = new double[instances.numAttributes()];
// Set new set of centroids
for( int j = 0; j < instances.numAttributes(); j++ ) {
// Use Median of data values to set the new centroid
vals[j] = MedianOrModeCompute( tempI[i], j );
}
}
m_ClusterCentroids.add( new Instance( 1.0, vals ) );
Como puede verse, el cálculo de los nuevos centroides es sumamente simple, para cada grupo se computa
la mediana (o moda en caso de variables nominales) para cada dimensión y se utiliza este valor como nuevo
centroide.
El cálculo de la mediana es el principal aspecto que distingue a este método de agrupamiento, es llevado a
cabo por el método MedianOrModeCompute y recibe como parámetro todas las instancias en el grupo y el
índice de la dimensión para el cual se quiere calcular el valor de la mediana.
Diciembre 2008
Página 12 de 20
AID - Trabajo Final
Implementación P-Median
/**
* Returns the median (mode) for a numeric (nominal) attribute as a
* floating-point value. Returns 0 if the attribute is neither nominal nor
* numeric. If all values are missing it returns zero.
*
* @param attIndex the attribute's index (index starts with 0)
* @return the median or the mode
*/
public static double MedianOrModeCompute(Instances instances, int attIndex){
if( instances.attribute( attIndex ).isNumeric() ) {
// copy instance's (values * weight) to a plain vector
Vector<Double> values = new Vector<Double>();
for( int j = 0; j < instances.numInstances(); j++ ) {
if( !instances.instance( j ).isMissing( attIndex ) ) {
values.add( new Double( instances.instance( j ).weight()
* instances.instance( j ).value( attIndex ) ) );
}
}
// order the vector
java.util.Collections.sort( values );
double median;
// even or odd number of values?
if( values.size() % 2 == 1 )
// odd => (n/2) element
median = values.get( values.size() / 2 );
else
// even => ( (n/2)-1 element + (n/2) element ) / 2
median = ( values.get((values.size()/2)-1)
+ values.get(values.size()/2) ) / 2;
return median;
}
return instances.meanOrMode( attIndex );
}
En el caso que la variable sea de tipo nominal el valor esperado es la moda. Dado que Weka provee esta
funcionalidad se delega en este método su computo (última línea del código referenciado en el cuadro
previo).
Si el atributo es numérico debe calcularse la mediana. Para tal fin se crea un vector con los valores de las
instancias para el atributo indicado, luego se ordena, y por último se accede al elemento de la mitad (o los
2 de la mitad y se divide por 2 en caso que haya una cantidad par de elementos) del vector para obtener la
mediana. Este valor es retornado como resultado, y luego empleado en la conformación del nuevo
centroide.
En este punto el algoritmo da inicio a una nueva iteración. Hasta aquí calculo los grupos iniciales, sus
centroides y las instancias que conforman cada grupo. Luego mediante la utilización de la media calculo
nuevos centroides candidatos para la solución, y en este punto de la ejecución es cuando debe decidir si los
nuevos centroides mejoran la solución inicial, y/o el problema converge dando por terminada su ejecución.
Diciembre 2008
Página 13 de 20
AID - Trabajo Final
Implementación P-Median
while( !converged ) {
m_Iterations++;
converged = true;
for( i = 0; i < instances.numInstances(); i++ ) {
Instance toCluster = instances.instance( i );
int newC = clusterProcessedInstance( toCluster, true );
if( newC != clusterAssignments[i] ) {
converged = false;
}
clusterAssignments[i] = newC;
}
Inicia una nueva iteración, y se reasignan todas las instancias a los nuevos centroides. Si todas las nuevas
asignaciones a grupos coinciden con las que tenian previamente el algoritmo concluye que el sistema
converge, y termina su ciclo de ejecución dando como resultado final estos conformación de grupos que
tiene actualmente.
En caso que el sistema no converja se vuelven a repetir todos los pasos descriptos previamente,
calculándose nuevamente la mediana para cada dimensión de las instancias de los grupos, calculando en
base a esto nuevos centroides y volviendo a reasignar los casos hasta que el sistema se estabilice.
Diciembre 2008
Página 14 de 20
AID - Trabajo Final
Implementación P-Median
Ejemplos
Con el fin de evaluar el comportamiento del algoritmo se plantea un ejemplo de tamaño reducido, con
datos en los cuales se espera ver una diferencia cuando se compare con otros algoritmo, por ejemplo KMeans.
La característica de este ejemplo es que cuenta con una variable que se encuentra alejada en uno de sus
ejes, lo cual no debiera ser un problema para el P-Median.
Los datos planteados, y su diagrama de dispersión son los siguientes:
Figure 2: Ejemplo realizado con Infostat.
Diciembre 2008
Página 15 de 20
AID - Trabajo Final
Implementación P-Median
El objetivo es conformar 2 grupos con estos casos.
Como primer paso se evaluará como se comporta este problema con otros algoritmos empleando el
software Infostat y Weka.
Utilizando Infostat, agrupamiento jerárquico con método de encadenamiento simple y distancia Euclídea al
cuadrado, los resultados obtenidos fueron:
Infostat, agrupamiento jerárquico con método de encadenamiento Ward y distancia Euclídea, los
resultados obtenidos fueron:
Diciembre 2008
Página 16 de 20
AID - Trabajo Final
Implementación P-Median
Infostat, agrupamiento por método No Jerárquico KMeans utilizando distancia Euclídea:
Utilizando Weka, agrupamiento por SimpleKmeans, el resultado es el siguiente:
kMeans
======
Number of iterations: 2
Within cluster sum of squared errors:
1.9419939418869898
Missing values globally replaced with mean/mode
Cluster centroids:
Cluster#
Full Data
0
1
(24)
(13)
(11)
============================================
X
43.2917
49.4615
36
Y
25.1667
29.1538
20.4545
Attribute
Clustered Instances
0
1
13 ( 54%)
11 ( 46%)
Puede observarse que ninguno de los algoritmos probados hasta el momento logra obtener la solución
correcta, tanto los jerárquicos como los no jerárquicos se ven influenciados por la instancia que se
encuentra alejada en el eje X.
Este problema podría tratarse como si fuese un caso de valor outlier, y en cuyo caso al retirarse el
elemento de la muestra si se obtendrían buenas soluciones con cualquiera de los algoritmos probados
hasta el momento.
Diciembre 2008
Página 17 de 20
AID - Trabajo Final
Implementación P-Median
Empleando P-Median, el resultado fue el siguiente:
PMedian
=======
Number of iterations: 3
Within cluster sum of squared errors: 4661.0
Cluster centroids:
Cluster#
Full Data
0
1
(24)
(12)
(12)
============================================
X
43.2917
67.5
18
Y
25.1667
27.5
24.5
Attribute
Clustered Instances
0
1
12 ( 50%)
12 ( 50%)
En este último gráfico puede observarse claramente que la asignación a los grupos es la correcta, y que el
valor alejado (outlier) no afecta el desempeño del algoritmo PMedian.
Problemas con muchas instancias
A medida que crece la cantidad de instancias comienzan los problemas de performance del algoritmo.
Como fue explicado en los detalles de implementación, en cada iteración el algoritmo calcula la mediana
para cada dimensión del problema. Para realizar esta tarea copia los valores numéricos a un vector y los
ordena para luego acceder a el/los elementos de la mitad y obtener la mediana. Esta operación es costosa
desde el punto de vista computacional, en el mejor de los casos el costo es del orden n*log2(n), siendo n la
cantidad de elementos existentes en ese grupo.
No obstante, las pruebas realizadas con casos de ejemplo de hasta 10.000 instancias y 2 dimensiones
fueron ejecutadas en un tiempo muy similar al que consumió la ejecución del mismo problema con el
algoritmo SimpleKmeans (empleando Hardware estándar, una PC hogareña modelo 2008).
Ideas para futuras investigaciones
Durante el desarrollo surgieron ideas para atacar el problema de la degradación de performance cuando
crece en forma importante el número de instancias.
Todas ellas están dirigidas a optimizar la forma de cálculo de la mediana. Buscar alternativas para que no
sea requisito tener que ordenar los valores de cada grupo en cada iteración basándose en el supuesto que
entre iteraciones solo una pequeña parte de las instancias se trasladan de un grupo hacia otro.
Otras alternativas incluyen el uso de estructuras con indexación que permitan mantener los elementos en
forma ordenada y eviten de esta forma el paso mas costoso del algoritmo: ordenar los valores de las
instancias.
Diciembre 2008
Página 18 de 20
AID - Trabajo Final
Implementación P-Median
Conclusiones
Los resultados obtenidos con los ejemplos muestran que el PMedian es un algoritmo que soporta la
existencia de datos lejanos sin que esto afecte la conformación de los grupos que genera.
Es una alternativa que permitiría obviar la etapa de eliminación de outliers, y por consiguiente aumenta su
confiabilidad ya que la existencia de algunos casos extremos no alterar la calidad de la solución resultante.
En cuanto al costo computacional que implica su utilización con grandes volúmenes de datos, es un campo
abierto para la investigación y el desarrollo, un desafio para el estudio y búsqueda de nuevas heurísticas y
optimizaciones que junto a la evolución del Hardware permitirán que el algoritmo PMedian sea empleado
masivamente en detrimento de otros métodos menos confiables como el KMeans.
Detalles de Instalación
Deben seguirse los siguientes pasos:
1)Instalar weka versión 3.5.8 o superior.
2) Copiar los archivos pmedian.jar y GenericPropertiesCreator.props al directorio donde se
encuentra instalado Weka (en una PC con Windows en Castellano el directorio es C:\Archivos de
programa\Weka-3-5).
3) Editar RunWeka.ini, modificando la asignación de la variable cp, debe quedar de la siguiente
manera:
cp=%CLASSPATH%;pmedian.jar
4) Ejecutar weka normalmente, el PMedian debe verse y encontrarse disponible como cualquier
otro algoritmo clusterer.
Disponibilidad pública
Este trabajo es acompañado por un CD con todo el código fuente en Java, las librerías para poder ser
utilizado libremente.
Asimismo se pone a disposición el repositorio del proyecto donde se puede descargar libremente la ultima
versión de todos los componentes en caso que esta tenga modificaciones posteriores a la entrega de este
informe.
http://www.assembla.com/wiki/show/pmedian
Libre acceso al código fuente:
http://trac.assembla.com/pmedian/browser
A través de un cliente subversión, mediante el URL:
http://svn.assembla.com/svn/pmedian
Diciembre 2008
Página 19 de 20
AID - Trabajo Final
Implementación P-Median
Bibliografía y referencias
Weka
http://www.cs.waikato.ac.nz/~ml/weka/index.html
Software estadístico Infostat, Manuel del usuario versión 2008
http://www.infostat.com.ar
K-Means Clustering Algorithm
http://mathworld.wolfram.com/K-MeansClusteringAlgorithm.html
An Efficient Algorithm for the Approximate Median Selection
Problem, por S. Battiato, D. Cantone, D. Catalano and G. Cincotti
http://web.cs.wpi.edu/~hofri/medsel.pdf
A constant-factor approximation algorithm for the -median problem
http://www.cs.cornell.edu/home/eva/median.ps
Some interchange algorithms for median location problems, por R A Whitaker
http://www.envplan.com/abstract.cgi?id=b090119
Fast and Robust Techniques for the Euclidean p-Median Problem
with Uniform Weights, por G. J. Lim_ J. Reesey A. Holder
http://ramanujan.math.trinity.edu/tumath/research/reports/report107.pdf
Diciembre 2008
Página 20 de 20